--- /dev/null
+// This library is free software; you can redistribute it and/or\r
+// modify it under the terms of the GNU Lesser General Public\r
+// License as published by the Free Software Foundation; either\r
+// version 2.1 of the License, or (at your option) any later version.\r
+\r
+#include "DallasTemperature.h"\r
+\r
+extern "C" {\r
+ #include "WConstants.h"\r
+}\r
+\r
+DallasTemperature::DallasTemperature(OneWire* _oneWire) \r
+ #if REQUIRESALARMS\r
+ : _AlarmHandler(&defaultAlarmHandler)\r
+ #endif\r
+{\r
+ _wire = _oneWire;\r
+ devices = 0;\r
+ parasite = false;\r
+ conversionDelay = TEMP_9_BIT;\r
+}\r
+\r
+// initialize the bus\r
+void DallasTemperature::begin(void)\r
+{\r
+ DeviceAddress deviceAddress;\r
+\r
+ _wire->reset_search();\r
+\r
+ while (_wire->search(deviceAddress))\r
+ {\r
+ if (validAddress(deviceAddress))\r
+ { \r
+ if (!parasite && readPowerSupply(deviceAddress)) parasite = true;\r
+\r
+ ScratchPad scratchPad;\r
+\r
+ readScratchPad(deviceAddress, scratchPad);\r
+\r
+ if (deviceAddress[0] == DS18S20MODEL) conversionDelay = TEMP_12_BIT; // 750 ms\r
+ else if (scratchPad[CONFIGURATION] > conversionDelay) conversionDelay = scratchPad[CONFIGURATION];\r
+\r
+ devices++;\r
+ }\r
+ }\r
+}\r
+\r
+// returns the number of devices found on the bus\r
+uint8_t DallasTemperature::getDeviceCount(void)\r
+{\r
+ return devices;\r
+}\r
+\r
+// returns true if address is valid\r
+bool DallasTemperature::validAddress(uint8_t* deviceAddress)\r
+{\r
+ return (_wire->crc8(deviceAddress, 7) == deviceAddress[7]);\r
+}\r
+\r
+// finds an address at a given index on the bus\r
+// returns true if the device was found\r
+bool DallasTemperature::getAddress(uint8_t* deviceAddress, uint8_t index)\r
+{\r
+ uint8_t depth = 0;\r
+\r
+ _wire->reset_search();\r
+\r
+ while (depth <= index && _wire->search(deviceAddress))\r
+ {\r
+ if (depth == index && validAddress(deviceAddress)) return true;\r
+ depth++;\r
+ }\r
+\r
+ return false;\r
+}\r
+\r
+// attempt to determine if the device at the given address is connected to the bus\r
+bool DallasTemperature::isConnected(uint8_t* deviceAddress)\r
+{\r
+ ScratchPad scratchPad;\r
+ return isConnected(deviceAddress, scratchPad);\r
+}\r
+\r
+// attempt to determine if the device at the given address is connected to the bus\r
+// also allows for updating the read scratchpad\r
+bool DallasTemperature::isConnected(uint8_t* deviceAddress, uint8_t* scratchPad)\r
+{\r
+ readScratchPad(deviceAddress, scratchPad);\r
+ return (_wire->crc8(scratchPad, 8) == scratchPad[SCRATCHPAD_CRC]);\r
+}\r
+\r
+// read device's scratch pad\r
+void DallasTemperature::readScratchPad(uint8_t* deviceAddress, uint8_t* scratchPad)\r
+{\r
+ // send the command\r
+ _wire->reset();\r
+ _wire->select(deviceAddress);\r
+ _wire->write(READSCRATCH);\r
+\r
+ // read the response \r
+\r
+ // byte 0: temperature LSB\r
+ scratchPad[TEMP_LSB] = _wire->read();\r
+\r
+ // byte 1: temperature MSB\r
+ scratchPad[TEMP_MSB] = _wire->read();\r
+\r
+ // byte 2: high alarm temp\r
+ scratchPad[HIGH_ALARM_TEMP] = _wire->read();\r
+\r
+ // byte 3: low alarm temp\r
+ scratchPad[LOW_ALARM_TEMP] = _wire->read();\r
+\r
+ // byte 4:\r
+ // DS18S20: store for crc\r
+ // DS18B20 & DS1822: configuration register\r
+ scratchPad[CONFIGURATION] = _wire->read();\r
+\r
+ // byte 5:\r
+ // internal use & crc\r
+ scratchPad[INTERNAL_BYTE] = _wire->read();\r
+\r
+ // byte 6:\r
+ // DS18S20: COUNT_REMAIN\r
+ // DS18B20 & DS1822: store for crc\r
+ scratchPad[COUNT_REMAIN] = _wire->read();\r
+ \r
+ // byte 7:\r
+ // DS18S20: COUNT_PER_C\r
+ // DS18B20 & DS1822: store for crc\r
+ scratchPad[COUNT_PER_C] = _wire->read();\r
+ \r
+ // byte 8:\r
+ // SCTRACHPAD_CRC\r
+ scratchPad[SCRATCHPAD_CRC] = _wire->read();\r
+\r
+ _wire->reset();\r
+}\r
+\r
+// writes device's scratch pad\r
+void DallasTemperature::writeScratchPad(uint8_t* deviceAddress, const uint8_t* scratchPad)\r
+{\r
+ _wire->reset();\r
+ _wire->select(deviceAddress);\r
+ _wire->write(WRITESCRATCH);\r
+ _wire->write(scratchPad[HIGH_ALARM_TEMP]); // high alarm temp\r
+ _wire->write(scratchPad[LOW_ALARM_TEMP]); // low alarm temp\r
+ // DS18S20 does not use the configuration register\r
+ if (deviceAddress[0] != DS18S20MODEL) _wire->write(scratchPad[CONFIGURATION]); // configuration\r
+ _wire->reset();\r
+ // save the newly written values to eeprom\r
+ _wire->write(COPYSCRATCH, parasite);\r
+ if (parasite) delay(10); // 10ms delay \r
+ _wire->reset();\r
+}\r
+\r
+// reads the device's power requirements\r
+bool DallasTemperature::readPowerSupply(uint8_t* deviceAddress)\r
+{\r
+ bool ret = false;\r
+ _wire->reset();\r
+ _wire->select(deviceAddress);\r
+ _wire->write(READPOWERSUPPLY);\r
+ if (_wire->read_bit() == 0) ret = true;\r
+ _wire->reset();\r
+ return ret;\r
+}\r
+\r
+// returns the current resolution, 9-12\r
+uint8_t DallasTemperature::getResolution(uint8_t* deviceAddress)\r
+{\r
+ if (deviceAddress[0] == DS18S20MODEL) return 9; // this model has a fixed resolution\r
+\r
+ ScratchPad scratchPad;\r
+ readScratchPad(deviceAddress, scratchPad);\r
+ switch (scratchPad[CONFIGURATION])\r
+ {\r
+ case TEMP_12_BIT:\r
+ return 12;\r
+ break;\r
+ case TEMP_11_BIT:\r
+ return 11;\r
+ break;\r
+ case TEMP_10_BIT:\r
+ return 10;\r
+ break;\r
+ case TEMP_9_BIT:\r
+ return 9;\r
+ break;\r
+ }\r
+}\r
+\r
+// set resolution of a device to 9, 10, 11, or 12 bits\r
+void DallasTemperature::setResolution(uint8_t* deviceAddress, uint8_t newResolution)\r
+{\r
+ ScratchPad scratchPad;\r
+ if (isConnected(deviceAddress, scratchPad))\r
+ {\r
+ // DS18S20 has a fixed 9-bit resolution\r
+ if (deviceAddress[0] != DS18S20MODEL)\r
+ {\r
+ switch (newResolution)\r
+ {\r
+ case 12:\r
+ scratchPad[CONFIGURATION] = TEMP_12_BIT;\r
+ break;\r
+ case 11:\r
+ scratchPad[CONFIGURATION] = TEMP_11_BIT;\r
+ break;\r
+ case 10:\r
+ scratchPad[CONFIGURATION] = TEMP_10_BIT;\r
+ break;\r
+ case 9:\r
+ default:\r
+ scratchPad[CONFIGURATION] = TEMP_9_BIT;\r
+ break;\r
+ }\r
+ writeScratchPad(deviceAddress, scratchPad);\r
+ }\r
+ }\r
+} \r
+\r
+// sends command for all devices on the bus to perform a temperature\r
+void DallasTemperature::requestTemperatures(void)\r
+{\r
+ _wire->reset();\r
+ _wire->skip();\r
+ _wire->write(STARTCONVO, parasite);\r
+\r
+ switch (conversionDelay)\r
+ {\r
+ case TEMP_9_BIT:\r
+ delay(94);\r
+ break;\r
+ case TEMP_10_BIT:\r
+ delay(188);\r
+ break;\r
+ case TEMP_11_BIT:\r
+ delay(375);\r
+ break;\r
+ case TEMP_12_BIT:\r
+ default:\r
+ delay(750);\r
+ break;\r
+ }\r
+}\r
+\r
+// sends command for one device to perform a temperature by address\r
+void DallasTemperature::requestTemperaturesByAddress(uint8_t* deviceAddress)\r
+{\r
+ _wire->reset();\r
+ _wire->select(deviceAddress);\r
+ _wire->write(STARTCONVO, parasite);\r
+\r
+ switch (conversionDelay)\r
+ {\r
+ case TEMP_9_BIT:\r
+ delay(94);\r
+ break;\r
+ case TEMP_10_BIT:\r
+ delay(188);\r
+ break;\r
+ case TEMP_11_BIT:\r
+ delay(375);\r
+ break;\r
+ case TEMP_12_BIT:\r
+ default:\r
+ delay(750);\r
+ break;\r
+ }\r
+}\r
+\r
+// sends command for one device to perform a temp conversion by index\r
+void DallasTemperature::requestTemperaturesByIndex(uint8_t deviceIndex)\r
+{\r
+ DeviceAddress deviceAddress;\r
+ getAddress(deviceAddress, deviceIndex);\r
+ requestTemperaturesByAddress(deviceAddress);\r
+}\r
+\r
+\r
+// Fetch temperature for device index\r
+float DallasTemperature::getTempCByIndex(uint8_t deviceIndex)\r
+{\r
+ DeviceAddress deviceAddress;\r
+ getAddress(deviceAddress, deviceIndex);\r
+ return getTempC((uint8_t*)deviceAddress);\r
+}\r
+\r
+// Fetch temperature for device index\r
+float DallasTemperature::getTempFByIndex(uint8_t deviceIndex)\r
+{\r
+ return DallasTemperature::toFahrenheit(getTempCByIndex(deviceIndex));\r
+}\r
+\r
+// reads scratchpad and returns the temperature in degrees C\r
+float DallasTemperature::calculateTemperature(uint8_t* deviceAddress, uint8_t* scratchPad)\r
+{\r
+ int16_t rawTemperature = (((int16_t)scratchPad[TEMP_MSB]) << 8) | scratchPad[TEMP_LSB];\r
+\r
+ switch (deviceAddress[0])\r
+ {\r
+ case DS18B20MODEL:\r
+ case DS1822MODEL:\r
+ switch (scratchPad[CONFIGURATION])\r
+ {\r
+ case TEMP_12_BIT:\r
+ return (float)rawTemperature * 0.0625;\r
+ break;\r
+ case TEMP_11_BIT:\r
+ return (float)(rawTemperature >> 1) * 0.125;\r
+ break;\r
+ case TEMP_10_BIT:\r
+ return (float)(rawTemperature >> 2) * 0.25;\r
+ break;\r
+ case TEMP_9_BIT:\r
+ return (float)(rawTemperature >> 3) * 0.5;\r
+ break;\r
+ }\r
+ break;\r
+ case DS18S20MODEL:\r
+ /*\r
+ \r
+ Resolutions greater than 9 bits can be calculated using the data from \r
+ the temperature, COUNT REMAIN and COUNT PER °C registers in the \r
+ scratchpad. Note that the COUNT PER °C register is hard-wired to 16 \r
+ (10h). After reading the scratchpad, the TEMP_READ value is obtained \r
+ by truncating the 0.5°C bit (bit 0) from the temperature data. The \r
+ extended resolution temperature can then be calculated using the \r
+ following equation:\r
+ \r
+ COUNT_PER_C - COUNT_REMAIN\r
+ TEMPERATURE = TEMP_READ - 0.25 + --------------------------\r
+ COUNT_PER_C\r
+ */\r
+ \r
+ // Good spot. Thanks Nic Johns for your contribution\r
+ return (float)(rawTemperature >> 1) - 0.25 +((float)(scratchPad[COUNT_PER_C] - scratchPad[COUNT_REMAIN]) / (float)scratchPad[COUNT_PER_C] ); \r
+ break;\r
+ }\r
+}\r
+\r
+// returns temperature in degrees C or DEVICE_DISCONNECTED if the \r
+// device's scratch pad cannot be read successfully.\r
+// the numeric value of DEVICE_DISCONNECTED is defined in \r
+// DallasTemperature.h. it is a large negative number outside the \r
+// operating range of the device\r
+float DallasTemperature::getTempC(uint8_t* deviceAddress)\r
+{\r
+ // TODO: Multiple devices (up to 64) on the same bus may take some time to negotiate a response\r
+ // What happens in case of collision?\r
+\r
+ ScratchPad scratchPad;\r
+ if (isConnected(deviceAddress, scratchPad)) return calculateTemperature(deviceAddress, scratchPad);\r
+ return DEVICE_DISCONNECTED;\r
+}\r
+\r
+// returns temperature in degrees F\r
+float DallasTemperature::getTempF(uint8_t* deviceAddress)\r
+{\r
+ return toFahrenheit(getTempC(deviceAddress));\r
+}\r
+\r
+// returns true if the bus requires parasite power\r
+bool DallasTemperature::isParasitePowerMode(void)\r
+{\r
+ return parasite;\r
+}\r
+\r
+#if REQUIRESALARMS\r
+\r
+/*\r
+\r
+ALARMS:\r
+\r
+TH and TL Register Format\r
+\r
+BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0\r
+ S 2^6 2^5 2^4 2^3 2^2 2^1 2^0\r
+\r
+Only bits 11 through 4 of the temperature register are used \r
+in the TH and TL comparison since TH and TL are 8-bit \r
+registers. If the measured temperature is lower than or equal \r
+to TL or higher than or equal to TH, an alarm condition exists \r
+and an alarm flag is set inside the DS18B20. This flag is \r
+updated after every temperature measurement; therefore, if the \r
+alarm condition goes away, the flag will be turned off after \r
+the next temperature conversion.\r
+\r
+*/\r
+\r
+// sets the high alarm temperature for a device in degrees celsius\r
+// accepts a float, but the alarm resolution will ignore anything \r
+// after a decimal point. valid range is -55C - 125C\r
+void DallasTemperature::setHighAlarmTemp(uint8_t* deviceAddress, char celsius)\r
+{\r
+ // make sure the alarm temperature is within the device's range\r
+ if (celsius > 125) celsius = 125;\r
+ else if (celsius < -55) celsius = -55;\r
+ \r
+ ScratchPad scratchPad;\r
+ if (isConnected(deviceAddress, scratchPad))\r
+ { \r
+ scratchPad[HIGH_ALARM_TEMP] = (uint8_t)celsius;\r
+ writeScratchPad(deviceAddress, scratchPad);\r
+ }\r
+}\r
+\r
+// sets the low alarm temperature for a device in degreed celsius\r
+// accepts a float, but the alarm resolution will ignore anything \r
+// after a decimal point. valid range is -55C - 125C\r
+void DallasTemperature::setLowAlarmTemp(uint8_t* deviceAddress, char celsius)\r
+{\r
+ // make sure the alarm temperature is within the device's range\r
+ if (celsius > 125) celsius = 125;\r
+ else if (celsius < -55) celsius = -55;\r
+\r
+ ScratchPad scratchPad;\r
+ if (isConnected(deviceAddress, scratchPad))\r
+ {\r
+ scratchPad[LOW_ALARM_TEMP] = (uint8_t)celsius;\r
+ writeScratchPad(deviceAddress, scratchPad);\r
+ }\r
+}\r
+\r
+// returns a char with the current high alarm temperature or \r
+// DEVICE_DISCONNECTED for an address\r
+char DallasTemperature::getHighAlarmTemp(uint8_t* deviceAddress)\r
+{\r
+ ScratchPad scratchPad;\r
+ if (isConnected(deviceAddress, scratchPad)) return (char)scratchPad[HIGH_ALARM_TEMP];\r
+ return DEVICE_DISCONNECTED;\r
+}\r
+\r
+// returns a char with the current low alarm temperature or \r
+// DEVICE_DISCONNECTED for an address\r
+char DallasTemperature::getLowAlarmTemp(uint8_t* deviceAddress)\r
+{\r
+ ScratchPad scratchPad;\r
+ if (isConnected(deviceAddress, scratchPad)) return (char)scratchPad[LOW_ALARM_TEMP];\r
+ return DEVICE_DISCONNECTED;\r
+}\r
+\r
+// resets internal variables used for the alarm search\r
+void DallasTemperature::resetAlarmSearch()\r
+{\r
+ alarmSearchJunction = -1;\r
+ alarmSearchExhausted = 0;\r
+ for(uint8_t i = 0; i < 7; i++)\r
+ alarmSearchAddress[i] = 0;\r
+}\r
+\r
+// This is a modified version of the OneWire::search method. \r
+//\r
+// Also added the OneWire search fix documented here:\r
+// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295\r
+//\r
+// Perform an alarm search. If this function returns a '1' then it has\r
+// enumerated the next device and you may retrieve the ROM from the\r
+// OneWire::address variable. If there are no devices, no further\r
+// devices, or something horrible happens in the middle of the\r
+// enumeration then a 0 is returned. If a new device is found then\r
+// its address is copied to newAddr. Use \r
+// DallasTemperature::resetAlarmSearch() to start over.\r
+bool DallasTemperature::alarmSearch(uint8_t* newAddr)\r
+{\r
+ uint8_t i;\r
+ char lastJunction = -1;\r
+ uint8_t done = 1;\r
+ \r
+ if (alarmSearchExhausted) return false;\r
+ if (!_wire->reset()) return false;\r
+\r
+ // send the alarm search command\r
+ _wire->write(0xEC, 0);\r
+ \r
+ for(i = 0; i < 64; i++)\r
+ {\r
+ uint8_t a = _wire->read_bit( );\r
+ uint8_t nota = _wire->read_bit( );\r
+ uint8_t ibyte = i / 8;\r
+ uint8_t ibit = 1 << (i & 7);\r
+ \r
+ // I don't think this should happen, this means nothing responded, but maybe if\r
+ // something vanishes during the search it will come up.\r
+ if (a && nota) return false;\r
+\r
+ if (!a && !nota)\r
+ {\r
+ if (i == alarmSearchJunction)\r
+ {\r
+ // this is our time to decide differently, we went zero last time, go one.\r
+ a = 1;\r
+ alarmSearchJunction = lastJunction;\r
+ }\r
+ else if (i < alarmSearchJunction) \r
+ {\r
+ // take whatever we took last time, look in address\r
+ if (alarmSearchAddress[ibyte] & ibit) a = 1;\r
+ else\r
+ {\r
+ // Only 0s count as pending junctions, we've already exhasuted the 0 side of 1s\r
+ a = 0;\r
+ done = 0;\r
+ lastJunction = i;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ // we are blazing new tree, take the 0\r
+ a = 0;\r
+ alarmSearchJunction = i;\r
+ done = 0;\r
+ }\r
+ // OneWire search fix\r
+ // See: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295\r
+ }\r
+\r
+ if (a) alarmSearchAddress[ibyte] |= ibit;\r
+ else alarmSearchAddress[ibyte] &= ~ibit;\r
+ \r
+ _wire->write_bit(a);\r
+ }\r
+\r
+ if (done) alarmSearchExhausted = 1;\r
+ for (i = 0; i < 8; i++) newAddr[i] = alarmSearchAddress[i];\r
+ return true; \r
+}\r
+\r
+// returns true if device address has an alarm condition\r
+bool DallasTemperature::hasAlarm(uint8_t* deviceAddress)\r
+{\r
+ ScratchPad scratchPad;\r
+ if (isConnected(deviceAddress, scratchPad))\r
+ {\r
+ float temp = calculateTemperature(deviceAddress, scratchPad);\r
+ \r
+ // check low alarm\r
+ if ((char)temp <= (char)scratchPad[LOW_ALARM_TEMP]) return true;\r
+ \r
+ // check high alarm\r
+ if ((char)temp >= (char)scratchPad[HIGH_ALARM_TEMP]) return true;\r
+ }\r
+\r
+ // no alarm\r
+ return false;\r
+}\r
+\r
+// returns true if any device is reporting an alarm condition on the bus\r
+bool DallasTemperature::hasAlarm(void)\r
+{\r
+ DeviceAddress deviceAddress;\r
+ resetAlarmSearch();\r
+ return alarmSearch(deviceAddress);\r
+}\r
+\r
+// runs the alarm handler for all devices returned by alarmSearch()\r
+void DallasTemperature::processAlarms(void)\r
+{\r
+ resetAlarmSearch();\r
+ DeviceAddress alarmAddr;\r
+\r
+ while (alarmSearch(alarmAddr))\r
+ {\r
+ if (validAddress(alarmAddr))\r
+ _AlarmHandler(alarmAddr);\r
+ }\r
+}\r
+\r
+// sets the alarm handler\r
+void DallasTemperature::setAlarmHandler(AlarmHandler *handler)\r
+{\r
+ _AlarmHandler = handler;\r
+}\r
+\r
+// The default alarm handler\r
+void DallasTemperature::defaultAlarmHandler(uint8_t* deviceAddress)\r
+{\r
+}\r
+\r
+#endif\r
+\r
+// Convert float celsius to fahrenheit\r
+float DallasTemperature::toFahrenheit(float celsius)\r
+{\r
+ return (celsius * 1.8) + 32;\r
+}\r
+\r
+// Convert float fahrenheit to celsius\r
+float DallasTemperature::toCelsius(float fahrenheit)\r
+{\r
+ return (fahrenheit - 32) / 1.8;\r
+}\r
+\r
+#if REQUIRESNEW\r
+\r
+// MnetCS - Allocates memory for DallasTemperature. Allows us to instance a new object\r
+void* DallasTemperature::operator new(unsigned int size) // Implicit NSS obj size\r
+{\r
+ void * p; // void pointer\r
+ p = malloc(size); // Allocate memory\r
+ memset((DallasTemperature*)p,0,size); // Initalise memory\r
+\r
+ //!!! CANT EXPLICITLY CALL CONSTRUCTOR - workaround by using an init() methodR - workaround by using an init() method\r
+ return (DallasTemperature*) p; // Cast blank region to NSS pointer\r
+}\r
+\r
+// MnetCS 2009 - Unallocates the memory used by this instance\r
+void DallasTemperature::operator delete(void* p)\r
+{\r
+ DallasTemperature* pNss = (DallasTemperature*) p; // Cast to NSS pointer\r
+ pNss->~DallasTemperature(); // Destruct the object\r
+\r
+ free(p); // Free the memory\r
+}\r
+\r
+#endif\r
--- /dev/null
+#ifndef DallasTemperature_h\r
+#define DallasTemperature_h\r
+\r
+// This library is free software; you can redistribute it and/or\r
+// modify it under the terms of the GNU Lesser General Public\r
+// License as published by the Free Software Foundation; either\r
+// version 2.1 of the License, or (at your option) any later version.\r
+\r
+// set to true to include code for new and delete operators\r
+#ifndef REQUIRESNEW\r
+#define REQUIRESNEW false\r
+#endif\r
+\r
+// set to true to include code implementing alarm search functions\r
+#ifndef REQUIRESALARMS\r
+#define REQUIRESALARMS true\r
+#endif\r
+\r
+#include <inttypes.h>\r
+#include <OneWire.h>\r
+\r
+// Model IDs\r
+#define DS18S20MODEL 0x10\r
+#define DS18B20MODEL 0x28\r
+#define DS1822MODEL 0x22\r
+\r
+// OneWire commands\r
+#define STARTCONVO 0x44 // Tells device to take a temperature reading and put it on the scratchpad\r
+#define COPYSCRATCH 0x48 // Copy EEPROM\r
+#define READSCRATCH 0xBE // Read EEPROM\r
+#define WRITESCRATCH 0x4E // Write to EEPROM\r
+#define RECALLSCRATCH 0xB8 // Reload from last known\r
+#define READPOWERSUPPLY 0xB4 // Determine if device needs parasite power\r
+#define ALARMSEARCH 0xEC // Query bus for devices with an alarm condition\r
+\r
+// Scratchpad locations\r
+#define TEMP_LSB 0\r
+#define TEMP_MSB 1\r
+#define HIGH_ALARM_TEMP 2\r
+#define LOW_ALARM_TEMP 3\r
+#define CONFIGURATION 4\r
+#define INTERNAL_BYTE 5\r
+#define COUNT_REMAIN 6\r
+#define COUNT_PER_C 7\r
+#define SCRATCHPAD_CRC 8\r
+\r
+// Device resolution\r
+#define TEMP_9_BIT 0x1F // 9 bit\r
+#define TEMP_10_BIT 0x3F // 10 bit\r
+#define TEMP_11_BIT 0x5F // 11 bit\r
+#define TEMP_12_BIT 0x7F // 12 bit\r
+\r
+// Error Codes\r
+#define DEVICE_DISCONNECTED -127\r
+\r
+typedef uint8_t DeviceAddress[8];\r
+\r
+class DallasTemperature\r
+{\r
+ public:\r
+\r
+ DallasTemperature(OneWire*);\r
+\r
+ // initalize bus\r
+ void begin(void);\r
+\r
+ // returns the number of devices found on the bus\r
+ uint8_t getDeviceCount(void);\r
+ \r
+ // returns true if address is valid\r
+ bool validAddress(uint8_t*);\r
+\r
+ // finds an address at a given index on the bus \r
+ bool getAddress(uint8_t*, const uint8_t);\r
+ \r
+ // attempt to determine if the device at the given address is connected to the bus\r
+ bool isConnected(uint8_t*);\r
+\r
+ // attempt to determine if the device at the given address is connected to the bus\r
+ // also allows for updating the read scratchpad\r
+ bool isConnected(uint8_t*, uint8_t*);\r
+\r
+ // read device's scratchpad\r
+ void readScratchPad(uint8_t*, uint8_t*);\r
+\r
+ // write device's scratchpad\r
+ void writeScratchPad(uint8_t*, const uint8_t*);\r
+\r
+ // read device's power requirements\r
+ bool readPowerSupply(uint8_t*);\r
+\r
+ // returns the current resolution, 9-12\r
+ uint8_t getResolution(uint8_t*);\r
+\r
+ // set resolution of a device to 9, 10, 11, or 12 bits\r
+ void setResolution(uint8_t*, uint8_t);\r
+\r
+ // sends command for all devices on the bus to perform a temperature conversion\r
+ void requestTemperatures(void);\r
+ \r
+ // sends command for one device to perform a temperature conversion by address\r
+ void requestTemperaturesByAddress(uint8_t*);\r
+\r
+ // sends command for one device to perform a temperature conversion by index\r
+ void requestTemperaturesByIndex(uint8_t);\r
+\r
+ // returns temperature in degrees C\r
+ float getTempC(uint8_t*);\r
+\r
+ // returns temperature in degrees F\r
+ float getTempF(uint8_t*);\r
+\r
+ // Get temperature for device index (slow)\r
+ float getTempCByIndex(uint8_t);\r
+ \r
+ // Get temperature for device index (slow)\r
+ float getTempFByIndex(uint8_t);\r
+ \r
+ // returns true if the bus requires parasite power\r
+ bool isParasitePowerMode(void);\r
+\r
+ #if REQUIRESALARMS\r
+ \r
+ typedef void AlarmHandler(uint8_t*);\r
+\r
+ // sets the high alarm temperature for a device\r
+ // accepts a char. valid range is -55C - 125C\r
+ void setHighAlarmTemp(uint8_t*, const char);\r
+\r
+ // sets the low alarm temperature for a device\r
+ // accepts a char. valid range is -55C - 125C\r
+ void setLowAlarmTemp(uint8_t*, const char);\r
+\r
+ // returns a signed char with the current high alarm temperature for a device\r
+ // in the range -55C - 125C\r
+ char getHighAlarmTemp(uint8_t*);\r
+\r
+ // returns a signed char with the current low alarm temperature for a device\r
+ // in the range -55C - 125C\r
+ char getLowAlarmTemp(uint8_t*);\r
+ \r
+ // resets internal variables used for the alarm search\r
+ void resetAlarmSearch(void);\r
+\r
+ // search the wire for devices with active alarms\r
+ bool alarmSearch(uint8_t*);\r
+\r
+ // returns true if ia specific device has an alarm\r
+ bool hasAlarm(uint8_t*);\r
+\r
+ // returns true if any device is reporting an alarm on the bus\r
+ bool hasAlarm(void);\r
+\r
+ // runs the alarm handler for all devices returned by alarmSearch()\r
+ void processAlarms(void);\r
+ \r
+ // sets the alarm handler\r
+ void setAlarmHandler(AlarmHandler *);\r
+ \r
+ // The default alarm handler\r
+ static void defaultAlarmHandler(uint8_t*);\r
+\r
+ #endif\r
+\r
+ // convert from celcius to farenheit\r
+ static float toFahrenheit(const float);\r
+\r
+ // convert from farenheit to celsius\r
+ static float toCelsius(const float);\r
+\r
+ #if REQUIRESNEW\r
+\r
+ // initalize memory area\r
+ void* operator new (unsigned int);\r
+\r
+ // delete memory reference\r
+ void operator delete(void*);\r
+ \r
+ #endif\r
+\r
+ private:\r
+ typedef uint8_t ScratchPad[9];\r
+ \r
+ // parasite power on or off\r
+ bool parasite;\r
+\r
+ // used to determine the delay amount needed to allow for the\r
+ // temperature conversion to take place\r
+ int conversionDelay;\r
+\r
+ // count of devices on the bus\r
+ uint8_t devices;\r
+ \r
+ // Take a pointer to one wire instance\r
+ OneWire* _wire;\r
+\r
+ // reads scratchpad and returns the temperature in degrees C\r
+ float calculateTemperature(uint8_t*, uint8_t*);\r
+ \r
+ #if REQUIRESALARMS\r
+\r
+ // required for alarmSearch \r
+ uint8_t alarmSearchAddress[8];\r
+ char alarmSearchJunction;\r
+ uint8_t alarmSearchExhausted;\r
+\r
+ // the alarm handler function pointer\r
+ AlarmHandler *_AlarmHandler;\r
+\r
+ #endif\r
+ \r
+};\r
+#endif\r
--- /dev/null
+Arduino Library for Dallas Temperature ICs
+==========================================
+
+Usage
+-----
+
+This library supports the following devices:
+ DS18B20
+ DS18S20 - Please note there appears to be an issue with this series.
+ DS1822
+
+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'.
+
+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 a the top of DallasTemperature.h
+
+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)
+
+Website
+-------
+
+You can find the latest version of the library at
+http://milesburton.com/index.php?title=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
--- /dev/null
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 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);
+
+// 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);
+ }
+*/
+
+}
+\r
--- /dev/null
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 3
+#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;
+
+// function that will be called when an alarm condition exists during DallasTemperatures::processAlarms();
+void newAlarmHandler(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(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(DeviceAddress deviceAddress)
+{
+ float tempC = sensors.getTempC(deviceAddress);
+ if (tempC != DEVICE_DISCONNECTED)
+ {
+ Serial.print("Current Temp C: ");
+ Serial.print(tempC);
+ }
+ else Serial.print("DEVICE DISCONNECTED");
+ Serial.print(" ");
+}
+
+void printAlarmInfo(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);
+}
+\r
--- /dev/null
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 3
+#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;
+
+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");
+
+ // 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)
+ //insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
+ //outsideThermometer = { 0x28, 0x3F, 0x1C, 0x31, 0x2, 0x0, 0x0, 0x2 };
+
+ // 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
+ sensors.setResolution(insideThermometer, 9);
+ sensors.setResolution(outsideThermometer, 9);
+
+ 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);
+ 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();
+}
+
+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);
+}
+\r
--- /dev/null
+#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(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));
+}\r
--- /dev/null
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 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);
+
+// arrays to hold device address
+DeviceAddress insideThermometer;
+
+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)
+ //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);
+ 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");
+
+ // 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);
+ }
+}\r
--- /dev/null
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 3
+#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);
+
+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 9 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);
+ 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);
+ }
+}\r
--- /dev/null
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+DallasTemperature KEYWORD1
+OneWire KEYWORD1
+AlarmHandler KEYWORD1
+DeviceAddress KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+setResolution KEYWORD2
+getResolution KEYWORD2
+getTempC KEYWORD2
+toFahrenheit KEYWORD2
+getTempF KEYWORD2
+getTempCByIndex KEYWORD2
+getTempFByIndex KEYWORD2
+requestTemperatures KEYWORD2
+requestTemperaturesByAddress KEYWORD2
+requestTemperaturesByIndex KEYWORD2
+isParasitePowerMode KEYWORD2
+begin KEYWORD2
+getDeviceCount KEYWORD2
+getAddress KEYWORD2
+validAddress KEYWORD2
+isConnected KEYWORD2
+readScratchPad KEYWORD2
+writeScratchPad KEYWORD2
+readPowerSupply KEYWORD2
+setHighAlarmTemp KEYWORD2
+setLowAlarmTemp KEYWORD2
+getHighAlarmTemp KEYWORD2
+getLowAlarmTemp KEYWORD2
+resetAlarmSearch KEYWORD2
+alarmSearch KEYWORD2
+hasAlarm KEYWORD2
+toCelsius KEYWORD2
+processAlarmss KEYWORD2
+setAlarmHandlers KEYWORD2
+defaultAlarmHandler KEYWORD2
+calculateTemperature KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
## see README file
TARGET = rf433ctl
-INSTALL_DIR = /home/equinox/realraum/rf433ctl/arduino
+#TARGET = find_onewire
+INSTALL_DIR = $(PWD)/arduino
PORT = /dev/ttyUSB0
UPLOAD_RATE = 57600
AVRDUDE_PROGRAMMER = stk500v1
$(ARDUINO)/wiring_analog.c $(ARDUINO)/wiring_digital.c \
$(ARDUINO)/wiring_pulse.c $(ARDUINO)/wiring_serial.c \
$(ARDUINO)/wiring_shift.c $(ARDUINO)/WInterrupts.c
-CXXSRC = $(ARDUINO)/HardwareSerial.cpp $(ARDUINO)/Print.cpp $(ARDUINO)/WMath.cpp
+CXXSRC = OneWire/OneWire.cpp DallasTemperature/DallasTemperature.cpp $(ARDUINO)/HardwareSerial.cpp $(ARDUINO)/Print.cpp $(ARDUINO)/WMath.cpp
FORMAT = ihex
CXXDEFS = -DF_CPU=$(F_CPU)
# Place -I options here
-CINCS = -I$(ARDUINO)
-CXXINCS = -I$(ARDUINO)
+CINCS = -I ./OneWire -I ./DallasTemperature -I$(ARDUINO)
+CXXINCS = -I ./OneWire -I ./DallasTemperature -I$(ARDUINO)
# Compiler flag to set the C Standard level.
# c89 - "ANSI" C
#CEXTRA = -Wa,-adhlns=$(<:.c=.lst)
CFLAGS = $(CDEBUG) $(CDEFS) $(CINCS) -O$(OPT) $(CWARN) $(CSTANDARD) $(CEXTRA)
-CXXFLAGS = $(CDEFS) $(CINCS) -O$(OPT)
+CXXFLAGS = $(CDEFS) $(CXXINCS) -O$(OPT)
#ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs
LDFLAGS = -lm
--- /dev/null
+/*\r
+Copyright (c) 2007, Jim Studt\r
+\r
+\r
+Version 2.0: Modifications by Paul Stoffregen, January 2010:\r
+http://www.pjrc.com/teensy/td_libs_OneWire.html\r
+ Search fix from Robin James\r
+ http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27\r
+ Use direct optimized I/O in all cases\r
+ Disable interrupts during timing critical sections\r
+ (this solves many random communication errors)\r
+ Disable interrupts during read-modify-write I/O\r
+ Reduce RAM consumption by eliminating unnecessary\r
+ variables and trimming many to 8 bits\r
+ Optimize both crc8 - table version moved to flash\r
+\r
+Modified to work with larger numbers of devices - avoids loop.\r
+Tested in Arduino 11 alpha with 12 sensors.\r
+26 Sept 2008 -- Robin James\r
+http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27\r
+\r
+Updated to work with arduino-0008 and to include skip() as of\r
+2007/07/06. --RJL20\r
+\r
+Modified to calculate the 8-bit CRC directly, avoiding the need for\r
+the 256-byte lookup table to be loaded in RAM. Tested in arduino-0010\r
+-- Tom Pollard, Jan 23, 2008\r
+\r
+Permission is hereby granted, free of charge, to any person obtaining\r
+a copy of this software and associated documentation files (the\r
+"Software"), to deal in the Software without restriction, including\r
+without limitation the rights to use, copy, modify, merge, publish,\r
+distribute, sublicense, and/or sell copies of the Software, and to\r
+permit persons to whom the Software is furnished to do so, subject to\r
+the following conditions:\r
+\r
+The above copyright notice and this permission notice shall be\r
+included in all copies or substantial portions of the Software.\r
+\r
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+\r
+Much of the code was inspired by Derek Yerger's code, though I don't\r
+think much of that remains. In any event that was..\r
+ (copyleft) 2006 by Derek Yerger - Free to distribute freely.\r
+\r
+The CRC code was excerpted and inspired by the Dallas Semiconductor\r
+sample code bearing this copyright.\r
+//---------------------------------------------------------------------------\r
+// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved.\r
+//\r
+// Permission is hereby granted, free of charge, to any person obtaining a\r
+// copy of this software and associated documentation files (the "Software"),\r
+// to deal in the Software without restriction, including without limitation\r
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
+// and/or sell copies of the Software, and to permit persons to whom the\r
+// Software is furnished to do so, subject to the following conditions:\r
+//\r
+// The above copyright notice and this permission notice shall be included\r
+// in all copies or substantial portions of the Software.\r
+//\r
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\r
+// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES\r
+// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\r
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\r
+// OTHER DEALINGS IN THE SOFTWARE.\r
+//\r
+// Except as contained in this notice, the name of Dallas Semiconductor\r
+// shall not be used except as stated in the Dallas Semiconductor\r
+// Branding Policy.\r
+//--------------------------------------------------------------------------\r
+*/\r
+\r
+#include "OneWire.h"\r
+#include "pins_arduino.h"\r
+\r
+extern "C" {\r
+#include "WConstants.h"\r
+#include <avr/io.h>\r
+#include <avr/interrupt.h>\r
+#include <avr/pgmspace.h>\r
+}\r
+\r
+OneWire::OneWire(uint8_t pin)\r
+{\r
+ bitmask = digitalPinToBitMask(pin);\r
+ baseReg = portInputRegister(digitalPinToPort(pin));\r
+#if ONEWIRE_SEARCH\r
+ reset_search();\r
+#endif\r
+}\r
+\r
+\r
+#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)\r
+#define DIRECT_MODE_INPUT(base, mask) ((*(base+1)) &= ~(mask))\r
+#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) |= (mask))\r
+#define DIRECT_WRITE_LOW(base, mask) ((*(base+2)) &= ~(mask))\r
+#define DIRECT_WRITE_HIGH(base, mask) ((*(base+2)) |= (mask))\r
+\r
+\r
+// Perform the onewire reset function. We will wait up to 250uS for\r
+// the bus to come high, if it doesn't then it is broken or shorted\r
+// and we return a 0;\r
+//\r
+// Returns 1 if a device asserted a presence pulse, 0 otherwise.\r
+//\r
+uint8_t OneWire::reset(void)\r
+{\r
+ uint8_t mask=bitmask;\r
+ volatile uint8_t *reg asm("r30") = baseReg;\r
+ uint8_t r;\r
+ uint8_t retries = 125;\r
+\r
+ cli();\r
+ DIRECT_MODE_INPUT(reg, mask);\r
+ sei();\r
+ // wait until the wire is high... just in case\r
+ do {\r
+ if (--retries == 0) return 0;\r
+ delayMicroseconds(2);\r
+ } while ( !DIRECT_READ(reg, mask));\r
+\r
+ cli();\r
+ DIRECT_WRITE_LOW(reg, mask);\r
+ DIRECT_MODE_OUTPUT(reg, mask); // drive output low\r
+ sei();\r
+ delayMicroseconds(500);\r
+ cli();\r
+ DIRECT_MODE_INPUT(reg, mask); // allow it to float\r
+ delayMicroseconds(80);\r
+ r = !DIRECT_READ(reg, mask);\r
+ sei();\r
+ delayMicroseconds(420);\r
+ return r;\r
+}\r
+\r
+//\r
+// Write a bit. Port and bit is used to cut lookup time and provide\r
+// more certain timing.\r
+//\r
+void OneWire::write_bit(uint8_t v)\r
+{\r
+ uint8_t mask=bitmask;\r
+ volatile uint8_t *reg asm("r30") = baseReg;\r
+\r
+ if (v & 1) {\r
+ cli();\r
+ DIRECT_WRITE_LOW(reg, mask);\r
+ DIRECT_MODE_OUTPUT(reg, mask); // drive output low\r
+ delayMicroseconds(10);\r
+ DIRECT_WRITE_HIGH(reg, mask); // drive output high\r
+ sei();\r
+ delayMicroseconds(55);\r
+ } else {\r
+ cli();\r
+ DIRECT_WRITE_LOW(reg, mask);\r
+ DIRECT_MODE_OUTPUT(reg, mask); // drive output low\r
+ delayMicroseconds(65);\r
+ DIRECT_WRITE_HIGH(reg, mask); // drive output high\r
+ sei();\r
+ delayMicroseconds(5);\r
+ }\r
+}\r
+\r
+//\r
+// Read a bit. Port and bit is used to cut lookup time and provide\r
+// more certain timing.\r
+//\r
+uint8_t OneWire::read_bit(void)\r
+{\r
+ uint8_t mask=bitmask;\r
+ volatile uint8_t *reg asm("r30") = baseReg;\r
+ uint8_t r;\r
+\r
+ cli();\r
+ DIRECT_MODE_OUTPUT(reg, mask);\r
+ DIRECT_WRITE_LOW(reg, mask);\r
+ delayMicroseconds(3);\r
+ DIRECT_MODE_INPUT(reg, mask); // let pin float, pull up will raise\r
+ delayMicroseconds(9);\r
+ r = DIRECT_READ(reg, mask);\r
+ sei();\r
+ delayMicroseconds(53);\r
+ return r;\r
+}\r
+\r
+//\r
+// Write a byte. The writing code uses the active drivers to raise the\r
+// pin high, if you need power after the write (e.g. DS18S20 in\r
+// parasite power mode) then set 'power' to 1, otherwise the pin will\r
+// go tri-state at the end of the write to avoid heating in a short or\r
+// other mishap.\r
+//\r
+void OneWire::write(uint8_t v, uint8_t power /* = 0 */) {\r
+ uint8_t bitMask;\r
+\r
+ for (bitMask = 0x01; bitMask; bitMask <<= 1) {\r
+ OneWire::write_bit( (bitMask & v)?1:0);\r
+ }\r
+ if ( !power) {\r
+ cli();\r
+ DIRECT_MODE_INPUT(baseReg, bitmask);\r
+ DIRECT_WRITE_LOW(baseReg, bitmask);\r
+ sei();\r
+ }\r
+}\r
+\r
+//\r
+// Read a byte\r
+//\r
+uint8_t OneWire::read() {\r
+ uint8_t bitMask;\r
+ uint8_t r = 0;\r
+\r
+ for (bitMask = 0x01; bitMask; bitMask <<= 1) {\r
+ if ( OneWire::read_bit()) r |= bitMask;\r
+ }\r
+ return r;\r
+}\r
+\r
+//\r
+// Do a ROM select\r
+//\r
+void OneWire::select( uint8_t rom[8])\r
+{\r
+ int i;\r
+\r
+ write(0x55); // Choose ROM\r
+\r
+ for( i = 0; i < 8; i++) write(rom[i]);\r
+}\r
+\r
+//\r
+// Do a ROM skip\r
+//\r
+void OneWire::skip()\r
+{\r
+ write(0xCC); // Skip ROM\r
+}\r
+\r
+void OneWire::depower()\r
+{\r
+ cli();\r
+ DIRECT_MODE_INPUT(baseReg, bitmask);\r
+ sei();\r
+}\r
+\r
+#if ONEWIRE_SEARCH\r
+\r
+//\r
+// You need to use this function to start a search again from the beginning.\r
+// You do not need to do it for the first search, though you could.\r
+//\r
+void OneWire::reset_search()\r
+ {\r
+ // reset the search state\r
+ LastDiscrepancy = 0;\r
+ LastDeviceFlag = FALSE;\r
+ LastFamilyDiscrepancy = 0;\r
+ for(int i = 7; ; i--)\r
+ {\r
+ ROM_NO[i] = 0;\r
+ if ( i == 0) break;\r
+ }\r
+ }\r
+\r
+//\r
+// Perform a search. If this function returns a '1' then it has\r
+// enumerated the next device and you may retrieve the ROM from the\r
+// OneWire::address variable. If there are no devices, no further\r
+// devices, or something horrible happens in the middle of the\r
+// enumeration then a 0 is returned. If a new device is found then\r
+// its address is copied to newAddr. Use OneWire::reset_search() to\r
+// start over.\r
+//\r
+// --- Replaced by the one from the Dallas Semiconductor web site ---\r
+//--------------------------------------------------------------------------\r
+// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing\r
+// search state.\r
+// Return TRUE : device found, ROM number in ROM_NO buffer\r
+// FALSE : device not found, end of search\r
+//\r
+uint8_t OneWire::search(uint8_t *newAddr)\r
+{\r
+ uint8_t id_bit_number;\r
+ uint8_t last_zero, rom_byte_number, search_result;\r
+ uint8_t id_bit, cmp_id_bit;\r
+\r
+ unsigned char rom_byte_mask, search_direction;\r
+\r
+ // initialize for search\r
+ id_bit_number = 1;\r
+ last_zero = 0;\r
+ rom_byte_number = 0;\r
+ rom_byte_mask = 1;\r
+ search_result = 0;\r
+\r
+ // if the last call was not the last one\r
+ if (!LastDeviceFlag)\r
+ {\r
+ // 1-Wire reset\r
+ if (!reset())\r
+ {\r
+ // reset the search\r
+ LastDiscrepancy = 0;\r
+ LastDeviceFlag = FALSE;\r
+ LastFamilyDiscrepancy = 0;\r
+ return FALSE;\r
+ }\r
+\r
+ // issue the search command\r
+ write(0xF0);\r
+\r
+ // loop to do the search\r
+ do\r
+ {\r
+ // read a bit and its complement\r
+ id_bit = read_bit();\r
+ cmp_id_bit = read_bit();\r
+\r
+ // check for no devices on 1-wire\r
+ if ((id_bit == 1) && (cmp_id_bit == 1))\r
+ break;\r
+ else\r
+ {\r
+ // all devices coupled have 0 or 1\r
+ if (id_bit != cmp_id_bit)\r
+ search_direction = id_bit; // bit write value for search\r
+ else\r
+ {\r
+ // if this discrepancy if before the Last Discrepancy\r
+ // on a previous next then pick the same as last time\r
+ if (id_bit_number < LastDiscrepancy)\r
+ search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0);\r
+ else\r
+ // if equal to last pick 1, if not then pick 0\r
+ search_direction = (id_bit_number == LastDiscrepancy);\r
+\r
+ // if 0 was picked then record its position in LastZero\r
+ if (search_direction == 0)\r
+ {\r
+ last_zero = id_bit_number;\r
+\r
+ // check for Last discrepancy in family\r
+ if (last_zero < 9)\r
+ LastFamilyDiscrepancy = last_zero;\r
+ }\r
+ }\r
+\r
+ // set or clear the bit in the ROM byte rom_byte_number\r
+ // with mask rom_byte_mask\r
+ if (search_direction == 1)\r
+ ROM_NO[rom_byte_number] |= rom_byte_mask;\r
+ else\r
+ ROM_NO[rom_byte_number] &= ~rom_byte_mask;\r
+\r
+ // serial number search direction write bit\r
+ write_bit(search_direction);\r
+\r
+ // increment the byte counter id_bit_number\r
+ // and shift the mask rom_byte_mask\r
+ id_bit_number++;\r
+ rom_byte_mask <<= 1;\r
+\r
+ // if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask\r
+ if (rom_byte_mask == 0)\r
+ {\r
+ rom_byte_number++;\r
+ rom_byte_mask = 1;\r
+ }\r
+ }\r
+ }\r
+ while(rom_byte_number < 8); // loop until through all ROM bytes 0-7\r
+\r
+ // if the search was successful then\r
+ if (!(id_bit_number < 65))\r
+ {\r
+ // search successful so set LastDiscrepancy,LastDeviceFlag,search_result\r
+ LastDiscrepancy = last_zero;\r
+\r
+ // check for last device\r
+ if (LastDiscrepancy == 0)\r
+ LastDeviceFlag = TRUE;\r
+\r
+ search_result = TRUE;\r
+ }\r
+ }\r
+\r
+ // if no device found then reset counters so next 'search' will be like a first\r
+ if (!search_result || !ROM_NO[0])\r
+ {\r
+ LastDiscrepancy = 0;\r
+ LastDeviceFlag = FALSE;\r
+ LastFamilyDiscrepancy = 0;\r
+ search_result = FALSE;\r
+ }\r
+ for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i];\r
+ return search_result;\r
+ }\r
+\r
+#endif\r
+\r
+#if ONEWIRE_CRC\r
+// The 1-Wire CRC scheme is described in Maxim Application Note 27:\r
+// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products"\r
+//\r
+\r
+#if ONEWIRE_CRC8_TABLE\r
+// This table comes from Dallas sample code where it is freely reusable,\r
+// though Copyright (C) 2000 Dallas Semiconductor Corporation\r
+static const uint8_t PROGMEM dscrc_table[] = {\r
+ 0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,\r
+ 157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,\r
+ 35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,\r
+ 190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,\r
+ 70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,\r
+ 219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,\r
+ 101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,\r
+ 248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,\r
+ 140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,\r
+ 17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,\r
+ 175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,\r
+ 50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,\r
+ 202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,\r
+ 87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,\r
+ 233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,\r
+ 116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};\r
+\r
+//\r
+// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM\r
+// and the registers. (note: this might better be done without to\r
+// table, it would probably be smaller and certainly fast enough\r
+// compared to all those delayMicrosecond() calls. But I got\r
+// confused, so I use this table from the examples.)\r
+//\r
+uint8_t OneWire::crc8( uint8_t *addr, uint8_t len)\r
+{\r
+ uint8_t crc = 0;\r
+\r
+ while (len--) {\r
+ crc = pgm_read_byte(dscrc_table + (crc ^ *addr++));\r
+ }\r
+ return crc;\r
+}\r
+#else\r
+//\r
+// Compute a Dallas Semiconductor 8 bit CRC directly.\r
+//\r
+uint8_t OneWire::crc8( uint8_t *addr, uint8_t len)\r
+{\r
+ uint8_t crc = 0;\r
+ \r
+ while (len--) {\r
+ uint8_t inbyte = *addr++;\r
+ for (uint8_t i = 8; i; i--) {\r
+ uint8_t mix = (crc ^ inbyte) & 0x01;\r
+ crc >>= 1;\r
+ if (mix) crc ^= 0x8C;\r
+ inbyte >>= 1;\r
+ }\r
+ }\r
+ return crc;\r
+}\r
+#endif\r
+\r
+#if ONEWIRE_CRC16\r
+static short oddparity[16] = { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };\r
+\r
+//\r
+// Compute a Dallas Semiconductor 16 bit CRC. I have never seen one of\r
+// these, but here it is.\r
+//\r
+unsigned short OneWire::crc16(unsigned short *data, unsigned short len)\r
+{\r
+ unsigned short i;\r
+ unsigned short crc = 0;\r
+\r
+ for ( i = 0; i < len; i++) {\r
+ unsigned short cdata = data[len];\r
+\r
+ cdata = (cdata ^ (crc & 0xff)) & 0xff;\r
+ crc >>= 8;\r
+\r
+ if (oddparity[cdata & 0xf] ^ oddparity[cdata >> 4]) crc ^= 0xc001;\r
+\r
+ cdata <<= 6;\r
+ crc ^= cdata;\r
+ cdata <<= 1;\r
+ crc ^= cdata;\r
+ }\r
+ return crc;\r
+}\r
+#endif\r
+\r
+#endif\r
--- /dev/null
+#ifndef OneWire_h
+#define OneWire_h
+
+#include <inttypes.h>
+
+// 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 no longer consumes
+// limited RAM, but enlarges total code size by about 250 bytes
+#ifndef ONEWIRE_CRC8_TABLE
+#define ONEWIRE_CRC8_TABLE 0
+#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 0
+#endif
+
+#define FALSE 0
+#define TRUE 1
+
+class OneWire
+{
+ private:
+ uint8_t bitmask;
+ volatile uint8_t *baseReg;
+
+#if ONEWIRE_SEARCH
+ // global search state
+ unsigned char ROM_NO[8];
+ uint8_t LastDiscrepancy;
+ uint8_t LastFamilyDiscrepancy;
+ uint8_t LastDeviceFlag;
+#endif
+
+ public:
+ OneWire( 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( 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);
+
+ // Read a byte.
+ uint8_t read(void);
+
+ // Write a bit. The bus is always left powered at the end, see
+ // note in write() about that.
+ void write_bit(uint8_t v);
+
+ // Read a bit.
+ uint8_t read_bit(void);
+
+ // Stop forcing power onto the bus. You only need to do this if
+ // you used the 'power' flag to write() or used a write_bit() call
+ // and aren't about to do another read or write. You would rather
+ // not leave this powered if you don't have to, just in case
+ // someone shorts your bus.
+ void depower(void);
+
+#if ONEWIRE_SEARCH
+ // Clear the search state so that if will start from the beginning again.
+ void reset_search();
+
+ // 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.
+ uint8_t search(uint8_t *newAddr);
+#endif
+
+#if ONEWIRE_CRC
+ // Compute a Dallas Semiconductor 8 bit CRC, these are used in the
+ // ROM and scratchpad registers.
+ static uint8_t crc8( uint8_t *addr, uint8_t len);
+
+#if ONEWIRE_CRC16
+ // Compute a Dallas Semiconductor 16 bit CRC. Maybe. I don't have
+ // any devices that use this so this might be wrong. I just copied
+ // it from their sample code.
+ static unsigned short crc16(unsigned short *data, unsigned short len);
+#endif
+#endif
+};
+
+#endif
--- /dev/null
+
+OneWire library for Arduino
+---------------------------
+
+Version 2.0 fixes search bugs (thanks to Robin James) and interrupt issues.
+http://www.pjrc.com/teensy/td_libs_OneWire.html
+
+
+This is a slightly modified version of the OneWire library originally written by Jim Studt for arduino-0007 and later updated for arduino-0008 by Josh Larios. This new version eliminates the large lookup table that was previously used by the checksum calculation - otherwise it's identical to Josh's version. It was developed under arduino-0010.
+
+For a general description and links, see
+
+ http://www.arduino.cc/playground/Learning/OneWire
+
+Jim Studt's original verion of this library is still available at
+
+ http://www.federated.com/~jim/onewire/
+
+Josh Larios' version is available at
+
+ http://www.elsewhere.org/onewire/
+
+To install this library, you should just have to unzip the archive in the arduino-0010/hardware/libraries directory. It will create a subdirectory
+called 'OneWire'.
+
+Tom Pollard
+pollard@alum.mit.edu
+May 20, 2008
--- /dev/null
+#include <OneWire.h>
+
+/* DS18S20 Temperature chip i/o */
+
+OneWire ds(8); // on pin 10
+
+void setup(void) {
+ Serial.begin(9600);
+}
+
+void loop(void) {
+ byte i;
+ byte present = 0;
+ byte data[12];
+ byte addr[8];
+
+ if ( !ds.search(addr)) {
+ Serial.print("No more addresses.\n");
+ ds.reset_search();
+ delay(250);
+ return;
+ }
+
+ Serial.print("R=");
+ for( i = 0; i < 8; i++) {
+ Serial.print(addr[i], HEX);
+ Serial.print(" ");
+ }
+
+ if ( OneWire::crc8( addr, 7) != addr[7]) {
+ Serial.print("CRC is not valid!\n");
+ return;
+ }
+
+ if ( addr[0] != 0x10) {
+ Serial.print("Device is not a DS18S20 family device.\n");
+ return;
+ }
+
+ // The DallasTemperature library can do all this work for you!
+
+ ds.reset();
+ ds.select(addr);
+ ds.write(0x44,1); // start conversion, with parasite power on at the end
+
+ delay(1000); // maybe 750ms is enough, maybe not
+ // we might do a ds.depower() here, but the reset will take care of it.
+
+ present = ds.reset();
+ ds.select(addr);
+ ds.write(0xBE); // Read Scratchpad
+
+ Serial.print("P=");
+ Serial.print(present,HEX);
+ Serial.print(" ");
+ for ( i = 0; i < 9; i++) { // we need 9 bytes
+ data[i] = ds.read();
+ Serial.print(data[i], HEX);
+ Serial.print(" ");
+ }
+ Serial.print(" CRC=");
+ Serial.print( OneWire::crc8( data, 8), HEX);
+ Serial.println();
+}
--- /dev/null
+#######################################
+# Syntax Coloring Map For OneWire
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+OneWire KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+reset KEYWORD2
+write_bit KEYWORD2
+read_bit KEYWORD2
+write KEYWORD2
+read KEYWORD2
+select KEYWORD2
+skip KEYWORD2
+depower KEYWORD2
+reset_search KEYWORD2
+search KEYWORD2
+crc8 KEYWORD2
+crc16 KEYWORD2
+
+#######################################
+# Instances (KEYWORD2)
+#######################################
+
+
+#######################################
+# Constants (LITERAL1)
+#######################################
6. flash it (press reset)
$ make upload
+
+
+
+Arduino OneWire Lib 2.0:
+http://www.pjrc.com/teensy/td_libs_OneWire.html
+
+Dallas Temperature Library:
+http://download.milesburton.com/Arduino/MaximTemperature/DallasTemperature_350.zip
--- /dev/null
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+/* DS18S20 Temperature chip i/o */
+
+OneWire ds(8);
+DallasTemperature sensors(&ds);
+
+DeviceAddress insideThermometer = { 0x10, 0xE7, 0x77, 0xD3, 0x01, 0x08, 0x00, 0x3F };
+
+void printTemperature(DeviceAddress deviceAddress)
+{
+ float tempC = sensors.getTempC(deviceAddress);
+ Serial.print("Temp C: ");
+ Serial.print(tempC);
+ Serial.print(" Temp F: ");
+ Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
+}
+
+void setup(void) {
+ Serial.begin(9600);
+ sensors.begin();
+}
+
+void loop(void) {
+ if (millis() < 2000)
+ {
+ return;
+ }
+
+ printTemperature(insideThermometer);
+
+ byte i;
+ byte present = 0;
+ byte data[12];
+ byte addr[8];
+
+ if ( !ds.search(addr)) {
+ Serial.print("\nNo more addresses.\n");
+ ds.reset_search();
+ delay(250);
+ return;
+ }
+
+ Serial.print("\nR=");
+ for( i = 0; i < 8; i++) {
+ Serial.print(addr[i], HEX);
+ Serial.print(" ");
+ }
+
+ if ( OneWire::crc8( addr, 7) != addr[7]) {
+ Serial.print(" CRC is not valid!\n");
+ return;
+ }
+
+ if ( addr[0] != 0x10) {
+ Serial.print("\nDevice is not a DS18S20 family device.\n");
+ return;
+ }
+
+ // The DallasTemperature library can do all this work for you!
+
+ ds.reset();
+ ds.select(addr);
+ ds.write(0x44,1); // start conversion, with parasite power on at the end
+
+ delay(1000); // maybe 750ms is enough, maybe not
+ // we might do a ds.depower() here, but the reset will take care of it.
+
+ present = ds.reset();
+ ds.select(addr);
+ ds.write(0xBE); // Read Scratchpad
+
+ Serial.print("\nP=");
+ Serial.print(present,HEX);
+ Serial.print(" ");
+ for ( i = 0; i < 9; i++) { // we need 9 bytes
+ data[i] = ds.read();
+ Serial.print(data[i], HEX);
+ Serial.print(" ");
+ }
+ Serial.println();
+ Serial.print(" CRC=");
+ Serial.print( OneWire::crc8( data, 8), HEX);
+ Serial.println();
+}
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
+#include <OneWire.h>
+#include <DallasTemperature.h>
//********************************************************************//
#define DATA_OUT_PIN 13
+#define IR_MOVEMENT_PIN 9
+#define ONE_WIRE_PIN 8
+#define PANIC_BUTTON_PIN 7
+#define IR_SAMPLE_DURATION 20000
+#define IR_TRESHOLD 13000
+#define PB_SAMPLE_DURATION 5000
+#define PB_TRESHOLD 5000
+
+OneWire onewire(ONE_WIRE_PIN);
+DallasTemperature dallas_sensors(&onewire);
+DeviceAddress onShieldTemp = { 0x10, 0xE7, 0x77, 0xD3, 0x01, 0x08, 0x00, 0x3F };
typedef struct {
byte offset;
//********************************************************************//
+void printTemperature(DeviceAddress deviceAddress)
+{
+ dallas_sensors.requestTemperatures();
+ float tempC = dallas_sensors.getTempC(deviceAddress);
+ Serial.print("Temp C: ");
+ Serial.println(tempC);
+ //Serial.print(" Temp F: ");
+ //Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
+}
+
+//********************************************************************//
+
void setup()
{
pinMode(DATA_OUT_PIN, OUTPUT);
digitalWrite(DATA_OUT_PIN, LOW);
+ pinMode(IR_MOVEMENT_PIN, INPUT); // set pin to input
+ digitalWrite(IR_MOVEMENT_PIN, LOW); // turn off pullup resistors
+ pinMode(PANIC_BUTTON_PIN, INPUT); // set pin to input
+ digitalWrite(PANIC_BUTTON_PIN, HIGH); // turn on pullup resistors
+
+ onewire.reset();
+ onewire.reset_search();
+ dallas_sensors.begin();
+ //in case we change temp sensor:
+ if (!dallas_sensors.getAddress(onShieldTemp, 0))
+ Serial.println("Unable to find address for Device 0");
+ dallas_sensors.setResolution(onShieldTemp, 9);
+
Serial.begin(9600);
}
+unsigned int ir_time=IR_SAMPLE_DURATION;
+unsigned int ir_count=0;
+unsigned int pb_time=PB_SAMPLE_DURATION;
+unsigned int pb_count=0;
+
void loop()
{
+ ir_time--;
+ pb_time--;
+ ir_count += (digitalRead(IR_MOVEMENT_PIN) == HIGH);
+ pb_count += (digitalRead(PANIC_BUTTON_PIN) == LOW);
+
+ if (ir_time == 0)
+ {
+ if (ir_count >= IR_TRESHOLD)
+ Serial.println("movement");
+ ir_time=IR_SAMPLE_DURATION;
+ ir_count=0;
+ }
+
+ if (pb_time == 0)
+ {
+ if (pb_count >= PB_TRESHOLD)
+ Serial.println("PanicButton");
+ pb_time=PB_SAMPLE_DURATION;
+ pb_count=0;
+ }
+
if(Serial.available()) {
char command = Serial.read();
send_frame(words[D2_ON]);
else if(command == 'k')
send_frame(words[D2_OFF]);
-
+ else if(command == 'T')
+ printTemperature(onShieldTemp);
}
}
projects / svn42.git / commitdiff