From 767988a7c597c155e076d52d52ef14a35db8950a Mon Sep 17 00:00:00 2001 From: Magnus Persson Date: Fri, 21 Jan 2022 17:15:27 +0100 Subject: [PATCH] Added ESP32 as new target (still on SDK 1.0.6) --- .../DallasTemperature.cpp | 1051 +++++++++++++++++ .../DallasTemperature.h | 323 +++++ lib/OneWire/OneWire.cpp | 588 +++++++++ lib/OneWire/OneWire.h | 190 +++ lib/OneWire/util/OneWire_direct_gpio.h | 463 ++++++++ lib/OneWire/util/OneWire_direct_regtype.h | 55 + platformio.ini | 31 +- script/copy_firmware.py | 2 + src/config.cpp | 14 +- src/gyro.cpp | 3 - src/helper.cpp | 18 + src/main.cpp | 27 +- src/main.hpp | 20 +- src/pushtarget.cpp | 4 + src/resources.cpp | 2 + src/tempsensor.cpp | 2 +- src/webserver.cpp | 114 +- src/webserver.hpp | 10 +- src/wifi.cpp | 22 +- src/wifi.hpp | 11 +- 20 files changed, 2866 insertions(+), 84 deletions(-) create mode 100644 lib/Arduino-Temperature-Control-Library/DallasTemperature.cpp create mode 100644 lib/Arduino-Temperature-Control-Library/DallasTemperature.h create mode 100644 lib/OneWire/OneWire.cpp create mode 100644 lib/OneWire/OneWire.h create mode 100644 lib/OneWire/util/OneWire_direct_gpio.h create mode 100644 lib/OneWire/util/OneWire_direct_regtype.h diff --git a/lib/Arduino-Temperature-Control-Library/DallasTemperature.cpp b/lib/Arduino-Temperature-Control-Library/DallasTemperature.cpp new file mode 100644 index 0000000..3f81f97 --- /dev/null +++ b/lib/Arduino-Temperature-Control-Library/DallasTemperature.cpp @@ -0,0 +1,1051 @@ +// 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 scratchpad to EEPROM +#define READSCRATCH 0xBE // Read from scratchpad +#define WRITESCRATCH 0x4E // Write to scratchpad +#define RECALLSCRATCH 0xB8 // Recall from EEPROM to scratchpad +#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 + +// DSROM FIELDS +#define DSROM_FAMILY 0 +#define DSROM_CRC 7 + +// 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 MAX_CONVERSION_TIMEOUT 750 + +// Alarm handler +#define NO_ALARM_HANDLER ((AlarmHandler *)0) + + +DallasTemperature::DallasTemperature() { +#if REQUIRESALARMS + setAlarmHandler(NO_ALARM_HANDLER); +#endif + useExternalPullup = false; +} + +DallasTemperature::DallasTemperature(OneWire* _oneWire) : DallasTemperature() { + setOneWire(_oneWire); +} + +bool DallasTemperature::validFamily(const uint8_t* deviceAddress) { + switch (deviceAddress[DSROM_FAMILY]) { + 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; + autoSaveScratchPad = 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)) { + devices++; + + if (validFamily(deviceAddress)) { + ds18Count++; + + if (!parasite && readPowerSupply(deviceAddress)) + parasite = true; + + uint8_t b = getResolution(deviceAddress); + if (b > bitResolution) bitResolution = b; + } + } + } +} + +// 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[DSROM_CRC]); +} + +// 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[DSROM_FAMILY] != DS18S20MODEL) + _wire->write(scratchPad[CONFIGURATION]); + + if (autoSaveScratchPad) + saveScratchPad(deviceAddress); + else + _wire->reset(); +} + +// returns true if parasite mode is used (2 wire) +// returns false if normal mode is used (3 wire) +// if no address is given (or nullptr) it checks if any device on the bus +// uses parasite mode. +// See issue #145 +bool DallasTemperature::readPowerSupply(const uint8_t* deviceAddress) +{ + bool parasiteMode = false; + _wire->reset(); + if (deviceAddress == nullptr) + _wire->skip(); + else + _wire->select(deviceAddress); + + _wire->write(READPOWERSUPPLY); + if (_wire->read_bit() == 0) + parasiteMode = true; + _wire->reset(); + return parasiteMode; +} + +// 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 (uint8_t i = 0; i < devices; i++) { + getAddress(deviceAddress, i); + setResolution(deviceAddress, bitResolution, true); + } +} + +/* PROPOSAL */ + +// 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) { + + bool success = false; + + // DS1820 and DS18S20 have no resolution configuration register + if (deviceAddress[DSROM_FAMILY] == DS18S20MODEL) + { + success = true; + } + else + { + + // handle the sensors with configuration register + newResolution = constrain(newResolution, 9, 12); + uint8_t newValue = 0; + ScratchPad scratchPad; + + // we can only update the sensor if it is connected + if (isConnected(deviceAddress, scratchPad)) + { + switch (newResolution) { + case 12: + newValue = TEMP_12_BIT; + break; + case 11: + newValue = TEMP_11_BIT; + break; + case 10: + newValue = TEMP_10_BIT; + break; + case 9: + default: + newValue = TEMP_9_BIT; + break; + } + + // if it needs to be updated we write the new value + if (scratchPad[CONFIGURATION] != newValue) + { + scratchPad[CONFIGURATION] = newValue; + writeScratchPad(deviceAddress, scratchPad); + } + // done + success = true; + } + } + + // do we need to update the max resolution used? + if (skipGlobalBitResolutionCalculation == false) + { + bitResolution = newResolution; + if (devices > 1) + { + for (uint8_t i = 0; i < devices; i++) + { + if (bitResolution == 12) break; + DeviceAddress deviceAddr; + getAddress(deviceAddr, i); + uint8_t b = getResolution(deviceAddr); + if (b > bitResolution) bitResolution = b; + } + } + } + + return success; +} + + +// 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[DSROM_FAMILY] == 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) { + + if (checkForConversion && !parasite) { + unsigned long start = millis(); + while (!isConversionComplete() && (millis() - start < MAX_CONVERSION_TIMEOUT )) + yield(); + } else { + unsigned long delms = millisToWaitForConversion(bitResolution); + activateExternalPullup(); + delay(delms); + deactivateExternalPullup(); + } + +} + +// returns number of milliseconds to wait till conversion is complete (based on IC datasheet) +uint16_t DallasTemperature::millisToWaitForConversion(uint8_t bitResolution) { + + switch (bitResolution) { + case 9: + return 94; + case 10: + return 188; + case 11: + return 375; + default: + return 750; + } + +} + +// returns number of milliseconds to wait till conversion is complete (based on IC datasheet) +uint16_t DallasTemperature::millisToWaitForConversion() { + return millisToWaitForConversion(bitResolution); +} + +// Sends command to one device to save values from scratchpad to EEPROM by index +// Returns true if no errors were encountered, false indicates failure +bool DallasTemperature::saveScratchPadByIndex(uint8_t deviceIndex) { + + DeviceAddress deviceAddress; + if (!getAddress(deviceAddress, deviceIndex)) return false; + + return saveScratchPad(deviceAddress); + +} + +// Sends command to one or more devices to save values from scratchpad to EEPROM +// If optional argument deviceAddress is omitted the command is send to all devices +// Returns true if no errors were encountered, false indicates failure +bool DallasTemperature::saveScratchPad(const uint8_t* deviceAddress) { + + if (_wire->reset() == 0) + return false; + + if (deviceAddress == nullptr) + _wire->skip(); + else + _wire->select(deviceAddress); + + _wire->write(COPYSCRATCH,parasite); + + // Specification: NV Write Cycle Time is typically 2ms, max 10ms + // Waiting 20ms to allow for sensors that take longer in practice + if (!parasite) { + delay(20); + } else { + activateExternalPullup(); + delay(20); + deactivateExternalPullup(); + } + + return _wire->reset() == 1; + +} + +// Sends command to one device to recall values from EEPROM to scratchpad by index +// Returns true if no errors were encountered, false indicates failure +bool DallasTemperature::recallScratchPadByIndex(uint8_t deviceIndex) { + + DeviceAddress deviceAddress; + if (!getAddress(deviceAddress, deviceIndex)) return false; + + return recallScratchPad(deviceAddress); + +} + +// Sends command to one or more devices to recall values from EEPROM to scratchpad +// If optional argument deviceAddress is omitted the command is send to all devices +// Returns true if no errors were encountered, false indicates failure +bool DallasTemperature::recallScratchPad(const uint8_t* deviceAddress) { + + if (_wire->reset() == 0) + return false; + + if (deviceAddress == nullptr) + _wire->skip(); + else + _wire->select(deviceAddress); + + _wire->write(RECALLSCRATCH,parasite); + + // Specification: Strong pullup only needed when writing to EEPROM (and temp conversion) + unsigned long start = millis(); + while (_wire->read_bit() == 0) { + // Datasheet doesn't specify typical/max duration, testing reveals typically within 1ms + if (millis() - start > 20) return false; + yield(); + } + + return _wire->reset() == 1; + +} + +// Sets the autoSaveScratchPad flag +void DallasTemperature::setAutoSaveScratchPad(bool flag) { + autoSaveScratchPad = flag; +} + +// Gets the autoSaveScratchPad flag +bool DallasTemperature::getAutoSaveScratchPad() { + return autoSaveScratchPad; +} + +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[DSROM_FAMILY] == DS18S20MODEL) && (scratchPad[COUNT_PER_C] != 0)) { + 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.8f) + 32.0f; +} + +// Convert float Fahrenheit to Celsius +float DallasTemperature::toCelsius(float fahrenheit) { + return (fahrenheit - 32.0f) * 0.555555556f; +} + +// 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.0078125f; + +} + +// Convert from Celsius to raw returns temperature in raw integer format. +// The rounding error in the conversion is smaller than 0.01°C +// where the resolution of the sensor is at best 0.0625°C (in 12 bit mode). +// Rounding error can be verified by running: +// for (float t=-55.; t<125.; t+=0.01) +// { +// Serial.println( DallasTemperature::rawToCelsius(DallasTemperature::celsiusToRaw(t))-t, 4 ); +// } +int16_t DallasTemperature::celsiusToRaw(float celsius) { + + return static_cast( celsius * 128.f ); +} + +// 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.0140625f) + 32.0f; + +} + +// 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/lib/Arduino-Temperature-Control-Library/DallasTemperature.h b/lib/Arduino-Temperature-Control-Library/DallasTemperature.h new file mode 100644 index 0000000..edd9a3d --- /dev/null +++ b/lib/Arduino-Temperature-Control-Library/DallasTemperature.h @@ -0,0 +1,323 @@ +#ifndef DallasTemperature_h +#define DallasTemperature_h + +#define DALLASTEMPLIBVERSION "3.8.1" // To be deprecated -> TODO remove in 4.0.0 + +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. + +// set to true to include code for new and delete operators +#ifndef REQUIRESNEW +#define REQUIRESNEW false +#endif + +// set to true to include code implementing alarm search functions +#ifndef REQUIRESALARMS +#define REQUIRESALARMS true +#endif + +#include +#ifdef __STM32F1__ +#include +#else +#include +#endif + +// Model IDs +#define DS18S20MODEL 0x10 // also DS1820 +#define DS18B20MODEL 0x28 // also MAX31820 +#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 + +// For readPowerSupply on oneWire bus +// definition of nullptr for C++ < 11, using official workaround: +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf +#if __cplusplus < 201103L +const class +{ +public: + template + operator T *() const + { + return 0; + } + template + operator T C::*() const + { + return 0; + } + +private: + void operator&() const; +} nullptr = {}; +#endif + +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* deviceAddress = nullptr); + + // 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); + + static uint16_t millisToWaitForConversion(uint8_t); + + uint16_t millisToWaitForConversion(); + + // Sends command to one device to save values from scratchpad to EEPROM by index + // Returns true if no errors were encountered, false indicates failure + bool saveScratchPadByIndex(uint8_t); + + // Sends command to one or more devices to save values from scratchpad to EEPROM + // Returns true if no errors were encountered, false indicates failure + bool saveScratchPad(const uint8_t* = nullptr); + + // Sends command to one device to recall values from EEPROM to scratchpad by index + // Returns true if no errors were encountered, false indicates failure + bool recallScratchPadByIndex(uint8_t); + + // Sends command to one or more devices to recall values from EEPROM to scratchpad + // Returns true if no errors were encountered, false indicates failure + bool recallScratchPad(const uint8_t* = nullptr); + + // Sets the autoSaveScratchPad flag + void setAutoSaveScratchPad(bool); + + // Gets the autoSaveScratchPad flag + bool getAutoSaveScratchPad(void); + +#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 Celsius to raw + static int16_t celsiusToRaw(float); + + // 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 + + void blockTillConversionComplete(uint8_t); + +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; + + // used to determine if values will be saved from scratchpad to EEPROM on every scratchpad write + bool autoSaveScratchPad; + + // 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*); + + + // 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/lib/OneWire/OneWire.cpp b/lib/OneWire/OneWire.cpp new file mode 100644 index 0000000..8d4b66c --- /dev/null +++ b/lib/OneWire/OneWire.cpp @@ -0,0 +1,588 @@ +/* +Copyright (c) 2007, Jim Studt (original old version - many contributors since) + +The latest version of this library may be found at: + http://www.pjrc.com/teensy/td_libs_OneWire.html + +OneWire has been maintained by Paul Stoffregen (paul@pjrc.com) since +January 2010. + +DO NOT EMAIL for technical support, especially not for ESP chips! +All project support questions must be posted on public forums +relevant to the board or chips used. If using Arduino, post on +Arduino's forum. If using ESP, post on the ESP community forums. +There is ABSOLUTELY NO TECH SUPPORT BY PRIVATE EMAIL! + +Github's issue tracker for OneWire should be used only to report +specific bugs. DO NOT request project support via Github. All +project and tech support questions must be posted on forums, not +github issues. If you experience a problem and you are not +absolutely sure it's an issue with the library, ask on a forum +first. Only use github to report issues after experts have +confirmed the issue is with OneWire rather than your project. + +Back in 2010, OneWire was in need of many bug fixes, but had +been abandoned the original author (Jim Studt). None of the known +contributors were interested in maintaining OneWire. Paul typically +works on OneWire every 6 to 12 months. Patches usually wait that +long. If anyone is interested in more actively maintaining OneWire, +please contact Paul (this is pretty much the only reason to use +private email about OneWire). + +OneWire is now very mature code. No changes other than adding +definitions for newer hardware support are anticipated. + +Version 2.3: + Unknown chip fallback mode, Roger Clark + Teensy-LC compatibility, Paul Stoffregen + Search bug fix, Love Nystrom + +Version 2.2: + Teensy 3.0 compatibility, Paul Stoffregen, paul@pjrc.com + Arduino Due compatibility, http://arduino.cc/forum/index.php?topic=141030 + Fix DS18B20 example negative temperature + Fix DS18B20 example's low res modes, Ken Butcher + Improve reset timing, Mark Tillotson + Add const qualifiers, Bertrik Sikken + Add initial value input to crc16, Bertrik Sikken + Add target_search() function, Scott Roberts + +Version 2.1: + Arduino 1.0 compatibility, Paul Stoffregen + Improve temperature example, Paul Stoffregen + DS250x_PROM example, Guillermo Lovato + PIC32 (chipKit) compatibility, Jason Dangel, dangel.jason AT gmail.com + Improvements from Glenn Trewitt: + - crc16() now works + - check_crc16() does all of calculation/checking work. + - Added read_bytes() and write_bytes(), to reduce tedious loops. + - Added ds2408 example. + Delete very old, out-of-date readme file (info is here) + +Version 2.0: Modifications by Paul Stoffregen, January 2010: +http://www.pjrc.com/teensy/td_libs_OneWire.html + Search fix from Robin James + http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27 + Use direct optimized I/O in all cases + Disable interrupts during timing critical sections + (this solves many random communication errors) + Disable interrupts during read-modify-write I/O + Reduce RAM consumption by eliminating unnecessary + variables and trimming many to 8 bits + Optimize both crc8 - table version moved to flash + +Modified to work with larger numbers of devices - avoids loop. +Tested in Arduino 11 alpha with 12 sensors. +26 Sept 2008 -- Robin James +http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27 + +Updated to work with arduino-0008 and to include skip() as of +2007/07/06. --RJL20 + +Modified to calculate the 8-bit CRC directly, avoiding the need for +the 256-byte lookup table to be loaded in RAM. Tested in arduino-0010 +-- Tom Pollard, Jan 23, 2008 + +Jim Studt's original library was modified by Josh Larios. + +Tom Pollard, pollard@alum.mit.edu, contributed around May 20, 2008 + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Much of the code was inspired by Derek Yerger's code, though I don't +think much of that remains. In any event that was.. + (copyleft) 2006 by Derek Yerger - Free to distribute freely. + +The CRC code was excerpted and inspired by the Dallas Semiconductor +sample code bearing this copyright. +//--------------------------------------------------------------------------- +// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES +// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +// Except as contained in this notice, the name of Dallas Semiconductor +// shall not be used except as stated in the Dallas Semiconductor +// Branding Policy. +//-------------------------------------------------------------------------- +*/ + +#include +#include "OneWire.h" +#include "util/OneWire_direct_gpio.h" + + +void OneWire::begin(uint8_t pin) +{ + pinMode(pin, INPUT); + bitmask = PIN_TO_BITMASK(pin); + baseReg = PIN_TO_BASEREG(pin); +#if ONEWIRE_SEARCH + reset_search(); +#endif +} + + +// Perform the onewire reset function. We will wait up to 250uS for +// the bus to come high, if it doesn't then it is broken or shorted +// and we return a 0; +// +// Returns 1 if a device asserted a presence pulse, 0 otherwise. +// +uint8_t OneWire::reset(void) +{ + IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask; + volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg; + uint8_t r; + uint8_t retries = 125; + + noInterrupts(); + DIRECT_MODE_INPUT(reg, mask); + interrupts(); + // wait until the wire is high... just in case + do { + if (--retries == 0) return 0; + delayMicroseconds(2); + } while ( !DIRECT_READ(reg, mask)); + + noInterrupts(); + DIRECT_WRITE_LOW(reg, mask); + DIRECT_MODE_OUTPUT(reg, mask); // drive output low + interrupts(); + delayMicroseconds(480); + noInterrupts(); + DIRECT_MODE_INPUT(reg, mask); // allow it to float + delayMicroseconds(70); + r = !DIRECT_READ(reg, mask); + interrupts(); + delayMicroseconds(410); + return r; +} + +// +// Write a bit. Port and bit is used to cut lookup time and provide +// more certain timing. +// +#if defined(ARDUINO_ARCH_ESP32) +void IRAM_ATTR OneWire::write_bit(uint8_t v) +#else +void OneWire::write_bit(uint8_t v) +#endif +{ + 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. +// +#if defined(ARDUINO_ARCH_ESP32) +uint8_t IRAM_ATTR OneWire::read_bit(void) +#else +uint8_t OneWire::read_bit(void) +#endif +{ + 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/lib/OneWire/OneWire.h b/lib/OneWire/OneWire.h new file mode 100644 index 0000000..a8126f7 --- /dev/null +++ b/lib/OneWire/OneWire.h @@ -0,0 +1,190 @@ +#ifndef OneWire_h +#define OneWire_h + +#ifdef __cplusplus + +#include + +#if defined(__AVR__) +#include +#endif + +#if ARDUINO >= 100 +#include // for delayMicroseconds, digitalPinToBitMask, etc +#else +#include "WProgram.h" // for delayMicroseconds +#include "pins_arduino.h" // for digitalPinToBitMask, etc +#endif + +// You can exclude certain features from OneWire. In theory, this +// might save some space. In practice, the compiler automatically +// removes unused code (technically, the linker, using -fdata-sections +// and -ffunction-sections when compiling, and Wl,--gc-sections +// when linking), so most of these will not result in any code size +// reduction. Well, unless you try to use the missing features +// and redesign your program to not need them! ONEWIRE_CRC8_TABLE +// is the exception, because it selects a fast but large algorithm +// or a small but slow algorithm. + +// you can exclude onewire_search by defining that to 0 +#ifndef ONEWIRE_SEARCH +#define ONEWIRE_SEARCH 1 +#endif + +// You can exclude CRC checks altogether by defining this to 0 +#ifndef ONEWIRE_CRC +#define ONEWIRE_CRC 1 +#endif + +// Select the table-lookup method of computing the 8-bit CRC +// by setting this to 1. The lookup table enlarges code size by +// about 250 bytes. It does NOT consume RAM (but did in very +// old versions of OneWire). If you disable this, a slower +// but very compact algorithm is used. +#ifndef ONEWIRE_CRC8_TABLE +#define ONEWIRE_CRC8_TABLE 1 +#endif + +// You can allow 16-bit CRC checks by defining this to 1 +// (Note that ONEWIRE_CRC must also be 1.) +#ifndef ONEWIRE_CRC16 +#define ONEWIRE_CRC16 1 +#endif + +// Board-specific macros for direct GPIO +#include "util/OneWire_direct_regtype.h" + +class OneWire +{ + private: + IO_REG_TYPE bitmask; + volatile IO_REG_TYPE *baseReg; + +#if ONEWIRE_SEARCH + // global search state + unsigned char ROM_NO[8]; + uint8_t LastDiscrepancy; + uint8_t LastFamilyDiscrepancy; + bool LastDeviceFlag; +#endif + + public: + OneWire() { } + OneWire(uint8_t pin) { begin(pin); } + void begin(uint8_t pin); + + // Perform a 1-Wire reset cycle. Returns 1 if a device responds + // with a presence pulse. Returns 0 if there is no device or the + // bus is shorted or otherwise held low for more than 250uS + uint8_t reset(void); + + // Issue a 1-Wire rom select command, you do the reset first. + void select(const uint8_t rom[8]); + + // Issue a 1-Wire rom skip command, to address all on bus. + void skip(void); + + // Write a byte. If 'power' is one then the wire is held high at + // the end for parasitically powered devices. You are responsible + // for eventually depowering it by calling depower() or doing + // another read or write. + void write(uint8_t v, uint8_t power = 0); + + void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0); + + // Read a byte. + uint8_t read(void); + + void read_bytes(uint8_t *buf, uint16_t count); + + // Write a bit. The bus is always left powered at the end, see + // note in write() about that. + #if defined (ARDUINO_ARCH_ESP32) + void IRAM_ATTR write_bit(uint8_t v); + #else + void write_bit(uint8_t v); + #endif + + // Read a bit. + #if defined (ARDUINO_ARCH_ESP32) + uint8_t IRAM_ATTR read_bit(void); + #else + uint8_t read_bit(void); + #endif + + // 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/lib/OneWire/util/OneWire_direct_gpio.h b/lib/OneWire/util/OneWire_direct_gpio.h new file mode 100644 index 0000000..8df13c8 --- /dev/null +++ b/lib/OneWire/util/OneWire_direct_gpio.h @@ -0,0 +1,463 @@ +#ifndef OneWire_Direct_GPIO_h +#define OneWire_Direct_GPIO_h + +// This header should ONLY be included by OneWire.cpp. These defines are +// meant to be private, used within OneWire.cpp, but not exposed to Arduino +// sketches or other libraries which may include OneWire.h. + +#include + +// Platform specific I/O definitions + +#if defined(__AVR__) +#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin))) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint8_t +#define IO_REG_BASE_ATTR asm("r30") +#define IO_REG_MASK_ATTR +#if defined(__AVR_ATmega4809__) +#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) ((*((base)-8)) &= ~(mask)) +#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)-8)) |= (mask)) +#define DIRECT_WRITE_LOW(base, mask) ((*((base)-4)) &= ~(mask)) +#define DIRECT_WRITE_HIGH(base, mask) ((*((base)-4)) |= (mask)) +#else +#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) &= ~(mask)) +#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+1)) |= (mask)) +#define DIRECT_WRITE_LOW(base, mask) ((*((base)+2)) &= ~(mask)) +#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+2)) |= (mask)) +#endif + +#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__) +#define PIN_TO_BASEREG(pin) (portOutputRegister(pin)) +#define PIN_TO_BITMASK(pin) (1) +#define IO_REG_TYPE uint8_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR __attribute__ ((unused)) +#define DIRECT_READ(base, mask) (*((base)+512)) +#define DIRECT_MODE_INPUT(base, mask) (*((base)+640) = 0) +#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+640) = 1) +#define DIRECT_WRITE_LOW(base, mask) (*((base)+256) = 1) +#define DIRECT_WRITE_HIGH(base, mask) (*((base)+128) = 1) + +#elif defined(__MKL26Z64__) +#define PIN_TO_BASEREG(pin) (portOutputRegister(pin)) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint8_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) ((*((base)+16) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) (*((base)+20) &= ~(mask)) +#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+20) |= (mask)) +#define DIRECT_WRITE_LOW(base, mask) (*((base)+8) = (mask)) +#define DIRECT_WRITE_HIGH(base, mask) (*((base)+4) = (mask)) + +#elif defined(__IMXRT1052__) || defined(__IMXRT1062__) +#define PIN_TO_BASEREG(pin) (portOutputRegister(pin)) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) ((*((base)+2) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) (*((base)+1) &= ~(mask)) +#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+1) |= (mask)) +#define DIRECT_WRITE_LOW(base, mask) (*((base)+34) = (mask)) +#define DIRECT_WRITE_HIGH(base, mask) (*((base)+33) = (mask)) + +#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__) +// Arduino 1.5.1 may have a bug in delayMicroseconds() on Arduino Due. +// http://arduino.cc/forum/index.php/topic,141030.msg1076268.html#msg1076268 +// If you have trouble with OneWire on Arduino Due, please check the +// status of delayMicroseconds() before reporting a bug in OneWire! +#define PIN_TO_BASEREG(pin) (&(digitalPinToPort(pin)->PIO_PER)) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) (((*((base)+15)) & (mask)) ? 1 : 0) +#define DIRECT_MODE_INPUT(base, mask) ((*((base)+5)) = (mask)) +#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+4)) = (mask)) +#define DIRECT_WRITE_LOW(base, mask) ((*((base)+13)) = (mask)) +#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+12)) = (mask)) +#ifndef PROGMEM +#define PROGMEM +#endif +#ifndef pgm_read_byte +#define pgm_read_byte(addr) (*(const uint8_t *)(addr)) +#endif + +#elif defined(__PIC32MX__) +#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin))) +#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0) //PORTX + 0x10 +#define DIRECT_MODE_INPUT(base, mask) ((*(base+2)) = (mask)) //TRISXSET + 0x08 +#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) = (mask)) //TRISXCLR + 0x04 +#define DIRECT_WRITE_LOW(base, mask) ((*(base+8+1)) = (mask)) //LATXCLR + 0x24 +#define DIRECT_WRITE_HIGH(base, mask) ((*(base+8+2)) = (mask)) //LATXSET + 0x28 + +#elif defined(ARDUINO_ARCH_ESP8266) +// Special note: I depend on the ESP community to maintain these definitions and +// submit good pull requests. I can not answer any ESP questions or help you +// resolve any problems related to ESP chips. Please do not contact me and please +// DO NOT CREATE GITHUB ISSUES for ESP support. All ESP questions must be asked +// on ESP community forums. +#define PIN_TO_BASEREG(pin) ((volatile uint32_t*) GPO) +#define PIN_TO_BITMASK(pin) (1 << pin) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR +#define DIRECT_READ(base, mask) ((GPI & (mask)) ? 1 : 0) //GPIO_IN_ADDRESS +#define DIRECT_MODE_INPUT(base, mask) (GPE &= ~(mask)) //GPIO_ENABLE_W1TC_ADDRESS +#define DIRECT_MODE_OUTPUT(base, mask) (GPE |= (mask)) //GPIO_ENABLE_W1TS_ADDRESS +#define DIRECT_WRITE_LOW(base, mask) (GPOC = (mask)) //GPIO_OUT_W1TC_ADDRESS +#define DIRECT_WRITE_HIGH(base, mask) (GPOS = (mask)) //GPIO_OUT_W1TS_ADDRESS + +#elif defined(ARDUINO_ARCH_ESP32) +#include +#define PIN_TO_BASEREG(pin) (0) +#define PIN_TO_BITMASK(pin) (pin) +#define IO_REG_TYPE uint32_t +#define IO_REG_BASE_ATTR +#define IO_REG_MASK_ATTR + +static inline __attribute__((always_inline)) +IO_REG_TYPE directRead(IO_REG_TYPE pin) +{ + if ( pin < 32 ) + return (GPIO.in >> pin) & 0x1; + else if ( pin < 40 ) + return (GPIO.in1.val >> (pin - 32)) & 0x1; + + return 0; +} + +static inline __attribute__((always_inline)) +void directWriteLow(IO_REG_TYPE pin) +{ + if ( pin < 32 ) + GPIO.out_w1tc = ((uint32_t)1 << pin); + else if ( pin < 34 ) + GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32)); +} + +static inline __attribute__((always_inline)) +void directWriteHigh(IO_REG_TYPE pin) +{ + if ( pin < 32 ) + GPIO.out_w1ts = ((uint32_t)1 << pin); + else if ( pin < 34 ) + GPIO.out1_w1ts.val = ((uint32_t)1 << (pin - 32)); +} + +static inline __attribute__((always_inline)) +void directModeInput(IO_REG_TYPE pin) +{ + if ( digitalPinIsValid(pin) ) + { + #if defined(ESP_ARDUINO_VERSION) + #if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(2, 0, 0) + int pin_io = rtc_io_number_get((gpio_num_t)pin); + uint32_t rtc_reg(rtc_io_desc[pin_io].reg); + + if ( rtc_reg ) // RTC pins PULL settings + { + ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_io_desc[pin_io].mux); + ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_io_desc[pin_io].pullup | rtc_io_desc[pin_io].pulldown); + } + #endif + #else + 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); + } + #endif + + 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 + { + #if defined(ESP_ARDUINO_VERSION) + #if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(2, 0, 0) + int pin_io = rtc_io_number_get((gpio_num_t)pin); + uint32_t rtc_reg(rtc_io_desc[pin_io].reg); + + if ( rtc_reg ) // RTC pins PULL settings + { + ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_io_desc[pin_io].mux); + ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_io_desc[pin_io].pullup | rtc_io_desc[pin_io].pulldown); + } + #endif + #else + 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); + } + #endif + + 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(__ASR6501__) +#define PIN_IN_PORT(pin) (pin % PIN_NUMBER_IN_PORT) +#define PORT_FROM_PIN(pin) (pin / PIN_NUMBER_IN_PORT) +#define PORT_OFFSET(port) (PORT_REG_SHFIT * port) +#define PORT_ADDRESS(pin) (CYDEV_GPIO_BASE + PORT_OFFSET(PORT_FROM_PIN(pin))) + +#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) CY_SYS_PINS_READ_PIN(PORT_ADDRESS(pin)+4, PIN_IN_PORT(pin)) +#define DIRECT_WRITE_LOW(base, pin) CY_SYS_PINS_CLEAR_PIN(PORT_ADDRESS(pin), PIN_IN_PORT(pin)) +#define DIRECT_WRITE_HIGH(base, pin) CY_SYS_PINS_SET_PIN(PORT_ADDRESS(pin), PIN_IN_PORT(pin)) +#define DIRECT_MODE_INPUT(base, pin) CY_SYS_PINS_SET_DRIVE_MODE(PORT_ADDRESS(pin)+8, PIN_IN_PORT(pin), CY_SYS_PINS_DM_DIG_HIZ) +#define DIRECT_MODE_OUTPUT(base, pin) CY_SYS_PINS_SET_DRIVE_MODE(PORT_ADDRESS(pin)+8, PIN_IN_PORT(pin), CY_SYS_PINS_DM_STRONG) + +#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/lib/OneWire/util/OneWire_direct_regtype.h b/lib/OneWire/util/OneWire_direct_regtype.h new file mode 100644 index 0000000..ca6aff7 --- /dev/null +++ b/lib/OneWire/util/OneWire_direct_regtype.h @@ -0,0 +1,55 @@ +#ifndef OneWire_Direct_RegType_h +#define OneWire_Direct_RegType_h + +#include + +// Platform specific I/O register type + +#if defined(__AVR__) +#define IO_REG_TYPE uint8_t + +#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__) +#define IO_REG_TYPE uint8_t + +#elif defined(__IMXRT1052__) || defined(__IMXRT1062__) +#define IO_REG_TYPE uint32_t + +#elif defined(__MKL26Z64__) +#define IO_REG_TYPE uint8_t + +#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__) +#define IO_REG_TYPE uint32_t + +#elif defined(__PIC32MX__) +#define IO_REG_TYPE uint32_t + +#elif defined(ARDUINO_ARCH_ESP8266) +#define IO_REG_TYPE uint32_t + +#elif defined(ARDUINO_ARCH_ESP32) +#define IO_REG_TYPE uint32_t +#define IO_REG_MASK_ATTR + +#elif defined(ARDUINO_ARCH_STM32) +#define IO_REG_TYPE uint32_t + +#elif defined(__SAMD21G18A__) +#define IO_REG_TYPE uint32_t + +#elif defined(__ASR6501__) +#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/platformio.ini b/platformio.ini index 378a7f5..1f9378f 100644 --- a/platformio.ini +++ b/platformio.ini @@ -36,16 +36,16 @@ build_flags = -D USER_SSID_PWD=\""\"" # =\""mypwd\"" -D CFG_APPVER="\"0.6.1\"" lib_deps = # Switched to forks for better version control. - # Using local copy of this library + # Using local copy of these libraries #https://github.com/jrowberg/i2cdevlib.git# #https://github.com/khoih-prog/ESP_WiFiManager# #https://github.com/khoih-prog/ESP_DoubleResetDetector# + #https://github.com/PaulStoffregen/OneWire + #https://github.com/milesburton/Arduino-Temperature-Control-Library https://github.com/mp-se/tinyexpr # https://github.com/codeplea/tinyexpr https://github.com/mp-se/incbin # https://github.com/graphitemaster/incbin https://github.com/mp-se/Arduino-Log#1.1.1 # https://github.com/thijse/Arduino-Log https://github.com/mp-se/ArduinoJson#v6.18.5 # https://github.com/bblanchon/ArduinoJson - https://github.com/mp-se/OneWire#v2.3.6 # https://github.com/PaulStoffregen/OneWire - https://github.com/mp-se/Arduino-Temperature-Control-Library#3.9.1 # https://github.com/milesburton/Arduino-Temperature-Control-Library https://github.com/mp-se/arduinoCurveFitting#v1.0.6 # https://github.com/Rotario/arduinoCurveFitting https://github.com/mp-se/arduino-mqtt#v2.5.0 # https://github.com/256dpi/arduino-mqtt @@ -122,3 +122,28 @@ lib_deps = board = ${common_env_data.board} build_type = release board_build.filesystem = littlefs + +[env:gravity32-perf] +# platformio only supports v1.0.6 of the esp32 libs. +upload_speed = ${common_env_data.upload_speed} +monitor_speed = ${common_env_data.monitor_speed} +framework = arduino +platform = espressif32 +extra_scripts = + script/copy_html.py + script/copy_firmware.py + script/create_versionjson.py +build_unflags = + ${common_env_data.build_unflags} +build_flags = + ${common_env_data.build_flags} + -D COLLECT_PERFDATA + -D LOG_LEVEL=5 +lib_deps = + ${common_env_data.lib_deps} +board = nodemcu-32s +build_type = release +#build_type = debug +#board_build.filesystem = littlefs +board_build.filesystem = spiffs +monitor_filters = esp32_exception_decoder \ No newline at end of file diff --git a/script/copy_firmware.py b/script/copy_firmware.py index 6d1d89d..2dadc13 100644 --- a/script/copy_firmware.py +++ b/script/copy_firmware.py @@ -18,6 +18,8 @@ def after_build(source, target, env): target = dir + "/bin/firmware.bin" if name == "gravity-perf" : target = dir + "/bin/firmware-perf.bin" + if name == "gravity32-perf" : + target = dir + "/bin/firmware32-perf.bin" print( "Copy file : " + source + " -> " + target ) shutil.copyfile( source, target ) diff --git a/src/config.cpp b/src/config.cpp index 7c54c2d..e7c053c 100644 --- a/src/config.cpp +++ b/src/config.cpp @@ -34,7 +34,15 @@ HardwareConfig myHardwareConfig; Config::Config() { // Assiging default values char buf[30]; +#if defined (ESP8266) snprintf(&buf[0], sizeof(buf), "%6x", (unsigned int)ESP.getChipId()); +#else // defined (ESP32) + uint32_t chipId = 0; + for (int i = 0; i < 17; i = i+8) { + chipId |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i; + } + snprintf(&buf[0], sizeof(buf), "%6x", chipId); +#endif _id = String(&buf[0]); snprintf(&buf[0], sizeof(buf), "" WIFI_MDNS "%s", getID()); _mDNS = String(&buf[0]); @@ -47,7 +55,11 @@ Config::Config() { setTempFormat('C'); setGravityFormat('G'); setSleepInterval(900); // 15 minutes - setVoltageFactor(1.59); // Conversion factor for battery +#if defined (ESP8266) + setVoltageFactor(1.59); // Conversion factor for battery on ESP8266 +#else // defined (ESP32) + setVoltageFactor(1.43); // Conversion factor for battery on ESP32 +#endif setTempSensorAdjC(0.0); setGravityTempAdj(false); _gyroCalibration = {0, 0, 0, 0, 0, 0}; diff --git a/src/gyro.cpp b/src/gyro.cpp index fbcf1c1..45fca00 100644 --- a/src/gyro.cpp +++ b/src/gyro.cpp @@ -32,9 +32,6 @@ MPU6050 accelgyro; // calibration // #define GYRO_CALIBRATE_STARTUP // Will calibrate sensor at startup -#define PIN_SDA D3 -#define PIN_SCL D4 - // // Initialize the sensor chip. // diff --git a/src/helper.cpp b/src/helper.cpp index 4cc7173..3c1e525 100644 --- a/src/helper.cpp +++ b/src/helper.cpp @@ -21,8 +21,13 @@ 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. */ +#if defined (ESP8266) #include #include +#else // defined (ESP32) +#include +#include +#endif #include #include @@ -59,9 +64,14 @@ float convertFtoC(float f) { return (f - 32.0) / 1.8; } // void printHeap() { #if LOG_LEVEL == 6 && !defined(HELPER_DISABLE_LOGGING) +#if defined (ESP8266) Log.verbose(F("HELP: Heap %d kb, HeapFrag %d %%, FreeSketch %d kb." CR), ESP.getFreeHeap() / 1024, ESP.getHeapFragmentation(), ESP.getFreeSketchSpace() / 1024); +#else // defined (ESP32) + Log.verbose(F("HELP: Heap %d kb, FreeSketch %d kb." CR), + ESP.getFreeHeap() / 1024, ESP.getFreeSketchSpace() / 1024); +#endif #endif } @@ -127,7 +137,15 @@ void BatteryVoltage::read() { // the voltage (from max 5V) float factor = myConfig.getVoltageFactor(); // Default value is 1.63 int v = analogRead(A0); + + // An ESP8266 has a ADC range of 0-1023 and a maximum voltage of 3.3V + // An ESP32 has an ADC range of 0-4095 and a maximum voltage of 3.3V + +#if defined (ESP8266) _batteryLevel = ((3.3 / 1023) * v) * factor; +#else // defined (ESP32) + _batteryLevel = ((3.3 / 4095) * v) * factor; +#endif #if LOG_LEVEL == 6 && !defined(HELPER_DISABLE_LOGGING) Log.verbose( F("BATT: Reading voltage level. Factor=%F Value=%d, Voltage=%F." CR), diff --git a/src/main.cpp b/src/main.cpp index 3956a86..00f5b35 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -110,22 +110,39 @@ void setup() { #if LOG_LEVEL == 6 && !defined(MAIN_DISABLE_LOGGING) // Add a delay so that serial is started. // delay(3000); +#if defined (ESP8266) Log.verbose(F("Main: Reset reason %s." CR), ESP.getResetInfo().c_str()); +#else // defined (ESP32) +#endif #endif // Main startup +#if defined (ESP8266) Log.notice(F("Main: Started setup for %s." CR), String(ESP.getChipId(), HEX).c_str()); +#else // defined (ESP32) + char buf[20]; + uint32_t chipId = 0; + for (int i = 0; i < 17; i = i+8) { + chipId |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i; + } + snprintf(&buf[0], sizeof(buf), "%6x", chipId); + Log.notice(F("Main: Started setup for %s." CR), &buf[0]); +#endif printBuildOptions(); LOG_PERF_START("main-config-load"); myConfig.checkFileSystem(); myConfig.loadFile(); + myWifi.init(); myHardwareConfig.loadFile(); LOG_PERF_STOP("main-config-load"); // Setup watchdog +#if defined (ESP8266) ESP.wdtDisable(); ESP.wdtEnable(5000); // 5 seconds +#else // defined (ESP32) +#endif // No stored config, move to portal if (!myWifi.hasConfig()) { @@ -177,7 +194,7 @@ void setup() { if (myWifi.checkFirmwareVersion()) myWifi.updateFirmware(); LOG_PERF_STOP("main-wifi-ota"); #endif - myWebServer + myWebServerHandler .setupWebServer(); // Takes less than 4ms, so skip this measurement } @@ -248,11 +265,7 @@ void loopGravityOnInterval() { if (abs((int32_t)(millis() - loopMillis)) > interval) { loopReadGravity(); loopMillis = millis(); -#if LOG_LEVEL == 6 && !defined(MAIN_DISABLE_LOGGING) - Log.verbose(F("Main: Heap %d kb FreeSketch %d kb HeapFrag %d %%." CR), - ESP.getFreeHeap() / 1024, ESP.getFreeSketchSpace() / 1024, - ESP.getHeapFragmentation()); -#endif + printHeap(); LOG_PERF_START("loop-gyro-read"); myGyro.read(); LOG_PERF_STOP("loop-gyro-read"); @@ -286,7 +299,7 @@ void goToSleep(int sleepInterval) { void loop() { switch (runMode) { case RunMode::configurationMode: - myWebServer.loop(); + myWebServerHandler.loop(); myWifi.loop(); loopGravityOnInterval(); break; diff --git a/src/main.hpp b/src/main.hpp index ff15bbb..813b929 100644 --- a/src/main.hpp +++ b/src/main.hpp @@ -27,7 +27,25 @@ SOFTWARE. #include #include #include -#include #include +#if defined (ESP8266) +#include +#define ESP_RESET ESP.reset +#define PIN_SDA D3 +#define PIN_SCL D4 +#define PIN_DS D6 +#else // defined (ESP32) +#define LittleFS SPIFFS +#define ESPhttpUpdate httpUpdate +#define ESP_RESET ESP.restart +#define ESP8266WebServer WebServer +#include +#define PIN_SDA 17 +#define PIN_SCL 16 +#define PIN_DS 19 +#endif + +#define PIN_LED 2 + #endif // SRC_MAIN_HPP_ diff --git a/src/pushtarget.cpp b/src/pushtarget.cpp index 62c12e8..a38a094 100644 --- a/src/pushtarget.cpp +++ b/src/pushtarget.cpp @@ -21,7 +21,11 @@ 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. */ +#if defined (ESP8266) #include +#else // defined (ESP32) +#include +#endif #include #include diff --git a/src/resources.cpp b/src/resources.cpp index 2083723..d3de083 100644 --- a/src/resources.cpp +++ b/src/resources.cpp @@ -21,7 +21,9 @@ 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. */ +#if defined (ESP8266) #define INCBIN_OUTPUT_SECTION ".irom.text" +#endif #include #include diff --git a/src/tempsensor.cpp b/src/tempsensor.cpp index 9eeeb3a..4cabbd7 100644 --- a/src/tempsensor.cpp +++ b/src/tempsensor.cpp @@ -30,7 +30,7 @@ SOFTWARE. #include #include -OneWire myOneWire(D6); +OneWire myOneWire(PIN_DS); DallasTemperature mySensors(&myOneWire); #define TEMPERATURE_PRECISION 9 diff --git a/src/webserver.cpp b/src/webserver.cpp index b17d6bb..6019e20 100644 --- a/src/webserver.cpp +++ b/src/webserver.cpp @@ -31,14 +31,14 @@ SOFTWARE. #include #include -WebServer myWebServer; // My wrapper class fr webserver functions +WebServerHandler myWebServerHandler; // My wrapper class fr webserver functions extern bool sleepModeActive; extern bool sleepModeAlwaysSkip; // // Callback from webServer when / has been accessed. // -void WebServer::webHandleDevice() { +void WebServerHandler::webHandleDevice() { LOG_PERF_START("webserver-api-device"); #if LOG_LEVEL == 6 && !defined(WEB_DISABLE_LOGGING) Log.verbose(F("WEB : webServer callback for /api/device." CR)); @@ -62,7 +62,7 @@ void WebServer::webHandleDevice() { // // Callback from webServer when / has been accessed. // -void WebServer::webHandleConfig() { +void WebServerHandler::webHandleConfig() { LOG_PERF_START("webserver-api-config"); Log.notice(F("WEB : webServer callback for /api/config." CR)); @@ -105,16 +105,16 @@ void WebServer::webHandleConfig() { // // Callback from webServer when / has been accessed. // -void WebServer::webHandleUpload() { +void WebServerHandler::webHandleUpload() { LOG_PERF_START("webserver-api-upload"); Log.notice(F("WEB : webServer callback for /api/upload." CR)); DynamicJsonDocument doc(100); - doc["index"] = myWebServer.checkHtmlFile(WebServer::HTML_INDEX); - doc["device"] = myWebServer.checkHtmlFile(WebServer::HTML_DEVICE); - doc["config"] = myWebServer.checkHtmlFile(WebServer::HTML_CONFIG); - doc["calibration"] = myWebServer.checkHtmlFile(WebServer::HTML_CALIBRATION); - doc["about"] = myWebServer.checkHtmlFile(WebServer::HTML_ABOUT); + doc["index"] = checkHtmlFile(WebServerHandler::HTML_INDEX); + doc["device"] = checkHtmlFile(WebServerHandler::HTML_DEVICE); + doc["config"] = checkHtmlFile(WebServerHandler::HTML_CONFIG); + doc["calibration"] = checkHtmlFile(WebServerHandler::HTML_CALIBRATION); + doc["about"] = checkHtmlFile(WebServerHandler::HTML_ABOUT); #if LOG_LEVEL == 6 && !defined(WEB_DISABLE_LOGGING) serializeJson(doc, Serial); @@ -130,7 +130,7 @@ void WebServer::webHandleUpload() { // // Callback from webServer when / has been accessed. // -void WebServer::webHandleUploadFile() { +void WebServerHandler::webHandleUploadFile() { LOG_PERF_START("webserver-api-upload-file"); Log.notice(F("WEB : webServer callback for /api/upload/file." CR)); HTTPUpload& upload = _server->upload(); @@ -177,7 +177,7 @@ void WebServer::webHandleUploadFile() { // // Callback from webServer when / has been accessed. // -void WebServer::webHandleCalibrate() { +void WebServerHandler::webHandleCalibrate() { LOG_PERF_START("webserver-api-calibrate"); String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/calibrate." CR)); @@ -197,7 +197,7 @@ void WebServer::webHandleCalibrate() { // // Callback from webServer when / has been accessed. // -void WebServer::webHandleFactoryReset() { +void WebServerHandler::webHandleFactoryReset() { String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/factory." CR)); @@ -206,7 +206,7 @@ void WebServer::webHandleFactoryReset() { LittleFS.remove(CFG_FILENAME); LittleFS.end(); delay(500); - ESP.reset(); + ESP_RESET(); } else { _server->send(400, "text/plain", "Unknown ID."); } @@ -215,7 +215,7 @@ void WebServer::webHandleFactoryReset() { // // Callback from webServer when / has been accessed. // -void WebServer::webHandleStatus() { +void WebServerHandler::webHandleStatus() { LOG_PERF_START("webserver-api-status"); Log.notice(F("WEB : webServer callback for /api/status." CR)); @@ -257,7 +257,7 @@ void WebServer::webHandleStatus() { // // Callback from webServer when / has been accessed. // -void WebServer::webHandleClearWIFI() { +void WebServerHandler::webHandleClearWIFI() { String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/clearwifi." CR)); @@ -266,7 +266,7 @@ void WebServer::webHandleClearWIFI() { "Clearing WIFI credentials and doing reset..."); delay(1000); WiFi.disconnect(); // Clear credentials - ESP.reset(); + ESP_RESET(); } else { _server->send(400, "text/plain", "Unknown ID."); } @@ -275,7 +275,7 @@ void WebServer::webHandleClearWIFI() { // // Used to force the device to never sleep. // -void WebServer::webHandleStatusSleepmode() { +void WebServerHandler::webHandleStatusSleepmode() { LOG_PERF_START("webserver-api-sleepmode"); String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/status/sleepmode." CR)); @@ -303,7 +303,7 @@ void WebServer::webHandleStatusSleepmode() { // // Update device settings. // -void WebServer::webHandleConfigDevice() { +void WebServerHandler::webHandleConfigDevice() { LOG_PERF_START("webserver-api-config-device"); String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/config/device." CR)); @@ -332,7 +332,7 @@ void WebServer::webHandleConfigDevice() { // // Update push settings. // -void WebServer::webHandleConfigPush() { +void WebServerHandler::webHandleConfigPush() { LOG_PERF_START("webserver-api-config-push"); String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/config/push." CR)); @@ -370,7 +370,7 @@ void WebServer::webHandleConfigPush() { // // Get string with all received arguments. Used for debugging only. // -String WebServer::getRequestArguments() { +String WebServerHandler::getRequestArguments() { String debug; for (int i = 0; i < _server->args(); i++) { @@ -389,7 +389,7 @@ String WebServer::getRequestArguments() { // // Update gravity settings. // -void WebServer::webHandleConfigGravity() { +void WebServerHandler::webHandleConfigGravity() { LOG_PERF_START("webserver-api-config-gravity"); String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/config/gravity." CR)); @@ -420,7 +420,7 @@ void WebServer::webHandleConfigGravity() { // // Update hardware settings. // -void WebServer::webHandleConfigHardware() { +void WebServerHandler::webHandleConfigHardware() { LOG_PERF_START("webserver-api-config-hardware"); String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/config/hardware." CR)); @@ -455,7 +455,7 @@ void WebServer::webHandleConfigHardware() { // // Update device parameters. // -void WebServer::webHandleDeviceParam() { +void WebServerHandler::webHandleDeviceParam() { LOG_PERF_START("webserver-api-device-param"); String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/device/param." CR)); @@ -520,7 +520,7 @@ void WebServer::webHandleDeviceParam() { // // Callback from webServer when / has been accessed. // -void WebServer::webHandleFormulaRead() { +void WebServerHandler::webHandleFormulaRead() { LOG_PERF_START("webserver-api-formula-read"); Log.notice(F("WEB : webServer callback for /api/formula/get." CR)); @@ -586,7 +586,7 @@ void WebServer::webHandleFormulaRead() { // // Update hardware settings. // -void WebServer::webHandleFormulaWrite() { +void WebServerHandler::webHandleFormulaWrite() { LOG_PERF_START("webserver-api-formula-write"); String id = _server->arg(PARAM_ID); Log.notice(F("WEB : webServer callback for /api/formula/post." CR)); @@ -665,7 +665,7 @@ void WebServer::webHandleFormulaWrite() { // // Helper function to check if files exist on file system. // -const char* WebServer::getHtmlFileName(HtmlFile item) { +const char* WebServerHandler::getHtmlFileName(HtmlFile item) { Log.notice(F("WEB : Looking up filename for %d." CR), item); switch (item) { @@ -687,7 +687,7 @@ const char* WebServer::getHtmlFileName(HtmlFile item) { // // Helper function to check if files exist on file system. // -bool WebServer::checkHtmlFile(HtmlFile item) { +bool WebServerHandler::checkHtmlFile(HtmlFile item) { const char* fn = getHtmlFileName(item); #if LOG_LEVEL == 6 && !defined(WEB_DISABLE_LOGGING) @@ -703,7 +703,7 @@ bool WebServer::checkHtmlFile(HtmlFile item) { // // Handler for page not found // -void WebServer::webHandlePageNotFound() { +void WebServerHandler::webHandlePageNotFound() { Log.error(F("WEB : URL not found %s received." CR), _server->uri().c_str()); _server->send(404, "text/plain", F("URL not found")); } @@ -711,7 +711,7 @@ void WebServer::webHandlePageNotFound() { // // Setup the Web Server callbacks and start it // -bool WebServer::setupWebServer() { +bool WebServerHandler::setupWebServer() { Log.notice(F("WEB : Configuring web server." CR)); _server = new ESP8266WebServer(); @@ -721,13 +721,13 @@ bool WebServer::setupWebServer() { // Static content #if defined(EMBED_HTML) - _server->on("/", std::bind(&WebServer::webReturnIndexHtm, this)); - _server->on("/index.htm", std::bind(&WebServer::webReturnIndexHtm, this)); - _server->on("/device.htm", std::bind(&WebServer::webReturnDeviceHtm, this)); - _server->on("/config.htm", std::bind(&WebServer::webReturnConfigHtm, this)); + _server->on("/", std::bind(&WebServerHandler::webReturnIndexHtm, this)); + _server->on("/index.htm", std::bind(&WebServerHandler::webReturnIndexHtm, this)); + _server->on("/device.htm", std::bind(&WebServerHandler::webReturnDeviceHtm, this)); + _server->on("/config.htm", std::bind(&WebServerHandler::webReturnConfigHtm, this)); _server->on("/calibration.htm", - std::bind(&WebServer::webReturnCalibrationHtm, this)); - _server->on("/about.htm", std::bind(&WebServer::webReturnAboutHtm, this)); + std::bind(&WebServerHandler::webReturnCalibrationHtm, this)); + _server->on("/about.htm", std::bind(&WebServerHandler::webReturnAboutHtm, this)); #else // Show files in the filessytem at startup @@ -757,62 +757,62 @@ bool WebServer::setupWebServer() { // Also add the static upload view in case we we have issues that needs to // be fixed. - _server->on("/upload.htm", std::bind(&WebServer::webReturnUploadHtm, this)); + _server->on("/upload.htm", std::bind(&WebServerHandler::webReturnUploadHtm, this)); } else { Log.error(F("WEB : Missing html files, starting with upload UI." CR)); - _server->on("/", std::bind(&WebServer::webReturnUploadHtm, this)); + _server->on("/", std::bind(&WebServerHandler::webReturnUploadHtm, this)); } #endif // Dynamic content _server->on("/api/config", HTTP_GET, - std::bind(&WebServer::webHandleConfig, this)); // Get config.json + std::bind(&WebServerHandler::webHandleConfig, this)); // Get config.json _server->on("/api/device", HTTP_GET, - std::bind(&WebServer::webHandleDevice, this)); // Get device.json + std::bind(&WebServerHandler::webHandleDevice, this)); // Get device.json _server->on("/api/formula", HTTP_GET, - std::bind(&WebServer::webHandleFormulaRead, + std::bind(&WebServerHandler::webHandleFormulaRead, this)); // Get formula.json (calibration page) _server->on("/api/formula", HTTP_POST, - std::bind(&WebServer::webHandleFormulaWrite, + std::bind(&WebServerHandler::webHandleFormulaWrite, this)); // Get formula.json (calibration page) _server->on("/api/calibrate", HTTP_POST, - std::bind(&WebServer::webHandleCalibrate, + std::bind(&WebServerHandler::webHandleCalibrate, this)); // Run calibration routine (param id) _server->on( "/api/factory", HTTP_GET, - std::bind(&WebServer::webHandleFactoryReset, this)); // Reset the device + std::bind(&WebServerHandler::webHandleFactoryReset, this)); // Reset the device _server->on( "/api/status", HTTP_GET, - std::bind(&WebServer::webHandleStatus, this)); // Get the status.json + std::bind(&WebServerHandler::webHandleStatus, this)); // Get the status.json _server->on( "/api/clearwifi", HTTP_GET, - std::bind(&WebServer::webHandleClearWIFI, this)); // Clear wifi settings + std::bind(&WebServerHandler::webHandleClearWIFI, this)); // Clear wifi settings _server->on("/api/upload", HTTP_GET, - std::bind(&WebServer::webHandleUpload, this)); // Get upload.json + std::bind(&WebServerHandler::webHandleUpload, this)); // Get upload.json _server->on( - "/api/upload", HTTP_POST, std::bind(&WebServer::webReturnOK, this), - std::bind(&WebServer::webHandleUploadFile, this)); // File upload data + "/api/upload", HTTP_POST, std::bind(&WebServerHandler::webReturnOK, this), + std::bind(&WebServerHandler::webHandleUploadFile, this)); // File upload data _server->on("/api/status/sleepmode", HTTP_POST, - std::bind(&WebServer::webHandleStatusSleepmode, + std::bind(&WebServerHandler::webHandleStatusSleepmode, this)); // Change sleep mode _server->on("/api/config/device", HTTP_POST, - std::bind(&WebServer::webHandleConfigDevice, + std::bind(&WebServerHandler::webHandleConfigDevice, this)); // Change device settings _server->on("/api/config/push", HTTP_POST, - std::bind(&WebServer::webHandleConfigPush, + std::bind(&WebServerHandler::webHandleConfigPush, this)); // Change push settings _server->on("/api/config/gravity", HTTP_POST, - std::bind(&WebServer::webHandleConfigGravity, + std::bind(&WebServerHandler::webHandleConfigGravity, this)); // Change gravity settings _server->on("/api/config/hardware", HTTP_POST, - std::bind(&WebServer::webHandleConfigHardware, + std::bind(&WebServerHandler::webHandleConfigHardware, this)); // Change hardware settings _server->on("/api/device/param", HTTP_GET, - std::bind(&WebServer::webHandleDeviceParam, + std::bind(&WebServerHandler::webHandleDeviceParam, this)); // Change device params - _server->onNotFound(std::bind(&WebServer::webHandlePageNotFound, this)); + _server->onNotFound(std::bind(&WebServerHandler::webHandlePageNotFound, this)); _server->begin(); Log.notice(F("WEB : Web server started." CR)); return true; @@ -821,8 +821,10 @@ bool WebServer::setupWebServer() { // // called from main loop // -void WebServer::loop() { +void WebServerHandler::loop() { +#if defined (ESP8266) MDNS.update(); +#endif _server->handleClient(); } diff --git a/src/webserver.hpp b/src/webserver.hpp index e2a892c..49f4b5c 100644 --- a/src/webserver.hpp +++ b/src/webserver.hpp @@ -24,9 +24,15 @@ SOFTWARE. #ifndef SRC_WEBSERVER_HPP_ #define SRC_WEBSERVER_HPP_ +#if defined (ESP8266) #include #include #include +#else // defined (ESP32) +#include +#include +#include +#endif #include #if defined(EMBED_HTML) @@ -39,7 +45,7 @@ INCBIN_EXTERN(AboutHtm); INCBIN_EXTERN(UploadHtm); #endif -class WebServer { +class WebServerHandler { private: ESP8266WebServer* _server = 0; File _uploadFile; @@ -111,7 +117,7 @@ class WebServer { }; // Global instance created -extern WebServer myWebServer; +extern WebServerHandler myWebServerHandler; #endif // SRC_WEBSERVER_HPP_ diff --git a/src/wifi.cpp b/src/wifi.cpp index 975f1b7..bf3c43a 100644 --- a/src/wifi.cpp +++ b/src/wifi.cpp @@ -21,18 +21,27 @@ 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. */ +#if defined (ESP8266) #include #include -#include +#else // defined (ESP32) +#include +#include +#include +#endif #include - #include #include #include // Settings for DRD +#if defined (ESP8266) #define ESP_DRD_USE_LITTLEFS true #define ESP_DRD_USE_SPIFFS false +#else // defined (ESP32) +#define ESP_DRD_USE_LITTLEFS false +#define ESP_DRD_USE_SPIFFS true +#endif #define ESP_DRD_USE_EEPROM false #include #define DRD_TIMEOUT 3 @@ -64,12 +73,11 @@ WifiConnection myWifi; const char *userSSID = USER_SSID; const char *userPWD = USER_SSID_PWD; -const int PIN_LED = 2; // -// Constructor +// Initialize // -WifiConnection::WifiConnection() { +void WifiConnection::init() { myDRD = new DoubleResetDetector(DRD_TIMEOUT, DRD_ADDRESS); } @@ -143,7 +151,7 @@ void WifiConnection::startPortal() { stopDoubleReset(); delay(500); - ESP.reset(); + ESP_RESET(); } // @@ -252,7 +260,7 @@ bool WifiConnection::updateFirmware() { case HTTP_UPDATE_OK: Log.notice("WIFI: OTA Update sucesfull, rebooting."); delay(100); - ESP.reset(); + ESP_RESET(); break; } return false; diff --git a/src/wifi.hpp b/src/wifi.hpp index 049f7e3..caaa9cc 100644 --- a/src/wifi.hpp +++ b/src/wifi.hpp @@ -24,7 +24,12 @@ SOFTWARE. #ifndef SRC_WIFI_HPP_ #define SRC_WIFI_HPP_ +#if defined (ESP8266) #include +#else // defined (ESP32) +#include +#include +#endif #define WIFI_DEFAULT_SSID "GravityMon" // Name of created SSID #define WIFI_DEFAULT_PWD "password" // Password for created SSID @@ -50,7 +55,7 @@ class WifiConnection { public: // WIFI - WifiConnection(); + void init(); bool connect(); bool disconnect(); @@ -65,8 +70,8 @@ class WifiConnection { WiFiClient& getWifiClient() { return _client; } WiFiClientSecure& getWifiClientSecure() { return _secureClient; } void closeWifiClient() { - _client.stopAll(); - _secureClient.stopAll(); + _client.stop(); + _secureClient.stop(); // Cleanup memory allocated by open tcp connetions. while (tcp_tw_pcbs) tcp_abort(tcp_tw_pcbs);