alexey.zholtikov/upm
1
0
Fork 0
mirror of https://github.com/eclipse/upm.git synced 2025-07-16 00:31:12 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

ds18b20: Initial implementation

Browse Source 
This driver supports, and was tested with, a DS18B20 1-wire
Temperature Sensor using external power.

This device requires the use of a UART to provide access to a Dallas
1-wire bus, via a new facility supported by MRAA (once the relevant PR
is accepted), using the UartOW access class.  It is important to
realize that the UART is only being used to access and control a
Dallas 1-wire compliant bus, it is not actually a UART device.

Multiple DS18B20 devices can be connected to this bus.  This module
will identify all such devices connected, and allow you to access them
using an index starting at 0.

Parasitic power is not currently supported due to the very tight 10us
limit on switching a GPIO properly to supply power during certain
operations.  For this reason, you should use external power for your
sensors.

Setting the alarm values (Tl, Th) is also not supported, since this is
only useful when doing a 1-wire device search looking for devices in
an alarm state, a capability not yet supported in MRAA.  In reality,
this is trivial to handle yourself in your application.

Signed-off-by: Jon Trulson <jtrulson@ics.com>
Signed-off-by: Noel Eck <noel.eck@intel.com>
This commit is contained in:
Jon Trulson
2016-01-26 16:45:05 -07:00
committed by Noel Eck
parent bf9059c846
commit e679d40d44
10 changed files with 806 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

298
src/ds18b20/ds18b20.cxx Normal file
View File

@ -0,0 +1,298 @@
/*
* Author: Jon Trulson <jtrulson@ics.com>
* Copyright (c) 2016 Intel Corporation.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <iostream>
#include <time.h>
#include <stdexcept>
#include "ds18b20.h"
using namespace upm;
using namespace std;
// conversion from celcius to fahrenheit
static float c2f(float c)
{
return (c * (9.0 / 5.0) + 32.0);
}
DS18B20::DS18B20(int uart) :
m_uart(uart)
{
m_devicesFound = 0;
// check basic access to the 1-wire bus (presence detect)
mraa::Result rv;
if ((rv = m_uart.reset()) != mraa::SUCCESS)
{
throw std::runtime_error(std::string(__FUNCTION__) +
": reset() failed, no devices on bus?");
}
}
DS18B20::~DS18B20()
{
}
void DS18B20::init()
{
// iterate through the bus and build up a list of detected DS18B20
// devices (only)
// empty the map, in case this method has already been run once
// before
m_devicesFound = 0;
m_deviceMap.clear();
sensor_info_t sinfo;
// defaults
sinfo.temperature = 0.0;
sinfo.resolution = RESOLUTION_12BITS;
// start the search from scratch
string id = m_uart.search(true);
if (id.empty())
{
throw std::runtime_error(std::string(__FUNCTION__) +
": no devices detected on bus");
}
while (!id.empty())
{
// The first byte (id[0]]) is the device type (family) code. We
// are only interested in the family code for these devices.
if ((uint8_t)id[0] == DS18B20_FAMILY_CODE)
{
// we have a winner, add it to our map and continue searching
sinfo.id = id;
m_deviceMap[m_devicesFound] = sinfo;
m_devicesFound++;
}
// continue search
id = m_uart.search(false);
}
if (!m_devicesFound)
{
throw std::runtime_error(std::string(__FUNCTION__) +
": no DS18B20 devices found on bus");
}
// iterate through the found devices and query their resolutions
for (int i=0; i<m_devicesFound; i++)
{
// read only the first 5 bytes of the scratchpad
static const int numScratch = 5;
uint8_t scratch[numScratch];
m_uart.command(CMD_READ_SCRATCHPAD, m_deviceMap[i].id);
for (int j=0; j<numScratch; j++)
scratch[j] = m_uart.readByte();
// config byte, shift the resolution to bit 0
scratch[4] >>= _CFG_RESOLUTION_SHIFT;
switch (scratch[4] & _CFG_RESOLUTION_MASK)
{
case 0: m_deviceMap[i].resolution = RESOLUTION_9BITS; break;
case 1: m_deviceMap[i].resolution = RESOLUTION_10BITS; break;
case 2: m_deviceMap[i].resolution = RESOLUTION_11BITS; break;
case 3: m_deviceMap[i].resolution = RESOLUTION_12BITS; break;
}
// reset the bus
m_uart.reset();
}
}
void DS18B20::update(int index)
{
if (index >= m_devicesFound)
{
throw std::out_of_range(std::string(__FUNCTION__) +
": device index out of range");
}
// should we update all of them?
bool doAll = (index < 0) ? true : false;
if (doAll)
{
// if we want to update all of them, we will first send the
// convert command to all of them, then wait. This will be
// faster, timey-wimey wise, then converting, sleeping, and
// reading each individual sensor.
for (int i=0; i<m_devicesFound; i++)
m_uart.command(CMD_CONVERT, m_deviceMap[i].id);
}
else
m_uart.command(CMD_CONVERT, m_deviceMap[index].id);
// wait for conversion(s) to finish
usleep(750000); // 750ms max
if (doAll)
{
for (int i=0; i<m_devicesFound; i++)
m_deviceMap[i].temperature = readSingleTemp(i);
}
else
m_deviceMap[index].temperature = readSingleTemp(index);
}
// utility function to read temp data from a single sensor
float DS18B20::readSingleTemp(int index)
{
if (index < 0 || index >= m_devicesFound)
{
throw std::out_of_range(std::string(__FUNCTION__) +
": device index out of range");
}
static const int numScratch = 9;
uint8_t scratch[numScratch];
// read the 9-byte scratchpad
m_uart.command(CMD_READ_SCRATCHPAD, m_deviceMap[index].id);
for (int i=0; i<numScratch; i++)
scratch[i] = m_uart.readByte();
// validate cksum -- if we get an error, we will warn and simply
// return the current (previously read) temperature
uint8_t crc = m_uart.crc8(scratch, 8);
if (crc != scratch[8])
{
cerr << __FUNCTION__ << ": crc check failed for device "
<< index << ", returning previously measured temperature" << endl;
return m_deviceMap[index].temperature;
}
// check the sign bit(s)
bool negative = (scratch[1] & 0x80) ? true : false;
// shift everything into position
int16_t temp = (scratch[1] << 8) | scratch[0];
// grab the fractional
uint8_t frac = temp & 0x0f;
// depending on the resolution, some frac bits should be ignored, so
// we mask them off. For 12bits, all bits are valid so we leve them
// alone.
switch (m_deviceMap[index].resolution)
{
case RESOLUTION_9BITS: frac &= 0x08; break;
case RESOLUTION_10BITS: frac &= 0x0c; break;
case RESOLUTION_11BITS: frac &= 0x0e; break;
}
// remove the fractional with extreme prejudice
temp >>= 4;
// compensate for sign
if (negative)
temp -= 65536; // 2^^16
// convert
return ( float(temp) + (float(frac) * 0.0625) );
}
float DS18B20::getTemperature(int index, bool fahrenheit)
{
if (index < 0 || index >= m_devicesFound)
{
throw std::out_of_range(std::string(__FUNCTION__) +
": device index out of range");
}
if (fahrenheit)
return c2f(m_deviceMap[index].temperature);
else
return m_deviceMap[index].temperature;
}
void DS18B20::setResolution(int index, RESOLUTIONS_T res)
{
if (index < 0 || index >= m_devicesFound)
{
throw std::out_of_range(std::string(__FUNCTION__) +
": device index out of range");
}
static const int numScratch = 9;
uint8_t scratch[numScratch];
// read the 9-byte scratchpad
m_uart.command(CMD_READ_SCRATCHPAD, m_deviceMap[index].id);
for (int i=0; i<numScratch; i++)
scratch[i] = m_uart.readByte();
// resolution is stored in byte 4
scratch[4] = ((scratch[4] & ~(_CFG_RESOLUTION_MASK << _CFG_RESOLUTION_SHIFT))
| (res << _CFG_RESOLUTION_SHIFT));
// now, write back, we only write 3 bytes (2-4), no cksum.
m_uart.command(CMD_WRITE_SCRATCHPAD, m_deviceMap[index].id);
for (int i=0; i<3; i++)
m_uart.writeByte(scratch[i+2]);
}
void DS18B20::copyScratchPad(int index)
{
if (index < 0 || index >= m_devicesFound)
{
throw std::out_of_range(std::string(__FUNCTION__) +
": device index out of range");
}
// issue the command
m_uart.command(CMD_COPY_SCRATCHPAD, m_deviceMap[index].id);
sleep(1); // to be safe...
}
void DS18B20::recallEEPROM(int index)
{
if (index < 0 || index >= m_devicesFound)
{
throw std::out_of_range(std::string(__FUNCTION__) +
": device index out of range");
}
// issue the command
m_uart.command(CMD_RECALL_EEPROM, m_deviceMap[index].id);
// issue read timeslots until a '1' is read back, indicating completion
while (!m_uart.writeBit(1))
usleep(100);
}