v2.9

lib/DallasTemperature/.arduino-ci.yml

@@ -0,0 +1,15 @@
+compile:
+  # Choosing to run compilation tests on 2 different Arduino platforms
+  platforms:
+    - uno
+    - due
+    # - zero         # SAMD covered by M4
+    # - leonardo     # AVR covered by UNO
+    - m4
+    # - esp32        # errors on OneWire =>  util/crc16.h  vs  rom/crc.h
+    - esp8266
+    # - mega2560     # AVR covered by UNO
+unittest:
+  # These dependent libraries will be installed
+  libraries:
+    - "OneWire"

lib/DallasTemperature/.gitattributes

@@ -0,0 +1 @@
+*	text=auto

lib/DallasTemperature/.github/workflows/arduino-lint.yml

@@ -0,0 +1,13 @@
+
+name: Arduino-lint
+
+on: [push, pull_request]
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: arduino/arduino-lint-action@v1
+        with:
+          library-manager: update
+          # compliance: strict

lib/DallasTemperature/.github/workflows/arduino_test_runner.yml

@@ -0,0 +1,17 @@
+---
+name: Arduino CI
+
+on: [push, pull_request]
+
+jobs:
+  runTest:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.6
+      - run: |
+          gem install arduino_ci
+          arduino_ci.rb

lib/DallasTemperature/.github/workflows/jsoncheck.yml

@@ -0,0 +1,18 @@
+name: JSON check
+
+on:
+  push:
+    paths:
+      - '**.json'
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: json-syntax-check
+        uses: limitusus/json-syntax-check@v1
+        with:
+          pattern: "\\.json$"
+

lib/DallasTemperature/.gitignore

@@ -0,0 +1,16 @@
+.idea
+classes
+target
+out
+build
+*.iml
+*.ipr
+*.iws
+*.log
+*.war
+.idea
+.project
+.classpath
+.settings
+.gradle
+.vscode

lib/DallasTemperature/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "DallasTemperature", "version": "3.11.0", "spec": {"owner": "milesburton", "id": 54, "name": "DallasTemperature", "requirements": null, "uri": null}}

lib/DallasTemperature/DallasTemperature.h

@@ -0,0 +1,346 @@
+#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 <inttypes.h>
+#ifdef __STM32F1__
+#include <OneWireSTM.h>
+#else
+#include <OneWire.h>
+#endif
+
+// Model IDs
+#define DS18S20MODEL 0x10  // also DS1820
+#define DS18B20MODEL 0x28  // also MAX31820
+#define DS1822MODEL  0x22
+#define DS1825MODEL  0x3B  // also MAX31850
+#define DS28EA00MODEL 0x42
+
+// Error Codes
+// See https://github.com/milesburton/Arduino-Temperature-Control-Library/commit/ac1eb7f56e3894e855edc3353be4bde4aa838d41#commitcomment-75490966 for the 16bit implementation. Reverted due to microcontroller resource constraints.
+#define DEVICE_DISCONNECTED_C -127
+#define DEVICE_DISCONNECTED_F -196.6
+#define DEVICE_DISCONNECTED_RAW -7040
+
+#define DEVICE_FAULT_OPEN_C -254
+#define DEVICE_FAULT_OPEN_F -425.199982
+#define DEVICE_FAULT_OPEN_RAW -32512
+
+#define DEVICE_FAULT_SHORTGND_C -253
+#define DEVICE_FAULT_SHORTGND_F -423.399994
+#define DEVICE_FAULT_SHORTGND_RAW -32384
+
+#define DEVICE_FAULT_SHORTVDD_C -252
+#define DEVICE_FAULT_SHORTVDD_F -421.599976
+#define DEVICE_FAULT_SHORTVDD_RAW -32256
+
+// 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 <class T>
+	operator T *() const {
+		return 0;
+	}
+
+	template <class C, class T>
+	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);
+
+	struct request_t {
+		bool result;
+		unsigned long timestamp;
+
+		operator bool() {
+			return result;
+		}
+	};
+
+	// sends command for all devices on the bus to perform a temperature conversion
+	request_t requestTemperatures(void);
+
+	// sends command for one device to perform a temperature conversion by address
+	request_t requestTemperaturesByAddress(const uint8_t*);
+
+	// sends command for one device to perform a temperature conversion by index
+	request_t requestTemperaturesByIndex(uint8_t);
+
+	// returns temperature raw value (12 bit integer of 1/128 degrees C)
+	int32_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(int32_t);
+
+	// convert from Celsius to raw
+	static int16_t celsiusToRaw(float);
+
+	// convert from raw to Fahrenheit
+	static float rawToFahrenheit(int32_t);
+
+#if REQUIRESNEW
+
+	// initialize memory area
+	void* operator new(unsigned int);
+
+	// delete memory reference
+	void operator delete(void*);
+
+#endif
+
+	void blockTillConversionComplete(uint8_t);
+	void blockTillConversionComplete(uint8_t, unsigned long);
+	void blockTillConversionComplete(uint8_t, request_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
+	int32_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

lib/DallasTemperature/README.md

@@ -0,0 +1,80 @@
+[![Arduino CI](https://github.com/milesburton/Arduino-Temperature-Control-Library/workflows/Arduino%20CI/badge.svg)](https://github.com/marketplace/actions/arduino_ci)
+[![Arduino-lint](https://github.com/milesburton/Arduino-Temperature-Control-Library/actions/workflows/arduino-lint.yml/badge.svg)](https://github.com/RobTillaart/AS5600/actions/workflows/arduino-lint.yml)
+[![JSON check](https://github.com/milesburton/Arduino-Temperature-Control-Library/actions/workflows/jsoncheck.yml/badge.svg)](https://github.com/RobTillaart/AS5600/actions/workflows/jsoncheck.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/milesburton/Arduino-Temperature-Control-Library/blob/master/LICENSE)
+[![GitHub release](https://img.shields.io/github/release/milesburton/Arduino-Temperature-Control-Library.svg?maxAge=3600)](https://github.com/milesburton/Arduino-Temperature-Control-Library/releases)
+
+
+# Arduino Library for Maxim Temperature Integrated Circuits
+
+## Usage
+
+This library supports the following devices :
+
+
+* DS18B20
+* DS18S20 - Please note there appears to be an issue with this series.
+* DS1822
+* DS1820
+* MAX31820
+* MAX31850
+
+
+You will need a pull-up resistor of about 5 KOhm between the 1-Wire data line
+and your 5V power. If you are using the DS18B20, ground pins 1 and 3. The
+centre pin is the data line '1-wire'.
+
+In case of temperature conversion problems (result is `-85`), strong pull-up setup may be necessary. See section 
+_Powering the DS18B20_ in 
+[DS18B20 datasheet](https://datasheets.maximintegrated.com/en/ds/DS18B20.pdf) (page 7)
+and use `DallasTemperature(OneWire*, uint8_t)` constructor.
+
+We have included a "REQUIRESNEW" and "REQUIRESALARMS" definition. If you 
+want to slim down the code feel free to use either of these by including
+
+
+
+	#define REQUIRESNEW 
+
+or 
+
+	#define REQUIRESALARMS
+
+
+at the top of DallasTemperature.h
+
+Finally, please include OneWire from Paul Stoffregen in the library manager before you begin.
+
+## Credits
+
+The OneWire code has been derived from
+http://www.arduino.cc/playground/Learning/OneWire.
+Miles Burton <miles@mnetcs.com> originally developed this library.
+Tim Newsome <nuisance@casualhacker.net> added support for multiple sensors on
+the same bus.
+Guil Barros [gfbarros@bappos.com] added getTempByAddress (v3.5)
+   Note: these are implemented as getTempC(address) and getTempF(address)
+Rob Tillaart [rob.tillaart@gmail.com] added async modus (v3.7.0)
+
+
+## Website
+
+
+Additional documentation may be found here
+https://www.milesburton.com/Dallas_Temperature_Control_Library
+
+# License
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

lib/DallasTemperature/examples/Alarm/Alarm.ino

@@ -0,0 +1,161 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device addresses
+DeviceAddress insideThermometer, outsideThermometer;
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+
+  // locate devices on the bus
+  Serial.print("Found ");
+  Serial.print(sensors.getDeviceCount(), DEC);
+  Serial.println(" devices.");
+
+  // search for devices on the bus and assign based on an index.
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");
+  if (!sensors.getAddress(outsideThermometer, 1)) Serial.println("Unable to find address for Device 1");
+
+  // show the addresses we found on the bus
+  Serial.print("Device 0 Address: ");
+  printAddress(insideThermometer);
+  Serial.println();
+
+  Serial.print("Device 0 Alarms: ");
+  printAlarms(insideThermometer);
+  Serial.println();
+
+  Serial.print("Device 1 Address: ");
+  printAddress(outsideThermometer);
+  Serial.println();
+
+  Serial.print("Device 1 Alarms: ");
+  printAlarms(outsideThermometer);
+  Serial.println();
+
+  Serial.println("Setting alarm temps...");
+
+  // alarm when temp is higher than 30C
+  sensors.setHighAlarmTemp(insideThermometer, 30);
+
+  // alarm when temp is lower than -10C
+  sensors.setLowAlarmTemp(insideThermometer, -10);
+
+  // alarm when temp is higher than 31C
+  sensors.setHighAlarmTemp(outsideThermometer, 31);
+
+  // alarn when temp is lower than 27C
+  sensors.setLowAlarmTemp(outsideThermometer, 27);
+
+  Serial.print("New Device 0 Alarms: ");
+  printAlarms(insideThermometer);
+  Serial.println();
+
+  Serial.print("New Device 1 Alarms: ");
+  printAlarms(outsideThermometer);
+  Serial.println();
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+// function to print the temperature for a device
+void printTemperature(DeviceAddress deviceAddress)
+{
+  float tempC = sensors.getTempC(deviceAddress);
+  Serial.print("Temp C: ");
+  Serial.print(tempC);
+  Serial.print(" Temp F: ");
+  Serial.print(DallasTemperature::toFahrenheit(tempC));
+}
+
+void printAlarms(uint8_t deviceAddress[])
+{
+  char temp;
+  temp = sensors.getHighAlarmTemp(deviceAddress);
+  Serial.print("High Alarm: ");
+  Serial.print(temp, DEC);
+  Serial.print("C/");
+  Serial.print(DallasTemperature::toFahrenheit(temp));
+  Serial.print("F | Low Alarm: ");
+  temp = sensors.getLowAlarmTemp(deviceAddress);
+  Serial.print(temp, DEC);
+  Serial.print("C/");
+  Serial.print(DallasTemperature::toFahrenheit(temp));
+  Serial.print("F");
+}
+
+// main function to print information about a device
+void printData(DeviceAddress deviceAddress)
+{
+  Serial.print("Device Address: ");
+  printAddress(deviceAddress);
+  Serial.print(" ");
+  printTemperature(deviceAddress);
+  Serial.println();
+}
+
+void checkAlarm(DeviceAddress deviceAddress)
+{
+  if (sensors.hasAlarm(deviceAddress))
+  {
+    Serial.print("ALARM: ");
+    printData(deviceAddress);
+  }
+}
+
+void loop(void)
+{
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures();
+  Serial.println("DONE");
+
+  // Method 1:
+  // check each address individually for an alarm condition
+  checkAlarm(insideThermometer);
+  checkAlarm(outsideThermometer);
+/*
+  // Alternate method:
+  // Search the bus and iterate through addresses of devices with alarms
+
+  // space for the alarm device's address
+  DeviceAddress alarmAddr;
+
+  Serial.println("Searching for alarms...");
+
+  // resetAlarmSearch() must be called before calling alarmSearch()
+  sensors.resetAlarmSearch();
+
+  // alarmSearch() returns 0 when there are no devices with alarms
+  while (sensors.alarmSearch(alarmAddr))
+  {
+    Serial.print("ALARM: ");
+    printData(alarmAddr);
+  }
+*/
+
+}

lib/DallasTemperature/examples/AlarmHandler/AlarmHandler.ino

@@ -0,0 +1,143 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device addresses
+DeviceAddress insideThermometer, outsideThermometer;
+
+// function that will be called when an alarm condition exists during DallasTemperatures::processAlarms();
+void newAlarmHandler(const uint8_t* deviceAddress)
+{
+  Serial.println("Alarm Handler Start");
+  printAlarmInfo(deviceAddress);
+  printTemp(deviceAddress);
+  Serial.println();
+  Serial.println("Alarm Handler Finish");
+}
+
+void printCurrentTemp(DeviceAddress deviceAddress)
+{
+  printAddress(deviceAddress);
+  printTemp(deviceAddress);
+  Serial.println();
+}
+
+void printAddress(const DeviceAddress deviceAddress)
+{
+  Serial.print("Address: ");
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+  Serial.print(" ");
+}
+
+void printTemp(const DeviceAddress deviceAddress)
+{
+  float tempC = sensors.getTempC(deviceAddress);
+  if (tempC != DEVICE_DISCONNECTED_C)
+  {
+    Serial.print("Current Temp C: ");
+    Serial.print(tempC);
+  }
+  else Serial.print("DEVICE DISCONNECTED");
+  Serial.print(" ");
+}
+
+void printAlarmInfo(const DeviceAddress deviceAddress)
+{
+  char temp;
+  printAddress(deviceAddress);
+  temp = sensors.getHighAlarmTemp(deviceAddress);
+  Serial.print("High Alarm: ");
+  Serial.print(temp, DEC);
+  Serial.print("C");
+  Serial.print(" Low Alarm: ");
+  temp = sensors.getLowAlarmTemp(deviceAddress);
+  Serial.print(temp, DEC);
+  Serial.print("C");
+  Serial.print(" ");
+}
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+
+  // locate devices on the bus
+  Serial.print("Found ");
+  Serial.print(sensors.getDeviceCount(), DEC);
+  Serial.println(" devices.");
+
+  // search for devices on the bus and assign based on an index
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");
+  if (!sensors.getAddress(outsideThermometer, 1)) Serial.println("Unable to find address for Device 1");
+
+  Serial.print("Device insideThermometer ");
+  printAlarmInfo(insideThermometer);
+  Serial.println();
+
+  Serial.print("Device outsideThermometer ");
+  printAlarmInfo(outsideThermometer);
+  Serial.println();
+
+  // set alarm ranges
+  Serial.println("Setting alarm temps...");
+  sensors.setHighAlarmTemp(insideThermometer, 26);
+  sensors.setLowAlarmTemp(insideThermometer, 22);
+  sensors.setHighAlarmTemp(outsideThermometer, 25);
+  sensors.setLowAlarmTemp(outsideThermometer, 21);
+
+  Serial.print("New insideThermometer ");
+  printAlarmInfo(insideThermometer);
+  Serial.println();
+
+  Serial.print("New outsideThermometer ");
+  printAlarmInfo(outsideThermometer);
+  Serial.println();
+
+  // attach alarm handler
+  sensors.setAlarmHandler(&newAlarmHandler);
+
+}
+
+void loop(void)
+{
+  // ask the devices to measure the temperature
+  sensors.requestTemperatures();
+
+  // if an alarm condition exists as a result of the most recent
+  // requestTemperatures() request, it exists until the next time
+  // requestTemperatures() is called AND there isn't an alarm condition
+  // on the device
+  if (sensors.hasAlarm())
+  {
+    Serial.println("Oh noes!  There is at least one alarm on the bus.");
+  }
+
+  // call alarm handler function defined by sensors.setAlarmHandler
+  // for each device reporting an alarm
+  sensors.processAlarms();
+
+  if (!sensors.hasAlarm())
+  {
+    // just print out the current temperature
+    printCurrentTemp(insideThermometer);
+    printCurrentTemp(outsideThermometer);
+  }
+
+  delay(1000);
+}

lib/DallasTemperature/examples/ExternalPullup/ExternalPullup.ino

@@ -0,0 +1,35 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino, while external pullup P-MOSFET gate into port 3
+#define ONE_WIRE_BUS    2
+#define ONE_WIRE_PULLUP 3
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire, ONE_WIRE_PULLUP);
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+}
+
+void loop(void)
+{
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+
+  for (int i = 0; i < sensors.getDeviceCount(); i++) {
+    Serial.println("Temperature for Device " + String(i) + " is: " + String(sensors.getTempCByIndex(i)));
+  }
+}

lib/DallasTemperature/examples/Multibus_simple/Multibus_simple.ino

@@ -0,0 +1,43 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+OneWire ds18x20[] = { 3, 7 };
+const int oneWireCount = sizeof(ds18x20) / sizeof(OneWire);
+DallasTemperature sensor[oneWireCount];
+
+void setup(void) {
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature Multiple Bus Control Library Simple Demo");
+  Serial.print("============Ready with ");
+  Serial.print(oneWireCount);
+  Serial.println(" Sensors================");
+
+  // Start up the library on all defined bus-wires
+  DeviceAddress deviceAddress;
+  for (int i = 0; i < oneWireCount; i++) {
+    sensor[i].setOneWire(&ds18x20[i]);
+    sensor[i].begin();
+    if (sensor[i].getAddress(deviceAddress, 0)) sensor[i].setResolution(deviceAddress, 12);
+  }
+}
+
+void loop(void) {
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  for (int i = 0; i < oneWireCount; i++) {
+    sensor[i].requestTemperatures();
+  }
+  Serial.println("DONE");
+
+  delay(1000);
+  for (int i = 0; i < oneWireCount; i++) {
+    float temperature = sensor[i].getTempCByIndex(0);
+    Serial.print("Temperature for the sensor ");
+    Serial.print(i);
+    Serial.print(" is ");
+    Serial.println(temperature);
+  }
+  Serial.println();
+}

lib/DallasTemperature/examples/Multiple/Multiple.ino

@@ -0,0 +1,148 @@
+// Include the libraries we need
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+#define TEMPERATURE_PRECISION 9
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device addresses
+DeviceAddress insideThermometer, outsideThermometer;
+
+// Assign address manually. The addresses below will need to be changed
+// to valid device addresses on your bus. Device address can be retrieved
+// by using either oneWire.search(deviceAddress) or individually via
+// sensors.getAddress(deviceAddress, index)
+// DeviceAddress insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
+// DeviceAddress outsideThermometer   = { 0x28, 0x3F, 0x1C, 0x31, 0x2, 0x0, 0x0, 0x2 };
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+
+  // locate devices on the bus
+  Serial.print("Locating devices...");
+  Serial.print("Found ");
+  Serial.print(sensors.getDeviceCount(), DEC);
+  Serial.println(" devices.");
+
+  // report parasite power requirements
+  Serial.print("Parasite power is: ");
+  if (sensors.isParasitePowerMode()) Serial.println("ON");
+  else Serial.println("OFF");
+
+  // Search for devices on the bus and assign based on an index. Ideally,
+  // you would do this to initially discover addresses on the bus and then
+  // use those addresses and manually assign them (see above) once you know
+  // the devices on your bus (and assuming they don't change).
+  //
+  // method 1: by index
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");
+  if (!sensors.getAddress(outsideThermometer, 1)) Serial.println("Unable to find address for Device 1");
+
+  // method 2: search()
+  // search() looks 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
+  //
+  // Must be called before search()
+  //oneWire.reset_search();
+  // assigns the first address found to insideThermometer
+  //if (!oneWire.search(insideThermometer)) Serial.println("Unable to find address for insideThermometer");
+  // assigns the seconds address found to outsideThermometer
+  //if (!oneWire.search(outsideThermometer)) Serial.println("Unable to find address for outsideThermometer");
+
+  // show the addresses we found on the bus
+  Serial.print("Device 0 Address: ");
+  printAddress(insideThermometer);
+  Serial.println();
+
+  Serial.print("Device 1 Address: ");
+  printAddress(outsideThermometer);
+  Serial.println();
+
+  // set the resolution to 9 bit per device
+  sensors.setResolution(insideThermometer, TEMPERATURE_PRECISION);
+  sensors.setResolution(outsideThermometer, TEMPERATURE_PRECISION);
+
+  Serial.print("Device 0 Resolution: ");
+  Serial.print(sensors.getResolution(insideThermometer), DEC);
+  Serial.println();
+
+  Serial.print("Device 1 Resolution: ");
+  Serial.print(sensors.getResolution(outsideThermometer), DEC);
+  Serial.println();
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    // zero pad the address if necessary
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+// function to print the temperature for a device
+void printTemperature(DeviceAddress deviceAddress)
+{
+  float tempC = sensors.getTempC(deviceAddress);
+  if (tempC == DEVICE_DISCONNECTED_C)
+  {
+    Serial.println("Error: Could not read temperature data");
+    return;
+  }
+  Serial.print("Temp C: ");
+  Serial.print(tempC);
+  Serial.print(" Temp F: ");
+  Serial.print(DallasTemperature::toFahrenheit(tempC));
+}
+
+// function to print a device's resolution
+void printResolution(DeviceAddress deviceAddress)
+{
+  Serial.print("Resolution: ");
+  Serial.print(sensors.getResolution(deviceAddress));
+  Serial.println();
+}
+
+// main function to print information about a device
+void printData(DeviceAddress deviceAddress)
+{
+  Serial.print("Device Address: ");
+  printAddress(deviceAddress);
+  Serial.print(" ");
+  printTemperature(deviceAddress);
+  Serial.println();
+}
+
+/*
+   Main function, calls the temperatures in a loop.
+*/
+void loop(void)
+{
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures();
+  Serial.println("DONE");
+
+  // print the device information
+  printData(insideThermometer);
+  printData(outsideThermometer);
+}

lib/DallasTemperature/examples/SaveRecallScratchPad/SaveRecallScratchPad.ino

@@ -0,0 +1,106 @@
+//
+//    FILE: SaveRecallScratchPad.ino
+//  AUTHOR: GitKomodo
+// VERSION: 0.0.1
+// PURPOSE: Show DallasTemperature lib functionality to
+//          save/recall ScratchPad values to/from EEPROM
+//
+// HISTORY:
+// 0.0.1 = 2020-02-18 initial version
+//
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#define ONE_WIRE_BUS 2
+
+OneWire oneWire(ONE_WIRE_BUS);
+DallasTemperature sensors(&oneWire);
+DeviceAddress deviceAddress;
+
+void setup()
+{
+  Serial.begin(9600);
+  Serial.println(__FILE__);
+  Serial.println("Dallas Temperature Demo");
+
+  sensors.begin();
+
+  // Get ID of first sensor (at index 0)
+  sensors.getAddress(deviceAddress, 0);
+
+  // By default configuration and alarm/userdata registers are also saved to EEPROM
+  // when they're changed. Sensors recall these values automatically when powered up.
+
+  // Turn OFF automatic saving of configuration and alarm/userdata registers to EEPROM
+  sensors.setAutoSaveScratchPad(false);
+
+  // Change configuration and alarm/userdata registers on the scratchpad
+  int8_t resolution = 12;
+  sensors.setResolution(deviceAddress, resolution);
+  int16_t userdata = 24680;
+  sensors.setUserData(deviceAddress, userdata);
+
+  // Save configuration and alarm/userdata registers to EEPROM
+  sensors.saveScratchPad(deviceAddress);
+
+  // saveScratchPad can also be used without a parameter to save the configuration
+  // and alarm/userdata registers of ALL connected sensors to EEPROM:
+  //
+  //   sensors.saveScratchPad();
+  //
+  // Or the configuration and alarm/userdata registers of a sensor can be saved to
+  // EEPROM by index:
+  //
+  //   sensors.saveScratchPadByIndex(0);
+
+  // Print current values on the scratchpad (resolution = 12, userdata = 24680)
+  printValues();
+
+}
+
+void loop() {
+
+  // Change configuration and alarm/userdata registers on the scratchpad
+  int8_t resolution = 10;
+  sensors.setResolution(deviceAddress, resolution);
+  int16_t userdata = 12345;
+  sensors.setUserData(deviceAddress, userdata);
+
+  // Print current values on the scratchpad (resolution = 10, userdata = 12345)
+  printValues();
+
+  delay(2000);
+
+  // Recall configuration and alarm/userdata registers from EEPROM
+  sensors.recallScratchPad(deviceAddress);
+
+  // recallScratchPad can also be used without a parameter to recall the configuration
+  // and alarm/userdata registers of ALL connected sensors from EEPROM:
+  //
+  //   sensors.recallScratchPad();
+  //
+  // Or the configuration and alarm/userdata registers of a sensor can be recalled
+  // from EEPROM by index:
+  //
+  //   sensors.recallScratchPadByIndex(0);
+
+  // Print current values on the scratchpad (resolution = 12, userdata = 24680)
+  printValues();
+
+  delay(2000);
+
+}
+
+void printValues() {
+
+  Serial.println();
+  Serial.println("Current values on the scratchpad:");
+
+  Serial.print("Resolution:\t");
+  Serial.println(sensors.getResolution(deviceAddress));
+
+  Serial.print("User data:\t");
+  Serial.println(sensors.getUserData(deviceAddress));
+
+}

lib/DallasTemperature/examples/SetUserData/SetUserData.ino

@@ -0,0 +1,47 @@
+//
+// This sketch does not use the ALARM registers and uses those 2 bytes as a counter
+// these 2 bytes can be used for other purposes as well e.g. last temperature or
+// a specific ID.
+//
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+int count = 0;
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+
+}
+
+void loop(void)
+{
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+
+  Serial.print("Temperature for the device 1 (index 0) is: ");
+  Serial.println(sensors.getTempCByIndex(0));
+
+  count++;
+  sensors.setUserDataByIndex(0, count);
+  int x = sensors.getUserDataByIndex(0);
+  Serial.println(count);
+}

lib/DallasTemperature/examples/Simple/Simple.ino

@@ -0,0 +1,51 @@
+// Include the libraries we need
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+/*
+ * The setup function. We only start the sensors here
+ */
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+}
+
+/*
+ * Main function, get and show the temperature
+ */
+void loop(void)
+{
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+  // After we got the temperatures, we can print them here.
+  // We use the function ByIndex, and as an example get the temperature from the first sensor only.
+  float tempC = sensors.getTempCByIndex(0);
+
+  // Check if reading was successful
+  if (tempC != DEVICE_DISCONNECTED_C)
+  {
+    Serial.print("Temperature for the device 1 (index 0) is: ");
+    Serial.println(tempC);
+  }
+  else
+  {
+    Serial.println("Error: Could not read temperature data");
+  }
+}

lib/DallasTemperature/examples/Single/Single.ino

@@ -0,0 +1,121 @@
+// Include the libraries we need
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device address
+DeviceAddress insideThermometer;
+
+/*
+ * Setup function. Here we do the basics
+ */
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // locate devices on the bus
+  Serial.print("Locating devices...");
+  sensors.begin();
+  Serial.print("Found ");
+  Serial.print(sensors.getDeviceCount(), DEC);
+  Serial.println(" devices.");
+
+  // report parasite power requirements
+  Serial.print("Parasite power is: ");
+  if (sensors.isParasitePowerMode()) Serial.println("ON");
+  else Serial.println("OFF");
+
+  // Assign address manually. The addresses below will beed to be changed
+  // to valid device addresses on your bus. Device address can be retrieved
+  // by using either oneWire.search(deviceAddress) or individually via
+  // sensors.getAddress(deviceAddress, index)
+  // Note that you will need to use your specific address here
+  //insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
+
+  // Method 1:
+  // Search for devices on the bus and assign based on an index. Ideally,
+  // you would do this to initially discover addresses on the bus and then
+  // use those addresses and manually assign them (see above) once you know
+  // the devices on your bus (and assuming they don't change).
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");
+
+  // method 2: search()
+  // search() looks 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
+  //
+  // Must be called before search()
+  //oneWire.reset_search();
+  // assigns the first address found to insideThermometer
+  //if (!oneWire.search(insideThermometer)) Serial.println("Unable to find address for insideThermometer");
+
+  // show the addresses we found on the bus
+  Serial.print("Device 0 Address: ");
+  printAddress(insideThermometer);
+  Serial.println();
+
+  // set the resolution to 9 bit (Each Dallas/Maxim device is capable of several different resolutions)
+  sensors.setResolution(insideThermometer, 9);
+
+  Serial.print("Device 0 Resolution: ");
+  Serial.print(sensors.getResolution(insideThermometer), DEC);
+  Serial.println();
+}
+
+// function to print the temperature for a device
+void printTemperature(DeviceAddress deviceAddress)
+{
+  // method 1 - slower
+  //Serial.print("Temp C: ");
+  //Serial.print(sensors.getTempC(deviceAddress));
+  //Serial.print(" Temp F: ");
+  //Serial.print(sensors.getTempF(deviceAddress)); // Makes a second call to getTempC and then converts to Fahrenheit
+
+  // method 2 - faster
+  float tempC = sensors.getTempC(deviceAddress);
+  if (tempC == DEVICE_DISCONNECTED_C)
+  {
+    Serial.println("Error: Could not read temperature data");
+    return;
+  }
+  Serial.print("Temp C: ");
+  Serial.print(tempC);
+  Serial.print(" Temp F: ");
+  Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
+}
+/*
+ * Main function. It will request the tempC from the sensors and display on Serial.
+ */
+void loop(void)
+{
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+
+  // It responds almost immediately. Let's print out the data
+  printTemperature(insideThermometer); // Use a simple function to print out the data
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}

lib/DallasTemperature/examples/Tester/Tester.ino

@@ -0,0 +1,129 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+#define TEMPERATURE_PRECISION 9 // Lower resolution
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+int numberOfDevices; // Number of temperature devices found
+
+DeviceAddress tempDeviceAddress; // We'll use this variable to store a found device address
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+
+  // Grab a count of devices on the wire
+  numberOfDevices = sensors.getDeviceCount();
+
+  // locate devices on the bus
+  Serial.print("Locating devices...");
+
+  Serial.print("Found ");
+  Serial.print(numberOfDevices, DEC);
+  Serial.println(" devices.");
+
+  // report parasite power requirements
+  Serial.print("Parasite power is: ");
+  if (sensors.isParasitePowerMode()) Serial.println("ON");
+  else Serial.println("OFF");
+
+  // Loop through each device, print out address
+  for (int i = 0; i < numberOfDevices; i++)
+  {
+    // Search the wire for address
+    if (sensors.getAddress(tempDeviceAddress, i))
+    {
+      Serial.print("Found device ");
+      Serial.print(i, DEC);
+      Serial.print(" with address: ");
+      printAddress(tempDeviceAddress);
+      Serial.println();
+
+      Serial.print("Setting resolution to ");
+      Serial.println(TEMPERATURE_PRECISION, DEC);
+
+      // set the resolution to TEMPERATURE_PRECISION bit (Each Dallas/Maxim device is capable of several different resolutions)
+      sensors.setResolution(tempDeviceAddress, TEMPERATURE_PRECISION);
+
+      Serial.print("Resolution actually set to: ");
+      Serial.print(sensors.getResolution(tempDeviceAddress), DEC);
+      Serial.println();
+    } else {
+      Serial.print("Found ghost device at ");
+      Serial.print(i, DEC);
+      Serial.print(" but could not detect address. Check power and cabling");
+    }
+  }
+
+}
+
+// function to print the temperature for a device
+void printTemperature(DeviceAddress deviceAddress)
+{
+  // method 1 - slower
+  //Serial.print("Temp C: ");
+  //Serial.print(sensors.getTempC(deviceAddress));
+  //Serial.print(" Temp F: ");
+  //Serial.print(sensors.getTempF(deviceAddress)); // Makes a second call to getTempC and then converts to Fahrenheit
+
+  // method 2 - faster
+  float tempC = sensors.getTempC(deviceAddress);
+  if (tempC == DEVICE_DISCONNECTED_C)
+  {
+    Serial.println("Error: Could not read temperature data");
+    return;
+  }
+  Serial.print("Temp C: ");
+  Serial.print(tempC);
+  Serial.print(" Temp F: ");
+  Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
+}
+
+void loop(void)
+{
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+
+
+  // Loop through each device, print out temperature data
+  for (int i = 0; i < numberOfDevices; i++)
+  {
+    // Search the wire for address
+    if (sensors.getAddress(tempDeviceAddress, i))
+    {
+      // Output the device ID
+      Serial.print("Temperature for device: ");
+      Serial.println(i, DEC);
+
+      // It responds almost immediately. Let's print out the data
+      printTemperature(tempDeviceAddress); // Use a simple function to print out the data
+    }
+    //else ghost device! Check your power requirements and cabling
+
+  }
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}

lib/DallasTemperature/examples/Timing/Timing.ino

@@ -0,0 +1,77 @@
+//
+//    FILE: Timing.ino
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.0.3
+// PURPOSE: show performance of DallasTemperature lib
+//          compared to datasheet times per resolution
+//
+// HISTORY:
+// 0.0.1    2017-07-25 initial version
+// 0.0.2    2020-02-13 updates to work with current lib version
+// 0.0.3    2020-02-20 added timing measurement of setResolution
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#define ONE_WIRE_BUS 2
+
+OneWire oneWire(ONE_WIRE_BUS);
+DallasTemperature sensor(&oneWire);
+
+uint32_t start, stop;
+
+
+void setup()
+{
+  Serial.begin(9600);
+  Serial.println(__FILE__);
+  Serial.print("DallasTemperature Library version: ");
+  Serial.println(DALLASTEMPLIBVERSION);
+
+  sensor.begin();
+}
+
+void loop()
+{
+  float ti[4] = { 94, 188, 375, 750 };
+
+  Serial.println();
+  Serial.println("Test takes about 30 seconds for 4 resolutions");
+  Serial.println("RES\tTIME\tACTUAL\tGAIN");
+  for (int r = 9; r < 13; r++)
+  {
+    start = micros();
+    sensor.setResolution(r);
+    Serial.println(micros() - start);
+
+    start = micros();
+    sensor.setResolution(r);
+    Serial.println(micros() - start);
+
+    uint32_t duration = run(20);
+    float avgDuration = duration / 20.0;
+
+    Serial.print(r);
+    Serial.print("\t");
+    Serial.print(ti[r - 9]);
+    Serial.print("\t");
+    Serial.print(avgDuration, 2);
+    Serial.print("\t");
+    Serial.print(avgDuration * 100 / ti[r - 9], 1);
+    Serial.println("%");
+  }
+  delay(1000);
+}
+
+uint32_t run(int runs)
+{
+  float t;
+  start = millis();
+  for (int i = 0; i < runs; i++)
+  {
+    sensor.requestTemperatures();
+    t = sensor.getTempCByIndex(0);
+  }
+  stop = millis();
+  return stop - start;
+}

lib/DallasTemperature/examples/TwoPin_DS18B20/TwoPin_DS18B20.ino

@@ -0,0 +1,45 @@
+//
+// FILE: TwoPin_DS18B20.ino
+// AUTHOR: Rob Tillaart
+// VERSION: 0.1.00
+// PURPOSE: two pins for two sensors demo
+// DATE: 2014-06-13
+// URL: http://forum.arduino.cc/index.php?topic=216835.msg1764333#msg1764333
+//
+// Released to the public domain
+//
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#define ONE_WIRE_BUS_1 2
+#define ONE_WIRE_BUS_2 4
+
+OneWire oneWire_in(ONE_WIRE_BUS_1);
+OneWire oneWire_out(ONE_WIRE_BUS_2);
+
+DallasTemperature sensor_inhouse(&oneWire_in);
+DallasTemperature sensor_outhouse(&oneWire_out);
+
+void setup(void)
+{
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature Control Library Demo - TwoPin_DS18B20");
+
+  sensor_inhouse.begin();
+  sensor_outhouse.begin();
+}
+
+void loop(void)
+{
+  Serial.print("Requesting temperatures...");
+  sensor_inhouse.requestTemperatures();
+  sensor_outhouse.requestTemperatures();
+  Serial.println(" done");
+
+  Serial.print("Inhouse: ");
+  Serial.println(sensor_inhouse.getTempCByIndex(0));
+
+  Serial.print("Outhouse: ");
+  Serial.println(sensor_outhouse.getTempCByIndex(0));
+}

lib/DallasTemperature/examples/UserDataDemo/UserDataDemo.ino

@@ -0,0 +1,115 @@
+//
+// FILE: UserDataDemo.ino
+// AUTHOR: Rob Tillaart
+// VERSION: 0.1.0
+// PURPOSE: use of alarm field as user identification demo
+// DATE: 2019-12-23
+// URL:
+//
+// Released to the public domain
+//
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#define ONE_WIRE_BUS      2
+
+OneWire oneWire(ONE_WIRE_BUS);
+DallasTemperature sensors(&oneWire);
+
+uint8_t deviceCount = 0;
+
+// Add 4 prepared sensors to the bus
+// use the UserDataWriteBatch demo to prepare 4 different labeled sensors
+struct
+{
+  int id;
+  DeviceAddress addr;
+} T[4];
+
+float getTempByID(int id)
+{
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    if (T[index].id == id)
+    {
+      return sensors.getTempC(T[index].addr);
+    }
+  }
+  return -999;
+}
+
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    // zero pad the address if necessary
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+void setup(void)
+{
+  Serial.begin(115200);
+  Serial.println(__FILE__);
+  Serial.println("Dallas Temperature Demo");
+
+  sensors.begin();
+
+  // count devices
+  deviceCount = sensors.getDeviceCount();
+  Serial.print("#devices: ");
+  Serial.println(deviceCount);
+
+  // Read ID's per sensor
+  // and put them in T array
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    // go through sensors
+    sensors.getAddress(T[index].addr, index);
+    T[index].id = sensors.getUserData(T[index].addr);
+  }
+
+  // Check all 4 sensors are set
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    Serial.println();
+    Serial.println(T[index].id);
+    printAddress(T[index].addr);
+    Serial.println();
+  }
+  Serial.println();
+
+}
+
+
+void loop(void)
+{
+  Serial.println();
+  Serial.print(millis());
+  Serial.println("\treq temp");
+  sensors.requestTemperatures();
+
+  Serial.print(millis());
+  Serial.println("\tGet temp by address");
+  for (int i = 0; i < 4; i++)
+  {
+    Serial.print(millis());
+    Serial.print("\t temp:\t");
+    Serial.println(sensors.getTempC(T[i].addr));
+  }
+
+  Serial.print(millis());
+  Serial.println("\tGet temp by ID");  // assume ID = 0, 1, 2, 3
+  for (int id = 0; id < 4; id++)
+  {
+    Serial.print(millis());
+    Serial.print("\t temp:\t");
+    Serial.println(getTempByID(id));
+  }
+
+  delay(1000);
+}
+
+// END OF FILE

lib/DallasTemperature/examples/UserDataWriteBatch/UserDataWriteBatch.ino

@@ -0,0 +1,107 @@
+//
+// FILE: UserDataWriteBatch.ino
+// AUTHOR: Rob Tillaart
+// VERSION: 0.1.0
+// PURPOSE: use of alarm field as user identification demo
+// DATE: 2019-12-23
+// URL:
+//
+// Released to the public domain
+//
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#define ONE_WIRE_BUS      2
+
+OneWire oneWire(ONE_WIRE_BUS);
+DallasTemperature sensors(&oneWire);
+
+uint8_t deviceCount = 0;
+
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    // zero pad the address if necessary
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+
+
+void setup(void)
+{
+  Serial.begin(115200);
+  Serial.println(__FILE__);
+  Serial.println("Write user ID to DS18B20\n");
+
+  sensors.begin();
+
+  // count devices
+  deviceCount = sensors.getDeviceCount();
+  Serial.print("#devices: ");
+  Serial.println(deviceCount);
+
+  Serial.println();
+  Serial.println("current ID's");
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    DeviceAddress t;
+    sensors.getAddress(t, index);
+    printAddress(t);
+    Serial.print("\t\tID: ");
+    int id = sensors.getUserData(t);
+    Serial.println(id);
+  }
+
+  Serial.println();
+  Serial.print("Enter ID for batch: ");
+  int c = 0;
+  int id = 0;
+  while (c != '\n' && c != '\r')
+  {
+    c = Serial.read();
+    switch (c)
+    {
+    case '0'...'9':
+      id *= 10;
+      id += (c - '0');
+      break;
+    default:
+      break;
+    }
+  }
+  Serial.println();
+  Serial.println(id);
+  Serial.println();
+
+  Serial.println("Start labeling ...");
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    Serial.print(".");
+    DeviceAddress t;
+    sensors.getAddress(t, index);
+    sensors.setUserData(t, id);
+  }
+  Serial.println();
+
+  Serial.println();
+  Serial.println("Show results ...");
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    DeviceAddress t;
+    sensors.getAddress(t, index);
+    printAddress(t);
+    Serial.print("\t\tID: ");
+    int id = sensors.getUserData(t);
+    Serial.println(id);
+  }
+  Serial.println("Done ...");
+
+}
+
+void loop(void) {}
+
+// END OF FILE

lib/DallasTemperature/examples/WaitForConversion/WaitForConversion.ino

@@ -0,0 +1,66 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(115200);
+  Serial.println("Dallas Temperature Control Library - Async Demo");
+  Serial.println("\nDemo shows the difference in length of the call\n\n");
+
+  // Start up the library
+  sensors.begin();
+}
+
+void loop(void)
+{
+  // Request temperature conversion (traditional)
+  Serial.println("Before blocking requestForConversion");
+  unsigned long start = millis();
+
+  sensors.requestTemperatures();
+
+  unsigned long stop = millis();
+  Serial.println("After blocking requestForConversion");
+  Serial.print("Time used: ");
+  Serial.println(stop - start);
+
+  // get temperature
+  Serial.print("Temperature: ");
+  Serial.println(sensors.getTempCByIndex(0));
+  Serial.println("\n");
+
+  // Request temperature conversion - non-blocking / async
+  Serial.println("Before NON-blocking/async requestForConversion");
+  start = millis();
+  sensors.setWaitForConversion(false);  // makes it async
+  sensors.requestTemperatures();
+  sensors.setWaitForConversion(true);
+  stop = millis();
+  Serial.println("After NON-blocking/async requestForConversion");
+  Serial.print("Time used: ");
+  Serial.println(stop - start);
+
+
+  // 9 bit resolution by default
+  // Note the programmer is responsible for the right delay
+  // we could do something usefull here instead of the delay
+  int resolution = 9;
+  delay(750 / (1 << (12 - resolution)));
+
+  // get temperature
+  Serial.print("Temperature: ");
+  Serial.println(sensors.getTempCByIndex(0));
+  Serial.println("\n\n\n\n");
+
+  delay(5000);
+}

lib/DallasTemperature/examples/WaitForConversion2/WaitForConversion2.ino

@@ -0,0 +1,80 @@
+//
+// Sample of using Async reading of Dallas Temperature Sensors
+//
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+DeviceAddress tempDeviceAddress;
+
+int  resolution = 12;
+unsigned long lastTempRequest = 0;
+int  delayInMillis = 0;
+float temperature = 0.0;
+int  idle = 0;
+//
+// SETUP
+//
+void setup(void)
+{
+  Serial.begin(115200);
+  Serial.println("Dallas Temperature Control Library - Async Demo");
+  Serial.print("Library Version: ");
+  Serial.println(DALLASTEMPLIBVERSION);
+  Serial.println("\n");
+
+  sensors.begin();
+  sensors.getAddress(tempDeviceAddress, 0);
+  sensors.setResolution(tempDeviceAddress, resolution);
+
+  sensors.setWaitForConversion(false);
+  sensors.requestTemperatures();
+  delayInMillis = 750 / (1 << (12 - resolution));
+  lastTempRequest = millis();
+
+  pinMode(13, OUTPUT);
+}
+
+void loop(void)
+{
+
+  if (millis() - lastTempRequest >= delayInMillis) // waited long enough??
+  {
+    digitalWrite(13, LOW);
+    Serial.print(" Temperature: ");
+    temperature = sensors.getTempCByIndex(0);
+    Serial.println(temperature, resolution - 8);
+    Serial.print("  Resolution: ");
+    Serial.println(resolution);
+    Serial.print("Idle counter: ");
+    Serial.println(idle);
+    Serial.println();
+
+    idle = 0;
+
+    // immediately after fetching the temperature we request a new sample
+    // in the async modus
+    // for the demo we let the resolution change to show differences
+    resolution++;
+    if (resolution > 12) resolution = 9;
+
+    sensors.setResolution(tempDeviceAddress, resolution);
+    sensors.requestTemperatures();
+    delayInMillis = 750 / (1 << (12 - resolution));
+    lastTempRequest = millis();
+  }
+
+  digitalWrite(13, HIGH);
+  // we can do usefull things here
+  // for the demo we just count the idle time in millis
+  delay(1);
+  idle++;
+}

lib/DallasTemperature/examples/oneWireSearch/oneWireSearch.ino

@@ -0,0 +1,67 @@
+//
+//    FILE: oneWireSearch.ino
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.02
+// PURPOSE: scan for 1-Wire devices + code snippet generator
+//    DATE: 2015-june-30
+//     URL: http://forum.arduino.cc/index.php?topic=333923
+//
+// inspired by http://www.hacktronics.com/Tutorials/arduino-1-wire-address-finder.html
+//
+// Released to the public domain
+//
+// 0.1.00 initial version
+// 0.1.01 first published version
+// 0.1.02 small output changes
+
+#include <OneWire.h>
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println("//\n// Start oneWireSearch.ino \n//");
+
+  for (uint8_t pin = 2; pin < 13; pin++)
+  {
+    findDevices(pin);
+  }
+  Serial.println("\n//\n// End oneWireSearch.ino \n//");
+}
+
+void loop()
+{
+}
+
+uint8_t findDevices(int pin)
+{
+  OneWire ow(pin);
+
+  uint8_t address[8];
+  uint8_t count = 0;
+
+
+  if (ow.search(address))
+  {
+    Serial.print("\nuint8_t pin");
+    Serial.print(pin, DEC);
+    Serial.println("[][8] = {");
+    do {
+      count++;
+      Serial.println("  {");
+      for (uint8_t i = 0; i < 8; i++)
+      {
+        Serial.print("0x");
+        if (address[i] < 0x10) Serial.print("0");
+        Serial.print(address[i], HEX);
+        if (i < 7) Serial.print(", ");
+      }
+      Serial.println("  },");
+    } while (ow.search(address));
+
+    Serial.println("};");
+    Serial.print("// nr devices found: ");
+    Serial.println(count);
+  }
+
+  return count;
+}

lib/DallasTemperature/examples/readPowerSupply/readPowerSupply.ino

@@ -0,0 +1,92 @@
+//
+// FILE: readPowerSupply.ino
+// AUTHOR: Rob Tillaart
+// VERSION: 0.1.0
+// PURPOSE: demo
+// DATE: 2020-02-10
+//
+// Released to the public domain
+//
+
+// Include the libraries we need
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device addresses
+DeviceAddress insideThermometer, outsideThermometer;
+// Assign address manually. The addresses below will beed to be changed
+// to valid device addresses on your bus. Device address can be retrieved
+// by using either oneWire.search(deviceAddress) or individually via
+// sensors.getAddress(deviceAddress, index)
+// DeviceAddress insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
+// DeviceAddress outsideThermometer   = { 0x28, 0x3F, 0x1C, 0x31, 0x2, 0x0, 0x0, 0x2 };
+
+int devCount = 0;
+
+/*
+ * The setup function. We only start the sensors here
+ */
+void setup(void)
+{
+  Serial.begin(115200);
+  Serial.println("Arduino Temperature Control Library Demo - readPowerSupply");
+
+  sensors.begin();
+
+  devCount = sensors.getDeviceCount();
+  Serial.print("#devices: ");
+  Serial.println(devCount);
+
+  // report parasite power requirements
+  Serial.print("Parasite power is: ");
+  if (sensors.readPowerSupply()) Serial.println("ON");  // no address means "scan all devices for parasite mode"
+  else Serial.println("OFF");
+
+  // Search for devices on the bus and assign based on an index.
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");
+  if (!sensors.getAddress(outsideThermometer, 1)) Serial.println("Unable to find address for Device 1");
+
+  // show the addresses we found on the bus
+  Serial.print("Device 0 Address: ");
+  printAddress(insideThermometer);
+  Serial.println();
+  Serial.print("Power = parasite: ");
+  Serial.println(sensors.readPowerSupply(insideThermometer));
+  Serial.println();
+  Serial.println();
+
+  Serial.print("Device 1 Address: ");
+  printAddress(outsideThermometer);
+  Serial.println();
+  Serial.print("Power = parasite: ");
+  Serial.println(sensors.readPowerSupply(outsideThermometer));
+  Serial.println();
+  Serial.println();
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    // zero pad the address if necessary
+    if (deviceAddress[i] < 0x10) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+// empty on purpose
+void loop(void)
+{
+}
+
+// END OF FILE

lib/DallasTemperature/keywords.txt

@@ -0,0 +1,87 @@
+#######################################
+# Syntax Coloring Map For DallasTemperature
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+DallasTemperature	KEYWORD1
+OneWire	KEYWORD1
+AlarmHandler	KEYWORD1
+DeviceAddress	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+setOneWire	KEYWORD2
+setPullupPin	KEYWORD2
+setResolution	KEYWORD2
+getResolution	KEYWORD2
+getTemp	KEYWORD2
+getTempC	KEYWORD2
+toFahrenheit	KEYWORD2
+getTempF	KEYWORD2
+getTempCByIndex	KEYWORD2
+getTempFByIndex	KEYWORD2
+rawToCelsius	KEYWORD2
+rawToFahrenheit	KEYWORD2
+setWaitForConversion	KEYWORD2
+getWaitForConversion	KEYWORD2
+requestTemperatures	KEYWORD2
+requestTemperaturesByAddress	KEYWORD2
+requestTemperaturesByIndex	KEYWORD2
+setCheckForConversion	KEYWORD2
+getCheckForConversion	KEYWORD2
+isConversionComplete	KEYWORD2
+millisToWaitForConversion	KEYWORD2
+isParasitePowerMode	KEYWORD2
+begin	KEYWORD2
+getDeviceCount	KEYWORD2
+getDS18Count	KEYWORD2
+getAddress	KEYWORD2
+validAddress	KEYWORD2
+validFamily	KEYWORD2
+isConnected	KEYWORD2
+readScratchPad	KEYWORD2
+writeScratchPad	KEYWORD2
+readPowerSupply	KEYWORD2
+saveScratchPadByIndex	KEYWORD2
+saveScratchPad	KEYWORD2
+recallScratchPadByIndex	KEYWORD2
+recallScratchPad	KEYWORD2
+setAutoSaveScratchPad	KEYWORD2
+getAutoSaveScratchPad	KEYWORD2
+setHighAlarmTemp	KEYWORD2
+setLowAlarmTemp	KEYWORD2
+getHighAlarmTemp	KEYWORD2
+getLowAlarmTemp	KEYWORD2
+resetAlarmSearch	KEYWORD2
+alarmSearch	KEYWORD2
+hasAlarm	KEYWORD2
+toCelsius	KEYWORD2
+processAlarms	KEYWORD2
+setAlarmHandler	KEYWORD2
+hasAlarmHandler	KEYWORD2
+setUserData	KEYWORD2
+setUserDataByIndex	KEYWORD2
+getUserData	KEYWORD2
+getUserDataByIndex	KEYWORD2
+calculateTemperature	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+DEVICE_DISCONNECTED_C	LITERAL1
+DEVICE_DISCONNECTED_F	LITERAL1
+DEVICE_DISCONNECTED_RAW	LITERAL1
+DEVICE_FAULT_OPEN_C	LITERAL1
+DEVICE_FAULT_OPEN_F	LITERAL1
+DEVICE_FAULT_OPEN_RAW	LITERAL1
+DEVICE_FAULT_SHORTGND_C	LITERAL1
+DEVICE_FAULT_SHORTGND_F	LITERAL1
+DEVICE_FAULT_SHORTGND_RAW	LITERAL1
+DEVICE_FAULT_SHORTVDD_C	LITERAL1
+DEVICE_FAULT_SHORTVDD_F	LITERAL1
+DEVICE_FAULT_SHORTVDD_RAW	LITERAL1

lib/DallasTemperature/library.json

@@ -0,0 +1,38 @@
+{
+  "name": "DallasTemperature",
+  "keywords": "onewire, 1-wire, bus, sensor, temperature",
+  "description": "Arduino Library for Dallas Temperature ICs (DS18B20, DS18S20, DS1822, DS1820, MAX31850)",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/milesburton/Arduino-Temperature-Control-Library.git"
+  },
+  "authors": 
+  [
+    {
+      "name": "Miles Burton",
+      "email": "miles@mnetcs.com",
+      "url": "http://www.milesburton.com",
+      "maintainer": true
+    },
+    {
+      "name": "Tim Newsome",
+      "email": "nuisance@casualhacker.net"
+    },
+    {
+      "name": "Guil Barros",
+      "email": "gfbarros@bappos.com"
+    },
+    {
+      "name": "Rob Tillaart",
+      "email": "rob.tillaart@gmail.com"
+    }
+  ],
+  "dependencies":
+  {
+    "paulstoffregen/OneWire": "^2.3.5"
+  },
+  "version": "3.11.0",
+  "frameworks": "arduino",
+  "platforms": "*"
+}

lib/DallasTemperature/library.properties

@@ -0,0 +1,10 @@
+name=DallasTemperature
+version=3.11.0
+author=Miles Burton <miles@mnetcs.com>, Tim Newsome <nuisance@casualhacker.net>, Guil Barros <gfbarros@bappos.com>, Rob Tillaart <rob.tillaart@gmail.com>
+maintainer=Miles Burton <miles@mnetcs.com>
+sentence=Arduino Library for Dallas Temperature ICs
+paragraph=Supports DS18B20, DS18S20, DS1822, DS1820, MAX31850
+category=Sensors
+url=https://github.com/milesburton/Arduino-Temperature-Control-Library
+architectures=*
+depends=OneWire