From 73fdbdf50e1d024eea755407765991ed5c61c90b Mon Sep 17 00:00:00 2001 From: "Matthias P. Braendli" Date: Sat, 19 Oct 2019 15:25:33 +0200 Subject: Restructure lib, add uart --- sw/lib/DallasTemperature.cpp | 928 +++++++++++++++ sw/lib/DallasTemperature.h | 269 +++++ sw/lib/DallasTemperature/DallasTemperature.cpp | 928 --------------- sw/lib/DallasTemperature/DallasTemperature.h | 269 ----- sw/lib/LTC2400/LTC24XX_general.cpp | 434 ------- sw/lib/LTC2400/LTC24XX_general.h | 501 -------- sw/lib/LTC24XX_general.cpp | 434 +++++++ sw/lib/LTC24XX_general.h | 501 ++++++++ sw/lib/OneWire.cpp | 580 +++++++++ sw/lib/OneWire.h | 182 +++ sw/lib/OneWire/OneWire.cpp | 580 --------- sw/lib/OneWire/OneWire.h | 182 --- sw/lib/OneWire/util/OneWire_direct_gpio.h | 420 ------- sw/lib/OneWire/util/OneWire_direct_regtype.h | 52 - sw/lib/uart.c | 1522 ++++++++++++++++++++++++ sw/lib/uart.h | 436 +++++++ sw/lib/util/OneWire_direct_gpio.h | 420 +++++++ sw/lib/util/OneWire_direct_regtype.h | 52 + 18 files changed, 5324 insertions(+), 3366 deletions(-) create mode 100644 sw/lib/DallasTemperature.cpp create mode 100644 sw/lib/DallasTemperature.h delete mode 100644 sw/lib/DallasTemperature/DallasTemperature.cpp delete mode 100644 sw/lib/DallasTemperature/DallasTemperature.h delete mode 100644 sw/lib/LTC2400/LTC24XX_general.cpp delete mode 100644 sw/lib/LTC2400/LTC24XX_general.h create mode 100644 sw/lib/LTC24XX_general.cpp create mode 100644 sw/lib/LTC24XX_general.h create mode 100644 sw/lib/OneWire.cpp create mode 100644 sw/lib/OneWire.h delete mode 100644 sw/lib/OneWire/OneWire.cpp delete mode 100644 sw/lib/OneWire/OneWire.h delete mode 100644 sw/lib/OneWire/util/OneWire_direct_gpio.h delete mode 100644 sw/lib/OneWire/util/OneWire_direct_regtype.h create mode 100644 sw/lib/uart.c create mode 100644 sw/lib/uart.h create mode 100644 sw/lib/util/OneWire_direct_gpio.h create mode 100644 sw/lib/util/OneWire_direct_regtype.h (limited to 'sw/lib') diff --git a/sw/lib/DallasTemperature.cpp b/sw/lib/DallasTemperature.cpp new file mode 100644 index 0000000..a1107ec --- /dev/null +++ b/sw/lib/DallasTemperature.cpp @@ -0,0 +1,928 @@ +// 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 + useExternalPullup = false; +} +DallasTemperature::DallasTemperature(OneWire* _oneWire) +{ + setOneWire(_oneWire); +#if REQUIRESALARMS + setAlarmHandler(NO_ALARM_HANDLER); +#endif + useExternalPullup = false; +} + +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; + } +} + +/* + * Constructs DallasTemperature with strong pull-up turned on. Strong pull-up is mandated in DS18B20 datasheet for parasitic + * power (2 wires) setup. (https://datasheets.maximintegrated.com/en/ds/DS18B20.pdf, p. 7, section 'Powering the DS18B20'). + */ +DallasTemperature::DallasTemperature(OneWire* _oneWire, uint8_t _pullupPin) : DallasTemperature(_oneWire){ + setPullupPin(_pullupPin); +} + +void DallasTemperature::setPullupPin(uint8_t _pullupPin) { + useExternalPullup = true; + pullupPin = _pullupPin; + pinMode(pullupPin, OUTPUT); + deactivateExternalPullup(); +} + +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 && !isAllZeros(scratchPad) && (_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) { + activateExternalPullup(); + delay(10); // 10ms delay + deactivateExternalPullup(); + } + _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 { + activateExternalPullup(); + delay(delms); + deactivateExternalPullup(); + } + +} + +// 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; + } + +} + +void DallasTemperature::activateExternalPullup() { + if(useExternalPullup) + digitalWrite(pullupPin, LOW); +} + +void DallasTemperature::deactivateExternalPullup() { + if(useExternalPullup) + digitalWrite(pullupPin, HIGH); +} + +// 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) - 32 + + (((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; + +} + +// Returns true if all bytes of scratchPad are '\0' +bool DallasTemperature::isAllZeros(const uint8_t * const scratchPad, const size_t length) { + for (size_t i = 0; i < length; i++) { + if (scratchPad[i] != 0) { + return false; + } + } + + return true; +} + +#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 diff --git a/sw/lib/DallasTemperature.h b/sw/lib/DallasTemperature.h new file mode 100644 index 0000000..49a059d --- /dev/null +++ b/sw/lib/DallasTemperature.h @@ -0,0 +1,269 @@ +#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 +#ifdef __STM32F1__ +#include +#else +#include +#endif + +// 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*); + DallasTemperature(OneWire*, uint8_t); + + void setOneWire(OneWire*); + + void setPullupPin(uint8_t); + + // 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; + + // external pullup + bool useExternalPullup; + uint8_t pullupPin; + + // 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); + + // Returns true if all bytes of scratchPad are '\0' + bool isAllZeros(const uint8_t* const scratchPad, const size_t length = 9); + + // External pullup control + void activateExternalPullup(void); + void deactivateExternalPullup(void); + +#if REQUIRESALARMS + + // required for alarmSearch + uint8_t alarmSearchAddress[8]; + int8_t alarmSearchJunction; + uint8_t alarmSearchExhausted; + + // the alarm handler function pointer + AlarmHandler *_AlarmHandler; + +#endif + +}; +#endif diff --git a/sw/lib/DallasTemperature/DallasTemperature.cpp b/sw/lib/DallasTemperature/DallasTemperature.cpp deleted file mode 100644 index a1107ec..0000000 --- a/sw/lib/DallasTemperature/DallasTemperature.cpp +++ /dev/null @@ -1,928 +0,0 @@ -// 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 - useExternalPullup = false; -} -DallasTemperature::DallasTemperature(OneWire* _oneWire) -{ - setOneWire(_oneWire); -#if REQUIRESALARMS - setAlarmHandler(NO_ALARM_HANDLER); -#endif - useExternalPullup = false; -} - -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; - } -} - -/* - * Constructs DallasTemperature with strong pull-up turned on. Strong pull-up is mandated in DS18B20 datasheet for parasitic - * power (2 wires) setup. (https://datasheets.maximintegrated.com/en/ds/DS18B20.pdf, p. 7, section 'Powering the DS18B20'). - */ -DallasTemperature::DallasTemperature(OneWire* _oneWire, uint8_t _pullupPin) : DallasTemperature(_oneWire){ - setPullupPin(_pullupPin); -} - -void DallasTemperature::setPullupPin(uint8_t _pullupPin) { - useExternalPullup = true; - pullupPin = _pullupPin; - pinMode(pullupPin, OUTPUT); - deactivateExternalPullup(); -} - -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 && !isAllZeros(scratchPad) && (_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) { - activateExternalPullup(); - delay(10); // 10ms delay - deactivateExternalPullup(); - } - _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 { - activateExternalPullup(); - delay(delms); - deactivateExternalPullup(); - } - -} - -// 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; - } - -} - -void DallasTemperature::activateExternalPullup() { - if(useExternalPullup) - digitalWrite(pullupPin, LOW); -} - -void DallasTemperature::deactivateExternalPullup() { - if(useExternalPullup) - digitalWrite(pullupPin, HIGH); -} - -// 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) - 32 - + (((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; - -} - -// Returns true if all bytes of scratchPad are '\0' -bool DallasTemperature::isAllZeros(const uint8_t * const scratchPad, const size_t length) { - for (size_t i = 0; i < length; i++) { - if (scratchPad[i] != 0) { - return false; - } - } - - return true; -} - -#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 diff --git a/sw/lib/DallasTemperature/DallasTemperature.h b/sw/lib/DallasTemperature/DallasTemperature.h deleted file mode 100644 index 49a059d..0000000 --- a/sw/lib/DallasTemperature/DallasTemperature.h +++ /dev/null @@ -1,269 +0,0 @@ -#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 -#ifdef __STM32F1__ -#include -#else -#include -#endif - -// 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*); - DallasTemperature(OneWire*, uint8_t); - - void setOneWire(OneWire*); - - void setPullupPin(uint8_t); - - // 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; - - // external pullup - bool useExternalPullup; - uint8_t pullupPin; - - // 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); - - // Returns true if all bytes of scratchPad are '\0' - bool isAllZeros(const uint8_t* const scratchPad, const size_t length = 9); - - // External pullup control - void activateExternalPullup(void); - void deactivateExternalPullup(void); - -#if REQUIRESALARMS - - // required for alarmSearch - uint8_t alarmSearchAddress[8]; - int8_t alarmSearchJunction; - uint8_t alarmSearchExhausted; - - // the alarm handler function pointer - AlarmHandler *_AlarmHandler; - -#endif - -}; -#endif diff --git a/sw/lib/LTC2400/LTC24XX_general.cpp b/sw/lib/LTC2400/LTC24XX_general.cpp deleted file mode 100644 index 615edff..0000000 --- a/sw/lib/LTC2400/LTC24XX_general.cpp +++ /dev/null @@ -1,434 +0,0 @@ -/*! -LTC24XX General Library: Functions and defines for all SINC4 Delta Sigma ADCs. - -@verbatim - -These functions and defines apply to all No Latency Delta Sigmas in the -LTC2480 EasyDrive family, LTC2410 differential family, LTC2400 single-ended family, -and the LTC2440 High Speed family with selectable speed / resolution. - -It does not cover the LTC2450 tiny, low cost delta sigma ADC famliy. - -Please refer to the No Latency Delta Sigma ADC selector guide available at: - -http://www.linear.com/docs/41341 - - -@endverbatim - -http://www.linear.com/product/LTC2449 - -http://www.linear.com/product/LTC2449#demoboards - -REVISION HISTORY -$Revision: 1807 $ -$Date: 2013-07-29 13:06:06 -0700 (Mon, 29 Jul 2013) $ - -Copyright (c) 2013, Linear Technology Corp.(LTC) -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of Linear Technology Corp. - -The Linear Technology Linduino is not affiliated with the official Arduino team. -However, the Linduino is only possible because of the Arduino team's commitment -to the open-source community. Please, visit http://www.arduino.cc and -http://store.arduino.cc , and consider a purchase that will help fund their -ongoing work. -*/ - -//! @defgroup LTC24XX LTC24XX: All no-latency delta sigma ADCs with SINC4 rejection - -/*! @file - @ingroup LTC24XX - Library for LTC24XX no-latency delta sigma ADCs with SINC4 rejection -*/ - -#include -#include -#include "Linduino.h" -#include -#include "LT_SPI.h" -#include -#include "LT_I2C.h" -#include "LTC24XX_general.h" - - -int8_t LTC24XX_EOC_timeout(uint8_t cs, uint16_t miso_timeout) -// Checks for EOC with a specified timeout (ms) -{ - uint16_t timer_count = 0; // Timer count for MISO - output_low(cs); //! 1) Pull CS low - while (1) //! 2) Wait for SDO (MISO) to go low - { - if (input(MISO) == 0) break; //! 3) If SDO is low, break loop - if (timer_count++>miso_timeout) // If timeout, return 1 (failure) - { - output_high(cs); // Pull CS high - return(1); - } - else - delay(1); - } - output_high(cs); // Pull CS high - return(0); -} - -// Reads from LTC24XX ADC that has no configuration word and a 32 bit output word. -void LTC24XX_SPI_32bit_data(uint8_t cs, int32_t *adc_code) -{ - LT_union_int32_4bytes data, command; // LTC2449 data and command - command.LT_uint32 = 0; // Set to zero, not necessary but avoids - // random data in scope shots. - output_low(cs); //! 1) Pull CS low - - spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)4); //! 2) Transfer arrays - - output_high(cs); //! 3) Pull CS high - *adc_code = data.LT_int32; -} - - -// Reads from a SPI LTC24XX device that has an 8 bit command and a 32 bit output word. -void LTC24XX_SPI_8bit_command_32bit_data(uint8_t cs, uint8_t adc_command, int32_t *adc_code) -{ - LT_union_int32_4bytes data, command; // LTC2449 data and command - command.LT_byte[3] = adc_command; - command.LT_byte[2] = 0; - command.LT_byte[1] = 0; - command.LT_byte[0] = 0; - - output_low(cs); //! 1) Pull CS low - - spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)4); //! 2) Transfer arrays - - output_high(cs); //! 3) Pull CS high - *adc_code = data.LT_int32; -} - - -// Reads from a SPI LTC24XX device that has a 16 bit command and a 32 bit output word. -void LTC24XX_SPI_16bit_command_32bit_data(uint8_t cs, uint8_t adc_command_high, uint8_t adc_command_low, int32_t *adc_code) -{ - - - LT_union_int32_4bytes data, command; // LTC24XX data and command - command.LT_byte[3] = adc_command_high; - command.LT_byte[2] = adc_command_low; - command.LT_byte[1] = 0; - command.LT_byte[0] = 0; - - output_low(cs); //! 1) Pull CS low - spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)4); //! 2) Transfer arrays - output_high(cs); //! 3) Pull CS high - *adc_code = data.LT_int32; -} - -//! Reads from LTC24XX two channel "Ping-Pong" ADC, placing the channel information in the adc_channel parameter -//! and returning the 32 bit result with the channel bit cleared so the data format matches the rest of the family -//! @return void -void LTC24XX_SPI_2ch_ping_pong_32bit_data(uint8_t cs, uint8_t *adc_channel, int32_t *code) -{ - LT_union_int32_4bytes data, command; // ADC data - - command.LT_int32 = 0x00000000; // This is a "don't care" - - spi_transfer_block(cs, command.LT_byte , data.LT_byte, (uint8_t)4); - if(data.LT_byte[3] & 0x40) // Obtains Channel Number - { - *adc_channel = 1; - } - else - { - *adc_channel = 0; - } - data.LT_byte[3] &= 0x3F; // Clear channel bit here so code to voltage function doesn't have to. - *code = data.LT_int32; // Return data -} - -//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. -//! @return void -void LTC24XX_SPI_24bit_data(uint8_t cs, int32_t *adc_code) -{ - LT_union_int32_4bytes data, command; // LTC24XX data and command - command.LT_int32 = 0; - - output_low(cs); //! 1) Pull CS low - spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)3); //! 2) Transfer arrays - output_high(cs); //! 3) Pull CS high - - data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, - data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- - data.LT_byte[1] = data.LT_byte[0]; // justify. - data.LT_byte[0] = 0x00; - - *adc_code = data.LT_int32; -} - -//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 24 bit output word. -//! @return void -void LTC24XX_SPI_8bit_command_24bit_data(uint8_t cs, uint8_t adc_command, int32_t *adc_code) -{ - LT_union_int32_4bytes data, command; // LTC24XX data and command - command.LT_byte[2] = adc_command; - command.LT_byte[1] = 0; - command.LT_byte[0] = 0; - - output_low(cs); //! 1) Pull CS low - spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)3); //! 2) Transfer arrays - output_high(cs); //! 3) Pull CS high - - data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, - data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- - data.LT_byte[1] = data.LT_byte[0]; // justify. - data.LT_byte[0] = 0x00; - - *adc_code = data.LT_int32; -} - -//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 24 bit output word. -//! @return void -void LTC24XX_SPI_16bit_command_24bit_data(uint8_t cs, uint8_t adc_command_high, uint8_t adc_command_low, int32_t *adc_code) -{ - LT_union_int32_4bytes data, command; // LTC24XX data and command - command.LT_byte[2] = adc_command_high; - command.LT_byte[1] = adc_command_low; - command.LT_byte[0] = 0; - - - output_low(cs); //! 1) Pull CS low - spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)3); //! 2) Transfer arrays - output_high(cs); //! 3) Pull CS high - - data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, - data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- - data.LT_byte[1] = data.LT_byte[0]; // justify. - data.LT_byte[0] = 0x00; - - *adc_code = data.LT_int32; -} - -//! Reads from LTC24XX two channel "Ping-Pong" ADC, placing the channel information in the adc_channel parameter -//! and returning the 24 bit result with the channel bit cleared so the data format matches the rest of the family -//! @return void -void LTC24XX_SPI_2ch_ping_pong_24bit_data(uint8_t cs, uint8_t *adc_channel, int32_t *code) -{ - LT_union_int32_4bytes data, command; // ADC data - - command.LT_int32 = 0x00000000; // This is a "don't care" - - spi_transfer_block(cs, command.LT_byte , data.LT_byte, (uint8_t)3); - data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, - data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- - data.LT_byte[1] = data.LT_byte[0]; // justify. - data.LT_byte[0] = 0x00; - - if(data.LT_byte[3] & 0x40) // Obtains Channel Number - { - *adc_channel = 1; - } - else - { - *adc_channel = 0; - } - data.LT_byte[3] &= 0x3F; // Clear channel bit here so code to voltage function doesn't have to. - *code = data.LT_int32; // Return data -} - - -//I2C functions - -//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 24 bit result. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_8bit_command_24bit_data(uint8_t i2c_address, uint8_t adc_command, int32_t *adc_code, uint16_t eoc_timeout) -{ - int8_t ack; - uint16_t timer_count = 0; // Timer count to wait for ACK - int8_t buf[4]; - LT_union_int32_4bytes data; // LTC24XX data - while(1) - { - ack = i2c_read_block_data(i2c_address, adc_command, 3, data.LT_byte); - if(!ack) break; // !ack indicates success - if (timer_count++>eoc_timeout) // If timeout, return 1 (failure) - return(1); - else - delay(1); - } - data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, - data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- - data.LT_byte[1] = data.LT_byte[0]; // justify. - data.LT_byte[0] = 0x00; - data.LT_uint32 >>= 2; // Shifts data 2 bits to the right; operating on unsigned member shifts in zeros. - data.LT_byte[3] = data.LT_byte[3] & 0x3F; // Clear upper 2 bits JUST IN CASE. Now the data format matches the SPI parts. - *adc_code = data.LT_int32; - return(ack); // Success -} - - - -//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. -//! Data is formatted to match the SPI devices, with the MSB in the bit 28 position. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_32bit_data(uint8_t i2c_address, //!< I2C address of device - int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX - uint16_t eoc_timeout //!< Timeout (in milliseconds) - ) -{ - int8_t ack; - uint16_t timer_count = 0; // Timer count to wait for ACK - int8_t buf[4]; - LT_union_int32_4bytes data; // LTC24XX data - while(1) - { - ack = i2c_read_block_data(i2c_address, 4, data.LT_byte); - if(!ack) break; // !ack indicates success - if (timer_count++>eoc_timeout) // If timeout, return 1 (failure) - return(1); - else - delay(1); - } - - data.LT_uint32 >>= 2; // Shifts data 2 bits to the right; operating on unsigned member shifts in zeros. - data.LT_byte[3] = data.LT_byte[3] & 0x3F; // Clear upper 2 bits JUST IN CASE. Now the data format matches the SPI parts. - *adc_code = data.LT_int32; - return(ack); // Success - } - - -//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_8bit_command_32bit_data(uint8_t i2c_address, uint8_t adc_command, int32_t *adc_code, uint16_t eoc_timeout) -{ - int8_t ack; - uint16_t timer_count = 0; // Timer count to wait for ACK - int8_t buf[4]; - LT_union_int32_4bytes data; // LTC24XX data - while(1) - { - ack = i2c_read_block_data(i2c_address, adc_command, 4, data.LT_byte); - if(!ack) break; // !ack indicates success - if (timer_count++>eoc_timeout) // If timeout, return 1 (failure) - return(1); - else - delay(1); - } - - data.LT_uint32 >>= 2; // Shifts data 2 bits to the right; operating on unsigned member shifts in zeros. - data.LT_byte[3] = data.LT_byte[3] & 0x3F; // Clear upper 2 bits JUST IN CASE. Now the data format matches the SPI parts. - *adc_code = data.LT_int32; - return(ack); // Success -} - -//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_16bit_command_32bit_data(uint8_t i2c_address,uint8_t adc_command_high, - uint8_t adc_command_low,int32_t *adc_code,uint16_t eoc_timeout) -{ - int8_t ack; - uint16_t adc_command, timer_count = 0; // Timer count to wait for ACK - int8_t buf[4]; - LT_union_int32_4bytes data; // LTC24XX data - adc_command = (adc_command_high << 8) | adc_command_low; - while(1) - { - ack = i2c_two_byte_command_read_block(i2c_address, adc_command, 4, data.LT_byte); - if(!ack) break; // !ack indicates success - if (timer_count++>eoc_timeout) // If timeout, return 1 (failure) - return(1); - else - delay(1); - } - - data.LT_uint32 >>= 2; // Shifts data 2 bits to the right; operating on unsigned member shifts in zeros. - data.LT_byte[3] = data.LT_byte[3] & 0x3F; // Clear upper 2 bits JUST IN CASE. Now the data format matches the SPI parts. - *adc_code = data.LT_int32; - return(ack); // Success -} - -// Calculates the voltage corresponding to an adc code, given the reference voltage (in volts) -float LTC24XX_SE_code_to_voltage(int32_t adc_code, float vref) -{ - float voltage; - adc_code -= 0x20000000; //! 1) Subtract offset - voltage=(float) adc_code; - voltage = voltage / 268435456.0; //! 2) This calculates the input as a fraction of the reference voltage (dimensionless) - voltage = voltage * vref; //! 3) Multiply fraction by Vref to get the actual voltage at the input (in volts) - return(voltage); -} - -// Calculates the voltage corresponding to an adc code, given the reference voltage (in volts) -// This function handles all differential input parts, including the "single-ended" mode on multichannel -// differential parts. Data from I2C parts must be right-shifted by two bit positions such that the MSB -// is in bit 28 (the same as the SPI parts.) -float LTC24XX_diff_code_to_voltage(int32_t adc_code, float vref) -{ - float voltage; - - #ifndef SKIP_EZDRIVE_2X_ZERO_CHECK - if(adc_code == 0x00000000) - { - adc_code = 0x20000000; - } - #endif - - adc_code -= 0x20000000; //! 1) Converts offset binary to binary - voltage=(float) adc_code; - voltage = voltage / 536870912.0; //! 2) This calculates the input as a fraction of the reference voltage (dimensionless) - voltage = voltage * vref; //! 3) Multiply fraction by Vref to get the actual voltage at the input (in volts) - return(voltage); -} - -// Calculates the voltage corresponding to an adc code, given lsb weight (in volts) and the calibrated -// adc offset code (zero code that is subtracted from adc_code). For use with the LTC24XX_cal_voltage() function. -float LTC24XX_diff_code_to_calibrated_voltage(int32_t adc_code, float LTC2449_lsb, int32_t LTC2449_offset_code) -{ - float adc_voltage; - - #ifndef SKIP_EZDRIVE_2X_ZERO_CHECK - if(adc_code == 0x00000000) - { - adc_code = 0x20000000; - } - #endif - - adc_code -= 536870912; //! 1) Converts offset binary to binary - adc_voltage=(float)(adc_code+LTC2449_offset_code)*LTC2449_lsb; //! 2) Calculate voltage from ADC code, lsb, offset. - return(adc_voltage); -} - - -// Calculate the lsb weight and offset code given a full-scale code and a measured zero-code. -void LTC24XX_calibrate_voltage(int32_t zero_code, int32_t fs_code, float zero_voltage, float fs_voltage, float *LTC24XX_lsb, int32_t *LTC24XX_offset_code) -{ - zero_code -= 536870912; //! 1) Converts zero code from offset binary to binary - fs_code -= 536870912; //! 2) Converts full scale code from offset binary to binary - - float temp_offset; - *LTC24XX_lsb = (fs_voltage-zero_voltage)/((float)(fs_code - zero_code)); //! 3) Calculate the LSB - - temp_offset = (zero_voltage/ *LTC24XX_lsb) - zero_code; //! 4) Calculate Unipolar offset - temp_offset = (temp_offset > (floor(temp_offset) + 0.5)) ? ceil(temp_offset) : floor(temp_offset); //! 5) Round - *LTC24XX_offset_code = (int32_t)temp_offset; //! 6) Cast as int32_t -} diff --git a/sw/lib/LTC2400/LTC24XX_general.h b/sw/lib/LTC2400/LTC24XX_general.h deleted file mode 100644 index 42fd65a..0000000 --- a/sw/lib/LTC2400/LTC24XX_general.h +++ /dev/null @@ -1,501 +0,0 @@ -/*! -LTC24XX General Library: Functions and defines for all SINC4 Delta Sigma ADCs. - -@verbatim - - -LTC2442 / LTC2444 / LTC2445 / LTC2448 / LTC2449 (Are there don't care bits in the low channel counts? -SPI DATA FORMAT (MSB First): - - Byte #1 Byte #2 - -Data Out : !EOC DMY SIG D28 D27 D26 D25 D24 D23 D22 D21 D20 D19 D18 D17 D16 -Data In : 1 0 EN SGL OS S2 S1 S0 OSR3 OSR2 OSR1 OSR1 SPD X X X - - Byte #3 Byte #4 - D15 D14 D13 D12 D11 D10 D9 D8 D7 D6 D5 D4 *D3 *D2 *D1 *D0 - X X X X X X X X X X X X X X X X - -!EOC : End of Conversion Bit (Active Low) -DMY : Dummy Bit (Always 0) -SIG : Sign Bit (1-data positive, 0-data negative) -Dx : Data Bits -*Dx : Data Bits Below lsb -EN : Enable Bit (0-keep previous mode, 1-change mode) -SGL : Enable Single-Ended Bit (0-differential, 1-single-ended) -OS : ODD/Sign Bit -Sx : Address Select Bit -0SRX : Over Sampling Rate Bits -SPD : Double Output Rate Select Bit (0-Normal rate, auto-calibration on, 2x rate, auto_calibration off) - -Command Byte #1 -1 0 EN SGL OS S2 S1 S0 Comments -1 0 0 X X X X X Keep Previous Mode -1 0 1 0 X X X X Differential Mode -1 0 1 1 X X X X Single-Ended Mode - -| Coversion Rate | RMS | ENOB | OSR | Latency -Command Byte #2 |Internal | External | Noise | | | -| 9MHz | 10.24MHz | | | | -OSR3 OSR2 OSR1 OSR1 SPD | Clock | Clock | | | | -0 0 0 0 0 Keep Previous Speed/Resolution -0 0 0 1 0 3.52kHz 4kHz 23uV 17 64 none -0 0 1 0 0 1.76kHz 2kHz 3.5uV 20.1 128 none -0 0 1 1 0 880Hz 1kHz 2uV 21.3 256 none -0 1 0 0 0 440Hz 500Hz 1.4uV 21.8 512 none -0 1 0 1 0 220Hz 250Hz 1uV 22.4 1024 none -0 1 1 0 0 110Hz 125Hz 750nV 22.9 2048 none -0 1 1 1 0 55Hz 62.5Hz 510nV 23.4 4096 none -1 0 0 0 0 27.5Hz 31.25Hz 375nV 24 8192 none -1 0 0 1 0 13.75Hz 15.625Hz 250nV 24.4 16384 none -1 1 1 1 0 6.87kHz 7.8125Hz 200nV 24.6 32768 none -0 0 0 0 1 Keep Previous Speed/Resolution -OSR3 OSR2 OSR1 OSR1 1 2X Mode *all clock speeds double - -Example Code: - -Read Channel 0 in Single-Ended with OSR of 65536 - - uint16_t miso_timeout = 1000; - adc_command = LTC2449_CH0 | LTC2449_OSR_32768 | LTC2449_SPEED_2X; // Build ADC command for channel 0 - // OSR = 32768*2 = 65536 - - if(LTC2449_EOC_timeout(LTC2449_CS, miso_timeout)) // Check for EOC - return; // Exit if timeout is reached - LTC2449_read(LTC2449_CS, adc_command, &adc_code); // Throws out last reading - - if(LTC2449_EOC_timeout(LTC2449_CS, miso_timeout)) // Check for EOC - return; // Exit if timeout is reached - LTC2449_read(LTC2449_CS, adc_command, &adc_code); // Obtains the current reading and stores to adc_code variable - - // Convert adc_code to voltage - adc_voltage = LTC2449_code_to_voltage(adc_code, LTC2449_lsb, LTC2449_offset_code); - -@endverbatim - -http://www.linear.com/product/LTC2449 - -http://www.linear.com/product/LTC2449#demoboards - -REVISION HISTORY -$Revision: 1881 $ -$Date: 2013-08-15 09:16:50 -0700 (Thu, 15 Aug 2013) $ - -Copyright (c) 2013, Linear Technology Corp.(LTC) -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of Linear Technology Corp. - -The Linear Technology Linduino is not affiliated with the official Arduino team. -However, the Linduino is only possible because of the Arduino team's commitment -to the open-source community. Please, visit http://www.arduino.cc and -http://store.arduino.cc , and consider a purchase that will help fund their -ongoing work. -*/ - -/*! @file - @ingroup LTC24XX_general - Header for LTC2449: 24-Bit, 16-Channel Delta Sigma ADCs with Selectable Speed/Resolution -*/ - -#ifndef LTC24XX_general_H -#define LTC24XX_general_H - -//! Define the SPI CS pin -#ifndef LTC24XX_CS -#define LTC24XX_CS QUIKEVAL_CS -#endif - -//! In 2X Mode, A non offset binary 0 can be produced. This is corrected in the -//! differential code to voltage functions. To disable this correction, uncomment -//! The following #define. -//#define SKIP_EZDRIVE_2X_ZERO_CHECK - -/*! @name Mode Configuration for High Speed Family - @{ -*/ -#define LTC24XX_HS_MULTI_KEEP_PREVIOUS_MODE 0x80 -#define LTC24XX_HS_MULTI_KEEP_PREVIOUS_SPEED_RESOLUTION 0x00 -#define LTC24XX_HS_MULTI_SPEED_1X 0x00 -#define LTC24XX_HS_MULTI_SPEED_2X 0x08 -/*! - @} -*/ - -/*! @name Mode Configuration for EasyDrive Family - @{ -*/ -// Select ADC source - differential input or PTAT circuit -#define LTC24XX_EZ_MULTI_VIN 0b10000000 -#define LTC24XX_EZ_MULTI_PTAT 0b11000000 - -// Select rejection frequency - 50, 55, or 60Hz -#define LTC24XX_EZ_MULTI_R50 0b10010000 -#define LTC24XX_EZ_MULTI_R55 0b10000000 -#define LTC24XX_EZ_MULTI_R60 0b10100000 - -// Speed settings is bit 7 in the 2nd byte -#define LTC24XX_EZ_MULTI_SLOW 0b10000000 // slow output rate with autozero -#define LTC24XX_EZ_MULTI_FAST 0b10001000 // fast output rate with no autozero -/*! - @} -*/ - - -/*! @name Single-Ended Channel Configuration -@verbatim -Channel selection for all multi-channel, differential input ADCs, even those that only require -8 bits of configuration (no further options.) Most devices in this category require a second -byte of configuration for speed mode, temperature sensor selection, etc., but for the sake -of simplicity a single function will be used to read all devices, sending zeros in the second -configuration byte if only the channel is specified. - -Applicable devices: -Easy Drive: -LTC2486, LTC2487, LTC2488, LTC2489, LTC2492, LTC2493, -LTC2494, LTC2495, LTC2496, LTC2497, LTC2498, LTC2499 -First Generation Differential: -LTC2414, LTC2418, LTC2439 -High Speed: -LTC2442, LTC2444, LTC2445, LTC2448, LTC2449 -@endverbatim -@{ */ -#define LTC24XX_MULTI_CH_CH0 0xB0 -#define LTC24XX_MULTI_CH_CH1 0xB8 -#define LTC24XX_MULTI_CH_CH2 0xB1 -#define LTC24XX_MULTI_CH_CH3 0xB9 -#define LTC24XX_MULTI_CH_CH4 0xB2 -#define LTC24XX_MULTI_CH_CH5 0xBA -#define LTC24XX_MULTI_CH_CH6 0xB3 -#define LTC24XX_MULTI_CH_CH7 0xBB -#define LTC24XX_MULTI_CH_CH8 0xB4 -#define LTC24XX_MULTI_CH_CH9 0xBC -#define LTC24XX_MULTI_CH_CH10 0xB5 -#define LTC24XX_MULTI_CH_CH11 0xBD -#define LTC24XX_MULTI_CH_CH12 0xB6 -#define LTC24XX_MULTI_CH_CH13 0xBE -#define LTC24XX_MULTI_CH_CH14 0xB7 -#define LTC24XX_MULTI_CH_CH15 0xBF -/*! @} */ - -/*! @name Differential Channel Configuration -@verbatim -See note for single-ended configuration above. - -@endverbatim -@{ */ -#define LTC24XX_MULTI_CH_P0_N1 0xA0 -#define LTC24XX_MULTI_CH_P1_N0 0xA8 - -#define LTC24XX_MULTI_CH_P2_N3 0xA1 -#define LTC24XX_MULTI_CH_P3_N2 0xA9 - -#define LTC24XX_MULTI_CH_P4_N5 0xA2 -#define LTC24XX_MULTI_CH_P5_N4 0xAA - -#define LTC24XX_MULTI_CH_P6_N7 0xA3 -#define LTC24XX_MULTI_CH_P7_N6 0xAB - -#define LTC24XX_MULTI_CH_P8_N9 0xA4 -#define LTC24XX_MULTI_CH_P9_N8 0xAC - -#define LTC24XX_MULTI_CH_P10_N11 0xA5 -#define LTC24XX_MULTI_CH_P11_N10 0xAD - -#define LTC24XX_MULTI_CH_P12_N13 0xA6 -#define LTC24XX_MULTI_CH_P13_N12 0xAE - -#define LTC24XX_MULTI_CH_P14_N15 0xA7 -#define LTC24XX_MULTI_CH_P15_N14 0xAF -/*! @} */ - -/*Commands -Construct a channel / resolution control word by bitwise ORing one choice from the channel configuration -and one choice from the Oversample ratio configuration. You can also enable 2Xmode, which will increase -sample rate by a factor of 2 but introduce one cycle of latency. - -Example - read channel 3 single-ended at OSR2048, with 2X mode enabled. -adc_command = (LTC2449_CH3 | LTC2449_OSR_2048) | LTC2449_SPEED_2X; -*/ - -/*! @name Oversample Ratio (OSR) Commands -@{ */ -#define LTC24XX_MULTI_CH_OSR_64 0x10 -#define LTC24XX_MULTI_CH_OSR_128 0x20 -#define LTC24XX_MULTI_CH_OSR_256 0x30 -#define LTC24XX_MULTI_CH_OSR_512 0x40 -#define LTC24XX_MULTI_CH_OSR_1024 0x50 -#define LTC24XX_MULTI_CH_OSR_2048 0x60 -#define LTC24XX_MULTI_CH_OSR_4096 0x70 -#define LTC24XX_MULTI_CH_OSR_8192 0x80 -#define LTC24XX_MULTI_CH_OSR_16384 0x90 -#define LTC24XX_MULTI_CH_OSR_32768 0xF0 -/*! @}*/ - -//! Checks for EOC with a specified timeout. Applies to all SPI interface delta sigma -//! ADCs that have SINC4 rejection, does NOT apply to LTC2450/60/70 family. -//! @return Returns 0=successful, 1=unsuccessful (exceeded timeout) -int8_t LTC24XX_EOC_timeout(uint8_t cs, //!< Chip Select pin - uint16_t miso_timeout //!< Timeout (in milliseconds) - ); - - -// Read functions for SPI interface ADCs with a 32 bit output word. These functions are used with both -// Single-ended and differential parts, as there is no interpretation of the data done in -// the function. Also note that these functions can be used for devices that have shorter output lengths, -// the lower bits will read out as "1", as the conversion will be triggered by the last data bit being -// read, which causes SDO to go high. - - -//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. -//! @return void -void LTC24XX_SPI_32bit_data(uint8_t cs, //!< Chip Select pin - int32_t *adc_code //!< 4 byte conversion code read from LTC24XX - ); - -//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. -//! @return void -void LTC24XX_SPI_8bit_command_32bit_data(uint8_t cs, //!< Chip Select pin - uint8_t adc_command, //!< 1 byte command written to LTC24XX - int32_t *adc_code //!< 4 byte conversion code read from LTC24XX - ); - -//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. -//! @return void -void LTC24XX_SPI_16bit_command_32bit_data(uint8_t cs, //!< Chip Select pin - uint8_t adc_command_high, //!< First command byte written to LTC24XX - uint8_t adc_command_low, //!< Second command written to LTC24XX - int32_t *adc_code //!< 4 byte conversion code read from LTC24XX - ); - -//! Reads from LTC24XX two channel "Ping-Pong" ADC, placing the channel information in the adc_channel parameter -//! and returning the 32 bit result with the channel bit cleared so the data format matches the rest of the family -//! @return void -void LTC24XX_SPI_2ch_ping_pong_32bit_data(uint8_t cs, //!< Chip Select pin - uint8_t *adc_channel, //!< Returns channel number read. - int32_t *code //!< 4 byte conversion code read from LTC24XX - ); - - -// Read functions for SPI interface ADCs with a 24 bit or 19 bit output word. These functions -// are used with both Single-ended and differential parts, as there is no interpretation of -// the data done in the function. 24 bits will be read out of 19 bit devices -// (LTC2433, LTC2436, LTC2439), with the additional 5 bits being set to 1. - -//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. -//! @return void -void LTC24XX_SPI_24bit_data(uint8_t cs, //!< Chip Select pin - int32_t *adc_code //!< 4 byte conversion code read from LTC24XX - ); - -//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. -//! @return void -void LTC24XX_SPI_8bit_command_24bit_data(uint8_t cs, //!< Chip Select pin - uint8_t adc_command, //!< 1 byte command written to LTC24XX - int32_t *adc_code //!< 4 byte conversion code read from LTC24XX - ); - -//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. -//! @return void -void LTC24XX_SPI_16bit_command_24bit_data(uint8_t cs, //!< Chip Select pin - uint8_t adc_command_high, //!< First command byte written to LTC24XX - uint8_t adc_command_low, //!< Second command written to LTC24XX - int32_t *adc_code //!< 4 byte conversion code read from LTC24XX - ); - -//! Reads from LTC24XX ADC that accepts a 8 bit configuration and returns a 16 bit result. -//! @return void -void LTC24XX_SPI_8bit_command_16bit_data(uint8_t cs, //!< Chip Select pin - uint8_t adc_command, //!< First command byte written to LTC24XX - int32_t *adc_code //!< 4 byte conversion code read from LTC24XX - ); - - -//! Reads from LTC24XX two channel "Ping-Pong" ADC, placing the channel information in the adc_channel parameter -//! and returning the 32 bit result with the channel bit cleared so the data format matches the rest of the family -//! @return void -void LTC24XX_SPI_2ch_ping_pong_24bit_data(uint8_t cs, //!< Chip Select pin - uint8_t *adc_channel, //!< Returns channel number read. - int32_t *code //!< 4 byte conversion code read from LTC24XX - ); - -// Read functions for I2C interface ADCs with a 32 bit output word. These functions are used with both -// Single-ended and differential parts, as there is no interpretation of the data done in -// the function. Also note that these functions can be used for devices that have shorter output lengths, -// the lower bits will read out as "1", as the conversion will be triggered by the last data bit being -// read, which causes SDO to go high. -// Data is formatted to match the SPI devices, with the MSB in the bit 28 position. -// Unlike the SPI members of this family, checking for EOC MUST immediately be followed by reading the data. This -// is because a stop condition will trigger a new conversion. - - -//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_32bit_data(uint8_t i2c_address, //!< I2C address of device - int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX - uint16_t eoc_timeout //!< Timeout (in milliseconds) - ); - - -//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_8bit_command_32bit_data(uint8_t i2c_address, //!< I2C address of device - uint8_t adc_command, //!< 1 byte command written to LTC24XX - int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX - uint16_t eoc_timeout //!< Timeout (in milliseconds) - ); - - -//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_16bit_command_32bit_data(uint8_t i2c_address, //!< I2C address of device - uint8_t adc_command_high, //!< First command byte written to LTC24XX - uint8_t adc_command_low, //!< Second command written to LTC24XX - int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX - uint16_t eoc_timeout //!< Timeout (in milliseconds) - ); - - -// Read functions for I2C interface ADCs with a 24 bit or 19 bit output word. These functions -// are used with both Single-ended and differential parts, as there is no interpretation of -// the data done in the function. 24 bits will be read out of 19 bit devices -// (LTC2433, LTC2436, LTC2439), with the additional 5 bits being set to 1. - - -//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. -//! Applies to: LTC2483 (only this lonely one!) -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_24bit_data(uint8_t i2c_address, //!< I2C address of device - int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX - uint16_t eoc_timeout //!< Timeout (in milliseconds) - ); - - -//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_8bit_command_24bit_data(uint8_t i2c_address, //!< I2C address of device - uint8_t adc_command, //!< 1 byte command written to LTC24XX - int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX - uint16_t eoc_timeout //!< Timeout (in milliseconds) - ); - -//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. -//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. -int8_t LTC24XX_I2C_16bit_command_24bit_data(uint8_t i2c_address, //!< I2C address of device - uint8_t adc_command_high, //!< First command byte written to LTC24XX - uint8_t adc_command_low, //!< Second command written to LTC24XX - int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX - uint16_t eoc_timeout //!< Timeout (in milliseconds) - ); - -//! Calculates the voltage corresponding to an ADC code, given the reference voltage. -//! Applies to Single-Ended input parts (LTC2400-type input) -//! @return Returns voltage calculated from ADC code. -float LTC24XX_SE_code_to_voltage(int32_t adc_code, //!< Code read from ADC - float vref //!< Reference voltage - ); -//! Calculates the voltage corresponding to an ADC code, given the reference voltage. -//! Applies to differential input parts (LTC2410 type input) -//! @return Returns voltage calculated from ADC code. -float LTC24XX_diff_code_to_voltage(int32_t adc_code, //!< Code read from ADC - float vref //!< Reference voltage - ); - -//! Calculates the voltage corresponding to an ADC code, given lsb weight (in volts) and the calibrated -//! ADC offset code (zero code that is subtracted from adc_code). -//! Applies to differential input, SPI interface parts. -//! @return Returns voltage calculated from ADC code. -float LTC24XX_diff_code_to_calibrated_voltage(int32_t adc_code, //!< Code read from ADC - float LTC24XX_lsb, //!< LSB weight (in volts) - int32_t LTC24XX_offset_code //!< The calibrated offset code (This is the ADC code zero code that will be subtracted from adc_code) - ); - -//! Calculate the lsb weight and offset code given a full-scale code and a measured zero-code. -//! @return Void -void LTC24XX_calibrate_voltage(int32_t zero_code, //!< Measured code with the inputs shorted to ground - int32_t fs_code, //!< Measured code at nearly full-scale - float zero_voltage, //!< Measured zero voltage - float fs_voltage, //!< Voltage measured at input (with voltmeter) when fs_code was read from ADC - float *LTC24XX_lsb, //!< Overwritten with lsb weight (in volts) - int32_t *LTC24XX_offset_code //!< Overwritten with offset code (zero code) - ); - - - -// I2C Addresses for 8/16 channel parts (LTC2495/7/9) -// ADDRESS CA2 CA1 CA0 -// #define LTC24XX_16CH_I2C_ADDRESS 0b0010100 // LOW LOW LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b0010110 // LOW LOW HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b0010101 // LOW LOW FLOAT -// #define LTC24XX_16CH_I2C_ADDRESS 0b0100110 // LOW HIGH LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b0110100 // LOW HIGH HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b0100111 // LOW HIGH FLOAT -// #define LTC24XX_16CH_I2C_ADDRESS 0b0010111 // LOW FLOAT LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b0100101 // LOW FLOAT HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b0100100 // LOW FLOAT FLOAT -// #define LTC24XX_16CH_I2C_ADDRESS 0b1010110 // HIGH LOW LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b1100100 // HIGH LOW HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b1010111 // HIGH LOW FLOAT -// #define LTC24XX_16CH_I2C_ADDRESS 0b1110100 // HIGH HIGH LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b1110110 // HIGH HIGH HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b1110101 // HIGH HIGH FLOAT -// #define LTC24XX_16CH_I2C_ADDRESS 0b1100101 // HIGH FLOAT LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b1100111 // HIGH FLOAT HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b1100110 // HIGH FLOAT FLOAT -// #define LTC24XX_16CH_I2C_ADDRESS 0b0110101 // FLOAT LOW LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b0110111 // FLOAT LOW HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b0110110 // FLOAT LOW FLOAT -// #define LTC24XX_16CH_I2C_ADDRESS 0b1000111 // FLOAT HIGH LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b1010101 // FLOAT HIGH HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b1010100 // FLOAT HIGH FLOAT -// #define LTC24XX_16CH_I2C_ADDRESS 0b1000100 // FLOAT FLOAT LOW -// #define LTC24XX_16CH_I2C_ADDRESS 0b1000110 // FLOAT FLOAT HIGH -// #define LTC24XX_16CH_I2C_ADDRESS 0b1000101 // FLOAT FLOAT FLOAT - -// I2C Addresses for 2/4 channel parts -// ADDRESS CA1 CA0 -// #define LTC24XX_4CH_I2C_ADDRESS 0b0010100 // LOW LOW -// #define LTC24XX_4CH_I2C_ADDRESS 0b0010110 // LOW HIGH -// #define LTC24XX_4CH_I2C_ADDRESS 0b0010101 // LOW FLOAT -// #define LTC24XX_4CH_I2C_ADDRESS 0b0100110 // HIGH LOW -// #define LTC24XX_4CH_I2C_ADDRESS 0b0110100 // HIGH HIGH -// #define LTC24XX_4CH_I2C_ADDRESS 0b0100111 // HIGH FLOAT -// #define LTC24XX_4CH_I2C_ADDRESS 0b0010111 // FLOAT LOW -// #define LTC24XX_4CH_I2C_ADDRESS 0b0100101 // FLOAT HIGH -// #define LTC24XX_4CH_I2C_ADDRESS 0b0100100 // FLOAT FLOAT - - -// I2C Addresses for Single channel parts (LTC2481/83/85) -// ADDRESS CA1 CA0/f0* -// #define LTC24XX_1CH_I2C_ADDRESS 0b0010100 // LOW HIGH -// #define LTC24XX_1CH_I2C_ADDRESS 0b0010101 // LOW FLOAT -// #define LTC24XX_1CH_I2C_ADDRESS 0b0010111 // FLOAT HIGH -// #define LTC24XX_1CH_I2C_ADDRESS 0b0100100 // FLOAT FLOAT -// #define LTC24XX_1CH_I2C_ADDRESS 0b0100110 // HIGH HIGH -// #define LTC24XX_1CH_I2C_ADDRESS 0b0100111 // HIGH FLOAT - - -#endif // LTC24XX_general_H - diff --git a/sw/lib/LTC24XX_general.cpp b/sw/lib/LTC24XX_general.cpp new file mode 100644 index 0000000..615edff --- /dev/null +++ b/sw/lib/LTC24XX_general.cpp @@ -0,0 +1,434 @@ +/*! +LTC24XX General Library: Functions and defines for all SINC4 Delta Sigma ADCs. + +@verbatim + +These functions and defines apply to all No Latency Delta Sigmas in the +LTC2480 EasyDrive family, LTC2410 differential family, LTC2400 single-ended family, +and the LTC2440 High Speed family with selectable speed / resolution. + +It does not cover the LTC2450 tiny, low cost delta sigma ADC famliy. + +Please refer to the No Latency Delta Sigma ADC selector guide available at: + +http://www.linear.com/docs/41341 + + +@endverbatim + +http://www.linear.com/product/LTC2449 + +http://www.linear.com/product/LTC2449#demoboards + +REVISION HISTORY +$Revision: 1807 $ +$Date: 2013-07-29 13:06:06 -0700 (Mon, 29 Jul 2013) $ + +Copyright (c) 2013, Linear Technology Corp.(LTC) +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those +of the authors and should not be interpreted as representing official policies, +either expressed or implied, of Linear Technology Corp. + +The Linear Technology Linduino is not affiliated with the official Arduino team. +However, the Linduino is only possible because of the Arduino team's commitment +to the open-source community. Please, visit http://www.arduino.cc and +http://store.arduino.cc , and consider a purchase that will help fund their +ongoing work. +*/ + +//! @defgroup LTC24XX LTC24XX: All no-latency delta sigma ADCs with SINC4 rejection + +/*! @file + @ingroup LTC24XX + Library for LTC24XX no-latency delta sigma ADCs with SINC4 rejection +*/ + +#include +#include +#include "Linduino.h" +#include +#include "LT_SPI.h" +#include +#include "LT_I2C.h" +#include "LTC24XX_general.h" + + +int8_t LTC24XX_EOC_timeout(uint8_t cs, uint16_t miso_timeout) +// Checks for EOC with a specified timeout (ms) +{ + uint16_t timer_count = 0; // Timer count for MISO + output_low(cs); //! 1) Pull CS low + while (1) //! 2) Wait for SDO (MISO) to go low + { + if (input(MISO) == 0) break; //! 3) If SDO is low, break loop + if (timer_count++>miso_timeout) // If timeout, return 1 (failure) + { + output_high(cs); // Pull CS high + return(1); + } + else + delay(1); + } + output_high(cs); // Pull CS high + return(0); +} + +// Reads from LTC24XX ADC that has no configuration word and a 32 bit output word. +void LTC24XX_SPI_32bit_data(uint8_t cs, int32_t *adc_code) +{ + LT_union_int32_4bytes data, command; // LTC2449 data and command + command.LT_uint32 = 0; // Set to zero, not necessary but avoids + // random data in scope shots. + output_low(cs); //! 1) Pull CS low + + spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)4); //! 2) Transfer arrays + + output_high(cs); //! 3) Pull CS high + *adc_code = data.LT_int32; +} + + +// Reads from a SPI LTC24XX device that has an 8 bit command and a 32 bit output word. +void LTC24XX_SPI_8bit_command_32bit_data(uint8_t cs, uint8_t adc_command, int32_t *adc_code) +{ + LT_union_int32_4bytes data, command; // LTC2449 data and command + command.LT_byte[3] = adc_command; + command.LT_byte[2] = 0; + command.LT_byte[1] = 0; + command.LT_byte[0] = 0; + + output_low(cs); //! 1) Pull CS low + + spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)4); //! 2) Transfer arrays + + output_high(cs); //! 3) Pull CS high + *adc_code = data.LT_int32; +} + + +// Reads from a SPI LTC24XX device that has a 16 bit command and a 32 bit output word. +void LTC24XX_SPI_16bit_command_32bit_data(uint8_t cs, uint8_t adc_command_high, uint8_t adc_command_low, int32_t *adc_code) +{ + + + LT_union_int32_4bytes data, command; // LTC24XX data and command + command.LT_byte[3] = adc_command_high; + command.LT_byte[2] = adc_command_low; + command.LT_byte[1] = 0; + command.LT_byte[0] = 0; + + output_low(cs); //! 1) Pull CS low + spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)4); //! 2) Transfer arrays + output_high(cs); //! 3) Pull CS high + *adc_code = data.LT_int32; +} + +//! Reads from LTC24XX two channel "Ping-Pong" ADC, placing the channel information in the adc_channel parameter +//! and returning the 32 bit result with the channel bit cleared so the data format matches the rest of the family +//! @return void +void LTC24XX_SPI_2ch_ping_pong_32bit_data(uint8_t cs, uint8_t *adc_channel, int32_t *code) +{ + LT_union_int32_4bytes data, command; // ADC data + + command.LT_int32 = 0x00000000; // This is a "don't care" + + spi_transfer_block(cs, command.LT_byte , data.LT_byte, (uint8_t)4); + if(data.LT_byte[3] & 0x40) // Obtains Channel Number + { + *adc_channel = 1; + } + else + { + *adc_channel = 0; + } + data.LT_byte[3] &= 0x3F; // Clear channel bit here so code to voltage function doesn't have to. + *code = data.LT_int32; // Return data +} + +//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. +//! @return void +void LTC24XX_SPI_24bit_data(uint8_t cs, int32_t *adc_code) +{ + LT_union_int32_4bytes data, command; // LTC24XX data and command + command.LT_int32 = 0; + + output_low(cs); //! 1) Pull CS low + spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)3); //! 2) Transfer arrays + output_high(cs); //! 3) Pull CS high + + data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, + data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- + data.LT_byte[1] = data.LT_byte[0]; // justify. + data.LT_byte[0] = 0x00; + + *adc_code = data.LT_int32; +} + +//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 24 bit output word. +//! @return void +void LTC24XX_SPI_8bit_command_24bit_data(uint8_t cs, uint8_t adc_command, int32_t *adc_code) +{ + LT_union_int32_4bytes data, command; // LTC24XX data and command + command.LT_byte[2] = adc_command; + command.LT_byte[1] = 0; + command.LT_byte[0] = 0; + + output_low(cs); //! 1) Pull CS low + spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)3); //! 2) Transfer arrays + output_high(cs); //! 3) Pull CS high + + data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, + data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- + data.LT_byte[1] = data.LT_byte[0]; // justify. + data.LT_byte[0] = 0x00; + + *adc_code = data.LT_int32; +} + +//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 24 bit output word. +//! @return void +void LTC24XX_SPI_16bit_command_24bit_data(uint8_t cs, uint8_t adc_command_high, uint8_t adc_command_low, int32_t *adc_code) +{ + LT_union_int32_4bytes data, command; // LTC24XX data and command + command.LT_byte[2] = adc_command_high; + command.LT_byte[1] = adc_command_low; + command.LT_byte[0] = 0; + + + output_low(cs); //! 1) Pull CS low + spi_transfer_block(cs, command.LT_byte, data.LT_byte, (uint8_t)3); //! 2) Transfer arrays + output_high(cs); //! 3) Pull CS high + + data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, + data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- + data.LT_byte[1] = data.LT_byte[0]; // justify. + data.LT_byte[0] = 0x00; + + *adc_code = data.LT_int32; +} + +//! Reads from LTC24XX two channel "Ping-Pong" ADC, placing the channel information in the adc_channel parameter +//! and returning the 24 bit result with the channel bit cleared so the data format matches the rest of the family +//! @return void +void LTC24XX_SPI_2ch_ping_pong_24bit_data(uint8_t cs, uint8_t *adc_channel, int32_t *code) +{ + LT_union_int32_4bytes data, command; // ADC data + + command.LT_int32 = 0x00000000; // This is a "don't care" + + spi_transfer_block(cs, command.LT_byte , data.LT_byte, (uint8_t)3); + data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, + data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- + data.LT_byte[1] = data.LT_byte[0]; // justify. + data.LT_byte[0] = 0x00; + + if(data.LT_byte[3] & 0x40) // Obtains Channel Number + { + *adc_channel = 1; + } + else + { + *adc_channel = 0; + } + data.LT_byte[3] &= 0x3F; // Clear channel bit here so code to voltage function doesn't have to. + *code = data.LT_int32; // Return data +} + + +//I2C functions + +//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 24 bit result. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_8bit_command_24bit_data(uint8_t i2c_address, uint8_t adc_command, int32_t *adc_code, uint16_t eoc_timeout) +{ + int8_t ack; + uint16_t timer_count = 0; // Timer count to wait for ACK + int8_t buf[4]; + LT_union_int32_4bytes data; // LTC24XX data + while(1) + { + ack = i2c_read_block_data(i2c_address, adc_command, 3, data.LT_byte); + if(!ack) break; // !ack indicates success + if (timer_count++>eoc_timeout) // If timeout, return 1 (failure) + return(1); + else + delay(1); + } + data.LT_byte[3] = data.LT_byte[2]; // Shift bytes up by one. We read out 24 bits, + data.LT_byte[2] = data.LT_byte[1]; // which are loaded into bytes 2,1,0. Need to left- + data.LT_byte[1] = data.LT_byte[0]; // justify. + data.LT_byte[0] = 0x00; + data.LT_uint32 >>= 2; // Shifts data 2 bits to the right; operating on unsigned member shifts in zeros. + data.LT_byte[3] = data.LT_byte[3] & 0x3F; // Clear upper 2 bits JUST IN CASE. Now the data format matches the SPI parts. + *adc_code = data.LT_int32; + return(ack); // Success +} + + + +//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. +//! Data is formatted to match the SPI devices, with the MSB in the bit 28 position. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_32bit_data(uint8_t i2c_address, //!< I2C address of device + int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX + uint16_t eoc_timeout //!< Timeout (in milliseconds) + ) +{ + int8_t ack; + uint16_t timer_count = 0; // Timer count to wait for ACK + int8_t buf[4]; + LT_union_int32_4bytes data; // LTC24XX data + while(1) + { + ack = i2c_read_block_data(i2c_address, 4, data.LT_byte); + if(!ack) break; // !ack indicates success + if (timer_count++>eoc_timeout) // If timeout, return 1 (failure) + return(1); + else + delay(1); + } + + data.LT_uint32 >>= 2; // Shifts data 2 bits to the right; operating on unsigned member shifts in zeros. + data.LT_byte[3] = data.LT_byte[3] & 0x3F; // Clear upper 2 bits JUST IN CASE. Now the data format matches the SPI parts. + *adc_code = data.LT_int32; + return(ack); // Success + } + + +//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_8bit_command_32bit_data(uint8_t i2c_address, uint8_t adc_command, int32_t *adc_code, uint16_t eoc_timeout) +{ + int8_t ack; + uint16_t timer_count = 0; // Timer count to wait for ACK + int8_t buf[4]; + LT_union_int32_4bytes data; // LTC24XX data + while(1) + { + ack = i2c_read_block_data(i2c_address, adc_command, 4, data.LT_byte); + if(!ack) break; // !ack indicates success + if (timer_count++>eoc_timeout) // If timeout, return 1 (failure) + return(1); + else + delay(1); + } + + data.LT_uint32 >>= 2; // Shifts data 2 bits to the right; operating on unsigned member shifts in zeros. + data.LT_byte[3] = data.LT_byte[3] & 0x3F; // Clear upper 2 bits JUST IN CASE. Now the data format matches the SPI parts. + *adc_code = data.LT_int32; + return(ack); // Success +} + +//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_16bit_command_32bit_data(uint8_t i2c_address,uint8_t adc_command_high, + uint8_t adc_command_low,int32_t *adc_code,uint16_t eoc_timeout) +{ + int8_t ack; + uint16_t adc_command, timer_count = 0; // Timer count to wait for ACK + int8_t buf[4]; + LT_union_int32_4bytes data; // LTC24XX data + adc_command = (adc_command_high << 8) | adc_command_low; + while(1) + { + ack = i2c_two_byte_command_read_block(i2c_address, adc_command, 4, data.LT_byte); + if(!ack) break; // !ack indicates success + if (timer_count++>eoc_timeout) // If timeout, return 1 (failure) + return(1); + else + delay(1); + } + + data.LT_uint32 >>= 2; // Shifts data 2 bits to the right; operating on unsigned member shifts in zeros. + data.LT_byte[3] = data.LT_byte[3] & 0x3F; // Clear upper 2 bits JUST IN CASE. Now the data format matches the SPI parts. + *adc_code = data.LT_int32; + return(ack); // Success +} + +// Calculates the voltage corresponding to an adc code, given the reference voltage (in volts) +float LTC24XX_SE_code_to_voltage(int32_t adc_code, float vref) +{ + float voltage; + adc_code -= 0x20000000; //! 1) Subtract offset + voltage=(float) adc_code; + voltage = voltage / 268435456.0; //! 2) This calculates the input as a fraction of the reference voltage (dimensionless) + voltage = voltage * vref; //! 3) Multiply fraction by Vref to get the actual voltage at the input (in volts) + return(voltage); +} + +// Calculates the voltage corresponding to an adc code, given the reference voltage (in volts) +// This function handles all differential input parts, including the "single-ended" mode on multichannel +// differential parts. Data from I2C parts must be right-shifted by two bit positions such that the MSB +// is in bit 28 (the same as the SPI parts.) +float LTC24XX_diff_code_to_voltage(int32_t adc_code, float vref) +{ + float voltage; + + #ifndef SKIP_EZDRIVE_2X_ZERO_CHECK + if(adc_code == 0x00000000) + { + adc_code = 0x20000000; + } + #endif + + adc_code -= 0x20000000; //! 1) Converts offset binary to binary + voltage=(float) adc_code; + voltage = voltage / 536870912.0; //! 2) This calculates the input as a fraction of the reference voltage (dimensionless) + voltage = voltage * vref; //! 3) Multiply fraction by Vref to get the actual voltage at the input (in volts) + return(voltage); +} + +// Calculates the voltage corresponding to an adc code, given lsb weight (in volts) and the calibrated +// adc offset code (zero code that is subtracted from adc_code). For use with the LTC24XX_cal_voltage() function. +float LTC24XX_diff_code_to_calibrated_voltage(int32_t adc_code, float LTC2449_lsb, int32_t LTC2449_offset_code) +{ + float adc_voltage; + + #ifndef SKIP_EZDRIVE_2X_ZERO_CHECK + if(adc_code == 0x00000000) + { + adc_code = 0x20000000; + } + #endif + + adc_code -= 536870912; //! 1) Converts offset binary to binary + adc_voltage=(float)(adc_code+LTC2449_offset_code)*LTC2449_lsb; //! 2) Calculate voltage from ADC code, lsb, offset. + return(adc_voltage); +} + + +// Calculate the lsb weight and offset code given a full-scale code and a measured zero-code. +void LTC24XX_calibrate_voltage(int32_t zero_code, int32_t fs_code, float zero_voltage, float fs_voltage, float *LTC24XX_lsb, int32_t *LTC24XX_offset_code) +{ + zero_code -= 536870912; //! 1) Converts zero code from offset binary to binary + fs_code -= 536870912; //! 2) Converts full scale code from offset binary to binary + + float temp_offset; + *LTC24XX_lsb = (fs_voltage-zero_voltage)/((float)(fs_code - zero_code)); //! 3) Calculate the LSB + + temp_offset = (zero_voltage/ *LTC24XX_lsb) - zero_code; //! 4) Calculate Unipolar offset + temp_offset = (temp_offset > (floor(temp_offset) + 0.5)) ? ceil(temp_offset) : floor(temp_offset); //! 5) Round + *LTC24XX_offset_code = (int32_t)temp_offset; //! 6) Cast as int32_t +} diff --git a/sw/lib/LTC24XX_general.h b/sw/lib/LTC24XX_general.h new file mode 100644 index 0000000..42fd65a --- /dev/null +++ b/sw/lib/LTC24XX_general.h @@ -0,0 +1,501 @@ +/*! +LTC24XX General Library: Functions and defines for all SINC4 Delta Sigma ADCs. + +@verbatim + + +LTC2442 / LTC2444 / LTC2445 / LTC2448 / LTC2449 (Are there don't care bits in the low channel counts? +SPI DATA FORMAT (MSB First): + + Byte #1 Byte #2 + +Data Out : !EOC DMY SIG D28 D27 D26 D25 D24 D23 D22 D21 D20 D19 D18 D17 D16 +Data In : 1 0 EN SGL OS S2 S1 S0 OSR3 OSR2 OSR1 OSR1 SPD X X X + + Byte #3 Byte #4 + D15 D14 D13 D12 D11 D10 D9 D8 D7 D6 D5 D4 *D3 *D2 *D1 *D0 + X X X X X X X X X X X X X X X X + +!EOC : End of Conversion Bit (Active Low) +DMY : Dummy Bit (Always 0) +SIG : Sign Bit (1-data positive, 0-data negative) +Dx : Data Bits +*Dx : Data Bits Below lsb +EN : Enable Bit (0-keep previous mode, 1-change mode) +SGL : Enable Single-Ended Bit (0-differential, 1-single-ended) +OS : ODD/Sign Bit +Sx : Address Select Bit +0SRX : Over Sampling Rate Bits +SPD : Double Output Rate Select Bit (0-Normal rate, auto-calibration on, 2x rate, auto_calibration off) + +Command Byte #1 +1 0 EN SGL OS S2 S1 S0 Comments +1 0 0 X X X X X Keep Previous Mode +1 0 1 0 X X X X Differential Mode +1 0 1 1 X X X X Single-Ended Mode + +| Coversion Rate | RMS | ENOB | OSR | Latency +Command Byte #2 |Internal | External | Noise | | | +| 9MHz | 10.24MHz | | | | +OSR3 OSR2 OSR1 OSR1 SPD | Clock | Clock | | | | +0 0 0 0 0 Keep Previous Speed/Resolution +0 0 0 1 0 3.52kHz 4kHz 23uV 17 64 none +0 0 1 0 0 1.76kHz 2kHz 3.5uV 20.1 128 none +0 0 1 1 0 880Hz 1kHz 2uV 21.3 256 none +0 1 0 0 0 440Hz 500Hz 1.4uV 21.8 512 none +0 1 0 1 0 220Hz 250Hz 1uV 22.4 1024 none +0 1 1 0 0 110Hz 125Hz 750nV 22.9 2048 none +0 1 1 1 0 55Hz 62.5Hz 510nV 23.4 4096 none +1 0 0 0 0 27.5Hz 31.25Hz 375nV 24 8192 none +1 0 0 1 0 13.75Hz 15.625Hz 250nV 24.4 16384 none +1 1 1 1 0 6.87kHz 7.8125Hz 200nV 24.6 32768 none +0 0 0 0 1 Keep Previous Speed/Resolution +OSR3 OSR2 OSR1 OSR1 1 2X Mode *all clock speeds double + +Example Code: + +Read Channel 0 in Single-Ended with OSR of 65536 + + uint16_t miso_timeout = 1000; + adc_command = LTC2449_CH0 | LTC2449_OSR_32768 | LTC2449_SPEED_2X; // Build ADC command for channel 0 + // OSR = 32768*2 = 65536 + + if(LTC2449_EOC_timeout(LTC2449_CS, miso_timeout)) // Check for EOC + return; // Exit if timeout is reached + LTC2449_read(LTC2449_CS, adc_command, &adc_code); // Throws out last reading + + if(LTC2449_EOC_timeout(LTC2449_CS, miso_timeout)) // Check for EOC + return; // Exit if timeout is reached + LTC2449_read(LTC2449_CS, adc_command, &adc_code); // Obtains the current reading and stores to adc_code variable + + // Convert adc_code to voltage + adc_voltage = LTC2449_code_to_voltage(adc_code, LTC2449_lsb, LTC2449_offset_code); + +@endverbatim + +http://www.linear.com/product/LTC2449 + +http://www.linear.com/product/LTC2449#demoboards + +REVISION HISTORY +$Revision: 1881 $ +$Date: 2013-08-15 09:16:50 -0700 (Thu, 15 Aug 2013) $ + +Copyright (c) 2013, Linear Technology Corp.(LTC) +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those +of the authors and should not be interpreted as representing official policies, +either expressed or implied, of Linear Technology Corp. + +The Linear Technology Linduino is not affiliated with the official Arduino team. +However, the Linduino is only possible because of the Arduino team's commitment +to the open-source community. Please, visit http://www.arduino.cc and +http://store.arduino.cc , and consider a purchase that will help fund their +ongoing work. +*/ + +/*! @file + @ingroup LTC24XX_general + Header for LTC2449: 24-Bit, 16-Channel Delta Sigma ADCs with Selectable Speed/Resolution +*/ + +#ifndef LTC24XX_general_H +#define LTC24XX_general_H + +//! Define the SPI CS pin +#ifndef LTC24XX_CS +#define LTC24XX_CS QUIKEVAL_CS +#endif + +//! In 2X Mode, A non offset binary 0 can be produced. This is corrected in the +//! differential code to voltage functions. To disable this correction, uncomment +//! The following #define. +//#define SKIP_EZDRIVE_2X_ZERO_CHECK + +/*! @name Mode Configuration for High Speed Family + @{ +*/ +#define LTC24XX_HS_MULTI_KEEP_PREVIOUS_MODE 0x80 +#define LTC24XX_HS_MULTI_KEEP_PREVIOUS_SPEED_RESOLUTION 0x00 +#define LTC24XX_HS_MULTI_SPEED_1X 0x00 +#define LTC24XX_HS_MULTI_SPEED_2X 0x08 +/*! + @} +*/ + +/*! @name Mode Configuration for EasyDrive Family + @{ +*/ +// Select ADC source - differential input or PTAT circuit +#define LTC24XX_EZ_MULTI_VIN 0b10000000 +#define LTC24XX_EZ_MULTI_PTAT 0b11000000 + +// Select rejection frequency - 50, 55, or 60Hz +#define LTC24XX_EZ_MULTI_R50 0b10010000 +#define LTC24XX_EZ_MULTI_R55 0b10000000 +#define LTC24XX_EZ_MULTI_R60 0b10100000 + +// Speed settings is bit 7 in the 2nd byte +#define LTC24XX_EZ_MULTI_SLOW 0b10000000 // slow output rate with autozero +#define LTC24XX_EZ_MULTI_FAST 0b10001000 // fast output rate with no autozero +/*! + @} +*/ + + +/*! @name Single-Ended Channel Configuration +@verbatim +Channel selection for all multi-channel, differential input ADCs, even those that only require +8 bits of configuration (no further options.) Most devices in this category require a second +byte of configuration for speed mode, temperature sensor selection, etc., but for the sake +of simplicity a single function will be used to read all devices, sending zeros in the second +configuration byte if only the channel is specified. + +Applicable devices: +Easy Drive: +LTC2486, LTC2487, LTC2488, LTC2489, LTC2492, LTC2493, +LTC2494, LTC2495, LTC2496, LTC2497, LTC2498, LTC2499 +First Generation Differential: +LTC2414, LTC2418, LTC2439 +High Speed: +LTC2442, LTC2444, LTC2445, LTC2448, LTC2449 +@endverbatim +@{ */ +#define LTC24XX_MULTI_CH_CH0 0xB0 +#define LTC24XX_MULTI_CH_CH1 0xB8 +#define LTC24XX_MULTI_CH_CH2 0xB1 +#define LTC24XX_MULTI_CH_CH3 0xB9 +#define LTC24XX_MULTI_CH_CH4 0xB2 +#define LTC24XX_MULTI_CH_CH5 0xBA +#define LTC24XX_MULTI_CH_CH6 0xB3 +#define LTC24XX_MULTI_CH_CH7 0xBB +#define LTC24XX_MULTI_CH_CH8 0xB4 +#define LTC24XX_MULTI_CH_CH9 0xBC +#define LTC24XX_MULTI_CH_CH10 0xB5 +#define LTC24XX_MULTI_CH_CH11 0xBD +#define LTC24XX_MULTI_CH_CH12 0xB6 +#define LTC24XX_MULTI_CH_CH13 0xBE +#define LTC24XX_MULTI_CH_CH14 0xB7 +#define LTC24XX_MULTI_CH_CH15 0xBF +/*! @} */ + +/*! @name Differential Channel Configuration +@verbatim +See note for single-ended configuration above. + +@endverbatim +@{ */ +#define LTC24XX_MULTI_CH_P0_N1 0xA0 +#define LTC24XX_MULTI_CH_P1_N0 0xA8 + +#define LTC24XX_MULTI_CH_P2_N3 0xA1 +#define LTC24XX_MULTI_CH_P3_N2 0xA9 + +#define LTC24XX_MULTI_CH_P4_N5 0xA2 +#define LTC24XX_MULTI_CH_P5_N4 0xAA + +#define LTC24XX_MULTI_CH_P6_N7 0xA3 +#define LTC24XX_MULTI_CH_P7_N6 0xAB + +#define LTC24XX_MULTI_CH_P8_N9 0xA4 +#define LTC24XX_MULTI_CH_P9_N8 0xAC + +#define LTC24XX_MULTI_CH_P10_N11 0xA5 +#define LTC24XX_MULTI_CH_P11_N10 0xAD + +#define LTC24XX_MULTI_CH_P12_N13 0xA6 +#define LTC24XX_MULTI_CH_P13_N12 0xAE + +#define LTC24XX_MULTI_CH_P14_N15 0xA7 +#define LTC24XX_MULTI_CH_P15_N14 0xAF +/*! @} */ + +/*Commands +Construct a channel / resolution control word by bitwise ORing one choice from the channel configuration +and one choice from the Oversample ratio configuration. You can also enable 2Xmode, which will increase +sample rate by a factor of 2 but introduce one cycle of latency. + +Example - read channel 3 single-ended at OSR2048, with 2X mode enabled. +adc_command = (LTC2449_CH3 | LTC2449_OSR_2048) | LTC2449_SPEED_2X; +*/ + +/*! @name Oversample Ratio (OSR) Commands +@{ */ +#define LTC24XX_MULTI_CH_OSR_64 0x10 +#define LTC24XX_MULTI_CH_OSR_128 0x20 +#define LTC24XX_MULTI_CH_OSR_256 0x30 +#define LTC24XX_MULTI_CH_OSR_512 0x40 +#define LTC24XX_MULTI_CH_OSR_1024 0x50 +#define LTC24XX_MULTI_CH_OSR_2048 0x60 +#define LTC24XX_MULTI_CH_OSR_4096 0x70 +#define LTC24XX_MULTI_CH_OSR_8192 0x80 +#define LTC24XX_MULTI_CH_OSR_16384 0x90 +#define LTC24XX_MULTI_CH_OSR_32768 0xF0 +/*! @}*/ + +//! Checks for EOC with a specified timeout. Applies to all SPI interface delta sigma +//! ADCs that have SINC4 rejection, does NOT apply to LTC2450/60/70 family. +//! @return Returns 0=successful, 1=unsuccessful (exceeded timeout) +int8_t LTC24XX_EOC_timeout(uint8_t cs, //!< Chip Select pin + uint16_t miso_timeout //!< Timeout (in milliseconds) + ); + + +// Read functions for SPI interface ADCs with a 32 bit output word. These functions are used with both +// Single-ended and differential parts, as there is no interpretation of the data done in +// the function. Also note that these functions can be used for devices that have shorter output lengths, +// the lower bits will read out as "1", as the conversion will be triggered by the last data bit being +// read, which causes SDO to go high. + + +//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. +//! @return void +void LTC24XX_SPI_32bit_data(uint8_t cs, //!< Chip Select pin + int32_t *adc_code //!< 4 byte conversion code read from LTC24XX + ); + +//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. +//! @return void +void LTC24XX_SPI_8bit_command_32bit_data(uint8_t cs, //!< Chip Select pin + uint8_t adc_command, //!< 1 byte command written to LTC24XX + int32_t *adc_code //!< 4 byte conversion code read from LTC24XX + ); + +//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. +//! @return void +void LTC24XX_SPI_16bit_command_32bit_data(uint8_t cs, //!< Chip Select pin + uint8_t adc_command_high, //!< First command byte written to LTC24XX + uint8_t adc_command_low, //!< Second command written to LTC24XX + int32_t *adc_code //!< 4 byte conversion code read from LTC24XX + ); + +//! Reads from LTC24XX two channel "Ping-Pong" ADC, placing the channel information in the adc_channel parameter +//! and returning the 32 bit result with the channel bit cleared so the data format matches the rest of the family +//! @return void +void LTC24XX_SPI_2ch_ping_pong_32bit_data(uint8_t cs, //!< Chip Select pin + uint8_t *adc_channel, //!< Returns channel number read. + int32_t *code //!< 4 byte conversion code read from LTC24XX + ); + + +// Read functions for SPI interface ADCs with a 24 bit or 19 bit output word. These functions +// are used with both Single-ended and differential parts, as there is no interpretation of +// the data done in the function. 24 bits will be read out of 19 bit devices +// (LTC2433, LTC2436, LTC2439), with the additional 5 bits being set to 1. + +//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. +//! @return void +void LTC24XX_SPI_24bit_data(uint8_t cs, //!< Chip Select pin + int32_t *adc_code //!< 4 byte conversion code read from LTC24XX + ); + +//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. +//! @return void +void LTC24XX_SPI_8bit_command_24bit_data(uint8_t cs, //!< Chip Select pin + uint8_t adc_command, //!< 1 byte command written to LTC24XX + int32_t *adc_code //!< 4 byte conversion code read from LTC24XX + ); + +//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. +//! @return void +void LTC24XX_SPI_16bit_command_24bit_data(uint8_t cs, //!< Chip Select pin + uint8_t adc_command_high, //!< First command byte written to LTC24XX + uint8_t adc_command_low, //!< Second command written to LTC24XX + int32_t *adc_code //!< 4 byte conversion code read from LTC24XX + ); + +//! Reads from LTC24XX ADC that accepts a 8 bit configuration and returns a 16 bit result. +//! @return void +void LTC24XX_SPI_8bit_command_16bit_data(uint8_t cs, //!< Chip Select pin + uint8_t adc_command, //!< First command byte written to LTC24XX + int32_t *adc_code //!< 4 byte conversion code read from LTC24XX + ); + + +//! Reads from LTC24XX two channel "Ping-Pong" ADC, placing the channel information in the adc_channel parameter +//! and returning the 32 bit result with the channel bit cleared so the data format matches the rest of the family +//! @return void +void LTC24XX_SPI_2ch_ping_pong_24bit_data(uint8_t cs, //!< Chip Select pin + uint8_t *adc_channel, //!< Returns channel number read. + int32_t *code //!< 4 byte conversion code read from LTC24XX + ); + +// Read functions for I2C interface ADCs with a 32 bit output word. These functions are used with both +// Single-ended and differential parts, as there is no interpretation of the data done in +// the function. Also note that these functions can be used for devices that have shorter output lengths, +// the lower bits will read out as "1", as the conversion will be triggered by the last data bit being +// read, which causes SDO to go high. +// Data is formatted to match the SPI devices, with the MSB in the bit 28 position. +// Unlike the SPI members of this family, checking for EOC MUST immediately be followed by reading the data. This +// is because a stop condition will trigger a new conversion. + + +//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_32bit_data(uint8_t i2c_address, //!< I2C address of device + int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX + uint16_t eoc_timeout //!< Timeout (in milliseconds) + ); + + +//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_8bit_command_32bit_data(uint8_t i2c_address, //!< I2C address of device + uint8_t adc_command, //!< 1 byte command written to LTC24XX + int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX + uint16_t eoc_timeout //!< Timeout (in milliseconds) + ); + + +//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_16bit_command_32bit_data(uint8_t i2c_address, //!< I2C address of device + uint8_t adc_command_high, //!< First command byte written to LTC24XX + uint8_t adc_command_low, //!< Second command written to LTC24XX + int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX + uint16_t eoc_timeout //!< Timeout (in milliseconds) + ); + + +// Read functions for I2C interface ADCs with a 24 bit or 19 bit output word. These functions +// are used with both Single-ended and differential parts, as there is no interpretation of +// the data done in the function. 24 bits will be read out of 19 bit devices +// (LTC2433, LTC2436, LTC2439), with the additional 5 bits being set to 1. + + +//! Reads from LTC24XX ADC that has no configuration word and returns a 32 bit result. +//! Applies to: LTC2483 (only this lonely one!) +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_24bit_data(uint8_t i2c_address, //!< I2C address of device + int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX + uint16_t eoc_timeout //!< Timeout (in milliseconds) + ); + + +//! Reads from LTC24XX ADC that accepts an 8 bit configuration and returns a 32 bit result. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_8bit_command_24bit_data(uint8_t i2c_address, //!< I2C address of device + uint8_t adc_command, //!< 1 byte command written to LTC24XX + int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX + uint16_t eoc_timeout //!< Timeout (in milliseconds) + ); + +//! Reads from LTC24XX ADC that accepts a 16 bit configuration and returns a 32 bit result. +//! @return Returns the state of the acknowledge bit after the I2C address write. 0=acknowledge, 1=no acknowledge. +int8_t LTC24XX_I2C_16bit_command_24bit_data(uint8_t i2c_address, //!< I2C address of device + uint8_t adc_command_high, //!< First command byte written to LTC24XX + uint8_t adc_command_low, //!< Second command written to LTC24XX + int32_t *adc_code, //!< 4 byte conversion code read from LTC24XX + uint16_t eoc_timeout //!< Timeout (in milliseconds) + ); + +//! Calculates the voltage corresponding to an ADC code, given the reference voltage. +//! Applies to Single-Ended input parts (LTC2400-type input) +//! @return Returns voltage calculated from ADC code. +float LTC24XX_SE_code_to_voltage(int32_t adc_code, //!< Code read from ADC + float vref //!< Reference voltage + ); +//! Calculates the voltage corresponding to an ADC code, given the reference voltage. +//! Applies to differential input parts (LTC2410 type input) +//! @return Returns voltage calculated from ADC code. +float LTC24XX_diff_code_to_voltage(int32_t adc_code, //!< Code read from ADC + float vref //!< Reference voltage + ); + +//! Calculates the voltage corresponding to an ADC code, given lsb weight (in volts) and the calibrated +//! ADC offset code (zero code that is subtracted from adc_code). +//! Applies to differential input, SPI interface parts. +//! @return Returns voltage calculated from ADC code. +float LTC24XX_diff_code_to_calibrated_voltage(int32_t adc_code, //!< Code read from ADC + float LTC24XX_lsb, //!< LSB weight (in volts) + int32_t LTC24XX_offset_code //!< The calibrated offset code (This is the ADC code zero code that will be subtracted from adc_code) + ); + +//! Calculate the lsb weight and offset code given a full-scale code and a measured zero-code. +//! @return Void +void LTC24XX_calibrate_voltage(int32_t zero_code, //!< Measured code with the inputs shorted to ground + int32_t fs_code, //!< Measured code at nearly full-scale + float zero_voltage, //!< Measured zero voltage + float fs_voltage, //!< Voltage measured at input (with voltmeter) when fs_code was read from ADC + float *LTC24XX_lsb, //!< Overwritten with lsb weight (in volts) + int32_t *LTC24XX_offset_code //!< Overwritten with offset code (zero code) + ); + + + +// I2C Addresses for 8/16 channel parts (LTC2495/7/9) +// ADDRESS CA2 CA1 CA0 +// #define LTC24XX_16CH_I2C_ADDRESS 0b0010100 // LOW LOW LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b0010110 // LOW LOW HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b0010101 // LOW LOW FLOAT +// #define LTC24XX_16CH_I2C_ADDRESS 0b0100110 // LOW HIGH LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b0110100 // LOW HIGH HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b0100111 // LOW HIGH FLOAT +// #define LTC24XX_16CH_I2C_ADDRESS 0b0010111 // LOW FLOAT LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b0100101 // LOW FLOAT HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b0100100 // LOW FLOAT FLOAT +// #define LTC24XX_16CH_I2C_ADDRESS 0b1010110 // HIGH LOW LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b1100100 // HIGH LOW HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b1010111 // HIGH LOW FLOAT +// #define LTC24XX_16CH_I2C_ADDRESS 0b1110100 // HIGH HIGH LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b1110110 // HIGH HIGH HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b1110101 // HIGH HIGH FLOAT +// #define LTC24XX_16CH_I2C_ADDRESS 0b1100101 // HIGH FLOAT LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b1100111 // HIGH FLOAT HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b1100110 // HIGH FLOAT FLOAT +// #define LTC24XX_16CH_I2C_ADDRESS 0b0110101 // FLOAT LOW LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b0110111 // FLOAT LOW HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b0110110 // FLOAT LOW FLOAT +// #define LTC24XX_16CH_I2C_ADDRESS 0b1000111 // FLOAT HIGH LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b1010101 // FLOAT HIGH HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b1010100 // FLOAT HIGH FLOAT +// #define LTC24XX_16CH_I2C_ADDRESS 0b1000100 // FLOAT FLOAT LOW +// #define LTC24XX_16CH_I2C_ADDRESS 0b1000110 // FLOAT FLOAT HIGH +// #define LTC24XX_16CH_I2C_ADDRESS 0b1000101 // FLOAT FLOAT FLOAT + +// I2C Addresses for 2/4 channel parts +// ADDRESS CA1 CA0 +// #define LTC24XX_4CH_I2C_ADDRESS 0b0010100 // LOW LOW +// #define LTC24XX_4CH_I2C_ADDRESS 0b0010110 // LOW HIGH +// #define LTC24XX_4CH_I2C_ADDRESS 0b0010101 // LOW FLOAT +// #define LTC24XX_4CH_I2C_ADDRESS 0b0100110 // HIGH LOW +// #define LTC24XX_4CH_I2C_ADDRESS 0b0110100 // HIGH HIGH +// #define LTC24XX_4CH_I2C_ADDRESS 0b0100111 // HIGH FLOAT +// #define LTC24XX_4CH_I2C_ADDRESS 0b0010111 // FLOAT LOW +// #define LTC24XX_4CH_I2C_ADDRESS 0b0100101 // FLOAT HIGH +// #define LTC24XX_4CH_I2C_ADDRESS 0b0100100 // FLOAT FLOAT + + +// I2C Addresses for Single channel parts (LTC2481/83/85) +// ADDRESS CA1 CA0/f0* +// #define LTC24XX_1CH_I2C_ADDRESS 0b0010100 // LOW HIGH +// #define LTC24XX_1CH_I2C_ADDRESS 0b0010101 // LOW FLOAT +// #define LTC24XX_1CH_I2C_ADDRESS 0b0010111 // FLOAT HIGH +// #define LTC24XX_1CH_I2C_ADDRESS 0b0100100 // FLOAT FLOAT +// #define LTC24XX_1CH_I2C_ADDRESS 0b0100110 // HIGH HIGH +// #define LTC24XX_1CH_I2C_ADDRESS 0b0100111 // HIGH FLOAT + + +#endif // LTC24XX_general_H + diff --git a/sw/lib/OneWire.cpp b/sw/lib/OneWire.cpp new file mode 100644 index 0000000..38bf4ee --- /dev/null +++ b/sw/lib/OneWire.cpp @@ -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 +#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 diff --git a/sw/lib/OneWire.h b/sw/lib/OneWire.h new file mode 100644 index 0000000..a7bfab7 --- /dev/null +++ b/sw/lib/OneWire.h @@ -0,0 +1,182 @@ +#ifndef OneWire_h +#define OneWire_h + +#ifdef __cplusplus + +#include + +#if defined(__AVR__) +#include +#endif + +#if ARDUINO >= 100 +#include // 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 diff --git a/sw/lib/OneWire/OneWire.cpp b/sw/lib/OneWire/OneWire.cpp deleted file mode 100644 index 38bf4ee..0000000 --- a/sw/lib/OneWire/OneWire.cpp +++ /dev/null @@ -1,580 +0,0 @@ -/* -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 -#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 diff --git a/sw/lib/OneWire/OneWire.h b/sw/lib/OneWire/OneWire.h deleted file mode 100644 index a7bfab7..0000000 --- a/sw/lib/OneWire/OneWire.h +++ /dev/null @@ -1,182 +0,0 @@ -#ifndef OneWire_h -#define OneWire_h - -#ifdef __cplusplus - -#include - -#if defined(__AVR__) -#include -#endif - -#if ARDUINO >= 100 -#include // 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 diff --git a/sw/lib/OneWire/util/OneWire_direct_gpio.h b/sw/lib/OneWire/util/OneWire_direct_gpio.h deleted file mode 100644 index 0771367..0000000 --- a/sw/lib/OneWire/util/OneWire_direct_gpio.h +++ /dev/null @@ -1,420 +0,0 @@ -#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 - -// 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 -#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 diff --git a/sw/lib/OneWire/util/OneWire_direct_regtype.h b/sw/lib/OneWire/util/OneWire_direct_regtype.h deleted file mode 100644 index 21c4634..0000000 --- a/sw/lib/OneWire/util/OneWire_direct_regtype.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef OneWire_Direct_RegType_h -#define OneWire_Direct_RegType_h - -#include - -// 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 diff --git a/sw/lib/uart.c b/sw/lib/uart.c new file mode 100644 index 0000000..d87bd54 --- /dev/null +++ b/sw/lib/uart.c @@ -0,0 +1,1522 @@ +/************************************************************************* + + Title: Interrupt UART library with receive/transmit circular buffers + Author: Andy Gock + Software: AVR-GCC 4.1, AVR Libc 1.4 + Hardware: any AVR with built-in UART, tested on AT90S8515 & ATmega8 at 4 Mhz + License: GNU General Public License + Usage: see README.md and Doxygen manual + + Based on original library by Peter Fluery, Tim Sharpe, Nicholas Zambetti. + + https://github.com/andygock/avr-uart + + Updated UART library (this one) by Andy Gock + https://github.com/andygock/avr-uart + + Based on updated UART library (this one) by Tim Sharpe + http://beaststwo.org/avr-uart/index.shtml + + Based on original library by Peter Fluery + http://homepage.hispeed.ch/peterfleury/avr-software.html + +*************************************************************************/ + +/************************************************************************* + +LICENSE: + Copyright (C) 2012 Andy Gock + Copyright (C) 2006 Peter Fleury + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + +*************************************************************************/ + +/************************************************************************ +uart_available, uart_flush, uart1_available, and uart1_flush functions +were adapted from the Arduino HardwareSerial.h library by Tim Sharpe on +11 Jan 2009. The license info for HardwareSerial.h is as follows: + + HardwareSerial.cpp - Hardware serial library for Wiring + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + 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. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Modified 23 November 2006 by David A. Mellis +************************************************************************/ + +/************************************************************************ +Changelog for modifications made by Tim Sharpe, starting with the current + library version on his Web site as of 05/01/2009. + +Date Description +========================================================================= +05/11/2009 Changed all existing UARTx_RECEIVE_INTERRUPT and UARTx_TRANSMIT_INTERRUPT + macros to use the "_vect" format introduced in AVR-Libc + v1.4.0. Had to split the 3290 and 6490 out of their existing + macro due to an inconsistency in the UART0_RECEIVE_INTERRUPT + vector name (seems like a typo: USART_RX_vect for the 3290/6490 + vice USART0_RX_vect for the others in the macro). + Verified all existing macro register names against the device + header files in AVR-Libc v1.6.6 to catch any inconsistencies. +05/12/2009 Added support for 48P, 88P, 168P, and 328P by adding them to the + existing 48/88/168 macro. + Added Arduino-style available() and flush() functions for both + supported UARTs. Really wanted to keep them out of the library, so + that it would be as close as possible to Peter Fleury's original + library, but has scoping issues accessing internal variables from + another program. Go C! +05/13/2009 Changed Interrupt Service Routine label from the old "SIGNAL" to + the "ISR" format introduced in AVR-Libc v1.4.0. + +************************************************************************/ + +#include +#include +#include +#include +#include "uart.h" + +/* + * constants and macros + */ + +/* size of RX/TX buffers */ +#define UART_RX0_BUFFER_MASK (UART_RX0_BUFFER_SIZE - 1) +#define UART_RX1_BUFFER_MASK (UART_RX1_BUFFER_SIZE - 1) +#define UART_RX2_BUFFER_MASK (UART_RX2_BUFFER_SIZE - 1) +#define UART_RX3_BUFFER_MASK (UART_RX3_BUFFER_SIZE - 1) + +#define UART_TX0_BUFFER_MASK (UART_TX0_BUFFER_SIZE - 1) +#define UART_TX1_BUFFER_MASK (UART_TX1_BUFFER_SIZE - 1) +#define UART_TX2_BUFFER_MASK (UART_TX2_BUFFER_SIZE - 1) +#define UART_TX3_BUFFER_MASK (UART_TX3_BUFFER_SIZE - 1) + +#if (UART_RX0_BUFFER_SIZE & UART_RX0_BUFFER_MASK) + #error RX0 buffer size is not a power of 2 +#endif +#if (UART_TX0_BUFFER_SIZE & UART_TX0_BUFFER_MASK) + #error TX0 buffer size is not a power of 2 +#endif + +#if (UART_RX1_BUFFER_SIZE & UART_RX1_BUFFER_MASK) + #error RX1 buffer size is not a power of 2 +#endif +#if (UART_TX1_BUFFER_SIZE & UART_TX1_BUFFER_MASK) + #error TX1 buffer size is not a power of 2 +#endif + +#if (UART_RX2_BUFFER_SIZE & UART_RX2_BUFFER_MASK) + #error RX2 buffer size is not a power of 2 +#endif +#if (UART_TX2_BUFFER_SIZE & UART_TX2_BUFFER_MASK) + #error TX2 buffer size is not a power of 2 +#endif + +#if (UART_RX3_BUFFER_SIZE & UART_RX3_BUFFER_MASK) + #error RX3 buffer size is not a power of 2 +#endif +#if (UART_TX3_BUFFER_SIZE & UART_TX3_BUFFER_MASK) + #error TX3 buffer size is not a power of 2 +#endif + +#if defined(__AVR_AT90S2313__) \ + || defined(__AVR_AT90S4414__) || defined(__AVR_AT90S4434__) \ + || defined(__AVR_AT90S8515__) || defined(__AVR_AT90S8535__) \ + || defined(__AVR_ATmega103__) + /* old AVR classic or ATmega103 with one UART */ + #define AT90_UART + #define UART0_RECEIVE_INTERRUPT UART_RX_vect + #define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect + #define UART0_STATUS USR + #define UART0_CONTROL UCR + #define UART0_DATA UDR + #define UART0_UDRIE UDRIE +#elif defined(__AVR_AT90S2333__) || defined(__AVR_AT90S4433__) + /* old AVR classic with one UART */ + #define AT90_UART + #define UART0_RECEIVE_INTERRUPT UART_RX_vect + #define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect + #define UART0_STATUS UCSRA + #define UART0_CONTROL UCSRB + #define UART0_DATA UDR + #define UART0_UDRIE UDRIE +#elif defined(__AVR_ATmega8__) || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \ + || defined(__AVR_ATmega323__) + /* ATmega with one USART */ + #define ATMEGA_USART + #define UART0_RECEIVE_INTERRUPT USART_RXC_vect + #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect + #define UART0_STATUS UCSRA + #define UART0_CONTROL UCSRB + #define UART0_DATA UDR + #define UART0_UDRIE UDRIE +#elif defined(__AVR_ATmega8U2__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega16U4__) || \ + defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega32U6__) + /* ATmega with one USART, but is called USART1 (untested) */ + #define ATMEGA_USART1 + #define UART1_RECEIVE_INTERRUPT USART1_RX_vect + #define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect + #define UART1_STATUS UCSR1A + #define UART1_CONTROL UCSR1B + #define UART1_DATA UDR1 + #define UART1_UDRIE UDRIE1 +#elif defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__) + /* ATmega with one USART */ + #define ATMEGA_USART + #define UART0_RECEIVE_INTERRUPT USART_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect + #define UART0_STATUS UCSRA + #define UART0_CONTROL UCSRB + #define UART0_DATA UDR + #define UART0_UDRIE UDRIE +#elif defined(__AVR_ATmega163__) + /* ATmega163 with one UART */ + #define ATMEGA_UART + #define UART0_RECEIVE_INTERRUPT UART_RX_vect + #define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect + #define UART0_STATUS UCSRA + #define UART0_CONTROL UCSRB + #define UART0_DATA UDR + #define UART0_UDRIE UDRIE +#elif defined(__AVR_ATmega162__) + /* ATmega with two USART */ + #define ATMEGA_USART0 + #define ATMEGA_USART1 + #define UART0_RECEIVE_INTERRUPT USART0_RXC_vect + #define UART1_RECEIVE_INTERRUPT USART1_RXC_vect + #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect + #define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect + #define UART0_STATUS UCSR0A + #define UART0_CONTROL UCSR0B + #define UART0_DATA UDR0 + #define UART0_UDRIE UDRIE0 + #define UART1_STATUS UCSR1A + #define UART1_CONTROL UCSR1B + #define UART1_DATA UDR1 + #define UART1_UDRIE UDRIE1 +#elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) + /* ATmega with two USART */ + #define ATMEGA_USART0 + #define ATMEGA_USART1 + #define UART0_RECEIVE_INTERRUPT USART0_RX_vect + #define UART1_RECEIVE_INTERRUPT USART1_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect + #define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect + #define UART0_STATUS UCSR0A + #define UART0_CONTROL UCSR0B + #define UART0_DATA UDR0 + #define UART0_UDRIE UDRIE0 + #define UART1_STATUS UCSR1A + #define UART1_CONTROL UCSR1B + #define UART1_DATA UDR1 + #define UART1_UDRIE UDRIE1 +#elif defined(__AVR_ATmega161__) + /* ATmega with UART */ + #error "AVR ATmega161 currently not supported by this libaray !" +#elif defined(__AVR_ATmega169__) + /* ATmega with one USART */ + #define ATMEGA_USART + #define UART0_RECEIVE_INTERRUPT USART0_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect + #define UART0_STATUS UCSRA + #define UART0_CONTROL UCSRB + #define UART0_DATA UDR + #define UART0_UDRIE UDRIE +#elif defined(__AVR_ATmega48__) ||defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) || \ + defined(__AVR_ATmega48P__) ||defined(__AVR_ATmega88P__) || defined(__AVR_ATmega168P__) || \ + defined(__AVR_ATmega328P__) + /* TLS-Added 48P/88P/168P/328P */ + /* ATmega with one USART */ + #define ATMEGA_USART0 + #define UART0_RECEIVE_INTERRUPT USART_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect + #define UART0_STATUS UCSR0A + #define UART0_CONTROL UCSR0B + #define UART0_DATA UDR0 + #define UART0_UDRIE UDRIE0 +#elif defined(__AVR_ATtiny2313__) || defined(__AVR_ATtiny2313A__) || defined(__AVR_ATtiny4313__) + #define ATMEGA_USART + #define UART0_RECEIVE_INTERRUPT USART_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect + #define UART0_STATUS UCSRA + #define UART0_CONTROL UCSRB + #define UART0_DATA UDR + #define UART0_UDRIE UDRIE +#elif defined(__AVR_ATmega329__) ||\ + defined(__AVR_ATmega649__) ||\ + defined(__AVR_ATmega325__) ||defined(__AVR_ATmega3250__) ||\ + defined(__AVR_ATmega645__) ||defined(__AVR_ATmega6450__) + /* ATmega with one USART */ + #define ATMEGA_USART0 + #define UART0_RECEIVE_INTERRUPT USART0_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect + #define UART0_STATUS UCSR0A + #define UART0_CONTROL UCSR0B + #define UART0_DATA UDR0 + #define UART0_UDRIE UDRIE0 +#elif defined(__AVR_ATmega3290__) ||\ + defined(__AVR_ATmega6490__) + /* TLS-Separated these two from the previous group because of inconsistency in the USART_RX */ + /* ATmega with one USART */ + #define ATMEGA_USART0 + #define UART0_RECEIVE_INTERRUPT USART_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect + #define UART0_STATUS UCSR0A + #define UART0_CONTROL UCSR0B + #define UART0_DATA UDR0 + #define UART0_UDRIE UDRIE0 +#elif defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega640__) + /* ATmega with four USART */ + #define ATMEGA_USART0 + #define ATMEGA_USART1 + #define ATMEGA_USART2 + #define ATMEGA_USART3 + #define UART0_RECEIVE_INTERRUPT USART0_RX_vect + #define UART1_RECEIVE_INTERRUPT USART1_RX_vect + #define UART2_RECEIVE_INTERRUPT USART2_RX_vect + #define UART3_RECEIVE_INTERRUPT USART3_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect + #define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect + #define UART2_TRANSMIT_INTERRUPT USART2_UDRE_vect + #define UART3_TRANSMIT_INTERRUPT USART3_UDRE_vect + #define UART0_STATUS UCSR0A + #define UART0_CONTROL UCSR0B + #define UART0_DATA UDR0 + #define UART0_UDRIE UDRIE0 + #define UART1_STATUS UCSR1A + #define UART1_CONTROL UCSR1B + #define UART1_DATA UDR1 + #define UART1_UDRIE UDRIE1 + #define UART2_STATUS UCSR2A + #define UART2_CONTROL UCSR2B + #define UART2_DATA UDR2 + #define UART2_UDRIE UDRIE2 + #define UART3_STATUS UCSR3A + #define UART3_CONTROL UCSR3B + #define UART3_DATA UDR3 + #define UART3_UDRIE UDRIE3 +#elif defined(__AVR_ATmega644__) + /* ATmega with one USART */ + #define ATMEGA_USART0 + #define UART0_RECEIVE_INTERRUPT USART0_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect + #define UART0_STATUS UCSR0A + #define UART0_CONTROL UCSR0B + #define UART0_DATA UDR0 + #define UART0_UDRIE UDRIE0 +#elif defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega644P__) || \ + defined(__AVR_ATmega1284P__) + /* ATmega with two USART */ + #define ATMEGA_USART0 + #define ATMEGA_USART1 + #define UART0_RECEIVE_INTERRUPT USART0_RX_vect + #define UART1_RECEIVE_INTERRUPT USART1_RX_vect + #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect + #define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect + #define UART0_STATUS UCSR0A + #define UART0_CONTROL UCSR0B + #define UART0_DATA UDR0 + #define UART0_UDRIE UDRIE0 + #define UART1_STATUS UCSR1A + #define UART1_CONTROL UCSR1B + #define UART1_DATA UDR1 + #define UART1_UDRIE UDRIE1 +#else + #error "no UART definition for MCU available" +#endif + +/* + * Module global variables + */ + +#if defined(USART0_ENABLED) + #if defined(ATMEGA_USART) || defined(ATMEGA_USART0) + static volatile uint8_t UART_TxBuf[UART_TX0_BUFFER_SIZE]; + static volatile uint8_t UART_RxBuf[UART_RX0_BUFFER_SIZE]; + + #if defined(USART0_LARGE_BUFFER) + static volatile uint16_t UART_TxHead; + static volatile uint16_t UART_TxTail; + static volatile uint16_t UART_RxHead; + static volatile uint16_t UART_RxTail; + static volatile uint8_t UART_LastRxError; + #else + static volatile uint8_t UART_TxHead; + static volatile uint8_t UART_TxTail; + static volatile uint8_t UART_RxHead; + static volatile uint8_t UART_RxTail; + static volatile uint8_t UART_LastRxError; + #endif + + #endif +#endif + +#if defined(USART1_ENABLED) + #if defined(ATMEGA_USART1) + static volatile uint8_t UART1_TxBuf[UART_TX1_BUFFER_SIZE]; + static volatile uint8_t UART1_RxBuf[UART_RX1_BUFFER_SIZE]; + + #if defined(USART1_LARGE_BUFFER) + static volatile uint16_t UART1_TxHead; + static volatile uint16_t UART1_TxTail; + static volatile uint16_t UART1_RxHead; + static volatile uint16_t UART1_RxTail; + static volatile uint8_t UART1_LastRxError; + #else + static volatile uint8_t UART1_TxHead; + static volatile uint8_t UART1_TxTail; + static volatile uint8_t UART1_RxHead; + static volatile uint8_t UART1_RxTail; + static volatile uint8_t UART1_LastRxError; + #endif + #endif +#endif + +#if defined(USART2_ENABLED) + #if defined(ATMEGA_USART2) + static volatile uint8_t UART2_TxBuf[UART_TX2_BUFFER_SIZE]; + static volatile uint8_t UART2_RxBuf[UART_RX2_BUFFER_SIZE]; + + #if defined(USART2_LARGE_BUFFER) + static volatile uint16_t UART2_TxHead; + static volatile uint16_t UART2_TxTail; + static volatile uint16_t UART2_RxHead; + static volatile uint16_t UART2_RxTail; + static volatile uint8_t UART2_LastRxError; + #else + static volatile uint8_t UART2_TxHead; + static volatile uint8_t UART2_TxTail; + static volatile uint8_t UART2_RxHead; + static volatile uint8_t UART2_RxTail; + static volatile uint8_t UART2_LastRxError; + #endif + #endif +#endif + +#if defined(USART3_ENABLED) + #if defined(ATMEGA_USART3) + static volatile uint8_t UART3_TxBuf[UART_TX3_BUFFER_SIZE]; + static volatile uint8_t UART3_RxBuf[UART_RX3_BUFFER_SIZE]; + + #if defined(USART3_LARGE_BUFFER) + static volatile uint16_t UART3_TxHead; + static volatile uint16_t UART3_TxTail; + static volatile uint16_t UART3_RxHead; + static volatile uint16_t UART3_RxTail; + static volatile uint8_t UART3_LastRxError; + #else + static volatile uint8_t UART3_TxHead; + static volatile uint8_t UART3_TxTail; + static volatile uint8_t UART3_RxHead; + static volatile uint8_t UART3_RxTail; + static volatile uint8_t UART3_LastRxError; + #endif + + #endif +#endif + +#if defined(USART0_ENABLED) + +#if defined(AT90_UART) || defined(ATMEGA_USART) || defined(ATMEGA_USART0) + +ISR(UART0_RECEIVE_INTERRUPT) +/************************************************************************* +Function: UART Receive Complete interrupt +Purpose: called when the UART has received a character +**************************************************************************/ +{ + uint16_t tmphead; + uint8_t data; + uint8_t usr; + uint8_t lastRxError; + + /* read UART status register and UART data register */ + usr = UART0_STATUS; + data = UART0_DATA; + + /* */ +#if defined(AT90_UART) + lastRxError = (usr & (_BV(FE)|_BV(DOR))); +#elif defined(ATMEGA_USART) + lastRxError = (usr & (_BV(FE)|_BV(DOR))); +#elif defined(ATMEGA_USART0) + lastRxError = (usr & (_BV(FE0)|_BV(DOR0))); +#elif defined (ATMEGA_UART) + lastRxError = (usr & (_BV(FE)|_BV(DOR))); +#endif + + /* calculate buffer index */ + tmphead = (UART_RxHead + 1) & UART_RX0_BUFFER_MASK; + + if (tmphead == UART_RxTail) { + /* error: receive buffer overflow */ + lastRxError = UART_BUFFER_OVERFLOW >> 8; + } else { + /* store new index */ + UART_RxHead = tmphead; + /* store received data in buffer */ + UART_RxBuf[tmphead] = data; + } + UART_LastRxError = lastRxError; +} + + +ISR(UART0_TRANSMIT_INTERRUPT) +/************************************************************************* +Function: UART Data Register Empty interrupt +Purpose: called when the UART is ready to transmit the next byte +**************************************************************************/ +{ + uint16_t tmptail; + + if (UART_TxHead != UART_TxTail) { + /* calculate and store new buffer index */ + tmptail = (UART_TxTail + 1) & UART_TX0_BUFFER_MASK; + UART_TxTail = tmptail; + /* get one byte from buffer and write it to UART */ + UART0_DATA = UART_TxBuf[tmptail]; /* start transmission */ + } else { + /* tx buffer empty, disable UDRE interrupt */ + UART0_CONTROL &= ~_BV(UART0_UDRIE); + } +} + + +/************************************************************************* +Function: uart0_init() +Purpose: initialize UART and set baudrate +Input: baudrate using macro UART_BAUD_SELECT() +Returns: none +**************************************************************************/ +void uart0_init(uint16_t baudrate) +{ + ATOMIC_BLOCK(ATOMIC_FORCEON) { + UART_TxHead = 0; + UART_TxTail = 0; + UART_RxHead = 0; + UART_RxTail = 0; + } + +#if defined(AT90_UART) + /* set baud rate */ + UBRR = (uint8_t) baudrate; + + /* enable UART receiver and transmitter and receive complete interrupt */ + UART0_CONTROL = _BV(RXCIE)|_BV(RXEN)|_BV(TXEN); + +#elif defined (ATMEGA_USART) + /* Set baud rate */ + if (baudrate & 0x8000) { + UART0_STATUS = (1<>8); + UBRRL = (uint8_t) baudrate; + + /* Enable USART receiver and transmitter and receive complete interrupt */ + UART0_CONTROL = _BV(RXCIE)|(1<>8); + UBRR0L = (uint8_t) baudrate; + + /* Enable USART receiver and transmitter and receive complete interrupt */ + UART0_CONTROL = _BV(RXCIE0)|(1<>8); + UBRR = (uint8_t) baudrate; + + /* Enable UART receiver and transmitter and receive complete interrupt */ + UART0_CONTROL = _BV(RXCIE)|(1<> 8; + } else { + /* store new index */ + UART1_RxHead = tmphead; + /* store received data in buffer */ + UART1_RxBuf[tmphead] = data; + } + UART1_LastRxError = lastRxError; +} + + +ISR(UART1_TRANSMIT_INTERRUPT) +/************************************************************************* +Function: UART1 Data Register Empty interrupt +Purpose: called when the UART1 is ready to transmit the next byte +**************************************************************************/ +{ + uint16_t tmptail; + + if (UART1_TxHead != UART1_TxTail) { + /* calculate and store new buffer index */ + tmptail = (UART1_TxTail + 1) & UART_TX1_BUFFER_MASK; + UART1_TxTail = tmptail; + /* get one byte from buffer and write it to UART */ + UART1_DATA = UART1_TxBuf[tmptail]; /* start transmission */ + } else { + /* tx buffer empty, disable UDRE interrupt */ + UART1_CONTROL &= ~_BV(UART1_UDRIE); + } +} + + +/************************************************************************* +Function: uart1_init() +Purpose: initialize UART1 and set baudrate +Input: baudrate using macro UART_BAUD_SELECT() +Returns: none +**************************************************************************/ +void uart1_init(uint16_t baudrate) +{ + ATOMIC_BLOCK(ATOMIC_FORCEON) { + UART1_TxHead = 0; + UART1_TxTail = 0; + UART1_RxHead = 0; + UART1_RxTail = 0; + } + + /* Set baud rate */ + if (baudrate & 0x8000) { + UART1_STATUS = (1<>8); + UBRR1L = (uint8_t) baudrate; + + /* Enable USART receiver and transmitter and receive complete interrupt */ + UART1_CONTROL = _BV(RXCIE1)|(1<> 8; + } else { + /* store new index */ + UART2_RxHead = tmphead; + /* store received data in buffer */ + UART2_RxBuf[tmphead] = data; + } + UART2_LastRxError = lastRxError; +} + + +ISR(UART2_TRANSMIT_INTERRUPT) +/************************************************************************* +Function: UART2 Data Register Empty interrupt +Purpose: called when the UART2 is ready to transmit the next byte +**************************************************************************/ +{ + uint16_t tmptail; + + + if (UART2_TxHead != UART2_TxTail) { + /* calculate and store new buffer index */ + tmptail = (UART2_TxTail + 1) & UART_TX2_BUFFER_MASK; + UART2_TxTail = tmptail; + /* get one byte from buffer and write it to UART */ + UART2_DATA = UART2_TxBuf[tmptail]; /* start transmission */ + } else { + /* tx buffer empty, disable UDRE interrupt */ + UART2_CONTROL &= ~_BV(UART2_UDRIE); + } +} + + +/************************************************************************* +Function: uart2_init() +Purpose: initialize UART2 and set baudrate +Input: baudrate using macro UART_BAUD_SELECT() +Returns: none +**************************************************************************/ +void uart2_init(uint16_t baudrate) +{ + ATOMIC_BLOCK(ATOMIC_FORCEON) { + UART2_TxHead = 0; + UART2_TxTail = 0; + UART2_RxHead = 0; + UART2_RxTail = 0; + } + + /* Set baud rate */ + if (baudrate & 0x8000) { + UART2_STATUS = (1<>8); + UBRR2L = (uint8_t) baudrate; + + /* Enable USART receiver and transmitter and receive complete interrupt */ + UART2_CONTROL = _BV(RXCIE2)|(1<> 8; + } else { + /* store new index */ + UART3_RxHead = tmphead; + /* store received data in buffer */ + UART3_RxBuf[tmphead] = data; + } + UART3_LastRxError = lastRxError; +} + + +ISR(UART3_TRANSMIT_INTERRUPT) +/************************************************************************* +Function: UART3 Data Register Empty interrupt +Purpose: called when the UART3 is ready to transmit the next byte +**************************************************************************/ +{ + uint16_t tmptail; + + + if (UART3_TxHead != UART3_TxTail) { + /* calculate and store new buffer index */ + tmptail = (UART3_TxTail + 1) & UART_TX3_BUFFER_MASK; + UART3_TxTail = tmptail; + /* get one byte from buffer and write it to UART */ + UART3_DATA = UART3_TxBuf[tmptail]; /* start transmission */ + } else { + /* tx buffer empty, disable UDRE interrupt */ + UART3_CONTROL &= ~_BV(UART3_UDRIE); + } +} + + +/************************************************************************* +Function: uart3_init() +Purpose: initialize UART3 and set baudrate +Input: baudrate using macro UART_BAUD_SELECT() +Returns: none +**************************************************************************/ +void uart3_init(uint16_t baudrate) +{ + ATOMIC_BLOCK(ATOMIC_FORCEON) { + UART3_TxHead = 0; + UART3_TxTail = 0; + UART3_RxHead = 0; + UART3_RxTail = 0; + } + + /* Set baud rate */ + if (baudrate & 0x8000) { + UART3_STATUS = (1<>8); + UBRR3L = (uint8_t) baudrate; + + /* Enable USART receiver and transmitter and receive complete interrupt */ + UART3_CONTROL = _BV(RXCIE3)|(1< @endcode + * + * @brief Interrupt UART library using the built-in UART with transmit and receive circular buffers. + * @see README.md + * + * This library can be used to transmit and receive data through the built in UART. + * + * An interrupt is generated when the UART has finished transmitting or + * receiving a byte. The interrupt handling routines use circular buffers + * for buffering received and transmitted data. + * + * The UART_RXn_BUFFER_SIZE and UART_TXn_BUFFER_SIZE constants define + * the size of the circular buffers in bytes. Note that these constants must be a power of 2. + * + * You need to define these buffer sizes as a symbol in your compiler settings or in uart.h + * + * See README.md for more detailed information. Especially that relating to symbols: USARTn_ENABLED and USARTn_LARGE_BUFFER + * + * @author Andy Gock + * @note Based on Atmel Application Note AVR306 and original library by Peter Fleury and Tim Sharpe. + */ + +/**@{*/ +#include +#include + +#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304 +#error "This library requires AVR-GCC 3.4 or later, update to newer AVR-GCC compiler !" +#endif + +/* + * constants and macros + */ + +/* Enable USART 1, 2, 3 as required */ +/* Can be defined in compiler symbol setup with -D option (preferred) */ +#ifndef USART0_ENABLED + #define USART0_ENABLED /**< Enable USART0 */ +#endif +//#define USART1_ENABLED +//#define USART2_ENABLED +//#define USART3_ENABLED + +/* Set size of receive and transmit buffers */ + +#ifndef UART_RX0_BUFFER_SIZE + #define UART_RX0_BUFFER_SIZE 128 /**< Size of the circular receive buffer, must be power of 2 */ +#endif +#ifndef UART_RX1_BUFFER_SIZE + #define UART_RX1_BUFFER_SIZE 128 /**< Size of the circular receive buffer, must be power of 2 */ +#endif +#ifndef UART_RX2_BUFFER_SIZE + #define UART_RX2_BUFFER_SIZE 128 /**< Size of the circular receive buffer, must be power of 2 */ +#endif +#ifndef UART_RX3_BUFFER_SIZE + #define UART_RX3_BUFFER_SIZE 128 /**< Size of the circular receive buffer, must be power of 2 */ +#endif + +#ifndef UART_TX0_BUFFER_SIZE + #define UART_TX0_BUFFER_SIZE 128 /**< Size of the circular transmit buffer, must be power of 2 */ +#endif +#ifndef UART_TX1_BUFFER_SIZE + #define UART_TX1_BUFFER_SIZE 128 /**< Size of the circular transmit buffer, must be power of 2 */ +#endif +#ifndef UART_TX2_BUFFER_SIZE + #define UART_TX2_BUFFER_SIZE 128 /**< Size of the circular transmit buffer, must be power of 2 */ +#endif +#ifndef UART_TX3_BUFFER_SIZE + #define UART_TX3_BUFFER_SIZE 128 /**< Size of the circular transmit buffer, must be power of 2 */ +#endif + +/* Check buffer sizes are not too large for 8-bit positioning */ + +#if (UART_RX0_BUFFER_SIZE > 256 & !defined(USART0_LARGE_BUFFER)) + #error "Buffer too large, please use -DUSART0_LARGE_BUFFER switch in compiler options" +#endif + +#if (UART_RX1_BUFFER_SIZE > 256 & !defined(USART1_LARGE_BUFFER)) + #error "Buffer too large, please use -DUSART1_LARGE_BUFFER switch in compiler options" +#endif + +#if (UART_RX2_BUFFER_SIZE > 256 & !defined(USART2_LARGE_BUFFER)) + #error "Buffer too large, please use -DUSART2_LARGE_BUFFER switch in compiler options" +#endif + +#if (UART_RX3_BUFFER_SIZE > 256 & !defined(USART3_LARGE_BUFFER)) + #error "Buffer too large, please use -DUSART3_LARGE_BUFFER switch in compiler options" +#endif + +/* Check buffer sizes are not too large for *_LARGE_BUFFER operation (16-bit positioning) */ + +#if (UART_RX0_BUFFER_SIZE > 32768) + #error "Buffer too large, maximum allowed is 32768 bytes" +#endif + +#if (UART_RX1_BUFFER_SIZE > 32768) + #error "Buffer too large, maximum allowed is 32768 bytes" +#endif + +#if (UART_RX2_BUFFER_SIZE > 32768) + #error "Buffer too large, maximum allowed is 32768 bytes" +#endif + +#if (UART_RX3_BUFFER_SIZE > 32768) + #error "Buffer too large, maximum allowed is 32768 bytes" +#endif + +/** @brief UART Baudrate Expression + * @param xtalCpu system clock in Mhz, e.g. 4000000L for 4Mhz + * @param baudRate baudrate in bps, e.g. 1200, 2400, 9600 + */ +#define UART_BAUD_SELECT(baudRate,xtalCpu) (((xtalCpu)+8UL*(baudRate))/(16UL*(baudRate))-1UL) + +/** @brief UART Baudrate Expression for ATmega double speed mode + * @param xtalCpu system clock in Mhz, e.g. 4000000L for 4Mhz + * @param baudRate baudrate in bps, e.g. 1200, 2400, 9600 + */ +#define UART_BAUD_SELECT_DOUBLE_SPEED(baudRate,xtalCpu) ((((xtalCpu)+4UL*(baudRate))/(8UL*(baudRate))-1)|0x8000) + +/* test if the size of the circular buffers fits into SRAM */ + +#if defined(USART0_ENABLED) && ( (UART_RX0_BUFFER_SIZE+UART_TX0_BUFFER_SIZE) >= (RAMEND-0x60)) + #error "size of UART_RX0_BUFFER_SIZE + UART_TX0_BUFFER_SIZE larger than size of SRAM" +#endif + +#if defined(USART1_ENABLED) && ( (UART_RX1_BUFFER_SIZE+UART_TX1_BUFFER_SIZE) >= (RAMEND-0x60)) + #error "size of UART_RX1_BUFFER_SIZE + UART_TX1_BUFFER_SIZE larger than size of SRAM" +#endif + +#if defined(USART2_ENABLED) && ( (UART_RX2_BUFFER_SIZE+UART_RX2_BUFFER_SIZE) >= (RAMEND-0x60)) + #error "size of UART_RX2_BUFFER_SIZE + UART_TX2_BUFFER_SIZE larger than size of SRAM" +#endif + +#if defined(USART3_ENABLED) && ( (UART_RX3_BUFFER_SIZE+UART_RX3_BUFFER_SIZE) >= (RAMEND-0x60)) + #error "size of UART_RX3_BUFFER_SIZE + UART_TX3_BUFFER_SIZE larger than size of SRAM" +#endif + +/* +** high byte error return code of uart_getc() +*/ +#define UART_FRAME_ERROR 0x0800 /**< Framing Error by UART */ +#define UART_OVERRUN_ERROR 0x0400 /**< Overrun condition by UART */ +#define UART_BUFFER_OVERFLOW 0x0200 /**< receive ringbuffer overflow */ +#define UART_NO_DATA 0x0100 /**< no receive data available */ + +/* Macros, to allow use of legacy names */ + +/** @brief Macro to initialize USART0 (only available on selected ATmegas) @see uart0_init */ +#define uart_init(b) uart0_init(b) + +/** @brief Macro to get received byte of USART0 from ringbuffer. (only available on selected ATmega) @see uart0_getc */ +#define uart_getc() uart0_getc() + +/** @brief Macro to peek at next byte in USART0 ringbuffer */ +#define uart_peek() uart0_peek() + +/** @brief Macro to put byte to ringbuffer for transmitting via USART0 (only available on selected ATmega) @see uart0_putc */ +#define uart_putc(d) uart0_putc(d) + +/** @brief Macro to put string to ringbuffer for transmitting via USART0 (only available on selected ATmega) @see uart0_puts */ +#define uart_puts(s) uart0_puts(s) + +/** @brief Macro to put string from program memory to ringbuffer for transmitting via USART0 (only available on selected ATmega) @see uart0_puts_p */ +#define uart_puts_p(s) uart0_puts_p(s) + +/** @brief Macro to return number of bytes waiting in the receive buffer of USART0 @see uart0_available */ +#define uart_available() uart0_available() + +/** @brief Macro to flush bytes waiting in receive buffer of USART0 @see uart0_flush */ +#define uart_flush() uart0_flush() + +/* +** function prototypes +*/ + +/** + @brief Initialize UART and set baudrate + @param baudrate Specify baudrate using macro UART_BAUD_SELECT() + @return none +*/ +extern void uart0_init(uint16_t baudrate); + + +/** + * @brief Get received byte from ringbuffer + * + * Returns in the lower byte the received character and in the + * higher byte the last receive error. + * UART_NO_DATA is returned when no data is available. + * + * @return lower byte: received byte from ringbuffer + * @return higher byte: last receive status + * - \b 0 successfully received data from UART + * - \b UART_NO_DATA + *
no receive data available + * - \b UART_BUFFER_OVERFLOW + *
Receive ringbuffer overflow. + * We are not reading the receive buffer fast enough, + * one or more received character have been dropped + * - \b UART_OVERRUN_ERROR + *
Overrun condition by UART. + * A character already present in the UART UDR register was + * not read by the interrupt handler before the next character arrived, + * one or more received characters have been dropped. + * - \b UART_FRAME_ERROR + *
Framing Error by UART + */ +extern uint16_t uart0_getc(void); + +/** + * @brief Peek at next byte in ringbuffer + * + * Returns the next byte (character) of incoming UART data without removing it from the + * internal ring buffer. That is, successive calls to uartN_peek() will return the same + * character, as will the next call to uartN_getc(). + * + * UART_NO_DATA is returned when no data is available. + * + * @return lower byte: next byte in ringbuffer + * @return higher byte: last receive status + * - \b 0 successfully received data from UART + * - \b UART_NO_DATA + *
no receive data available + * - \b UART_BUFFER_OVERFLOW + *
Receive ringbuffer overflow. + * We are not reading the receive buffer fast enough, + * one or more received character have been dropped + * - \b UART_OVERRUN_ERROR + *
Overrun condition by UART. + * A character already present in the UART UDR register was + * not read by the interrupt handler before the next character arrived, + * one or more received characters have been dropped. + * - \b UART_FRAME_ERROR + *
Framing Error by UART + */ +extern uint16_t uart0_peek(void); + +/** + * @brief Put byte to ringbuffer for transmitting via UART + * @param data byte to be transmitted + * @return none + */ +extern void uart0_putc(uint8_t data); + + +/** + * @brief Put string to ringbuffer for transmitting via UART + * + * The string is buffered by the uart library in a circular buffer + * and one character at a time is transmitted to the UART using interrupts. + * Blocks if it can not write the whole string into the circular buffer. + * + * @param s string to be transmitted + * @return none + */ +extern void uart0_puts(const char *s); + + +/** + * @brief Put string from program memory to ringbuffer for transmitting via UART. + * + * The string is buffered by the uart library in a circular buffer + * and one character at a time is transmitted to the UART using interrupts. + * Blocks if it can not write the whole string into the circular buffer. + * + * @param s program memory string to be transmitted + * @return none + * @see uart0_puts_P + */ +extern void uart0_puts_p(const char *s); + +/** + * @brief Macro to automatically put a string constant into program memory + * \param __s string in program memory + */ +#define uart_puts_P(__s) uart0_puts_p(PSTR(__s)) + +/** @brief Macro to automatically put a string constant into program memory */ +#define uart0_puts_P(__s) uart0_puts_p(PSTR(__s)) + +/** + * @brief Return number of bytes waiting in the receive buffer + * @return bytes waiting in the receive buffer + */ +extern uint16_t uart0_available(void); + +/** + * @brief Flush bytes waiting in receive buffer + */ +extern void uart0_flush(void); + + +/** @brief Initialize USART1 (only available on selected ATmegas) @see uart_init */ +extern void uart1_init(uint16_t baudrate); + +/** @brief Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */ +extern uint16_t uart1_getc(void); + +/** @brief Peek at next byte in USART1 ringbuffer */ +extern uint16_t uart1_peek(void); + +/** @brief Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */ +extern void uart1_putc(uint8_t data); + +/** @brief Put string to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts */ +extern void uart1_puts(const char *s); + +/** @brief Put string from program memory to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts_p */ +extern void uart1_puts_p(const char *s); + +/** @brief Macro to automatically put a string constant into program memory of USART1 @see uart1_puts_p */ +#define uart1_puts_P(__s) uart1_puts_p(PSTR(__s)) + +/** @brief Return number of bytes waiting in the receive buffer of USART1 */ +extern uint16_t uart1_available(void); + +/** @brief Flush bytes waiting in receive buffer of USART1 */ +extern void uart1_flush(void); + + +/** @brief Initialize USART2 (only available on selected ATmegas) @see uart_init */ +extern void uart2_init(uint16_t baudrate); + +/** @brief Get received byte of USART2 from ringbuffer. (only available on selected ATmega) @see uart_getc */ +extern uint16_t uart2_getc(void); + +/** @brief Peek at next byte in USART2 ringbuffer */ +extern uint16_t uart2_peek(void); + +/** @brief Put byte to ringbuffer for transmitting via USART2 (only available on selected ATmega) @see uart_putc */ +extern void uart2_putc(uint8_t data); + +/** @brief Put string to ringbuffer for transmitting via USART2 (only available on selected ATmega) @see uart_puts */ +extern void uart2_puts(const char *s); + +/** @brief Put string from program memory to ringbuffer for transmitting via USART2 (only available on selected ATmega) @see uart_puts_p */ +extern void uart2_puts_p(const char *s); + +/** @brief Macro to automatically put a string constant into program memory of USART2 @see uart2_puts_p */ +#define uart2_puts_P(__s) uart2_puts_p(PSTR(__s)) + +/** @brief Return number of bytes waiting in the receive buffer of USART2 */ +extern uint16_t uart2_available(void); + +/** @brief Flush bytes waiting in receive buffer of USART2 */ +extern void uart2_flush(void); + + +/** @brief Initialize USART3 (only available on selected ATmegas) @see uart_init */ +extern void uart3_init(uint16_t baudrate); + +/** @brief Get received byte of USART3 from ringbuffer. (only available on selected ATmega) @see uart_getc */ +extern uint16_t uart3_getc(void); + +/** @brief Peek at next byte in USART3 ringbuffer */ +extern uint16_t uart3_peek(void); + +/** @brief Put byte to ringbuffer for transmitting via USART3 (only available on selected ATmega) @see uart_putc */ +extern void uart3_putc(uint8_t data); + +/** @brief Put string to ringbuffer for transmitting via USART3 (only available on selected ATmega) @see uart_puts */ +extern void uart3_puts(const char *s); + +/** @brief Put string from program memory to ringbuffer for transmitting via USART3 (only available on selected ATmega) @see uart_puts_p */ +extern void uart3_puts_p(const char *s); + +/** @brief Macro to automatically put a string constant into program memory of USART3 @see uart3_puts_p */ +#define uart3_puts_P(__s) uart3_puts_p(PSTR(__s)) + +/** @brief Return number of bytes waiting in the receive buffer of USART3 */ +extern uint16_t uart3_available(void); + +/** @brief Flush bytes waiting in receive buffer of USART3 */ +extern void uart3_flush(void); + +/**@}*/ + +#endif // UART_H + diff --git a/sw/lib/util/OneWire_direct_gpio.h b/sw/lib/util/OneWire_direct_gpio.h new file mode 100644 index 0000000..0771367 --- /dev/null +++ b/sw/lib/util/OneWire_direct_gpio.h @@ -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 + +// 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 +#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 diff --git a/sw/lib/util/OneWire_direct_regtype.h b/sw/lib/util/OneWire_direct_regtype.h new file mode 100644 index 0000000..21c4634 --- /dev/null +++ b/sw/lib/util/OneWire_direct_regtype.h @@ -0,0 +1,52 @@ +#ifndef OneWire_Direct_RegType_h +#define OneWire_Direct_RegType_h + +#include + +// 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 -- cgit v1.2.3