diff options
| -rw-r--r-- | sw/Makefile | 115 | ||||
| -rw-r--r-- | sw/lib/DallasTemperature/DallasTemperature.cpp | 928 | ||||
| -rw-r--r-- | sw/lib/DallasTemperature/DallasTemperature.h | 269 | ||||
| -rw-r--r-- | sw/lib/LTC2400/LTC24XX_general.cpp | 434 | ||||
| -rw-r--r-- | sw/lib/LTC2400/LTC24XX_general.h | 501 | ||||
| -rw-r--r-- | sw/lib/OneWire/OneWire.cpp | 580 | ||||
| -rw-r--r-- | sw/lib/OneWire/OneWire.h | 182 | ||||
| -rw-r--r-- | sw/lib/OneWire/util/OneWire_direct_gpio.h | 420 | ||||
| -rw-r--r-- | sw/lib/OneWire/util/OneWire_direct_regtype.h | 52 | ||||
| -rw-r--r-- | sw/lib/delay.h | 9 | ||||
| -rw-r--r-- | sw/main.cpp | 36 |
11 files changed, 3526 insertions, 0 deletions
diff --git a/sw/Makefile b/sw/Makefile new file mode 100644 index 0000000..06d8dd4 --- /dev/null +++ b/sw/Makefile @@ -0,0 +1,115 @@ +# Location of build tools +CC=avr-gcc +CXX=avr-g++ +OBJCOPY=avr-objcopy +SIZE=avr-size +AVRDUDE=avrdude + +# Modify this to the device name of the UART used for AVRDUDE +AVRDUDE_DEV=usb +PROG = dragon_isp + +# Modify this to the CPU you are using +PART=atmega328 +AVRDUDE_PART=m328 + +# Cpu frequency is 16MHz, divider = 2 +F_CPU="(16000000UL/2)" + +# Directory for built objects +BUILD_DIR=build + +# Port/application object files +APP_NAME = testapp1 + +# Application object files +APP_CXX_OBJECTS = main.o +APP_OBJECTS = + +# Library object files to build and use +LIB_OBJECTS = +LIB_CXX_OBJECTS = +LIB_ASM_OBJECTS = +LIB_DIR = lib + +# Collection of built objects +ALL_OBJECTS = $(LIB_OBJECTS) $(LIB_ASM_OBJECTS) $(APP_OBJECTS) $(APP_CXX_OBJECTS) +BUILT_OBJECTS = $(patsubst %,$(BUILD_DIR)/%,$(ALL_OBJECTS)) + +# Target application filenames (.elf and .hex) for each application object +APP_ELF = $(APP_NAME).elf +APP_HEX = $(APP_NAME).hex + +# Search build/output directory for dependencies +vpath %.o ./$(BUILD_DIR) +vpath %.elf ./$(BUILD_DIR) +vpath %.hex ./$(BUILD_DIR) + +# GCC flags +CFLAGS=-g -mmcu=$(PART) -O1 -Wall -Werror -DF_CPU=$(F_CPU) +INCLUDES=-I. -I$(LIB_DIR) + + +################# +# Build targets # +################# + +# All applications +all: $(BUILD_DIR) $(APP_HEX) Makefile + +# Make build/output directory +$(BUILD_DIR): + mkdir $(BUILD_DIR) + +# Application HEX files +$(APP_HEX): %.hex: %.elf + @echo Building $@ + $(OBJCOPY) -j .text -j .data -O ihex $(BUILD_DIR)/$< $(BUILD_DIR)/$@ + +# Application ELF files +$(APP_ELF): %.elf: $(LIB_OBJECTS) $(LIB_CXX_OBJECTS) $(LIB_ASM_OBJECTS) $(APP_OBJECTS) $(APP_CXX_OBJECTS) + $(CXX) $(CFLAGS) $(BUILT_OBJECTS) --output $(BUILD_DIR)/$@ -Wl,-Map,$(BUILD_DIR)/$(basename $@).map + +# Application objects builder +$(APP_OBJECTS): %.o: %.c + $(CC) -c $(CFLAGS) $(INCLUDES) $< -o $(BUILD_DIR)/$(notdir $@) + +$(APP_CXX_OBJECTS): %.o: %.cpp + $(CXX) -c $(CFLAGS) $(INCLUDES) $< -o $(BUILD_DIR)/$(notdir $@) + +# Application objects builder +$(LIB_OBJECTS): %.o: $(LIB_DIR)/%.c + $(CC) -c $(CFLAGS) $(INCLUDES) $< -o $(BUILD_DIR)/$(notdir $@) + +$(LIB_CXX_OBJECTS): %.o: $(LIB_DIR)/%.cpp + $(CXX) -c $(CFLAGS) $(INCLUDES) $< -o $(BUILD_DIR)/$(notdir $@) + +$(LIB_ASM_OBJECTS): %.o: $(LIB_DIR)/%.s + $(CC) -c $(CFLAGS) -x assembler-with-cpp $(INCLUDES) $< -o $(BUILD_DIR)/$(notdir $@) + +# .lst file builder +%.lst: %.c + $(CC) $(CFLAGS) $(INCLUDES) -Wa,-al $< > $@ + +%.lst: %.cpp + $(CXX) $(CFLAGS) $(INCLUDES) -Wa,-al $< > $@ + +# Clean +clean: + rm -f *.o *.elf *.map *.hex *.bin *.lst + rm -rf doxygen-avr + rm -rf build + +# Send to device +program: $(APP_HEX) + $(SIZE) -C $(BUILD_DIR)/$(APP_ELF) + $(AVRDUDE) $(AVRDUDE_FLAGS) -c $(PROG) -P $(AVRDUDE_DEV) -p $(AVRDUDE_PART) -U flash:w:$(BUILD_DIR)/$(APP_HEX) -v + +fuse: + $(AVRDUDE) $(AVRDUDE_FLAGS) -c $(PROG) -P $(AVRDUDE_DEV) -p $(AVRDUDE_PART) -U lfuse:w:0x60:m -U hfuse:w:0xdc:m -U efuse:w:0xff:m -v + +interactive: + $(AVRDUDE) $(AVRDUDE_FLAGS) -c $(PROG) -P $(AVRDUDE_DEV) -p $(AVRDUDE_PART) -t -v + +doxygen: + doxygen ./Doxyfile diff --git a/sw/lib/DallasTemperature/DallasTemperature.cpp b/sw/lib/DallasTemperature/DallasTemperature.cpp new file mode 100644 index 0000000..a1107ec --- /dev/null +++ b/sw/lib/DallasTemperature/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/DallasTemperature.h b/sw/lib/DallasTemperature/DallasTemperature.h new file mode 100644 index 0000000..49a059d --- /dev/null +++ b/sw/lib/DallasTemperature/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 <inttypes.h>
+#ifdef __STM32F1__
+#include <OneWireSTM.h>
+#else
+#include <OneWire.h>
+#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 new file mode 100644 index 0000000..615edff --- /dev/null +++ b/sw/lib/LTC2400/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 <stdint.h>
+#include <Arduino.h>
+#include "Linduino.h"
+#include <SPI.h>
+#include "LT_SPI.h"
+#include <Wire.h>
+#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 new file mode 100644 index 0000000..42fd65a --- /dev/null +++ b/sw/lib/LTC2400/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/OneWire.cpp b/sw/lib/OneWire/OneWire.cpp new file mode 100644 index 0000000..38bf4ee --- /dev/null +++ b/sw/lib/OneWire/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 <Arduino.h> +#include "OneWire.h" +#include "util/OneWire_direct_gpio.h" + + +void OneWire::begin(uint8_t pin) +{ + pinMode(pin, INPUT); + bitmask = PIN_TO_BITMASK(pin); + baseReg = PIN_TO_BASEREG(pin); +#if ONEWIRE_SEARCH + reset_search(); +#endif +} + + +// Perform the onewire reset function. We will wait up to 250uS for +// the bus to come high, if it doesn't then it is broken or shorted +// and we return a 0; +// +// Returns 1 if a device asserted a presence pulse, 0 otherwise. +// +uint8_t OneWire::reset(void) +{ + IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask; + volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg; + uint8_t r; + uint8_t retries = 125; + + noInterrupts(); + DIRECT_MODE_INPUT(reg, mask); + interrupts(); + // wait until the wire is high... just in case + do { + if (--retries == 0) return 0; + delayMicroseconds(2); + } while ( !DIRECT_READ(reg, mask)); + + noInterrupts(); + DIRECT_WRITE_LOW(reg, mask); + DIRECT_MODE_OUTPUT(reg, mask); // drive output low + interrupts(); + delayMicroseconds(480); + noInterrupts(); + DIRECT_MODE_INPUT(reg, mask); // allow it to float + delayMicroseconds(70); + r = !DIRECT_READ(reg, mask); + interrupts(); + delayMicroseconds(410); + return r; +} + +// +// Write a bit. Port and bit is used to cut lookup time and provide +// more certain timing. +// +void OneWire::write_bit(uint8_t v) +{ + IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask; + volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg; + + if (v & 1) { + noInterrupts(); + DIRECT_WRITE_LOW(reg, mask); + DIRECT_MODE_OUTPUT(reg, mask); // drive output low + delayMicroseconds(10); + DIRECT_WRITE_HIGH(reg, mask); // drive output high + interrupts(); + delayMicroseconds(55); + } else { + noInterrupts(); + DIRECT_WRITE_LOW(reg, mask); + DIRECT_MODE_OUTPUT(reg, mask); // drive output low + delayMicroseconds(65); + DIRECT_WRITE_HIGH(reg, mask); // drive output high + interrupts(); + delayMicroseconds(5); + } +} + +// +// Read a bit. Port and bit is used to cut lookup time and provide +// more certain timing. +// +uint8_t OneWire::read_bit(void) +{ + IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask; + volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg; + uint8_t r; + + noInterrupts(); + DIRECT_MODE_OUTPUT(reg, mask); + DIRECT_WRITE_LOW(reg, mask); + delayMicroseconds(3); + DIRECT_MODE_INPUT(reg, mask); // let pin float, pull up will raise + delayMicroseconds(10); + r = DIRECT_READ(reg, mask); + interrupts(); + delayMicroseconds(53); + return r; +} + +// +// Write a byte. The writing code uses the active drivers to raise the +// pin high, if you need power after the write (e.g. DS18S20 in +// parasite power mode) then set 'power' to 1, otherwise the pin will +// go tri-state at the end of the write to avoid heating in a short or +// other mishap. +// +void OneWire::write(uint8_t v, uint8_t power /* = 0 */) { + uint8_t bitMask; + + for (bitMask = 0x01; bitMask; bitMask <<= 1) { + OneWire::write_bit( (bitMask & v)?1:0); + } + if ( !power) { + noInterrupts(); + DIRECT_MODE_INPUT(baseReg, bitmask); + DIRECT_WRITE_LOW(baseReg, bitmask); + interrupts(); + } +} + +void OneWire::write_bytes(const uint8_t *buf, uint16_t count, bool power /* = 0 */) { + for (uint16_t i = 0 ; i < count ; i++) + write(buf[i]); + if (!power) { + noInterrupts(); + DIRECT_MODE_INPUT(baseReg, bitmask); + DIRECT_WRITE_LOW(baseReg, bitmask); + interrupts(); + } +} + +// +// Read a byte +// +uint8_t OneWire::read() { + uint8_t bitMask; + uint8_t r = 0; + + for (bitMask = 0x01; bitMask; bitMask <<= 1) { + if ( OneWire::read_bit()) r |= bitMask; + } + return r; +} + +void OneWire::read_bytes(uint8_t *buf, uint16_t count) { + for (uint16_t i = 0 ; i < count ; i++) + buf[i] = read(); +} + +// +// Do a ROM select +// +void OneWire::select(const uint8_t rom[8]) +{ + uint8_t i; + + write(0x55); // Choose ROM + + for (i = 0; i < 8; i++) write(rom[i]); +} + +// +// Do a ROM skip +// +void OneWire::skip() +{ + write(0xCC); // Skip ROM +} + +void OneWire::depower() +{ + noInterrupts(); + DIRECT_MODE_INPUT(baseReg, bitmask); + interrupts(); +} + +#if ONEWIRE_SEARCH + +// +// You need to use this function to start a search again from the beginning. +// You do not need to do it for the first search, though you could. +// +void OneWire::reset_search() +{ + // reset the search state + LastDiscrepancy = 0; + LastDeviceFlag = false; + LastFamilyDiscrepancy = 0; + for(int i = 7; ; i--) { + ROM_NO[i] = 0; + if ( i == 0) break; + } +} + +// Setup the search to find the device type 'family_code' on the next call +// to search(*newAddr) if it is present. +// +void OneWire::target_search(uint8_t family_code) +{ + // set the search state to find SearchFamily type devices + ROM_NO[0] = family_code; + for (uint8_t i = 1; i < 8; i++) + ROM_NO[i] = 0; + LastDiscrepancy = 64; + LastFamilyDiscrepancy = 0; + LastDeviceFlag = false; +} + +// +// Perform a search. If this function returns a '1' then it has +// enumerated the next device and you may retrieve the ROM from the +// OneWire::address variable. If there are no devices, no further +// devices, or something horrible happens in the middle of the +// enumeration then a 0 is returned. If a new device is found then +// its address is copied to newAddr. Use OneWire::reset_search() to +// start over. +// +// --- Replaced by the one from the Dallas Semiconductor web site --- +//-------------------------------------------------------------------------- +// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing +// search state. +// Return TRUE : device found, ROM number in ROM_NO buffer +// FALSE : device not found, end of search +// +bool OneWire::search(uint8_t *newAddr, bool search_mode /* = true */) +{ + uint8_t id_bit_number; + uint8_t last_zero, rom_byte_number; + bool search_result; + uint8_t id_bit, cmp_id_bit; + + unsigned char rom_byte_mask, search_direction; + + // initialize for search + id_bit_number = 1; + last_zero = 0; + rom_byte_number = 0; + rom_byte_mask = 1; + search_result = false; + + // if the last call was not the last one + if (!LastDeviceFlag) { + // 1-Wire reset + if (!reset()) { + // reset the search + LastDiscrepancy = 0; + LastDeviceFlag = false; + LastFamilyDiscrepancy = 0; + return false; + } + + // issue the search command + if (search_mode == true) { + write(0xF0); // NORMAL SEARCH + } else { + write(0xEC); // CONDITIONAL SEARCH + } + + // loop to do the search + do + { + // read a bit and its complement + id_bit = read_bit(); + cmp_id_bit = read_bit(); + + // check for no devices on 1-wire + if ((id_bit == 1) && (cmp_id_bit == 1)) { + break; + } else { + // all devices coupled have 0 or 1 + if (id_bit != cmp_id_bit) { + search_direction = id_bit; // bit write value for search + } else { + // if this discrepancy if before the Last Discrepancy + // on a previous next then pick the same as last time + if (id_bit_number < LastDiscrepancy) { + search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0); + } else { + // if equal to last pick 1, if not then pick 0 + search_direction = (id_bit_number == LastDiscrepancy); + } + // if 0 was picked then record its position in LastZero + if (search_direction == 0) { + last_zero = id_bit_number; + + // check for Last discrepancy in family + if (last_zero < 9) + LastFamilyDiscrepancy = last_zero; + } + } + + // set or clear the bit in the ROM byte rom_byte_number + // with mask rom_byte_mask + if (search_direction == 1) + ROM_NO[rom_byte_number] |= rom_byte_mask; + else + ROM_NO[rom_byte_number] &= ~rom_byte_mask; + + // serial number search direction write bit + write_bit(search_direction); + + // increment the byte counter id_bit_number + // and shift the mask rom_byte_mask + id_bit_number++; + rom_byte_mask <<= 1; + + // if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask + if (rom_byte_mask == 0) { + rom_byte_number++; + rom_byte_mask = 1; + } + } + } + while(rom_byte_number < 8); // loop until through all ROM bytes 0-7 + + // if the search was successful then + if (!(id_bit_number < 65)) { + // search successful so set LastDiscrepancy,LastDeviceFlag,search_result + LastDiscrepancy = last_zero; + + // check for last device + if (LastDiscrepancy == 0) { + LastDeviceFlag = true; + } + search_result = true; + } + } + + // if no device found then reset counters so next 'search' will be like a first + if (!search_result || !ROM_NO[0]) { + LastDiscrepancy = 0; + LastDeviceFlag = false; + LastFamilyDiscrepancy = 0; + search_result = false; + } else { + for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i]; + } + return search_result; + } + +#endif + +#if ONEWIRE_CRC +// The 1-Wire CRC scheme is described in Maxim Application Note 27: +// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products" +// + +#if ONEWIRE_CRC8_TABLE +// Dow-CRC using polynomial X^8 + X^5 + X^4 + X^0 +// Tiny 2x16 entry CRC table created by Arjen Lentz +// See http://lentz.com.au/blog/calculating-crc-with-a-tiny-32-entry-lookup-table +static const uint8_t PROGMEM dscrc2x16_table[] = { + 0x00, 0x5E, 0xBC, 0xE2, 0x61, 0x3F, 0xDD, 0x83, + 0xC2, 0x9C, 0x7E, 0x20, 0xA3, 0xFD, 0x1F, 0x41, + 0x00, 0x9D, 0x23, 0xBE, 0x46, 0xDB, 0x65, 0xF8, + 0x8C, 0x11, 0xAF, 0x32, 0xCA, 0x57, 0xE9, 0x74 +}; + +// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM +// and the registers. (Use tiny 2x16 entry CRC table) +uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len) +{ + uint8_t crc = 0; + + while (len--) { + crc = *addr++ ^ crc; // just re-using crc as intermediate + crc = pgm_read_byte(dscrc2x16_table + (crc & 0x0f)) ^ + pgm_read_byte(dscrc2x16_table + 16 + ((crc >> 4) & 0x0f)); + } + + return crc; +} +#else +// +// Compute a Dallas Semiconductor 8 bit CRC directly. +// this is much slower, but a little smaller, than the lookup table. +// +uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len) +{ + uint8_t crc = 0; + + while (len--) { +#if defined(__AVR__) + crc = _crc_ibutton_update(crc, *addr++); +#else + uint8_t inbyte = *addr++; + for (uint8_t i = 8; i; i--) { + uint8_t mix = (crc ^ inbyte) & 0x01; + crc >>= 1; + if (mix) crc ^= 0x8C; + inbyte >>= 1; + } +#endif + } + return crc; +} +#endif + +#if ONEWIRE_CRC16 +bool OneWire::check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc) +{ + crc = ~crc16(input, len, crc); + return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1]; +} + +uint16_t OneWire::crc16(const uint8_t* input, uint16_t len, uint16_t crc) +{ +#if defined(__AVR__) + for (uint16_t i = 0 ; i < len ; i++) { + crc = _crc16_update(crc, input[i]); + } +#else + static const uint8_t oddparity[16] = + { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 }; + + for (uint16_t i = 0 ; i < len ; i++) { + // Even though we're just copying a byte from the input, + // we'll be doing 16-bit computation with it. + uint16_t cdata = input[i]; + cdata = (cdata ^ crc) & 0xff; + crc >>= 8; + + if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4]) + crc ^= 0xC001; + + cdata <<= 6; + crc ^= cdata; + cdata <<= 1; + crc ^= cdata; + } +#endif + return crc; +} +#endif + +#endif diff --git a/sw/lib/OneWire/OneWire.h b/sw/lib/OneWire/OneWire.h new file mode 100644 index 0000000..a7bfab7 --- /dev/null +++ b/sw/lib/OneWire/OneWire.h @@ -0,0 +1,182 @@ +#ifndef OneWire_h +#define OneWire_h + +#ifdef __cplusplus + +#include <stdint.h> + +#if defined(__AVR__) +#include <util/crc16.h> +#endif + +#if ARDUINO >= 100 +#include <Arduino.h> // for delayMicroseconds, digitalPinToBitMask, etc +#else +#include "WProgram.h" // for delayMicroseconds +#include "pins_arduino.h" // for digitalPinToBitMask, etc +#endif + +// You can exclude certain features from OneWire. In theory, this +// might save some space. In practice, the compiler automatically +// removes unused code (technically, the linker, using -fdata-sections +// and -ffunction-sections when compiling, and Wl,--gc-sections +// when linking), so most of these will not result in any code size +// reduction. Well, unless you try to use the missing features +// and redesign your program to not need them! ONEWIRE_CRC8_TABLE +// is the exception, because it selects a fast but large algorithm +// or a small but slow algorithm. + +// you can exclude onewire_search by defining that to 0 +#ifndef ONEWIRE_SEARCH +#define ONEWIRE_SEARCH 1 +#endif + +// You can exclude CRC checks altogether by defining this to 0 +#ifndef ONEWIRE_CRC +#define ONEWIRE_CRC 1 +#endif + +// Select the table-lookup method of computing the 8-bit CRC +// by setting this to 1. The lookup table enlarges code size by +// about 250 bytes. It does NOT consume RAM (but did in very +// old versions of OneWire). If you disable this, a slower +// but very compact algorithm is used. +#ifndef ONEWIRE_CRC8_TABLE +#define ONEWIRE_CRC8_TABLE 1 +#endif + +// You can allow 16-bit CRC checks by defining this to 1 +// (Note that ONEWIRE_CRC must also be 1.) +#ifndef ONEWIRE_CRC16 +#define ONEWIRE_CRC16 1 +#endif + +// Board-specific macros for direct GPIO +#include "util/OneWire_direct_regtype.h" + +class OneWire +{ + private: + IO_REG_TYPE bitmask; + volatile IO_REG_TYPE *baseReg; + +#if ONEWIRE_SEARCH + // global search state + unsigned char ROM_NO[8]; + uint8_t LastDiscrepancy; + uint8_t LastFamilyDiscrepancy; + bool LastDeviceFlag; +#endif + + public: + OneWire() { } + OneWire(uint8_t pin) { begin(pin); } + void begin(uint8_t pin); + + // Perform a 1-Wire reset cycle. Returns 1 if a device responds + // with a presence pulse. Returns 0 if there is no device or the + // bus is shorted or otherwise held low for more than 250uS + uint8_t reset(void); + + // Issue a 1-Wire rom select command, you do the reset first. + void select(const uint8_t rom[8]); + + // Issue a 1-Wire rom skip command, to address all on bus. + void skip(void); + + // Write a byte. If 'power' is one then the wire is held high at + // the end for parasitically powered devices. You are responsible + // for eventually depowering it by calling depower() or doing + // another read or write. + void write(uint8_t v, uint8_t power = 0); + + void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0); + + // Read a byte. + uint8_t read(void); + + void read_bytes(uint8_t *buf, uint16_t count); + + // Write a bit. The bus is always left powered at the end, see + // note in write() about that. + void write_bit(uint8_t v); + + // Read a bit. + uint8_t read_bit(void); + + // Stop forcing power onto the bus. You only need to do this if + // you used the 'power' flag to write() or used a write_bit() call + // and aren't about to do another read or write. You would rather + // not leave this powered if you don't have to, just in case + // someone shorts your bus. + void depower(void); + +#if ONEWIRE_SEARCH + // Clear the search state so that if will start from the beginning again. + void reset_search(); + + // Setup the search to find the device type 'family_code' on the next call + // to search(*newAddr) if it is present. + void target_search(uint8_t family_code); + + // Look for the next device. Returns 1 if a new address has been + // returned. A zero might mean that the bus is shorted, there are + // no devices, or you have already retrieved all of them. It + // might be a good idea to check the CRC to make sure you didn't + // get garbage. The order is deterministic. You will always get + // the same devices in the same order. + bool search(uint8_t *newAddr, bool search_mode = true); +#endif + +#if ONEWIRE_CRC + // Compute a Dallas Semiconductor 8 bit CRC, these are used in the + // ROM and scratchpad registers. + static uint8_t crc8(const uint8_t *addr, uint8_t len); + +#if ONEWIRE_CRC16 + // Compute the 1-Wire CRC16 and compare it against the received CRC. + // Example usage (reading a DS2408): + // // Put everything in a buffer so we can compute the CRC easily. + // uint8_t buf[13]; + // buf[0] = 0xF0; // Read PIO Registers + // buf[1] = 0x88; // LSB address + // buf[2] = 0x00; // MSB address + // WriteBytes(net, buf, 3); // Write 3 cmd bytes + // ReadBytes(net, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16 + // if (!CheckCRC16(buf, 11, &buf[11])) { + // // Handle error. + // } + // + // @param input - Array of bytes to checksum. + // @param len - How many bytes to use. + // @param inverted_crc - The two CRC16 bytes in the received data. + // This should just point into the received data, + // *not* at a 16-bit integer. + // @param crc - The crc starting value (optional) + // @return True, iff the CRC matches. + static bool check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc = 0); + + // Compute a Dallas Semiconductor 16 bit CRC. This is required to check + // the integrity of data received from many 1-Wire devices. Note that the + // CRC computed here is *not* what you'll get from the 1-Wire network, + // for two reasons: + // 1) The CRC is transmitted bitwise inverted. + // 2) Depending on the endian-ness of your processor, the binary + // representation of the two-byte return value may have a different + // byte order than the two bytes you get from 1-Wire. + // @param input - Array of bytes to checksum. + // @param len - How many bytes to use. + // @param crc - The crc starting value (optional) + // @return The CRC16, as defined by Dallas Semiconductor. + static uint16_t crc16(const uint8_t* input, uint16_t len, uint16_t crc = 0); +#endif +#endif +}; + +// Prevent this name from leaking into Arduino sketches +#ifdef IO_REG_TYPE +#undef IO_REG_TYPE +#endif + +#endif // __cplusplus +#endif // OneWire_h diff --git a/sw/lib/OneWire/util/OneWire_direct_gpio.h b/sw/lib/OneWire/util/OneWire_direct_gpio.h new file mode 100644 index 0000000..0771367 --- /dev/null +++ b/sw/lib/OneWire/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 <stdint.h> + +// Platform specific I/O definitions + +#if defined(__AVR__) +#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin))) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint8_t +#define IO_REG_BASE_ATTR asm("r30") +#define IO_REG_MASK_ATTR +#if defined(__AVR_ATmega4809__) +#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) ((*((base)-8)) &= ~(mask)) +#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)-8)) |= (mask)) +#define DIRECT_WRITE_LOW(base, mask) ((*((base)-4)) &= ~(mask)) +#define DIRECT_WRITE_HIGH(base, mask) ((*((base)-4)) |= (mask)) +#else +#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) &= ~(mask)) +#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+1)) |= (mask)) +#define DIRECT_WRITE_LOW(base, mask) ((*((base)+2)) &= ~(mask)) +#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+2)) |= (mask)) +#endif + +#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__) +#define PIN_TO_BASEREG(pin) (portOutputRegister(pin)) +#define PIN_TO_BITMASK(pin) (1) +#define IO_REG_TYPE uint8_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR __attribute__ ((unused)) +#define DIRECT_READ(base, mask) (*((base)+512)) +#define DIRECT_MODE_INPUT(base, mask) (*((base)+640) = 0) +#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+640) = 1) +#define DIRECT_WRITE_LOW(base, mask) (*((base)+256) = 1) +#define DIRECT_WRITE_HIGH(base, mask) (*((base)+128) = 1) + +#elif defined(__MKL26Z64__) +#define PIN_TO_BASEREG(pin) (portOutputRegister(pin)) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint8_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) ((*((base)+16) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) (*((base)+20) &= ~(mask)) +#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+20) |= (mask)) +#define DIRECT_WRITE_LOW(base, mask) (*((base)+8) = (mask)) +#define DIRECT_WRITE_HIGH(base, mask) (*((base)+4) = (mask)) + +#elif defined(__IMXRT1052__) || defined(__IMXRT1062__) +#define PIN_TO_BASEREG(pin) (portOutputRegister(pin)) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) ((*((base)+2) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) (*((base)+1) &= ~(mask)) +#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+1) |= (mask)) +#define DIRECT_WRITE_LOW(base, mask) (*((base)+34) = (mask)) +#define DIRECT_WRITE_HIGH(base, mask) (*((base)+33) = (mask)) + +#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__) +// Arduino 1.5.1 may have a bug in delayMicroseconds() on Arduino Due. +// http://arduino.cc/forum/index.php/topic,141030.msg1076268.html#msg1076268 +// If you have trouble with OneWire on Arduino Due, please check the +// status of delayMicroseconds() before reporting a bug in OneWire! +#define PIN_TO_BASEREG(pin) (&(digitalPinToPort(pin)->PIO_PER)) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) (((*((base)+15)) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) ((*((base)+5)) = (mask)) +#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+4)) = (mask)) +#define DIRECT_WRITE_LOW(base, mask) ((*((base)+13)) = (mask)) +#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+12)) = (mask)) +#ifndef PROGMEM +#define PROGMEM +#endif +#ifndef pgm_read_byte +#define pgm_read_byte(addr) (*(const uint8_t *)(addr)) +#endif + +#elif defined(__PIC32MX__) +#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin))) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0) //PORTX + 0x10 +#define DIRECT_MODE_INPUT(base, mask) ((*(base+2)) = (mask)) //TRISXSET + 0x08 +#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) = (mask)) //TRISXCLR + 0x04 +#define DIRECT_WRITE_LOW(base, mask) ((*(base+8+1)) = (mask)) //LATXCLR + 0x24 +#define DIRECT_WRITE_HIGH(base, mask) ((*(base+8+2)) = (mask)) //LATXSET + 0x28 + +#elif defined(ARDUINO_ARCH_ESP8266) +// Special note: I depend on the ESP community to maintain these definitions and +// submit good pull requests. I can not answer any ESP questions or help you +// resolve any problems related to ESP chips. Please do not contact me and please +// DO NOT CREATE GITHUB ISSUES for ESP support. All ESP questions must be asked +// on ESP community forums. +#define PIN_TO_BASEREG(pin) ((volatile uint32_t*) GPO) +#define PIN_TO_BITMASK(pin) (1 << pin) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) ((GPI & (mask)) ? 1 : 0) //GPIO_IN_ADDRESS +#define DIRECT_MODE_INPUT(base, mask) (GPE &= ~(mask)) //GPIO_ENABLE_W1TC_ADDRESS +#define DIRECT_MODE_OUTPUT(base, mask) (GPE |= (mask)) //GPIO_ENABLE_W1TS_ADDRESS +#define DIRECT_WRITE_LOW(base, mask) (GPOC = (mask)) //GPIO_OUT_W1TC_ADDRESS +#define DIRECT_WRITE_HIGH(base, mask) (GPOS = (mask)) //GPIO_OUT_W1TS_ADDRESS + +#elif defined(ARDUINO_ARCH_ESP32) +#include <driver/rtc_io.h> +#define PIN_TO_BASEREG(pin) (0) +#define PIN_TO_BITMASK(pin) (pin) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR + +static inline __attribute__((always_inline)) +IO_REG_TYPE directRead(IO_REG_TYPE pin) +{ + if ( pin < 32 ) + return (GPIO.in >> pin) & 0x1; + else if ( pin < 40 ) + return (GPIO.in1.val >> (pin - 32)) & 0x1; + + return 0; +} + +static inline __attribute__((always_inline)) +void directWriteLow(IO_REG_TYPE pin) +{ + if ( pin < 32 ) + GPIO.out_w1tc = ((uint32_t)1 << pin); + else if ( pin < 34 ) + GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32)); +} + +static inline __attribute__((always_inline)) +void directWriteHigh(IO_REG_TYPE pin) +{ + if ( pin < 32 ) + GPIO.out_w1ts = ((uint32_t)1 << pin); + else if ( pin < 34 ) + GPIO.out1_w1ts.val = ((uint32_t)1 << (pin - 32)); +} + +static inline __attribute__((always_inline)) +void directModeInput(IO_REG_TYPE pin) +{ + if ( digitalPinIsValid(pin) ) + { + uint32_t rtc_reg(rtc_gpio_desc[pin].reg); + + if ( rtc_reg ) // RTC pins PULL settings + { + ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux); + ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown); + } + + if ( pin < 32 ) + GPIO.enable_w1tc = ((uint32_t)1 << pin); + else + GPIO.enable1_w1tc.val = ((uint32_t)1 << (pin - 32)); + + uint32_t pinFunction((uint32_t)2 << FUN_DRV_S); // what are the drivers? + pinFunction |= FUN_IE; // input enable but required for output as well? + pinFunction |= ((uint32_t)2 << MCU_SEL_S); + + ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction; + + GPIO.pin[pin].val = 0; + } +} + +static inline __attribute__((always_inline)) +void directModeOutput(IO_REG_TYPE pin) +{ + if ( digitalPinIsValid(pin) && pin <= 33 ) // pins above 33 can be only inputs + { + uint32_t rtc_reg(rtc_gpio_desc[pin].reg); + + if ( rtc_reg ) // RTC pins PULL settings + { + ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux); + ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown); + } + + if ( pin < 32 ) + GPIO.enable_w1ts = ((uint32_t)1 << pin); + else // already validated to pins <= 33 + GPIO.enable1_w1ts.val = ((uint32_t)1 << (pin - 32)); + + uint32_t pinFunction((uint32_t)2 << FUN_DRV_S); // what are the drivers? + pinFunction |= FUN_IE; // input enable but required for output as well? + pinFunction |= ((uint32_t)2 << MCU_SEL_S); + + ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction; + + GPIO.pin[pin].val = 0; + } +} + +#define DIRECT_READ(base, pin) directRead(pin) +#define DIRECT_WRITE_LOW(base, pin) directWriteLow(pin) +#define DIRECT_WRITE_HIGH(base, pin) directWriteHigh(pin) +#define DIRECT_MODE_INPUT(base, pin) directModeInput(pin) +#define DIRECT_MODE_OUTPUT(base, pin) directModeOutput(pin) +// https://github.com/PaulStoffregen/OneWire/pull/47 +// https://github.com/stickbreaker/OneWire/commit/6eb7fc1c11a15b6ac8c60e5671cf36eb6829f82c +#ifdef interrupts +#undef interrupts +#endif +#ifdef noInterrupts +#undef noInterrupts +#endif +#define noInterrupts() {portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;portENTER_CRITICAL(&mux) +#define interrupts() portEXIT_CRITICAL(&mux);} +//#warning "ESP32 OneWire testing" + +#elif defined(ARDUINO_ARCH_STM32) +#define PIN_TO_BASEREG(pin) (0) +#define PIN_TO_BITMASK(pin) ((uint32_t)digitalPinToPinName(pin)) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, pin) digitalReadFast((PinName)pin) +#define DIRECT_WRITE_LOW(base, pin) digitalWriteFast((PinName)pin, LOW) +#define DIRECT_WRITE_HIGH(base, pin) digitalWriteFast((PinName)pin, HIGH) +#define DIRECT_MODE_INPUT(base, pin) pin_function((PinName)pin, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0)) +#define DIRECT_MODE_OUTPUT(base, pin) pin_function((PinName)pin, STM_PIN_DATA(STM_MODE_OUTPUT_PP, GPIO_NOPULL, 0)) + +#elif defined(__SAMD21G18A__) +#define PIN_TO_BASEREG(pin) portModeRegister(digitalPinToPort(pin)) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) (((*((base)+8)) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) = (mask)) +#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+2)) = (mask)) +#define DIRECT_WRITE_LOW(base, mask) ((*((base)+5)) = (mask)) +#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+6)) = (mask)) + +#elif defined(RBL_NRF51822) +#define PIN_TO_BASEREG(pin) (0) +#define PIN_TO_BITMASK(pin) (pin) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, pin) nrf_gpio_pin_read(pin) +#define DIRECT_WRITE_LOW(base, pin) nrf_gpio_pin_clear(pin) +#define DIRECT_WRITE_HIGH(base, pin) nrf_gpio_pin_set(pin) +#define DIRECT_MODE_INPUT(base, pin) nrf_gpio_cfg_input(pin, NRF_GPIO_PIN_NOPULL) +#define DIRECT_MODE_OUTPUT(base, pin) nrf_gpio_cfg_output(pin) + +#elif defined(__arc__) /* Arduino101/Genuino101 specifics */ + +#include "scss_registers.h" +#include "portable.h" +#include "avr/pgmspace.h" + +#define GPIO_ID(pin) (g_APinDescription[pin].ulGPIOId) +#define GPIO_TYPE(pin) (g_APinDescription[pin].ulGPIOType) +#define GPIO_BASE(pin) (g_APinDescription[pin].ulGPIOBase) +#define DIR_OFFSET_SS 0x01 +#define DIR_OFFSET_SOC 0x04 +#define EXT_PORT_OFFSET_SS 0x0A +#define EXT_PORT_OFFSET_SOC 0x50 + +/* GPIO registers base address */ +#define PIN_TO_BASEREG(pin) ((volatile uint32_t *)g_APinDescription[pin].ulGPIOBase) +#define PIN_TO_BITMASK(pin) pin +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR + +static inline __attribute__((always_inline)) +IO_REG_TYPE directRead(volatile IO_REG_TYPE *base, IO_REG_TYPE pin) +{ + IO_REG_TYPE ret; + if (SS_GPIO == GPIO_TYPE(pin)) { + ret = READ_ARC_REG(((IO_REG_TYPE)base + EXT_PORT_OFFSET_SS)); + } else { + ret = MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, EXT_PORT_OFFSET_SOC); + } + return ((ret >> GPIO_ID(pin)) & 0x01); +} + +static inline __attribute__((always_inline)) +void directModeInput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin) +{ + if (SS_GPIO == GPIO_TYPE(pin)) { + WRITE_ARC_REG(READ_ARC_REG((((IO_REG_TYPE)base) + DIR_OFFSET_SS)) & ~(0x01 << GPIO_ID(pin)), + ((IO_REG_TYPE)(base) + DIR_OFFSET_SS)); + } else { + MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) &= ~(0x01 << GPIO_ID(pin)); + } +} + +static inline __attribute__((always_inline)) +void directModeOutput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin) +{ + if (SS_GPIO == GPIO_TYPE(pin)) { + WRITE_ARC_REG(READ_ARC_REG(((IO_REG_TYPE)(base) + DIR_OFFSET_SS)) | (0x01 << GPIO_ID(pin)), + ((IO_REG_TYPE)(base) + DIR_OFFSET_SS)); + } else { + MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) |= (0x01 << GPIO_ID(pin)); + } +} + +static inline __attribute__((always_inline)) +void directWriteLow(volatile IO_REG_TYPE *base, IO_REG_TYPE pin) +{ + if (SS_GPIO == GPIO_TYPE(pin)) { + WRITE_ARC_REG(READ_ARC_REG(base) & ~(0x01 << GPIO_ID(pin)), base); + } else { + MMIO_REG_VAL(base) &= ~(0x01 << GPIO_ID(pin)); + } +} + +static inline __attribute__((always_inline)) +void directWriteHigh(volatile IO_REG_TYPE *base, IO_REG_TYPE pin) +{ + if (SS_GPIO == GPIO_TYPE(pin)) { + WRITE_ARC_REG(READ_ARC_REG(base) | (0x01 << GPIO_ID(pin)), base); + } else { + MMIO_REG_VAL(base) |= (0x01 << GPIO_ID(pin)); + } +} + +#define DIRECT_READ(base, pin) directRead(base, pin) +#define DIRECT_MODE_INPUT(base, pin) directModeInput(base, pin) +#define DIRECT_MODE_OUTPUT(base, pin) directModeOutput(base, pin) +#define DIRECT_WRITE_LOW(base, pin) directWriteLow(base, pin) +#define DIRECT_WRITE_HIGH(base, pin) directWriteHigh(base, pin) + +#elif defined(__riscv) + +/* + * Tested on highfive1 + * + * Stable results are achieved operating in the + * two high speed modes of the highfive1. It + * seems to be less reliable in slow mode. + */ +#define PIN_TO_BASEREG(pin) (0) +#define PIN_TO_BITMASK(pin) digitalPinToBitMask(pin) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR + +static inline __attribute__((always_inline)) +IO_REG_TYPE directRead(IO_REG_TYPE mask) +{ + return ((GPIO_REG(GPIO_INPUT_VAL) & mask) != 0) ? 1 : 0; +} + +static inline __attribute__((always_inline)) +void directModeInput(IO_REG_TYPE mask) +{ + GPIO_REG(GPIO_OUTPUT_XOR) &= ~mask; + GPIO_REG(GPIO_IOF_EN) &= ~mask; + + GPIO_REG(GPIO_INPUT_EN) |= mask; + GPIO_REG(GPIO_OUTPUT_EN) &= ~mask; +} + +static inline __attribute__((always_inline)) +void directModeOutput(IO_REG_TYPE mask) +{ + GPIO_REG(GPIO_OUTPUT_XOR) &= ~mask; + GPIO_REG(GPIO_IOF_EN) &= ~mask; + + GPIO_REG(GPIO_INPUT_EN) &= ~mask; + GPIO_REG(GPIO_OUTPUT_EN) |= mask; +} + +static inline __attribute__((always_inline)) +void directWriteLow(IO_REG_TYPE mask) +{ + GPIO_REG(GPIO_OUTPUT_VAL) &= ~mask; +} + +static inline __attribute__((always_inline)) +void directWriteHigh(IO_REG_TYPE mask) +{ + GPIO_REG(GPIO_OUTPUT_VAL) |= mask; +} + +#define DIRECT_READ(base, mask) directRead(mask) +#define DIRECT_WRITE_LOW(base, mask) directWriteLow(mask) +#define DIRECT_WRITE_HIGH(base, mask) directWriteHigh(mask) +#define DIRECT_MODE_INPUT(base, mask) directModeInput(mask) +#define DIRECT_MODE_OUTPUT(base, mask) directModeOutput(mask) + +#else +#define PIN_TO_BASEREG(pin) (0) +#define PIN_TO_BITMASK(pin) (pin) +#define IO_REG_TYPE unsigned int +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, pin) digitalRead(pin) +#define DIRECT_WRITE_LOW(base, pin) digitalWrite(pin, LOW) +#define DIRECT_WRITE_HIGH(base, pin) digitalWrite(pin, HIGH) +#define DIRECT_MODE_INPUT(base, pin) pinMode(pin,INPUT) +#define DIRECT_MODE_OUTPUT(base, pin) pinMode(pin,OUTPUT) +#warning "OneWire. Fallback mode. Using API calls for pinMode,digitalRead and digitalWrite. Operation of this library is not guaranteed on this architecture." + +#endif + +#endif diff --git a/sw/lib/OneWire/util/OneWire_direct_regtype.h b/sw/lib/OneWire/util/OneWire_direct_regtype.h new file mode 100644 index 0000000..21c4634 --- /dev/null +++ b/sw/lib/OneWire/util/OneWire_direct_regtype.h @@ -0,0 +1,52 @@ +#ifndef OneWire_Direct_RegType_h +#define OneWire_Direct_RegType_h + +#include <stdint.h> + +// Platform specific I/O register type + +#if defined(__AVR__) +#define IO_REG_TYPE uint8_t + +#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__) +#define IO_REG_TYPE uint8_t + +#elif defined(__IMXRT1052__) || defined(__IMXRT1062__) +#define IO_REG_TYPE uint32_t + +#elif defined(__MKL26Z64__) +#define IO_REG_TYPE uint8_t + +#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__) +#define IO_REG_TYPE uint32_t + +#elif defined(__PIC32MX__) +#define IO_REG_TYPE uint32_t + +#elif defined(ARDUINO_ARCH_ESP8266) +#define IO_REG_TYPE uint32_t + +#elif defined(ARDUINO_ARCH_ESP32) +#define IO_REG_TYPE uint32_t +#define IO_REG_MASK_ATTR + +#elif defined(ARDUINO_ARCH_STM32) +#define IO_REG_TYPE uint32_t + +#elif defined(__SAMD21G18A__) +#define IO_REG_TYPE uint32_t + +#elif defined(RBL_NRF51822) +#define IO_REG_TYPE uint32_t + +#elif defined(__arc__) /* Arduino101/Genuino101 specifics */ +#define IO_REG_TYPE uint32_t + +#elif defined(__riscv) +#define IO_REG_TYPE uint32_t + +#else +#define IO_REG_TYPE unsigned int + +#endif +#endif diff --git a/sw/lib/delay.h b/sw/lib/delay.h new file mode 100644 index 0000000..af92a4f --- /dev/null +++ b/sw/lib/delay.h @@ -0,0 +1,9 @@ +#ifndef __DELAY_INT_H +#define __DELAY_INT_H + +#include <util/delay.h> + +#define delay_us(us) _delay_us(us) +#define delay_ms(ms) _delay_ms(ms) + +#endif diff --git a/sw/main.cpp b/sw/main.cpp new file mode 100644 index 0000000..a021b96 --- /dev/null +++ b/sw/main.cpp @@ -0,0 +1,36 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Matthias P. Braendli + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. +*/ + +#include <stdlib.h> +#include <stdint.h> + +#include <avr/pgmspace.h> +#include <avr/io.h> +#include <avr/interrupt.h> + +int main() +{ + + return 0; +} |