DS18B20 added
This commit is contained in:
parent
9a51210f38
commit
59aefd4928
8 changed files with 2433 additions and 1 deletions
885
Firmware/lib/DallasTemperature/DallasTemperature.cpp
Normal file
885
Firmware/lib/DallasTemperature/DallasTemperature.cpp
Normal file
|
@ -0,0 +1,885 @@
|
|||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Lesser General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
#include "DallasTemperature.h"
|
||||
|
||||
#if ARDUINO >= 100
|
||||
#include "Arduino.h"
|
||||
#else
|
||||
extern "C" {
|
||||
#include "WConstants.h"
|
||||
}
|
||||
#endif
|
||||
|
||||
// OneWire commands
|
||||
#define STARTCONVO 0x44 // Tells device to take a temperature reading and put it on the scratchpad
|
||||
#define COPYSCRATCH 0x48 // Copy EEPROM
|
||||
#define READSCRATCH 0xBE // Read EEPROM
|
||||
#define WRITESCRATCH 0x4E // Write to EEPROM
|
||||
#define RECALLSCRATCH 0xB8 // Reload from last known
|
||||
#define READPOWERSUPPLY 0xB4 // Determine if device needs parasite power
|
||||
#define ALARMSEARCH 0xEC // Query bus for devices with an alarm condition
|
||||
|
||||
// Scratchpad locations
|
||||
#define TEMP_LSB 0
|
||||
#define TEMP_MSB 1
|
||||
#define HIGH_ALARM_TEMP 2
|
||||
#define LOW_ALARM_TEMP 3
|
||||
#define CONFIGURATION 4
|
||||
#define INTERNAL_BYTE 5
|
||||
#define COUNT_REMAIN 6
|
||||
#define COUNT_PER_C 7
|
||||
#define SCRATCHPAD_CRC 8
|
||||
|
||||
// Device resolution
|
||||
#define TEMP_9_BIT 0x1F // 9 bit
|
||||
#define TEMP_10_BIT 0x3F // 10 bit
|
||||
#define TEMP_11_BIT 0x5F // 11 bit
|
||||
#define TEMP_12_BIT 0x7F // 12 bit
|
||||
|
||||
#define NO_ALARM_HANDLER ((AlarmHandler *)0)
|
||||
|
||||
DallasTemperature::DallasTemperature()
|
||||
{
|
||||
#if REQUIRESALARMS
|
||||
setAlarmHandler(NO_ALARM_HANDLER);
|
||||
#endif
|
||||
}
|
||||
DallasTemperature::DallasTemperature(OneWire* _oneWire)
|
||||
{
|
||||
setOneWire(_oneWire);
|
||||
#if REQUIRESALARMS
|
||||
setAlarmHandler(NO_ALARM_HANDLER);
|
||||
#endif
|
||||
}
|
||||
|
||||
bool DallasTemperature::validFamily(const uint8_t* deviceAddress) {
|
||||
switch (deviceAddress[0]) {
|
||||
case DS18S20MODEL:
|
||||
case DS18B20MODEL:
|
||||
case DS1822MODEL:
|
||||
case DS1825MODEL:
|
||||
case DS28EA00MODEL:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void DallasTemperature::setOneWire(OneWire* _oneWire) {
|
||||
|
||||
_wire = _oneWire;
|
||||
devices = 0;
|
||||
ds18Count = 0;
|
||||
parasite = false;
|
||||
bitResolution = 9;
|
||||
waitForConversion = true;
|
||||
checkForConversion = true;
|
||||
|
||||
}
|
||||
|
||||
// initialise the bus
|
||||
void DallasTemperature::begin(void) {
|
||||
|
||||
DeviceAddress deviceAddress;
|
||||
|
||||
_wire->reset_search();
|
||||
devices = 0; // Reset the number of devices when we enumerate wire devices
|
||||
ds18Count = 0; // Reset number of DS18xxx Family devices
|
||||
|
||||
while (_wire->search(deviceAddress)) {
|
||||
|
||||
if (validAddress(deviceAddress)) {
|
||||
|
||||
if (!parasite && readPowerSupply(deviceAddress))
|
||||
parasite = true;
|
||||
|
||||
bitResolution = max(bitResolution, getResolution(deviceAddress));
|
||||
|
||||
devices++;
|
||||
if (validFamily(deviceAddress)) {
|
||||
ds18Count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// returns the number of devices found on the bus
|
||||
uint8_t DallasTemperature::getDeviceCount(void) {
|
||||
return devices;
|
||||
}
|
||||
|
||||
uint8_t DallasTemperature::getDS18Count(void) {
|
||||
return ds18Count;
|
||||
}
|
||||
|
||||
// returns true if address is valid
|
||||
bool DallasTemperature::validAddress(const uint8_t* deviceAddress) {
|
||||
return (_wire->crc8(deviceAddress, 7) == deviceAddress[7]);
|
||||
}
|
||||
|
||||
// finds an address at a given index on the bus
|
||||
// returns true if the device was found
|
||||
bool DallasTemperature::getAddress(uint8_t* deviceAddress, uint8_t index) {
|
||||
|
||||
uint8_t depth = 0;
|
||||
|
||||
_wire->reset_search();
|
||||
|
||||
while (depth <= index && _wire->search(deviceAddress)) {
|
||||
if (depth == index && validAddress(deviceAddress))
|
||||
return true;
|
||||
depth++;
|
||||
}
|
||||
|
||||
return false;
|
||||
|
||||
}
|
||||
|
||||
// attempt to determine if the device at the given address is connected to the bus
|
||||
bool DallasTemperature::isConnected(const uint8_t* deviceAddress) {
|
||||
|
||||
ScratchPad scratchPad;
|
||||
return isConnected(deviceAddress, scratchPad);
|
||||
|
||||
}
|
||||
|
||||
// attempt to determine if the device at the given address is connected to the bus
|
||||
// also allows for updating the read scratchpad
|
||||
bool DallasTemperature::isConnected(const uint8_t* deviceAddress,
|
||||
uint8_t* scratchPad) {
|
||||
bool b = readScratchPad(deviceAddress, scratchPad);
|
||||
return b && (_wire->crc8(scratchPad, 8) == scratchPad[SCRATCHPAD_CRC]);
|
||||
}
|
||||
|
||||
bool DallasTemperature::readScratchPad(const uint8_t* deviceAddress,
|
||||
uint8_t* scratchPad) {
|
||||
|
||||
// send the reset command and fail fast
|
||||
int b = _wire->reset();
|
||||
if (b == 0)
|
||||
return false;
|
||||
|
||||
_wire->select(deviceAddress);
|
||||
_wire->write(READSCRATCH);
|
||||
|
||||
// Read all registers in a simple loop
|
||||
// byte 0: temperature LSB
|
||||
// byte 1: temperature MSB
|
||||
// byte 2: high alarm temp
|
||||
// byte 3: low alarm temp
|
||||
// byte 4: DS18S20: store for crc
|
||||
// DS18B20 & DS1822: configuration register
|
||||
// byte 5: internal use & crc
|
||||
// byte 6: DS18S20: COUNT_REMAIN
|
||||
// DS18B20 & DS1822: store for crc
|
||||
// byte 7: DS18S20: COUNT_PER_C
|
||||
// DS18B20 & DS1822: store for crc
|
||||
// byte 8: SCRATCHPAD_CRC
|
||||
for (uint8_t i = 0; i < 9; i++) {
|
||||
scratchPad[i] = _wire->read();
|
||||
}
|
||||
|
||||
b = _wire->reset();
|
||||
return (b == 1);
|
||||
}
|
||||
|
||||
void DallasTemperature::writeScratchPad(const uint8_t* deviceAddress,
|
||||
const uint8_t* scratchPad) {
|
||||
|
||||
_wire->reset();
|
||||
_wire->select(deviceAddress);
|
||||
_wire->write(WRITESCRATCH);
|
||||
_wire->write(scratchPad[HIGH_ALARM_TEMP]); // high alarm temp
|
||||
_wire->write(scratchPad[LOW_ALARM_TEMP]); // low alarm temp
|
||||
|
||||
// DS1820 and DS18S20 have no configuration register
|
||||
if (deviceAddress[0] != DS18S20MODEL)
|
||||
_wire->write(scratchPad[CONFIGURATION]);
|
||||
|
||||
_wire->reset();
|
||||
|
||||
// save the newly written values to eeprom
|
||||
_wire->select(deviceAddress);
|
||||
_wire->write(COPYSCRATCH, parasite);
|
||||
delay(20); // <--- added 20ms delay to allow 10ms long EEPROM write operation (as specified by datasheet)
|
||||
|
||||
if (parasite)
|
||||
delay(10); // 10ms delay
|
||||
_wire->reset();
|
||||
|
||||
}
|
||||
|
||||
bool DallasTemperature::readPowerSupply(const uint8_t* deviceAddress) {
|
||||
|
||||
bool ret = false;
|
||||
_wire->reset();
|
||||
_wire->select(deviceAddress);
|
||||
_wire->write(READPOWERSUPPLY);
|
||||
if (_wire->read_bit() == 0)
|
||||
ret = true;
|
||||
_wire->reset();
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
// set resolution of all devices to 9, 10, 11, or 12 bits
|
||||
// if new resolution is out of range, it is constrained.
|
||||
void DallasTemperature::setResolution(uint8_t newResolution) {
|
||||
|
||||
bitResolution = constrain(newResolution, 9, 12);
|
||||
DeviceAddress deviceAddress;
|
||||
for (int i = 0; i < devices; i++) {
|
||||
getAddress(deviceAddress, i);
|
||||
setResolution(deviceAddress, bitResolution, true);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// set resolution of a device to 9, 10, 11, or 12 bits
|
||||
// if new resolution is out of range, 9 bits is used.
|
||||
bool DallasTemperature::setResolution(const uint8_t* deviceAddress,
|
||||
uint8_t newResolution, bool skipGlobalBitResolutionCalculation) {
|
||||
|
||||
// ensure same behavior as setResolution(uint8_t newResolution)
|
||||
newResolution = constrain(newResolution, 9, 12);
|
||||
|
||||
// return when stored value == new value
|
||||
if (getResolution(deviceAddress) == newResolution)
|
||||
return true;
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad)) {
|
||||
|
||||
// DS1820 and DS18S20 have no resolution configuration register
|
||||
if (deviceAddress[0] != DS18S20MODEL) {
|
||||
|
||||
switch (newResolution) {
|
||||
case 12:
|
||||
scratchPad[CONFIGURATION] = TEMP_12_BIT;
|
||||
break;
|
||||
case 11:
|
||||
scratchPad[CONFIGURATION] = TEMP_11_BIT;
|
||||
break;
|
||||
case 10:
|
||||
scratchPad[CONFIGURATION] = TEMP_10_BIT;
|
||||
break;
|
||||
case 9:
|
||||
default:
|
||||
scratchPad[CONFIGURATION] = TEMP_9_BIT;
|
||||
break;
|
||||
}
|
||||
writeScratchPad(deviceAddress, scratchPad);
|
||||
|
||||
// without calculation we can always set it to max
|
||||
bitResolution = max(bitResolution, newResolution);
|
||||
|
||||
if (!skipGlobalBitResolutionCalculation
|
||||
&& (bitResolution > newResolution)) {
|
||||
bitResolution = newResolution;
|
||||
DeviceAddress deviceAddr;
|
||||
for (int i = 0; i < devices; i++) {
|
||||
getAddress(deviceAddr, i);
|
||||
bitResolution = max(bitResolution,
|
||||
getResolution(deviceAddr));
|
||||
}
|
||||
}
|
||||
}
|
||||
return true; // new value set
|
||||
}
|
||||
|
||||
return false;
|
||||
|
||||
}
|
||||
|
||||
// returns the global resolution
|
||||
uint8_t DallasTemperature::getResolution() {
|
||||
return bitResolution;
|
||||
}
|
||||
|
||||
// returns the current resolution of the device, 9-12
|
||||
// returns 0 if device not found
|
||||
uint8_t DallasTemperature::getResolution(const uint8_t* deviceAddress) {
|
||||
|
||||
// DS1820 and DS18S20 have no resolution configuration register
|
||||
if (deviceAddress[0] == DS18S20MODEL)
|
||||
return 12;
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad)) {
|
||||
switch (scratchPad[CONFIGURATION]) {
|
||||
case TEMP_12_BIT:
|
||||
return 12;
|
||||
|
||||
case TEMP_11_BIT:
|
||||
return 11;
|
||||
|
||||
case TEMP_10_BIT:
|
||||
return 10;
|
||||
|
||||
case TEMP_9_BIT:
|
||||
return 9;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
// sets the value of the waitForConversion flag
|
||||
// TRUE : function requestTemperature() etc returns when conversion is ready
|
||||
// FALSE: function requestTemperature() etc returns immediately (USE WITH CARE!!)
|
||||
// (1) programmer has to check if the needed delay has passed
|
||||
// (2) but the application can do meaningful things in that time
|
||||
void DallasTemperature::setWaitForConversion(bool flag) {
|
||||
waitForConversion = flag;
|
||||
}
|
||||
|
||||
// gets the value of the waitForConversion flag
|
||||
bool DallasTemperature::getWaitForConversion() {
|
||||
return waitForConversion;
|
||||
}
|
||||
|
||||
// sets the value of the checkForConversion flag
|
||||
// TRUE : function requestTemperature() etc will 'listen' to an IC to determine whether a conversion is complete
|
||||
// FALSE: function requestTemperature() etc will wait a set time (worst case scenario) for a conversion to complete
|
||||
void DallasTemperature::setCheckForConversion(bool flag) {
|
||||
checkForConversion = flag;
|
||||
}
|
||||
|
||||
// gets the value of the waitForConversion flag
|
||||
bool DallasTemperature::getCheckForConversion() {
|
||||
return checkForConversion;
|
||||
}
|
||||
|
||||
bool DallasTemperature::isConversionComplete() {
|
||||
uint8_t b = _wire->read_bit();
|
||||
return (b == 1);
|
||||
}
|
||||
|
||||
// sends command for all devices on the bus to perform a temperature conversion
|
||||
void DallasTemperature::requestTemperatures() {
|
||||
|
||||
_wire->reset();
|
||||
_wire->skip();
|
||||
_wire->write(STARTCONVO, parasite);
|
||||
|
||||
// ASYNC mode?
|
||||
if (!waitForConversion)
|
||||
return;
|
||||
blockTillConversionComplete(bitResolution);
|
||||
|
||||
}
|
||||
|
||||
// sends command for one device to perform a temperature by address
|
||||
// returns FALSE if device is disconnected
|
||||
// returns TRUE otherwise
|
||||
bool DallasTemperature::requestTemperaturesByAddress(
|
||||
const uint8_t* deviceAddress) {
|
||||
|
||||
uint8_t bitResolution = getResolution(deviceAddress);
|
||||
if (bitResolution == 0) {
|
||||
return false; //Device disconnected
|
||||
}
|
||||
|
||||
_wire->reset();
|
||||
_wire->select(deviceAddress);
|
||||
_wire->write(STARTCONVO, parasite);
|
||||
|
||||
// ASYNC mode?
|
||||
if (!waitForConversion)
|
||||
return true;
|
||||
|
||||
blockTillConversionComplete(bitResolution);
|
||||
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
// Continue to check if the IC has responded with a temperature
|
||||
void DallasTemperature::blockTillConversionComplete(uint8_t bitResolution) {
|
||||
|
||||
int delms = millisToWaitForConversion(bitResolution);
|
||||
if (checkForConversion && !parasite) {
|
||||
unsigned long now = millis();
|
||||
while (!isConversionComplete() && (millis() - delms < now))
|
||||
;
|
||||
} else {
|
||||
delay(delms);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// returns number of milliseconds to wait till conversion is complete (based on IC datasheet)
|
||||
int16_t DallasTemperature::millisToWaitForConversion(uint8_t bitResolution) {
|
||||
|
||||
switch (bitResolution) {
|
||||
case 9:
|
||||
return 94;
|
||||
case 10:
|
||||
return 188;
|
||||
case 11:
|
||||
return 375;
|
||||
default:
|
||||
return 750;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// sends command for one device to perform a temp conversion by index
|
||||
bool DallasTemperature::requestTemperaturesByIndex(uint8_t deviceIndex) {
|
||||
|
||||
DeviceAddress deviceAddress;
|
||||
getAddress(deviceAddress, deviceIndex);
|
||||
|
||||
return requestTemperaturesByAddress(deviceAddress);
|
||||
|
||||
}
|
||||
|
||||
// Fetch temperature for device index
|
||||
float DallasTemperature::getTempCByIndex(uint8_t deviceIndex) {
|
||||
|
||||
DeviceAddress deviceAddress;
|
||||
if (!getAddress(deviceAddress, deviceIndex)) {
|
||||
return DEVICE_DISCONNECTED_C;
|
||||
}
|
||||
|
||||
return getTempC((uint8_t*) deviceAddress);
|
||||
|
||||
}
|
||||
|
||||
// Fetch temperature for device index
|
||||
float DallasTemperature::getTempFByIndex(uint8_t deviceIndex) {
|
||||
|
||||
DeviceAddress deviceAddress;
|
||||
|
||||
if (!getAddress(deviceAddress, deviceIndex)) {
|
||||
return DEVICE_DISCONNECTED_F;
|
||||
}
|
||||
|
||||
return getTempF((uint8_t*) deviceAddress);
|
||||
|
||||
}
|
||||
|
||||
// reads scratchpad and returns fixed-point temperature, scaling factor 2^-7
|
||||
int16_t DallasTemperature::calculateTemperature(const uint8_t* deviceAddress,
|
||||
uint8_t* scratchPad) {
|
||||
|
||||
int16_t fpTemperature = (((int16_t) scratchPad[TEMP_MSB]) << 11)
|
||||
| (((int16_t) scratchPad[TEMP_LSB]) << 3);
|
||||
|
||||
/*
|
||||
DS1820 and DS18S20 have a 9-bit temperature register.
|
||||
|
||||
Resolutions greater than 9-bit can be calculated using the data from
|
||||
the temperature, and COUNT REMAIN and COUNT PER °C registers in the
|
||||
scratchpad. The resolution of the calculation depends on the model.
|
||||
|
||||
While the COUNT PER °C register is hard-wired to 16 (10h) in a
|
||||
DS18S20, it changes with temperature in DS1820.
|
||||
|
||||
After reading the scratchpad, the TEMP_READ value is obtained by
|
||||
truncating the 0.5°C bit (bit 0) from the temperature data. The
|
||||
extended resolution temperature can then be calculated using the
|
||||
following equation:
|
||||
|
||||
COUNT_PER_C - COUNT_REMAIN
|
||||
TEMPERATURE = TEMP_READ - 0.25 + --------------------------
|
||||
COUNT_PER_C
|
||||
|
||||
Hagai Shatz simplified this to integer arithmetic for a 12 bits
|
||||
value for a DS18S20, and James Cameron added legacy DS1820 support.
|
||||
|
||||
See - http://myarduinotoy.blogspot.co.uk/2013/02/12bit-result-from-ds18s20.html
|
||||
*/
|
||||
|
||||
if (deviceAddress[0] == DS18S20MODEL) {
|
||||
fpTemperature = ((fpTemperature & 0xfff0) << 3) - 16
|
||||
+ (((scratchPad[COUNT_PER_C] - scratchPad[COUNT_REMAIN]) << 7)
|
||||
/ scratchPad[COUNT_PER_C]);
|
||||
}
|
||||
|
||||
return fpTemperature;
|
||||
}
|
||||
|
||||
// returns temperature in 1/128 degrees C or DEVICE_DISCONNECTED_RAW if the
|
||||
// device's scratch pad cannot be read successfully.
|
||||
// the numeric value of DEVICE_DISCONNECTED_RAW is defined in
|
||||
// DallasTemperature.h. It is a large negative number outside the
|
||||
// operating range of the device
|
||||
int16_t DallasTemperature::getTemp(const uint8_t* deviceAddress) {
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad))
|
||||
return calculateTemperature(deviceAddress, scratchPad);
|
||||
return DEVICE_DISCONNECTED_RAW;
|
||||
|
||||
}
|
||||
|
||||
// returns temperature in degrees C or DEVICE_DISCONNECTED_C if the
|
||||
// device's scratch pad cannot be read successfully.
|
||||
// the numeric value of DEVICE_DISCONNECTED_C is defined in
|
||||
// DallasTemperature.h. It is a large negative number outside the
|
||||
// operating range of the device
|
||||
float DallasTemperature::getTempC(const uint8_t* deviceAddress) {
|
||||
return rawToCelsius(getTemp(deviceAddress));
|
||||
}
|
||||
|
||||
// returns temperature in degrees F or DEVICE_DISCONNECTED_F if the
|
||||
// device's scratch pad cannot be read successfully.
|
||||
// the numeric value of DEVICE_DISCONNECTED_F is defined in
|
||||
// DallasTemperature.h. It is a large negative number outside the
|
||||
// operating range of the device
|
||||
float DallasTemperature::getTempF(const uint8_t* deviceAddress) {
|
||||
return rawToFahrenheit(getTemp(deviceAddress));
|
||||
}
|
||||
|
||||
// returns true if the bus requires parasite power
|
||||
bool DallasTemperature::isParasitePowerMode(void) {
|
||||
return parasite;
|
||||
}
|
||||
|
||||
// IF alarm is not used one can store a 16 bit int of userdata in the alarm
|
||||
// registers. E.g. an ID of the sensor.
|
||||
// See github issue #29
|
||||
|
||||
// note if device is not connected it will fail writing the data.
|
||||
void DallasTemperature::setUserData(const uint8_t* deviceAddress,
|
||||
int16_t data) {
|
||||
// return when stored value == new value
|
||||
if (getUserData(deviceAddress) == data)
|
||||
return;
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad)) {
|
||||
scratchPad[HIGH_ALARM_TEMP] = data >> 8;
|
||||
scratchPad[LOW_ALARM_TEMP] = data & 255;
|
||||
writeScratchPad(deviceAddress, scratchPad);
|
||||
}
|
||||
}
|
||||
|
||||
int16_t DallasTemperature::getUserData(const uint8_t* deviceAddress) {
|
||||
int16_t data = 0;
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad)) {
|
||||
data = scratchPad[HIGH_ALARM_TEMP] << 8;
|
||||
data += scratchPad[LOW_ALARM_TEMP];
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
// note If address cannot be found no error will be reported.
|
||||
int16_t DallasTemperature::getUserDataByIndex(uint8_t deviceIndex) {
|
||||
DeviceAddress deviceAddress;
|
||||
getAddress(deviceAddress, deviceIndex);
|
||||
return getUserData((uint8_t*) deviceAddress);
|
||||
}
|
||||
|
||||
void DallasTemperature::setUserDataByIndex(uint8_t deviceIndex, int16_t data) {
|
||||
DeviceAddress deviceAddress;
|
||||
getAddress(deviceAddress, deviceIndex);
|
||||
setUserData((uint8_t*) deviceAddress, data);
|
||||
}
|
||||
|
||||
// Convert float Celsius to Fahrenheit
|
||||
float DallasTemperature::toFahrenheit(float celsius) {
|
||||
return (celsius * 1.8) + 32;
|
||||
}
|
||||
|
||||
// Convert float Fahrenheit to Celsius
|
||||
float DallasTemperature::toCelsius(float fahrenheit) {
|
||||
return (fahrenheit - 32) * 0.555555556;
|
||||
}
|
||||
|
||||
// convert from raw to Celsius
|
||||
float DallasTemperature::rawToCelsius(int16_t raw) {
|
||||
|
||||
if (raw <= DEVICE_DISCONNECTED_RAW)
|
||||
return DEVICE_DISCONNECTED_C;
|
||||
// C = RAW/128
|
||||
return (float) raw * 0.0078125;
|
||||
|
||||
}
|
||||
|
||||
// convert from raw to Fahrenheit
|
||||
float DallasTemperature::rawToFahrenheit(int16_t raw) {
|
||||
|
||||
if (raw <= DEVICE_DISCONNECTED_RAW)
|
||||
return DEVICE_DISCONNECTED_F;
|
||||
// C = RAW/128
|
||||
// F = (C*1.8)+32 = (RAW/128*1.8)+32 = (RAW*0.0140625)+32
|
||||
return ((float) raw * 0.0140625) + 32;
|
||||
|
||||
}
|
||||
|
||||
#if REQUIRESALARMS
|
||||
|
||||
/*
|
||||
|
||||
ALARMS:
|
||||
|
||||
TH and TL Register Format
|
||||
|
||||
BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0
|
||||
S 2^6 2^5 2^4 2^3 2^2 2^1 2^0
|
||||
|
||||
Only bits 11 through 4 of the temperature register are used
|
||||
in the TH and TL comparison since TH and TL are 8-bit
|
||||
registers. If the measured temperature is lower than or equal
|
||||
to TL or higher than or equal to TH, an alarm condition exists
|
||||
and an alarm flag is set inside the DS18B20. This flag is
|
||||
updated after every temperature measurement; therefore, if the
|
||||
alarm condition goes away, the flag will be turned off after
|
||||
the next temperature conversion.
|
||||
|
||||
*/
|
||||
|
||||
// sets the high alarm temperature for a device in degrees Celsius
|
||||
// accepts a float, but the alarm resolution will ignore anything
|
||||
// after a decimal point. valid range is -55C - 125C
|
||||
void DallasTemperature::setHighAlarmTemp(const uint8_t* deviceAddress,
|
||||
int8_t celsius) {
|
||||
|
||||
// return when stored value == new value
|
||||
if (getHighAlarmTemp(deviceAddress) == celsius)
|
||||
return;
|
||||
|
||||
// make sure the alarm temperature is within the device's range
|
||||
if (celsius > 125)
|
||||
celsius = 125;
|
||||
else if (celsius < -55)
|
||||
celsius = -55;
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad)) {
|
||||
scratchPad[HIGH_ALARM_TEMP] = (uint8_t) celsius;
|
||||
writeScratchPad(deviceAddress, scratchPad);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// sets the low alarm temperature for a device in degrees Celsius
|
||||
// accepts a float, but the alarm resolution will ignore anything
|
||||
// after a decimal point. valid range is -55C - 125C
|
||||
void DallasTemperature::setLowAlarmTemp(const uint8_t* deviceAddress,
|
||||
int8_t celsius) {
|
||||
|
||||
// return when stored value == new value
|
||||
if (getLowAlarmTemp(deviceAddress) == celsius)
|
||||
return;
|
||||
|
||||
// make sure the alarm temperature is within the device's range
|
||||
if (celsius > 125)
|
||||
celsius = 125;
|
||||
else if (celsius < -55)
|
||||
celsius = -55;
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad)) {
|
||||
scratchPad[LOW_ALARM_TEMP] = (uint8_t) celsius;
|
||||
writeScratchPad(deviceAddress, scratchPad);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// returns a int8_t with the current high alarm temperature or
|
||||
// DEVICE_DISCONNECTED for an address
|
||||
int8_t DallasTemperature::getHighAlarmTemp(const uint8_t* deviceAddress) {
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad))
|
||||
return (int8_t) scratchPad[HIGH_ALARM_TEMP];
|
||||
return DEVICE_DISCONNECTED_C;
|
||||
|
||||
}
|
||||
|
||||
// returns a int8_t with the current low alarm temperature or
|
||||
// DEVICE_DISCONNECTED for an address
|
||||
int8_t DallasTemperature::getLowAlarmTemp(const uint8_t* deviceAddress) {
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad))
|
||||
return (int8_t) scratchPad[LOW_ALARM_TEMP];
|
||||
return DEVICE_DISCONNECTED_C;
|
||||
|
||||
}
|
||||
|
||||
// resets internal variables used for the alarm search
|
||||
void DallasTemperature::resetAlarmSearch() {
|
||||
|
||||
alarmSearchJunction = -1;
|
||||
alarmSearchExhausted = 0;
|
||||
for (uint8_t i = 0; i < 7; i++) {
|
||||
alarmSearchAddress[i] = 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// This is a modified version of the OneWire::search method.
|
||||
//
|
||||
// Also added the OneWire search fix documented here:
|
||||
// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295
|
||||
//
|
||||
// Perform an alarm search. If this function returns a '1' then it has
|
||||
// enumerated the next device and you may retrieve the ROM from the
|
||||
// OneWire::address variable. If there are no devices, no further
|
||||
// devices, or something horrible happens in the middle of the
|
||||
// enumeration then a 0 is returned. If a new device is found then
|
||||
// its address is copied to newAddr. Use
|
||||
// DallasTemperature::resetAlarmSearch() to start over.
|
||||
bool DallasTemperature::alarmSearch(uint8_t* newAddr) {
|
||||
|
||||
uint8_t i;
|
||||
int8_t lastJunction = -1;
|
||||
uint8_t done = 1;
|
||||
|
||||
if (alarmSearchExhausted)
|
||||
return false;
|
||||
if (!_wire->reset())
|
||||
return false;
|
||||
|
||||
// send the alarm search command
|
||||
_wire->write(0xEC, 0);
|
||||
|
||||
for (i = 0; i < 64; i++) {
|
||||
|
||||
uint8_t a = _wire->read_bit();
|
||||
uint8_t nota = _wire->read_bit();
|
||||
uint8_t ibyte = i / 8;
|
||||
uint8_t ibit = 1 << (i & 7);
|
||||
|
||||
// I don't think this should happen, this means nothing responded, but maybe if
|
||||
// something vanishes during the search it will come up.
|
||||
if (a && nota)
|
||||
return false;
|
||||
|
||||
if (!a && !nota) {
|
||||
if (i == alarmSearchJunction) {
|
||||
// this is our time to decide differently, we went zero last time, go one.
|
||||
a = 1;
|
||||
alarmSearchJunction = lastJunction;
|
||||
} else if (i < alarmSearchJunction) {
|
||||
|
||||
// take whatever we took last time, look in address
|
||||
if (alarmSearchAddress[ibyte] & ibit) {
|
||||
a = 1;
|
||||
} else {
|
||||
// Only 0s count as pending junctions, we've already exhausted the 0 side of 1s
|
||||
a = 0;
|
||||
done = 0;
|
||||
lastJunction = i;
|
||||
}
|
||||
} else {
|
||||
// we are blazing new tree, take the 0
|
||||
a = 0;
|
||||
alarmSearchJunction = i;
|
||||
done = 0;
|
||||
}
|
||||
// OneWire search fix
|
||||
// See: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295
|
||||
}
|
||||
|
||||
if (a)
|
||||
alarmSearchAddress[ibyte] |= ibit;
|
||||
else
|
||||
alarmSearchAddress[ibyte] &= ~ibit;
|
||||
|
||||
_wire->write_bit(a);
|
||||
}
|
||||
|
||||
if (done)
|
||||
alarmSearchExhausted = 1;
|
||||
for (i = 0; i < 8; i++)
|
||||
newAddr[i] = alarmSearchAddress[i];
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
// returns true if device address might have an alarm condition
|
||||
// (only an alarm search can verify this)
|
||||
bool DallasTemperature::hasAlarm(const uint8_t* deviceAddress) {
|
||||
|
||||
ScratchPad scratchPad;
|
||||
if (isConnected(deviceAddress, scratchPad)) {
|
||||
|
||||
int8_t temp = calculateTemperature(deviceAddress, scratchPad) >> 7;
|
||||
|
||||
// check low alarm
|
||||
if (temp <= (int8_t) scratchPad[LOW_ALARM_TEMP])
|
||||
return true;
|
||||
|
||||
// check high alarm
|
||||
if (temp >= (int8_t) scratchPad[HIGH_ALARM_TEMP])
|
||||
return true;
|
||||
}
|
||||
|
||||
// no alarm
|
||||
return false;
|
||||
|
||||
}
|
||||
|
||||
// returns true if any device is reporting an alarm condition on the bus
|
||||
bool DallasTemperature::hasAlarm(void) {
|
||||
|
||||
DeviceAddress deviceAddress;
|
||||
resetAlarmSearch();
|
||||
return alarmSearch(deviceAddress);
|
||||
}
|
||||
|
||||
// runs the alarm handler for all devices returned by alarmSearch()
|
||||
// unless there no _AlarmHandler exist.
|
||||
void DallasTemperature::processAlarms(void) {
|
||||
|
||||
if (!hasAlarmHandler())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
resetAlarmSearch();
|
||||
DeviceAddress alarmAddr;
|
||||
|
||||
while (alarmSearch(alarmAddr)) {
|
||||
if (validAddress(alarmAddr)) {
|
||||
_AlarmHandler(alarmAddr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// sets the alarm handler
|
||||
void DallasTemperature::setAlarmHandler(const AlarmHandler *handler) {
|
||||
_AlarmHandler = handler;
|
||||
}
|
||||
|
||||
// checks if AlarmHandler has been set.
|
||||
bool DallasTemperature::hasAlarmHandler()
|
||||
{
|
||||
return _AlarmHandler != NO_ALARM_HANDLER;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if REQUIRESNEW
|
||||
|
||||
// MnetCS - Allocates memory for DallasTemperature. Allows us to instance a new object
|
||||
void* DallasTemperature::operator new(unsigned int size) { // Implicit NSS obj size
|
||||
|
||||
void * p;// void pointer
|
||||
p = malloc(size);// Allocate memory
|
||||
memset((DallasTemperature*)p,0,size);// Initialise memory
|
||||
|
||||
//!!! CANT EXPLICITLY CALL CONSTRUCTOR - workaround by using an init() methodR - workaround by using an init() method
|
||||
return (DallasTemperature*) p;// Cast blank region to NSS pointer
|
||||
}
|
||||
|
||||
// MnetCS 2009 - Free the memory used by this instance
|
||||
void DallasTemperature::operator delete(void* p) {
|
||||
|
||||
DallasTemperature* pNss = (DallasTemperature*) p; // Cast to NSS pointer
|
||||
pNss->~DallasTemperature();// Destruct the object
|
||||
|
||||
free(p);// Free the memory
|
||||
}
|
||||
|
||||
#endif
|
251
Firmware/lib/DallasTemperature/DallasTemperature.h
Normal file
251
Firmware/lib/DallasTemperature/DallasTemperature.h
Normal file
|
@ -0,0 +1,251 @@
|
|||
#ifndef DallasTemperature_h
|
||||
#define DallasTemperature_h
|
||||
|
||||
#define DALLASTEMPLIBVERSION "3.7.9" // To be deprecated
|
||||
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Lesser General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
// set to true to include code for new and delete operators
|
||||
#ifndef REQUIRESNEW
|
||||
#define REQUIRESNEW false
|
||||
#endif
|
||||
|
||||
// set to true to include code implementing alarm search functions
|
||||
#ifndef REQUIRESALARMS
|
||||
#define REQUIRESALARMS true
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <OneWire.h>
|
||||
|
||||
// Model IDs
|
||||
#define DS18S20MODEL 0x10 // also DS1820
|
||||
#define DS18B20MODEL 0x28
|
||||
#define DS1822MODEL 0x22
|
||||
#define DS1825MODEL 0x3B
|
||||
#define DS28EA00MODEL 0x42
|
||||
|
||||
// Error Codes
|
||||
#define DEVICE_DISCONNECTED_C -127
|
||||
#define DEVICE_DISCONNECTED_F -196.6
|
||||
#define DEVICE_DISCONNECTED_RAW -7040
|
||||
|
||||
typedef uint8_t DeviceAddress[8];
|
||||
|
||||
class DallasTemperature {
|
||||
public:
|
||||
|
||||
DallasTemperature();
|
||||
DallasTemperature(OneWire*);
|
||||
|
||||
void setOneWire(OneWire*);
|
||||
|
||||
// initialise bus
|
||||
void begin(void);
|
||||
|
||||
// returns the number of devices found on the bus
|
||||
uint8_t getDeviceCount(void);
|
||||
|
||||
// returns the number of DS18xxx Family devices on bus
|
||||
uint8_t getDS18Count(void);
|
||||
|
||||
// returns true if address is valid
|
||||
bool validAddress(const uint8_t*);
|
||||
|
||||
// returns true if address is of the family of sensors the lib supports.
|
||||
bool validFamily(const uint8_t* deviceAddress);
|
||||
|
||||
// finds an address at a given index on the bus
|
||||
bool getAddress(uint8_t*, uint8_t);
|
||||
|
||||
// attempt to determine if the device at the given address is connected to the bus
|
||||
bool isConnected(const uint8_t*);
|
||||
|
||||
// attempt to determine if the device at the given address is connected to the bus
|
||||
// also allows for updating the read scratchpad
|
||||
bool isConnected(const uint8_t*, uint8_t*);
|
||||
|
||||
// read device's scratchpad
|
||||
bool readScratchPad(const uint8_t*, uint8_t*);
|
||||
|
||||
// write device's scratchpad
|
||||
void writeScratchPad(const uint8_t*, const uint8_t*);
|
||||
|
||||
// read device's power requirements
|
||||
bool readPowerSupply(const uint8_t*);
|
||||
|
||||
// get global resolution
|
||||
uint8_t getResolution();
|
||||
|
||||
// set global resolution to 9, 10, 11, or 12 bits
|
||||
void setResolution(uint8_t);
|
||||
|
||||
// returns the device resolution: 9, 10, 11, or 12 bits
|
||||
uint8_t getResolution(const uint8_t*);
|
||||
|
||||
// set resolution of a device to 9, 10, 11, or 12 bits
|
||||
bool setResolution(const uint8_t*, uint8_t,
|
||||
bool skipGlobalBitResolutionCalculation = false);
|
||||
|
||||
// sets/gets the waitForConversion flag
|
||||
void setWaitForConversion(bool);
|
||||
bool getWaitForConversion(void);
|
||||
|
||||
// sets/gets the checkForConversion flag
|
||||
void setCheckForConversion(bool);
|
||||
bool getCheckForConversion(void);
|
||||
|
||||
// sends command for all devices on the bus to perform a temperature conversion
|
||||
void requestTemperatures(void);
|
||||
|
||||
// sends command for one device to perform a temperature conversion by address
|
||||
bool requestTemperaturesByAddress(const uint8_t*);
|
||||
|
||||
// sends command for one device to perform a temperature conversion by index
|
||||
bool requestTemperaturesByIndex(uint8_t);
|
||||
|
||||
// returns temperature raw value (12 bit integer of 1/128 degrees C)
|
||||
int16_t getTemp(const uint8_t*);
|
||||
|
||||
// returns temperature in degrees C
|
||||
float getTempC(const uint8_t*);
|
||||
|
||||
// returns temperature in degrees F
|
||||
float getTempF(const uint8_t*);
|
||||
|
||||
// Get temperature for device index (slow)
|
||||
float getTempCByIndex(uint8_t);
|
||||
|
||||
// Get temperature for device index (slow)
|
||||
float getTempFByIndex(uint8_t);
|
||||
|
||||
// returns true if the bus requires parasite power
|
||||
bool isParasitePowerMode(void);
|
||||
|
||||
// Is a conversion complete on the wire? Only applies to the first sensor on the wire.
|
||||
bool isConversionComplete(void);
|
||||
|
||||
int16_t millisToWaitForConversion(uint8_t);
|
||||
|
||||
#if REQUIRESALARMS
|
||||
|
||||
typedef void AlarmHandler(const uint8_t*);
|
||||
|
||||
// sets the high alarm temperature for a device
|
||||
// accepts a int8_t. valid range is -55C - 125C
|
||||
void setHighAlarmTemp(const uint8_t*, int8_t);
|
||||
|
||||
// sets the low alarm temperature for a device
|
||||
// accepts a int8_t. valid range is -55C - 125C
|
||||
void setLowAlarmTemp(const uint8_t*, int8_t);
|
||||
|
||||
// returns a int8_t with the current high alarm temperature for a device
|
||||
// in the range -55C - 125C
|
||||
int8_t getHighAlarmTemp(const uint8_t*);
|
||||
|
||||
// returns a int8_t with the current low alarm temperature for a device
|
||||
// in the range -55C - 125C
|
||||
int8_t getLowAlarmTemp(const uint8_t*);
|
||||
|
||||
// resets internal variables used for the alarm search
|
||||
void resetAlarmSearch(void);
|
||||
|
||||
// search the wire for devices with active alarms
|
||||
bool alarmSearch(uint8_t*);
|
||||
|
||||
// returns true if ia specific device has an alarm
|
||||
bool hasAlarm(const uint8_t*);
|
||||
|
||||
// returns true if any device is reporting an alarm on the bus
|
||||
bool hasAlarm(void);
|
||||
|
||||
// runs the alarm handler for all devices returned by alarmSearch()
|
||||
void processAlarms(void);
|
||||
|
||||
// sets the alarm handler
|
||||
void setAlarmHandler(const AlarmHandler *);
|
||||
|
||||
// returns true if an AlarmHandler has been set
|
||||
bool hasAlarmHandler();
|
||||
|
||||
#endif
|
||||
|
||||
// if no alarm handler is used the two bytes can be used as user data
|
||||
// example of such usage is an ID.
|
||||
// note if device is not connected it will fail writing the data.
|
||||
// note if address cannot be found no error will be reported.
|
||||
// in short use carefully
|
||||
void setUserData(const uint8_t*, int16_t);
|
||||
void setUserDataByIndex(uint8_t, int16_t);
|
||||
int16_t getUserData(const uint8_t*);
|
||||
int16_t getUserDataByIndex(uint8_t);
|
||||
|
||||
// convert from Celsius to Fahrenheit
|
||||
static float toFahrenheit(float);
|
||||
|
||||
// convert from Fahrenheit to Celsius
|
||||
static float toCelsius(float);
|
||||
|
||||
// convert from raw to Celsius
|
||||
static float rawToCelsius(int16_t);
|
||||
|
||||
// convert from raw to Fahrenheit
|
||||
static float rawToFahrenheit(int16_t);
|
||||
|
||||
#if REQUIRESNEW
|
||||
|
||||
// initialize memory area
|
||||
void* operator new (unsigned int);
|
||||
|
||||
// delete memory reference
|
||||
void operator delete(void*);
|
||||
|
||||
#endif
|
||||
|
||||
private:
|
||||
typedef uint8_t ScratchPad[9];
|
||||
|
||||
// parasite power on or off
|
||||
bool parasite;
|
||||
|
||||
// used to determine the delay amount needed to allow for the
|
||||
// temperature conversion to take place
|
||||
uint8_t bitResolution;
|
||||
|
||||
// used to requestTemperature with or without delay
|
||||
bool waitForConversion;
|
||||
|
||||
// used to requestTemperature to dynamically check if a conversion is complete
|
||||
bool checkForConversion;
|
||||
|
||||
// count of devices on the bus
|
||||
uint8_t devices;
|
||||
|
||||
// count of DS18xxx Family devices on bus
|
||||
uint8_t ds18Count;
|
||||
|
||||
// Take a pointer to one wire instance
|
||||
OneWire* _wire;
|
||||
|
||||
// reads scratchpad and returns the raw temperature
|
||||
int16_t calculateTemperature(const uint8_t*, uint8_t*);
|
||||
|
||||
void blockTillConversionComplete(uint8_t);
|
||||
|
||||
#if REQUIRESALARMS
|
||||
|
||||
// required for alarmSearch
|
||||
uint8_t alarmSearchAddress[8];
|
||||
int8_t alarmSearchJunction;
|
||||
uint8_t alarmSearchExhausted;
|
||||
|
||||
// the alarm handler function pointer
|
||||
AlarmHandler *_AlarmHandler;
|
||||
|
||||
#endif
|
||||
|
||||
};
|
||||
#endif
|
580
Firmware/lib/OneWire/OneWire.cpp
Normal file
580
Firmware/lib/OneWire/OneWire.cpp
Normal file
|
@ -0,0 +1,580 @@
|
|||
/*
|
||||
Copyright (c) 2007, Jim Studt (original old version - many contributors since)
|
||||
|
||||
The latest version of this library may be found at:
|
||||
http://www.pjrc.com/teensy/td_libs_OneWire.html
|
||||
|
||||
OneWire has been maintained by Paul Stoffregen (paul@pjrc.com) since
|
||||
January 2010.
|
||||
|
||||
DO NOT EMAIL for technical support, especially not for ESP chips!
|
||||
All project support questions must be posted on public forums
|
||||
relevant to the board or chips used. If using Arduino, post on
|
||||
Arduino's forum. If using ESP, post on the ESP community forums.
|
||||
There is ABSOLUTELY NO TECH SUPPORT BY PRIVATE EMAIL!
|
||||
|
||||
Github's issue tracker for OneWire should be used only to report
|
||||
specific bugs. DO NOT request project support via Github. All
|
||||
project and tech support questions must be posted on forums, not
|
||||
github issues. If you experience a problem and you are not
|
||||
absolutely sure it's an issue with the library, ask on a forum
|
||||
first. Only use github to report issues after experts have
|
||||
confirmed the issue is with OneWire rather than your project.
|
||||
|
||||
Back in 2010, OneWire was in need of many bug fixes, but had
|
||||
been abandoned the original author (Jim Studt). None of the known
|
||||
contributors were interested in maintaining OneWire. Paul typically
|
||||
works on OneWire every 6 to 12 months. Patches usually wait that
|
||||
long. If anyone is interested in more actively maintaining OneWire,
|
||||
please contact Paul (this is pretty much the only reason to use
|
||||
private email about OneWire).
|
||||
|
||||
OneWire is now very mature code. No changes other than adding
|
||||
definitions for newer hardware support are anticipated.
|
||||
|
||||
Version 2.3:
|
||||
Unknown chip fallback mode, Roger Clark
|
||||
Teensy-LC compatibility, Paul Stoffregen
|
||||
Search bug fix, Love Nystrom
|
||||
|
||||
Version 2.2:
|
||||
Teensy 3.0 compatibility, Paul Stoffregen, paul@pjrc.com
|
||||
Arduino Due compatibility, http://arduino.cc/forum/index.php?topic=141030
|
||||
Fix DS18B20 example negative temperature
|
||||
Fix DS18B20 example's low res modes, Ken Butcher
|
||||
Improve reset timing, Mark Tillotson
|
||||
Add const qualifiers, Bertrik Sikken
|
||||
Add initial value input to crc16, Bertrik Sikken
|
||||
Add target_search() function, Scott Roberts
|
||||
|
||||
Version 2.1:
|
||||
Arduino 1.0 compatibility, Paul Stoffregen
|
||||
Improve temperature example, Paul Stoffregen
|
||||
DS250x_PROM example, Guillermo Lovato
|
||||
PIC32 (chipKit) compatibility, Jason Dangel, dangel.jason AT gmail.com
|
||||
Improvements from Glenn Trewitt:
|
||||
- crc16() now works
|
||||
- check_crc16() does all of calculation/checking work.
|
||||
- Added read_bytes() and write_bytes(), to reduce tedious loops.
|
||||
- Added ds2408 example.
|
||||
Delete very old, out-of-date readme file (info is here)
|
||||
|
||||
Version 2.0: Modifications by Paul Stoffregen, January 2010:
|
||||
http://www.pjrc.com/teensy/td_libs_OneWire.html
|
||||
Search fix from Robin James
|
||||
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27
|
||||
Use direct optimized I/O in all cases
|
||||
Disable interrupts during timing critical sections
|
||||
(this solves many random communication errors)
|
||||
Disable interrupts during read-modify-write I/O
|
||||
Reduce RAM consumption by eliminating unnecessary
|
||||
variables and trimming many to 8 bits
|
||||
Optimize both crc8 - table version moved to flash
|
||||
|
||||
Modified to work with larger numbers of devices - avoids loop.
|
||||
Tested in Arduino 11 alpha with 12 sensors.
|
||||
26 Sept 2008 -- Robin James
|
||||
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27
|
||||
|
||||
Updated to work with arduino-0008 and to include skip() as of
|
||||
2007/07/06. --RJL20
|
||||
|
||||
Modified to calculate the 8-bit CRC directly, avoiding the need for
|
||||
the 256-byte lookup table to be loaded in RAM. Tested in arduino-0010
|
||||
-- Tom Pollard, Jan 23, 2008
|
||||
|
||||
Jim Studt's original library was modified by Josh Larios.
|
||||
|
||||
Tom Pollard, pollard@alum.mit.edu, contributed around May 20, 2008
|
||||
|
||||
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.
|
||||
|
||||
Much of the code was inspired by Derek Yerger's code, though I don't
|
||||
think much of that remains. In any event that was..
|
||||
(copyleft) 2006 by Derek Yerger - Free to distribute freely.
|
||||
|
||||
The CRC code was excerpted and inspired by the Dallas Semiconductor
|
||||
sample code bearing this copyright.
|
||||
//---------------------------------------------------------------------------
|
||||
// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved.
|
||||
//
|
||||
// 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 DALLAS SEMICONDUCTOR 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.
|
||||
//
|
||||
// Except as contained in this notice, the name of Dallas Semiconductor
|
||||
// shall not be used except as stated in the Dallas Semiconductor
|
||||
// Branding Policy.
|
||||
//--------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "OneWire.h"
|
||||
#include "util/OneWire_direct_gpio.h"
|
||||
|
||||
|
||||
void OneWire::begin(uint8_t pin)
|
||||
{
|
||||
pinMode(pin, INPUT);
|
||||
bitmask = PIN_TO_BITMASK(pin);
|
||||
baseReg = PIN_TO_BASEREG(pin);
|
||||
#if ONEWIRE_SEARCH
|
||||
reset_search();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// Perform the onewire reset function. We will wait up to 250uS for
|
||||
// the bus to come high, if it doesn't then it is broken or shorted
|
||||
// and we return a 0;
|
||||
//
|
||||
// Returns 1 if a device asserted a presence pulse, 0 otherwise.
|
||||
//
|
||||
uint8_t OneWire::reset(void)
|
||||
{
|
||||
IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
|
||||
volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
|
||||
uint8_t r;
|
||||
uint8_t retries = 125;
|
||||
|
||||
noInterrupts();
|
||||
DIRECT_MODE_INPUT(reg, mask);
|
||||
interrupts();
|
||||
// wait until the wire is high... just in case
|
||||
do {
|
||||
if (--retries == 0) return 0;
|
||||
delayMicroseconds(2);
|
||||
} while ( !DIRECT_READ(reg, mask));
|
||||
|
||||
noInterrupts();
|
||||
DIRECT_WRITE_LOW(reg, mask);
|
||||
DIRECT_MODE_OUTPUT(reg, mask); // drive output low
|
||||
interrupts();
|
||||
delayMicroseconds(480);
|
||||
noInterrupts();
|
||||
DIRECT_MODE_INPUT(reg, mask); // allow it to float
|
||||
delayMicroseconds(70);
|
||||
r = !DIRECT_READ(reg, mask);
|
||||
interrupts();
|
||||
delayMicroseconds(410);
|
||||
return r;
|
||||
}
|
||||
|
||||
//
|
||||
// Write a bit. Port and bit is used to cut lookup time and provide
|
||||
// more certain timing.
|
||||
//
|
||||
void OneWire::write_bit(uint8_t v)
|
||||
{
|
||||
IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
|
||||
volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
|
||||
|
||||
if (v & 1) {
|
||||
noInterrupts();
|
||||
DIRECT_WRITE_LOW(reg, mask);
|
||||
DIRECT_MODE_OUTPUT(reg, mask); // drive output low
|
||||
delayMicroseconds(10);
|
||||
DIRECT_WRITE_HIGH(reg, mask); // drive output high
|
||||
interrupts();
|
||||
delayMicroseconds(55);
|
||||
} else {
|
||||
noInterrupts();
|
||||
DIRECT_WRITE_LOW(reg, mask);
|
||||
DIRECT_MODE_OUTPUT(reg, mask); // drive output low
|
||||
delayMicroseconds(65);
|
||||
DIRECT_WRITE_HIGH(reg, mask); // drive output high
|
||||
interrupts();
|
||||
delayMicroseconds(5);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Read a bit. Port and bit is used to cut lookup time and provide
|
||||
// more certain timing.
|
||||
//
|
||||
uint8_t OneWire::read_bit(void)
|
||||
{
|
||||
IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
|
||||
volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
|
||||
uint8_t r;
|
||||
|
||||
noInterrupts();
|
||||
DIRECT_MODE_OUTPUT(reg, mask);
|
||||
DIRECT_WRITE_LOW(reg, mask);
|
||||
delayMicroseconds(3);
|
||||
DIRECT_MODE_INPUT(reg, mask); // let pin float, pull up will raise
|
||||
delayMicroseconds(10);
|
||||
r = DIRECT_READ(reg, mask);
|
||||
interrupts();
|
||||
delayMicroseconds(53);
|
||||
return r;
|
||||
}
|
||||
|
||||
//
|
||||
// Write a byte. The writing code uses the active drivers to raise the
|
||||
// pin high, if you need power after the write (e.g. DS18S20 in
|
||||
// parasite power mode) then set 'power' to 1, otherwise the pin will
|
||||
// go tri-state at the end of the write to avoid heating in a short or
|
||||
// other mishap.
|
||||
//
|
||||
void OneWire::write(uint8_t v, uint8_t power /* = 0 */) {
|
||||
uint8_t bitMask;
|
||||
|
||||
for (bitMask = 0x01; bitMask; bitMask <<= 1) {
|
||||
OneWire::write_bit( (bitMask & v)?1:0);
|
||||
}
|
||||
if ( !power) {
|
||||
noInterrupts();
|
||||
DIRECT_MODE_INPUT(baseReg, bitmask);
|
||||
DIRECT_WRITE_LOW(baseReg, bitmask);
|
||||
interrupts();
|
||||
}
|
||||
}
|
||||
|
||||
void OneWire::write_bytes(const uint8_t *buf, uint16_t count, bool power /* = 0 */) {
|
||||
for (uint16_t i = 0 ; i < count ; i++)
|
||||
write(buf[i]);
|
||||
if (!power) {
|
||||
noInterrupts();
|
||||
DIRECT_MODE_INPUT(baseReg, bitmask);
|
||||
DIRECT_WRITE_LOW(baseReg, bitmask);
|
||||
interrupts();
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Read a byte
|
||||
//
|
||||
uint8_t OneWire::read() {
|
||||
uint8_t bitMask;
|
||||
uint8_t r = 0;
|
||||
|
||||
for (bitMask = 0x01; bitMask; bitMask <<= 1) {
|
||||
if ( OneWire::read_bit()) r |= bitMask;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
void OneWire::read_bytes(uint8_t *buf, uint16_t count) {
|
||||
for (uint16_t i = 0 ; i < count ; i++)
|
||||
buf[i] = read();
|
||||
}
|
||||
|
||||
//
|
||||
// Do a ROM select
|
||||
//
|
||||
void OneWire::select(const uint8_t rom[8])
|
||||
{
|
||||
uint8_t i;
|
||||
|
||||
write(0x55); // Choose ROM
|
||||
|
||||
for (i = 0; i < 8; i++) write(rom[i]);
|
||||
}
|
||||
|
||||
//
|
||||
// Do a ROM skip
|
||||
//
|
||||
void OneWire::skip()
|
||||
{
|
||||
write(0xCC); // Skip ROM
|
||||
}
|
||||
|
||||
void OneWire::depower()
|
||||
{
|
||||
noInterrupts();
|
||||
DIRECT_MODE_INPUT(baseReg, bitmask);
|
||||
interrupts();
|
||||
}
|
||||
|
||||
#if ONEWIRE_SEARCH
|
||||
|
||||
//
|
||||
// You need to use this function to start a search again from the beginning.
|
||||
// You do not need to do it for the first search, though you could.
|
||||
//
|
||||
void OneWire::reset_search()
|
||||
{
|
||||
// reset the search state
|
||||
LastDiscrepancy = 0;
|
||||
LastDeviceFlag = false;
|
||||
LastFamilyDiscrepancy = 0;
|
||||
for(int i = 7; ; i--) {
|
||||
ROM_NO[i] = 0;
|
||||
if ( i == 0) break;
|
||||
}
|
||||
}
|
||||
|
||||
// Setup the search to find the device type 'family_code' on the next call
|
||||
// to search(*newAddr) if it is present.
|
||||
//
|
||||
void OneWire::target_search(uint8_t family_code)
|
||||
{
|
||||
// set the search state to find SearchFamily type devices
|
||||
ROM_NO[0] = family_code;
|
||||
for (uint8_t i = 1; i < 8; i++)
|
||||
ROM_NO[i] = 0;
|
||||
LastDiscrepancy = 64;
|
||||
LastFamilyDiscrepancy = 0;
|
||||
LastDeviceFlag = false;
|
||||
}
|
||||
|
||||
//
|
||||
// Perform a search. If this function returns a '1' then it has
|
||||
// enumerated the next device and you may retrieve the ROM from the
|
||||
// OneWire::address variable. If there are no devices, no further
|
||||
// devices, or something horrible happens in the middle of the
|
||||
// enumeration then a 0 is returned. If a new device is found then
|
||||
// its address is copied to newAddr. Use OneWire::reset_search() to
|
||||
// start over.
|
||||
//
|
||||
// --- Replaced by the one from the Dallas Semiconductor web site ---
|
||||
//--------------------------------------------------------------------------
|
||||
// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing
|
||||
// search state.
|
||||
// Return TRUE : device found, ROM number in ROM_NO buffer
|
||||
// FALSE : device not found, end of search
|
||||
//
|
||||
bool OneWire::search(uint8_t *newAddr, bool search_mode /* = true */)
|
||||
{
|
||||
uint8_t id_bit_number;
|
||||
uint8_t last_zero, rom_byte_number;
|
||||
bool search_result;
|
||||
uint8_t id_bit, cmp_id_bit;
|
||||
|
||||
unsigned char rom_byte_mask, search_direction;
|
||||
|
||||
// initialize for search
|
||||
id_bit_number = 1;
|
||||
last_zero = 0;
|
||||
rom_byte_number = 0;
|
||||
rom_byte_mask = 1;
|
||||
search_result = false;
|
||||
|
||||
// if the last call was not the last one
|
||||
if (!LastDeviceFlag) {
|
||||
// 1-Wire reset
|
||||
if (!reset()) {
|
||||
// reset the search
|
||||
LastDiscrepancy = 0;
|
||||
LastDeviceFlag = false;
|
||||
LastFamilyDiscrepancy = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
// issue the search command
|
||||
if (search_mode == true) {
|
||||
write(0xF0); // NORMAL SEARCH
|
||||
} else {
|
||||
write(0xEC); // CONDITIONAL SEARCH
|
||||
}
|
||||
|
||||
// loop to do the search
|
||||
do
|
||||
{
|
||||
// read a bit and its complement
|
||||
id_bit = read_bit();
|
||||
cmp_id_bit = read_bit();
|
||||
|
||||
// check for no devices on 1-wire
|
||||
if ((id_bit == 1) && (cmp_id_bit == 1)) {
|
||||
break;
|
||||
} else {
|
||||
// all devices coupled have 0 or 1
|
||||
if (id_bit != cmp_id_bit) {
|
||||
search_direction = id_bit; // bit write value for search
|
||||
} else {
|
||||
// if this discrepancy if before the Last Discrepancy
|
||||
// on a previous next then pick the same as last time
|
||||
if (id_bit_number < LastDiscrepancy) {
|
||||
search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0);
|
||||
} else {
|
||||
// if equal to last pick 1, if not then pick 0
|
||||
search_direction = (id_bit_number == LastDiscrepancy);
|
||||
}
|
||||
// if 0 was picked then record its position in LastZero
|
||||
if (search_direction == 0) {
|
||||
last_zero = id_bit_number;
|
||||
|
||||
// check for Last discrepancy in family
|
||||
if (last_zero < 9)
|
||||
LastFamilyDiscrepancy = last_zero;
|
||||
}
|
||||
}
|
||||
|
||||
// set or clear the bit in the ROM byte rom_byte_number
|
||||
// with mask rom_byte_mask
|
||||
if (search_direction == 1)
|
||||
ROM_NO[rom_byte_number] |= rom_byte_mask;
|
||||
else
|
||||
ROM_NO[rom_byte_number] &= ~rom_byte_mask;
|
||||
|
||||
// serial number search direction write bit
|
||||
write_bit(search_direction);
|
||||
|
||||
// increment the byte counter id_bit_number
|
||||
// and shift the mask rom_byte_mask
|
||||
id_bit_number++;
|
||||
rom_byte_mask <<= 1;
|
||||
|
||||
// if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask
|
||||
if (rom_byte_mask == 0) {
|
||||
rom_byte_number++;
|
||||
rom_byte_mask = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
while(rom_byte_number < 8); // loop until through all ROM bytes 0-7
|
||||
|
||||
// if the search was successful then
|
||||
if (!(id_bit_number < 65)) {
|
||||
// search successful so set LastDiscrepancy,LastDeviceFlag,search_result
|
||||
LastDiscrepancy = last_zero;
|
||||
|
||||
// check for last device
|
||||
if (LastDiscrepancy == 0) {
|
||||
LastDeviceFlag = true;
|
||||
}
|
||||
search_result = true;
|
||||
}
|
||||
}
|
||||
|
||||
// if no device found then reset counters so next 'search' will be like a first
|
||||
if (!search_result || !ROM_NO[0]) {
|
||||
LastDiscrepancy = 0;
|
||||
LastDeviceFlag = false;
|
||||
LastFamilyDiscrepancy = 0;
|
||||
search_result = false;
|
||||
} else {
|
||||
for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i];
|
||||
}
|
||||
return search_result;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if ONEWIRE_CRC
|
||||
// The 1-Wire CRC scheme is described in Maxim Application Note 27:
|
||||
// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products"
|
||||
//
|
||||
|
||||
#if ONEWIRE_CRC8_TABLE
|
||||
// Dow-CRC using polynomial X^8 + X^5 + X^4 + X^0
|
||||
// Tiny 2x16 entry CRC table created by Arjen Lentz
|
||||
// See http://lentz.com.au/blog/calculating-crc-with-a-tiny-32-entry-lookup-table
|
||||
static const uint8_t PROGMEM dscrc2x16_table[] = {
|
||||
0x00, 0x5E, 0xBC, 0xE2, 0x61, 0x3F, 0xDD, 0x83,
|
||||
0xC2, 0x9C, 0x7E, 0x20, 0xA3, 0xFD, 0x1F, 0x41,
|
||||
0x00, 0x9D, 0x23, 0xBE, 0x46, 0xDB, 0x65, 0xF8,
|
||||
0x8C, 0x11, 0xAF, 0x32, 0xCA, 0x57, 0xE9, 0x74
|
||||
};
|
||||
|
||||
// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
|
||||
// and the registers. (Use tiny 2x16 entry CRC table)
|
||||
uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
|
||||
{
|
||||
uint8_t crc = 0;
|
||||
|
||||
while (len--) {
|
||||
crc = *addr++ ^ crc; // just re-using crc as intermediate
|
||||
crc = pgm_read_byte(dscrc2x16_table + (crc & 0x0f)) ^
|
||||
pgm_read_byte(dscrc2x16_table + 16 + ((crc >> 4) & 0x0f));
|
||||
}
|
||||
|
||||
return crc;
|
||||
}
|
||||
#else
|
||||
//
|
||||
// Compute a Dallas Semiconductor 8 bit CRC directly.
|
||||
// this is much slower, but a little smaller, than the lookup table.
|
||||
//
|
||||
uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
|
||||
{
|
||||
uint8_t crc = 0;
|
||||
|
||||
while (len--) {
|
||||
#if defined(__AVR__)
|
||||
crc = _crc_ibutton_update(crc, *addr++);
|
||||
#else
|
||||
uint8_t inbyte = *addr++;
|
||||
for (uint8_t i = 8; i; i--) {
|
||||
uint8_t mix = (crc ^ inbyte) & 0x01;
|
||||
crc >>= 1;
|
||||
if (mix) crc ^= 0x8C;
|
||||
inbyte >>= 1;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return crc;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if ONEWIRE_CRC16
|
||||
bool OneWire::check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc)
|
||||
{
|
||||
crc = ~crc16(input, len, crc);
|
||||
return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1];
|
||||
}
|
||||
|
||||
uint16_t OneWire::crc16(const uint8_t* input, uint16_t len, uint16_t crc)
|
||||
{
|
||||
#if defined(__AVR__)
|
||||
for (uint16_t i = 0 ; i < len ; i++) {
|
||||
crc = _crc16_update(crc, input[i]);
|
||||
}
|
||||
#else
|
||||
static const uint8_t oddparity[16] =
|
||||
{ 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
|
||||
|
||||
for (uint16_t i = 0 ; i < len ; i++) {
|
||||
// Even though we're just copying a byte from the input,
|
||||
// we'll be doing 16-bit computation with it.
|
||||
uint16_t cdata = input[i];
|
||||
cdata = (cdata ^ crc) & 0xff;
|
||||
crc >>= 8;
|
||||
|
||||
if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4])
|
||||
crc ^= 0xC001;
|
||||
|
||||
cdata <<= 6;
|
||||
crc ^= cdata;
|
||||
cdata <<= 1;
|
||||
crc ^= cdata;
|
||||
}
|
||||
#endif
|
||||
return crc;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
182
Firmware/lib/OneWire/OneWire.h
Normal file
182
Firmware/lib/OneWire/OneWire.h
Normal file
|
@ -0,0 +1,182 @@
|
|||
#ifndef OneWire_h
|
||||
#define OneWire_h
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#if defined(__AVR__)
|
||||
#include <util/crc16.h>
|
||||
#endif
|
||||
|
||||
#if ARDUINO >= 100
|
||||
#include <Arduino.h> // for delayMicroseconds, digitalPinToBitMask, etc
|
||||
#else
|
||||
#include "WProgram.h" // for delayMicroseconds
|
||||
#include "pins_arduino.h" // for digitalPinToBitMask, etc
|
||||
#endif
|
||||
|
||||
// You can exclude certain features from OneWire. In theory, this
|
||||
// might save some space. In practice, the compiler automatically
|
||||
// removes unused code (technically, the linker, using -fdata-sections
|
||||
// and -ffunction-sections when compiling, and Wl,--gc-sections
|
||||
// when linking), so most of these will not result in any code size
|
||||
// reduction. Well, unless you try to use the missing features
|
||||
// and redesign your program to not need them! ONEWIRE_CRC8_TABLE
|
||||
// is the exception, because it selects a fast but large algorithm
|
||||
// or a small but slow algorithm.
|
||||
|
||||
// you can exclude onewire_search by defining that to 0
|
||||
#ifndef ONEWIRE_SEARCH
|
||||
#define ONEWIRE_SEARCH 1
|
||||
#endif
|
||||
|
||||
// You can exclude CRC checks altogether by defining this to 0
|
||||
#ifndef ONEWIRE_CRC
|
||||
#define ONEWIRE_CRC 1
|
||||
#endif
|
||||
|
||||
// Select the table-lookup method of computing the 8-bit CRC
|
||||
// by setting this to 1. The lookup table enlarges code size by
|
||||
// about 250 bytes. It does NOT consume RAM (but did in very
|
||||
// old versions of OneWire). If you disable this, a slower
|
||||
// but very compact algorithm is used.
|
||||
#ifndef ONEWIRE_CRC8_TABLE
|
||||
#define ONEWIRE_CRC8_TABLE 1
|
||||
#endif
|
||||
|
||||
// You can allow 16-bit CRC checks by defining this to 1
|
||||
// (Note that ONEWIRE_CRC must also be 1.)
|
||||
#ifndef ONEWIRE_CRC16
|
||||
#define ONEWIRE_CRC16 1
|
||||
#endif
|
||||
|
||||
// Board-specific macros for direct GPIO
|
||||
#include "util/OneWire_direct_regtype.h"
|
||||
|
||||
class OneWire
|
||||
{
|
||||
private:
|
||||
IO_REG_TYPE bitmask;
|
||||
volatile IO_REG_TYPE *baseReg;
|
||||
|
||||
#if ONEWIRE_SEARCH
|
||||
// global search state
|
||||
unsigned char ROM_NO[8];
|
||||
uint8_t LastDiscrepancy;
|
||||
uint8_t LastFamilyDiscrepancy;
|
||||
bool LastDeviceFlag;
|
||||
#endif
|
||||
|
||||
public:
|
||||
OneWire() { }
|
||||
OneWire(uint8_t pin) { begin(pin); }
|
||||
void begin(uint8_t pin);
|
||||
|
||||
// Perform a 1-Wire reset cycle. Returns 1 if a device responds
|
||||
// with a presence pulse. Returns 0 if there is no device or the
|
||||
// bus is shorted or otherwise held low for more than 250uS
|
||||
uint8_t reset(void);
|
||||
|
||||
// Issue a 1-Wire rom select command, you do the reset first.
|
||||
void select(const uint8_t rom[8]);
|
||||
|
||||
// Issue a 1-Wire rom skip command, to address all on bus.
|
||||
void skip(void);
|
||||
|
||||
// Write a byte. If 'power' is one then the wire is held high at
|
||||
// the end for parasitically powered devices. You are responsible
|
||||
// for eventually depowering it by calling depower() or doing
|
||||
// another read or write.
|
||||
void write(uint8_t v, uint8_t power = 0);
|
||||
|
||||
void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0);
|
||||
|
||||
// Read a byte.
|
||||
uint8_t read(void);
|
||||
|
||||
void read_bytes(uint8_t *buf, uint16_t count);
|
||||
|
||||
// Write a bit. The bus is always left powered at the end, see
|
||||
// note in write() about that.
|
||||
void write_bit(uint8_t v);
|
||||
|
||||
// Read a bit.
|
||||
uint8_t read_bit(void);
|
||||
|
||||
// Stop forcing power onto the bus. You only need to do this if
|
||||
// you used the 'power' flag to write() or used a write_bit() call
|
||||
// and aren't about to do another read or write. You would rather
|
||||
// not leave this powered if you don't have to, just in case
|
||||
// someone shorts your bus.
|
||||
void depower(void);
|
||||
|
||||
#if ONEWIRE_SEARCH
|
||||
// Clear the search state so that if will start from the beginning again.
|
||||
void reset_search();
|
||||
|
||||
// Setup the search to find the device type 'family_code' on the next call
|
||||
// to search(*newAddr) if it is present.
|
||||
void target_search(uint8_t family_code);
|
||||
|
||||
// Look for the next device. Returns 1 if a new address has been
|
||||
// returned. A zero might mean that the bus is shorted, there are
|
||||
// no devices, or you have already retrieved all of them. It
|
||||
// might be a good idea to check the CRC to make sure you didn't
|
||||
// get garbage. The order is deterministic. You will always get
|
||||
// the same devices in the same order.
|
||||
bool search(uint8_t *newAddr, bool search_mode = true);
|
||||
#endif
|
||||
|
||||
#if ONEWIRE_CRC
|
||||
// Compute a Dallas Semiconductor 8 bit CRC, these are used in the
|
||||
// ROM and scratchpad registers.
|
||||
static uint8_t crc8(const uint8_t *addr, uint8_t len);
|
||||
|
||||
#if ONEWIRE_CRC16
|
||||
// Compute the 1-Wire CRC16 and compare it against the received CRC.
|
||||
// Example usage (reading a DS2408):
|
||||
// // Put everything in a buffer so we can compute the CRC easily.
|
||||
// uint8_t buf[13];
|
||||
// buf[0] = 0xF0; // Read PIO Registers
|
||||
// buf[1] = 0x88; // LSB address
|
||||
// buf[2] = 0x00; // MSB address
|
||||
// WriteBytes(net, buf, 3); // Write 3 cmd bytes
|
||||
// ReadBytes(net, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16
|
||||
// if (!CheckCRC16(buf, 11, &buf[11])) {
|
||||
// // Handle error.
|
||||
// }
|
||||
//
|
||||
// @param input - Array of bytes to checksum.
|
||||
// @param len - How many bytes to use.
|
||||
// @param inverted_crc - The two CRC16 bytes in the received data.
|
||||
// This should just point into the received data,
|
||||
// *not* at a 16-bit integer.
|
||||
// @param crc - The crc starting value (optional)
|
||||
// @return True, iff the CRC matches.
|
||||
static bool check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc = 0);
|
||||
|
||||
// Compute a Dallas Semiconductor 16 bit CRC. This is required to check
|
||||
// the integrity of data received from many 1-Wire devices. Note that the
|
||||
// CRC computed here is *not* what you'll get from the 1-Wire network,
|
||||
// for two reasons:
|
||||
// 1) The CRC is transmitted bitwise inverted.
|
||||
// 2) Depending on the endian-ness of your processor, the binary
|
||||
// representation of the two-byte return value may have a different
|
||||
// byte order than the two bytes you get from 1-Wire.
|
||||
// @param input - Array of bytes to checksum.
|
||||
// @param len - How many bytes to use.
|
||||
// @param crc - The crc starting value (optional)
|
||||
// @return The CRC16, as defined by Dallas Semiconductor.
|
||||
static uint16_t crc16(const uint8_t* input, uint16_t len, uint16_t crc = 0);
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
|
||||
// Prevent this name from leaking into Arduino sketches
|
||||
#ifdef IO_REG_TYPE
|
||||
#undef IO_REG_TYPE
|
||||
#endif
|
||||
|
||||
#endif // __cplusplus
|
||||
#endif // OneWire_h
|
420
Firmware/lib/OneWire/util/OneWire_direct_gpio.h
Normal file
420
Firmware/lib/OneWire/util/OneWire_direct_gpio.h
Normal file
|
@ -0,0 +1,420 @@
|
|||
#ifndef OneWire_Direct_GPIO_h
|
||||
#define OneWire_Direct_GPIO_h
|
||||
|
||||
// This header should ONLY be included by OneWire.cpp. These defines are
|
||||
// meant to be private, used within OneWire.cpp, but not exposed to Arduino
|
||||
// sketches or other libraries which may include OneWire.h.
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
// Platform specific I/O definitions
|
||||
|
||||
#if defined(__AVR__)
|
||||
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
|
||||
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
|
||||
#define IO_REG_TYPE uint8_t
|
||||
#define IO_REG_BASE_ATTR asm("r30")
|
||||
#define IO_REG_MASK_ATTR
|
||||
#if defined(__AVR_ATmega4809__)
|
||||
#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
|
||||
#define DIRECT_MODE_INPUT(base, mask) ((*((base)-8)) &= ~(mask))
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)-8)) |= (mask))
|
||||
#define DIRECT_WRITE_LOW(base, mask) ((*((base)-4)) &= ~(mask))
|
||||
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)-4)) |= (mask))
|
||||
#else
|
||||
#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
|
||||
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) &= ~(mask))
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+1)) |= (mask))
|
||||
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+2)) &= ~(mask))
|
||||
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+2)) |= (mask))
|
||||
#endif
|
||||
|
||||
#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
|
||||
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
|
||||
#define PIN_TO_BITMASK(pin) (1)
|
||||
#define IO_REG_TYPE uint8_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR __attribute__ ((unused))
|
||||
#define DIRECT_READ(base, mask) (*((base)+512))
|
||||
#define DIRECT_MODE_INPUT(base, mask) (*((base)+640) = 0)
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+640) = 1)
|
||||
#define DIRECT_WRITE_LOW(base, mask) (*((base)+256) = 1)
|
||||
#define DIRECT_WRITE_HIGH(base, mask) (*((base)+128) = 1)
|
||||
|
||||
#elif defined(__MKL26Z64__)
|
||||
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
|
||||
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
|
||||
#define IO_REG_TYPE uint8_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, mask) ((*((base)+16) & (mask)) ? 1 : 0)
|
||||
#define DIRECT_MODE_INPUT(base, mask) (*((base)+20) &= ~(mask))
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+20) |= (mask))
|
||||
#define DIRECT_WRITE_LOW(base, mask) (*((base)+8) = (mask))
|
||||
#define DIRECT_WRITE_HIGH(base, mask) (*((base)+4) = (mask))
|
||||
|
||||
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
|
||||
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
|
||||
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, mask) ((*((base)+2) & (mask)) ? 1 : 0)
|
||||
#define DIRECT_MODE_INPUT(base, mask) (*((base)+1) &= ~(mask))
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+1) |= (mask))
|
||||
#define DIRECT_WRITE_LOW(base, mask) (*((base)+34) = (mask))
|
||||
#define DIRECT_WRITE_HIGH(base, mask) (*((base)+33) = (mask))
|
||||
|
||||
#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__)
|
||||
// Arduino 1.5.1 may have a bug in delayMicroseconds() on Arduino Due.
|
||||
// http://arduino.cc/forum/index.php/topic,141030.msg1076268.html#msg1076268
|
||||
// If you have trouble with OneWire on Arduino Due, please check the
|
||||
// status of delayMicroseconds() before reporting a bug in OneWire!
|
||||
#define PIN_TO_BASEREG(pin) (&(digitalPinToPort(pin)->PIO_PER))
|
||||
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, mask) (((*((base)+15)) & (mask)) ? 1 : 0)
|
||||
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+5)) = (mask))
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+4)) = (mask))
|
||||
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+13)) = (mask))
|
||||
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+12)) = (mask))
|
||||
#ifndef PROGMEM
|
||||
#define PROGMEM
|
||||
#endif
|
||||
#ifndef pgm_read_byte
|
||||
#define pgm_read_byte(addr) (*(const uint8_t *)(addr))
|
||||
#endif
|
||||
|
||||
#elif defined(__PIC32MX__)
|
||||
#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin)))
|
||||
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0) //PORTX + 0x10
|
||||
#define DIRECT_MODE_INPUT(base, mask) ((*(base+2)) = (mask)) //TRISXSET + 0x08
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) = (mask)) //TRISXCLR + 0x04
|
||||
#define DIRECT_WRITE_LOW(base, mask) ((*(base+8+1)) = (mask)) //LATXCLR + 0x24
|
||||
#define DIRECT_WRITE_HIGH(base, mask) ((*(base+8+2)) = (mask)) //LATXSET + 0x28
|
||||
|
||||
#elif defined(ARDUINO_ARCH_ESP8266)
|
||||
// Special note: I depend on the ESP community to maintain these definitions and
|
||||
// submit good pull requests. I can not answer any ESP questions or help you
|
||||
// resolve any problems related to ESP chips. Please do not contact me and please
|
||||
// DO NOT CREATE GITHUB ISSUES for ESP support. All ESP questions must be asked
|
||||
// on ESP community forums.
|
||||
#define PIN_TO_BASEREG(pin) ((volatile uint32_t*) GPO)
|
||||
#define PIN_TO_BITMASK(pin) (1 << pin)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, mask) ((GPI & (mask)) ? 1 : 0) //GPIO_IN_ADDRESS
|
||||
#define DIRECT_MODE_INPUT(base, mask) (GPE &= ~(mask)) //GPIO_ENABLE_W1TC_ADDRESS
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) (GPE |= (mask)) //GPIO_ENABLE_W1TS_ADDRESS
|
||||
#define DIRECT_WRITE_LOW(base, mask) (GPOC = (mask)) //GPIO_OUT_W1TC_ADDRESS
|
||||
#define DIRECT_WRITE_HIGH(base, mask) (GPOS = (mask)) //GPIO_OUT_W1TS_ADDRESS
|
||||
|
||||
#elif defined(ARDUINO_ARCH_ESP32)
|
||||
#include <driver/rtc_io.h>
|
||||
#define PIN_TO_BASEREG(pin) (0)
|
||||
#define PIN_TO_BITMASK(pin) (pin)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
IO_REG_TYPE directRead(IO_REG_TYPE pin)
|
||||
{
|
||||
if ( pin < 32 )
|
||||
return (GPIO.in >> pin) & 0x1;
|
||||
else if ( pin < 40 )
|
||||
return (GPIO.in1.val >> (pin - 32)) & 0x1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directWriteLow(IO_REG_TYPE pin)
|
||||
{
|
||||
if ( pin < 32 )
|
||||
GPIO.out_w1tc = ((uint32_t)1 << pin);
|
||||
else if ( pin < 34 )
|
||||
GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32));
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directWriteHigh(IO_REG_TYPE pin)
|
||||
{
|
||||
if ( pin < 32 )
|
||||
GPIO.out_w1ts = ((uint32_t)1 << pin);
|
||||
else if ( pin < 34 )
|
||||
GPIO.out1_w1ts.val = ((uint32_t)1 << (pin - 32));
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directModeInput(IO_REG_TYPE pin)
|
||||
{
|
||||
if ( digitalPinIsValid(pin) )
|
||||
{
|
||||
uint32_t rtc_reg(rtc_gpio_desc[pin].reg);
|
||||
|
||||
if ( rtc_reg ) // RTC pins PULL settings
|
||||
{
|
||||
ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux);
|
||||
ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown);
|
||||
}
|
||||
|
||||
if ( pin < 32 )
|
||||
GPIO.enable_w1tc = ((uint32_t)1 << pin);
|
||||
else
|
||||
GPIO.enable1_w1tc.val = ((uint32_t)1 << (pin - 32));
|
||||
|
||||
uint32_t pinFunction((uint32_t)2 << FUN_DRV_S); // what are the drivers?
|
||||
pinFunction |= FUN_IE; // input enable but required for output as well?
|
||||
pinFunction |= ((uint32_t)2 << MCU_SEL_S);
|
||||
|
||||
ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction;
|
||||
|
||||
GPIO.pin[pin].val = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directModeOutput(IO_REG_TYPE pin)
|
||||
{
|
||||
if ( digitalPinIsValid(pin) && pin <= 33 ) // pins above 33 can be only inputs
|
||||
{
|
||||
uint32_t rtc_reg(rtc_gpio_desc[pin].reg);
|
||||
|
||||
if ( rtc_reg ) // RTC pins PULL settings
|
||||
{
|
||||
ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux);
|
||||
ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown);
|
||||
}
|
||||
|
||||
if ( pin < 32 )
|
||||
GPIO.enable_w1ts = ((uint32_t)1 << pin);
|
||||
else // already validated to pins <= 33
|
||||
GPIO.enable1_w1ts.val = ((uint32_t)1 << (pin - 32));
|
||||
|
||||
uint32_t pinFunction((uint32_t)2 << FUN_DRV_S); // what are the drivers?
|
||||
pinFunction |= FUN_IE; // input enable but required for output as well?
|
||||
pinFunction |= ((uint32_t)2 << MCU_SEL_S);
|
||||
|
||||
ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction;
|
||||
|
||||
GPIO.pin[pin].val = 0;
|
||||
}
|
||||
}
|
||||
|
||||
#define DIRECT_READ(base, pin) directRead(pin)
|
||||
#define DIRECT_WRITE_LOW(base, pin) directWriteLow(pin)
|
||||
#define DIRECT_WRITE_HIGH(base, pin) directWriteHigh(pin)
|
||||
#define DIRECT_MODE_INPUT(base, pin) directModeInput(pin)
|
||||
#define DIRECT_MODE_OUTPUT(base, pin) directModeOutput(pin)
|
||||
// https://github.com/PaulStoffregen/OneWire/pull/47
|
||||
// https://github.com/stickbreaker/OneWire/commit/6eb7fc1c11a15b6ac8c60e5671cf36eb6829f82c
|
||||
#ifdef interrupts
|
||||
#undef interrupts
|
||||
#endif
|
||||
#ifdef noInterrupts
|
||||
#undef noInterrupts
|
||||
#endif
|
||||
#define noInterrupts() {portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;portENTER_CRITICAL(&mux)
|
||||
#define interrupts() portEXIT_CRITICAL(&mux);}
|
||||
//#warning "ESP32 OneWire testing"
|
||||
|
||||
#elif defined(ARDUINO_ARCH_STM32)
|
||||
#define PIN_TO_BASEREG(pin) (0)
|
||||
#define PIN_TO_BITMASK(pin) ((uint32_t)digitalPinToPinName(pin))
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, pin) digitalReadFast((PinName)pin)
|
||||
#define DIRECT_WRITE_LOW(base, pin) digitalWriteFast((PinName)pin, LOW)
|
||||
#define DIRECT_WRITE_HIGH(base, pin) digitalWriteFast((PinName)pin, HIGH)
|
||||
#define DIRECT_MODE_INPUT(base, pin) pin_function((PinName)pin, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0))
|
||||
#define DIRECT_MODE_OUTPUT(base, pin) pin_function((PinName)pin, STM_PIN_DATA(STM_MODE_OUTPUT_PP, GPIO_NOPULL, 0))
|
||||
|
||||
#elif defined(__SAMD21G18A__)
|
||||
#define PIN_TO_BASEREG(pin) portModeRegister(digitalPinToPort(pin))
|
||||
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, mask) (((*((base)+8)) & (mask)) ? 1 : 0)
|
||||
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) = (mask))
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+2)) = (mask))
|
||||
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+5)) = (mask))
|
||||
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+6)) = (mask))
|
||||
|
||||
#elif defined(RBL_NRF51822)
|
||||
#define PIN_TO_BASEREG(pin) (0)
|
||||
#define PIN_TO_BITMASK(pin) (pin)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, pin) nrf_gpio_pin_read(pin)
|
||||
#define DIRECT_WRITE_LOW(base, pin) nrf_gpio_pin_clear(pin)
|
||||
#define DIRECT_WRITE_HIGH(base, pin) nrf_gpio_pin_set(pin)
|
||||
#define DIRECT_MODE_INPUT(base, pin) nrf_gpio_cfg_input(pin, NRF_GPIO_PIN_NOPULL)
|
||||
#define DIRECT_MODE_OUTPUT(base, pin) nrf_gpio_cfg_output(pin)
|
||||
|
||||
#elif defined(__arc__) /* Arduino101/Genuino101 specifics */
|
||||
|
||||
#include "scss_registers.h"
|
||||
#include "portable.h"
|
||||
#include "avr/pgmspace.h"
|
||||
|
||||
#define GPIO_ID(pin) (g_APinDescription[pin].ulGPIOId)
|
||||
#define GPIO_TYPE(pin) (g_APinDescription[pin].ulGPIOType)
|
||||
#define GPIO_BASE(pin) (g_APinDescription[pin].ulGPIOBase)
|
||||
#define DIR_OFFSET_SS 0x01
|
||||
#define DIR_OFFSET_SOC 0x04
|
||||
#define EXT_PORT_OFFSET_SS 0x0A
|
||||
#define EXT_PORT_OFFSET_SOC 0x50
|
||||
|
||||
/* GPIO registers base address */
|
||||
#define PIN_TO_BASEREG(pin) ((volatile uint32_t *)g_APinDescription[pin].ulGPIOBase)
|
||||
#define PIN_TO_BITMASK(pin) pin
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
IO_REG_TYPE directRead(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
|
||||
{
|
||||
IO_REG_TYPE ret;
|
||||
if (SS_GPIO == GPIO_TYPE(pin)) {
|
||||
ret = READ_ARC_REG(((IO_REG_TYPE)base + EXT_PORT_OFFSET_SS));
|
||||
} else {
|
||||
ret = MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, EXT_PORT_OFFSET_SOC);
|
||||
}
|
||||
return ((ret >> GPIO_ID(pin)) & 0x01);
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directModeInput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
|
||||
{
|
||||
if (SS_GPIO == GPIO_TYPE(pin)) {
|
||||
WRITE_ARC_REG(READ_ARC_REG((((IO_REG_TYPE)base) + DIR_OFFSET_SS)) & ~(0x01 << GPIO_ID(pin)),
|
||||
((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
|
||||
} else {
|
||||
MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) &= ~(0x01 << GPIO_ID(pin));
|
||||
}
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directModeOutput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
|
||||
{
|
||||
if (SS_GPIO == GPIO_TYPE(pin)) {
|
||||
WRITE_ARC_REG(READ_ARC_REG(((IO_REG_TYPE)(base) + DIR_OFFSET_SS)) | (0x01 << GPIO_ID(pin)),
|
||||
((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
|
||||
} else {
|
||||
MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) |= (0x01 << GPIO_ID(pin));
|
||||
}
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directWriteLow(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
|
||||
{
|
||||
if (SS_GPIO == GPIO_TYPE(pin)) {
|
||||
WRITE_ARC_REG(READ_ARC_REG(base) & ~(0x01 << GPIO_ID(pin)), base);
|
||||
} else {
|
||||
MMIO_REG_VAL(base) &= ~(0x01 << GPIO_ID(pin));
|
||||
}
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directWriteHigh(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
|
||||
{
|
||||
if (SS_GPIO == GPIO_TYPE(pin)) {
|
||||
WRITE_ARC_REG(READ_ARC_REG(base) | (0x01 << GPIO_ID(pin)), base);
|
||||
} else {
|
||||
MMIO_REG_VAL(base) |= (0x01 << GPIO_ID(pin));
|
||||
}
|
||||
}
|
||||
|
||||
#define DIRECT_READ(base, pin) directRead(base, pin)
|
||||
#define DIRECT_MODE_INPUT(base, pin) directModeInput(base, pin)
|
||||
#define DIRECT_MODE_OUTPUT(base, pin) directModeOutput(base, pin)
|
||||
#define DIRECT_WRITE_LOW(base, pin) directWriteLow(base, pin)
|
||||
#define DIRECT_WRITE_HIGH(base, pin) directWriteHigh(base, pin)
|
||||
|
||||
#elif defined(__riscv)
|
||||
|
||||
/*
|
||||
* Tested on highfive1
|
||||
*
|
||||
* Stable results are achieved operating in the
|
||||
* two high speed modes of the highfive1. It
|
||||
* seems to be less reliable in slow mode.
|
||||
*/
|
||||
#define PIN_TO_BASEREG(pin) (0)
|
||||
#define PIN_TO_BITMASK(pin) digitalPinToBitMask(pin)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
IO_REG_TYPE directRead(IO_REG_TYPE mask)
|
||||
{
|
||||
return ((GPIO_REG(GPIO_INPUT_VAL) & mask) != 0) ? 1 : 0;
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directModeInput(IO_REG_TYPE mask)
|
||||
{
|
||||
GPIO_REG(GPIO_OUTPUT_XOR) &= ~mask;
|
||||
GPIO_REG(GPIO_IOF_EN) &= ~mask;
|
||||
|
||||
GPIO_REG(GPIO_INPUT_EN) |= mask;
|
||||
GPIO_REG(GPIO_OUTPUT_EN) &= ~mask;
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directModeOutput(IO_REG_TYPE mask)
|
||||
{
|
||||
GPIO_REG(GPIO_OUTPUT_XOR) &= ~mask;
|
||||
GPIO_REG(GPIO_IOF_EN) &= ~mask;
|
||||
|
||||
GPIO_REG(GPIO_INPUT_EN) &= ~mask;
|
||||
GPIO_REG(GPIO_OUTPUT_EN) |= mask;
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directWriteLow(IO_REG_TYPE mask)
|
||||
{
|
||||
GPIO_REG(GPIO_OUTPUT_VAL) &= ~mask;
|
||||
}
|
||||
|
||||
static inline __attribute__((always_inline))
|
||||
void directWriteHigh(IO_REG_TYPE mask)
|
||||
{
|
||||
GPIO_REG(GPIO_OUTPUT_VAL) |= mask;
|
||||
}
|
||||
|
||||
#define DIRECT_READ(base, mask) directRead(mask)
|
||||
#define DIRECT_WRITE_LOW(base, mask) directWriteLow(mask)
|
||||
#define DIRECT_WRITE_HIGH(base, mask) directWriteHigh(mask)
|
||||
#define DIRECT_MODE_INPUT(base, mask) directModeInput(mask)
|
||||
#define DIRECT_MODE_OUTPUT(base, mask) directModeOutput(mask)
|
||||
|
||||
#else
|
||||
#define PIN_TO_BASEREG(pin) (0)
|
||||
#define PIN_TO_BITMASK(pin) (pin)
|
||||
#define IO_REG_TYPE unsigned int
|
||||
#define IO_REG_BASE_ATTR
|
||||
#define IO_REG_MASK_ATTR
|
||||
#define DIRECT_READ(base, pin) digitalRead(pin)
|
||||
#define DIRECT_WRITE_LOW(base, pin) digitalWrite(pin, LOW)
|
||||
#define DIRECT_WRITE_HIGH(base, pin) digitalWrite(pin, HIGH)
|
||||
#define DIRECT_MODE_INPUT(base, pin) pinMode(pin,INPUT)
|
||||
#define DIRECT_MODE_OUTPUT(base, pin) pinMode(pin,OUTPUT)
|
||||
#warning "OneWire. Fallback mode. Using API calls for pinMode,digitalRead and digitalWrite. Operation of this library is not guaranteed on this architecture."
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
52
Firmware/lib/OneWire/util/OneWire_direct_regtype.h
Normal file
52
Firmware/lib/OneWire/util/OneWire_direct_regtype.h
Normal file
|
@ -0,0 +1,52 @@
|
|||
#ifndef OneWire_Direct_RegType_h
|
||||
#define OneWire_Direct_RegType_h
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
// Platform specific I/O register type
|
||||
|
||||
#if defined(__AVR__)
|
||||
#define IO_REG_TYPE uint8_t
|
||||
|
||||
#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
|
||||
#define IO_REG_TYPE uint8_t
|
||||
|
||||
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#elif defined(__MKL26Z64__)
|
||||
#define IO_REG_TYPE uint8_t
|
||||
|
||||
#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#elif defined(__PIC32MX__)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#elif defined(ARDUINO_ARCH_ESP8266)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#elif defined(ARDUINO_ARCH_ESP32)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
#define IO_REG_MASK_ATTR
|
||||
|
||||
#elif defined(ARDUINO_ARCH_STM32)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#elif defined(__SAMD21G18A__)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#elif defined(RBL_NRF51822)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#elif defined(__arc__) /* Arduino101/Genuino101 specifics */
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#elif defined(__riscv)
|
||||
#define IO_REG_TYPE uint32_t
|
||||
|
||||
#else
|
||||
#define IO_REG_TYPE unsigned int
|
||||
|
||||
#endif
|
||||
#endif
|
|
@ -87,6 +87,13 @@
|
|||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef DS18B20_PIN
|
||||
#include <OneWire.h>
|
||||
#include <DallasTemperature.h>
|
||||
OneWire oneWire(DS18B20_PIN);
|
||||
DallasTemperature sensors(&oneWire);
|
||||
#endif
|
||||
|
||||
// Global Variable to Track Deep Sleep
|
||||
uint16_t sleep_interval;
|
||||
|
||||
|
@ -266,6 +273,10 @@ void setup()
|
|||
PCMSK0 = (1<<ALARM_INT);
|
||||
pinMode(ALARM_PIN, INPUT_PULLUP);
|
||||
#endif
|
||||
|
||||
#ifdef DS18B20_POWER
|
||||
pinMode(DS18B20_POWER, OUTPUT); // set power pin for DS18B20 to output
|
||||
#endif
|
||||
|
||||
// Setup LED if defined
|
||||
#ifdef LED_PIN
|
||||
|
@ -329,6 +340,13 @@ void loop()
|
|||
int32_t pressure;
|
||||
uint8_t alarm;
|
||||
} __attribute__ ((packed)) data;
|
||||
#elif defined DS18B20_PIN
|
||||
struct lora_data {
|
||||
uint8_t bat;
|
||||
uint8_t count; //sensor count
|
||||
int temp1;
|
||||
int temp2; //fixme dynamic values via count
|
||||
} __attribute__ ((packed)) data;
|
||||
#endif
|
||||
|
||||
// Get Sensor Data
|
||||
|
@ -350,6 +368,25 @@ void loop()
|
|||
alarm = false;
|
||||
#endif
|
||||
|
||||
#if defined DS18B20_PIN
|
||||
|
||||
#ifdef DS18B20_POWER
|
||||
digitalWrite(DS18B20_POWER, HIGH); // turn DS18B20 sensor on
|
||||
#endif
|
||||
delay(100); // Allow 5ms for the sensor to be ready
|
||||
sensors.begin(); //start up temp sensor
|
||||
delay(100);
|
||||
data.count = sensors.getDeviceCount();
|
||||
blink(data.count);
|
||||
sensors.requestTemperatures(); // Get the temperature
|
||||
data.temp1=(sensors.getTempCByIndex(0)*100); // Read first sensor and convert to integer
|
||||
//Fixme , add more dynamic code
|
||||
data.temp2=(sensors.getTempCByIndex(1)*100); // Read second sensor and convert to integer
|
||||
#ifdef DS18B20_POWER
|
||||
digitalWrite(DS18B20_POWER, LOW); // turn DS18B20 off
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Add Battery Voltage, 20mv steps, encoded into 1 Byte
|
||||
uint32_t batv = readVcc();
|
||||
data.bat = (uint8_t)(batv/20);
|
||||
|
|
|
@ -26,6 +26,20 @@
|
|||
* Alarm
|
||||
#define ALARM_PIN PIN_A0 - The pin defined here will trigger an immideate send if pulled low.
|
||||
|
||||
* DS18B20
|
||||
Attention!
|
||||
If you want to use DS18B20 sensors, the Onewire Library requires a clock frequency of 8MHz.
|
||||
The value in platformio.ini must be adjusted accordingly
|
||||
|
||||
#define DS18B20_PIN PIN_A0 - DS18B20 Temperature sensor(s) connected on D10/ATtiny pin13
|
||||
|
||||
Currently 2 sensors are implemented, for more sensors either copy the lines or improve the code
|
||||
in main.cpp
|
||||
|
||||
If you want to turn your sensor(s) on and off connect Vdd Pin of DS18B20 with Pin defined here
|
||||
#define DS18B20_POWER PIN_A1 - DS18B20 Power pin is connected on D9/ATtiny pin 12
|
||||
|
||||
|
||||
* Time between Measurements
|
||||
#define SLEEP_TIME 528 - Time in Seconds between Measurements. Try it out to get a good Approximation
|
||||
Examples from my Tests::
|
||||
|
@ -37,6 +51,7 @@
|
|||
|
||||
|
||||
// LoRa RFM95 + SHT21, LED on Pin A7
|
||||
|
||||
#define RF_LORA
|
||||
#define HAS_SHT21
|
||||
#define LED_PIN PIN_A7
|
||||
|
@ -46,6 +61,7 @@
|
|||
unsigned char AppSkey[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
unsigned char DevAddr[4] = { 0x00, 0x00, 0x00, 0x00 };
|
||||
|
||||
|
||||
/* RFM69 + BME280, LED on Pin A7
|
||||
#define RF_RFM69
|
||||
#define HAS_BME280
|
||||
|
@ -73,4 +89,13 @@
|
|||
#define ALARM_PIN PIN_A0
|
||||
#define LED_PIN PIN_A7
|
||||
#define SLEEP_TIME 544
|
||||
*/
|
||||
*/
|
||||
|
||||
// Lora RFM95 + DS18B20
|
||||
/*
|
||||
#define RF_LORA
|
||||
#define LED_PIN PIN_A7
|
||||
#define DS18B20_PIN PIN_A0 // DS18B20 Temperature sensor(s) connected on D10/ATtiny pin13
|
||||
#define DS18B20_POWER PIN_A1 // DS18B20 Power pin(s) connected on D9/ATtiny pin 12
|
||||
#define SLEEP_TIME 544
|
||||
*/
|
||||
|
|
Loading…
Reference in a new issue