├── .gitignore ├── LICENSE.txt ├── README.md ├── examples ├── Alarms │ └── Alarms.ino ├── Multiple │ └── Multiple.ino └── Single │ └── Single.ino ├── extras ├── mixed_mode.png ├── multiple_external.png ├── multiple_parasite.png ├── single_external.png └── single_parasite.png ├── keywords.txt ├── library.properties └── src ├── DS18B20.cpp └── DS18B20.h /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode/* 2 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2013 Mathias Munk Hansen 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # DS18B20 # 2 | 3 | Arduino library for the Maxim Integrated DS18B20 1-Wire temperature sensor. This library is very simple and intuitive to use, and supports auto-discovering sensors with an optional high/low condition or manually addressing individual sensors. 4 | 5 | For example, we can get the temperature from every sensor on the wire with just a few lines of code: 6 | 7 | ``` 8 | #include 9 | 10 | DS18B20 ds(2); 11 | 12 | void setup() { 13 | Serial.begin(9600); 14 | } 15 | 16 | void loop() { 17 | while (ds.selectNext()) { 18 | Serial.println(ds.getTempC()); 19 | } 20 | } 21 | ``` 22 | 23 | See the included [examples](/examples/) for more. 24 | 25 | ## Installation ## 26 | 27 | This library uses the OneWire library, so you will need to have this installed. Install it using the Library Manager in the Arduino IDE or download the latest release from [GitHub](https://github.com/PaulStoffregen/OneWire). 28 | 29 | In the **OneWire.h** file set `ONEWIRE_SEARCH` to 0 since the search functionality is also implemented in this library (don't do this if you need the search functionality for other 1-Wire devices). CRC must be enabled (choose whichever algorithm you prefer). This may save some space on your Arduino. 30 | 31 | ## Wiring the DS18B20 ## 32 | The resistor shown in all the circuit diagrams is 4.7k Ohm pullup resistor. 33 | 34 | ### External Power Mode ### 35 | 36 | #### Single #### 37 | ![A single externally powered DS18B20](/extras/single_external.png) 38 | 39 | #### Multiple #### 40 | ![Multiple externally powered DS18B20s](/extras/multiple_external.png) 41 | 42 | ### Parasitic Power Mode ### 43 | 44 | #### Single #### 45 | ![A single parasite powered DS18B20](/extras/single_parasite.png) 46 | 47 | #### Multiple #### 48 | ![Multiple parasite powered DS18B20s](/extras/multiple_parasite.png) 49 | 50 | ### Mixed Power Mode ### 51 | ![Mixed mode DS18B20s](/extras/mixed_mode.png) 52 | -------------------------------------------------------------------------------- /examples/Alarms/Alarms.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define LOW_ALARM 20 4 | #define HIGH_ALARM 25 5 | 6 | DS18B20 ds(2); 7 | 8 | void setup() { 9 | Serial.begin(9600); 10 | 11 | while (ds.selectNext()) { 12 | ds.setAlarms(LOW_ALARM, HIGH_ALARM); 13 | } 14 | } 15 | 16 | void loop() { 17 | ds.doConversion(); 18 | 19 | while (ds.selectNextAlarm()) { 20 | Serial.print("Alarm Low: "); 21 | Serial.print(ds.getAlarmLow()); 22 | Serial.println(" C"); 23 | Serial.print("Alarm High: "); 24 | Serial.print(ds.getAlarmHigh()); 25 | Serial.println(" C"); 26 | Serial.print("Temperature: "); 27 | Serial.print(ds.getTempC()); 28 | Serial.println(" C\n"); 29 | } 30 | 31 | delay(10000); 32 | } 33 | -------------------------------------------------------------------------------- /examples/Multiple/Multiple.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | DS18B20 ds(2); 4 | 5 | void setup() { 6 | Serial.begin(9600); 7 | Serial.print("Devices: "); 8 | Serial.println(ds.getNumberOfDevices()); 9 | Serial.println(); 10 | } 11 | 12 | void loop() { 13 | while (ds.selectNext()) { 14 | switch (ds.getFamilyCode()) { 15 | case MODEL_DS18S20: 16 | Serial.println("Model: DS18S20/DS1820"); 17 | break; 18 | case MODEL_DS1822: 19 | Serial.println("Model: DS1822"); 20 | break; 21 | case MODEL_DS18B20: 22 | Serial.println("Model: DS18B20"); 23 | break; 24 | default: 25 | Serial.println("Unrecognized Device"); 26 | break; 27 | } 28 | 29 | uint8_t address[8]; 30 | ds.getAddress(address); 31 | 32 | Serial.print("Address:"); 33 | for (uint8_t i = 0; i < 8; i++) { 34 | Serial.print(" "); 35 | Serial.print(address[i]); 36 | } 37 | Serial.println(); 38 | 39 | Serial.print("Resolution: "); 40 | Serial.println(ds.getResolution()); 41 | 42 | Serial.print("Power Mode: "); 43 | if (ds.getPowerMode()) { 44 | Serial.println("External"); 45 | } else { 46 | Serial.println("Parasite"); 47 | } 48 | 49 | Serial.print("Temperature: "); 50 | Serial.print(ds.getTempC()); 51 | Serial.print(" C / "); 52 | Serial.print(ds.getTempF()); 53 | Serial.println(" F"); 54 | Serial.println(); 55 | } 56 | 57 | delay(10000); 58 | } 59 | -------------------------------------------------------------------------------- /examples/Single/Single.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define LOW_ALARM 20 4 | #define HIGH_ALARM 25 5 | 6 | DS18B20 ds(2); 7 | uint8_t address[] = {40, 250, 31, 218, 4, 0, 0, 52}; 8 | uint8_t selected; 9 | 10 | void setup() { 11 | Serial.begin(9600); 12 | selected = ds.select(address); 13 | 14 | if (selected) { 15 | ds.setAlarms(LOW_ALARM, HIGH_ALARM); 16 | } else { 17 | Serial.println("Device not found!"); 18 | } 19 | } 20 | 21 | void loop() { 22 | if (selected) { 23 | if (ds.hasAlarm()) { 24 | Serial.print("Warning! Temperature is "); 25 | Serial.print(ds.getTempC()); 26 | Serial.println(" C"); 27 | } 28 | } else { 29 | Serial.println("Device not found!"); 30 | } 31 | 32 | delay(10000); 33 | } 34 | -------------------------------------------------------------------------------- /extras/mixed_mode.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matmunk/DS18B20/28df9a8c609ed5bf7a2e720640261ffabdcf0b63/extras/mixed_mode.png -------------------------------------------------------------------------------- /extras/multiple_external.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matmunk/DS18B20/28df9a8c609ed5bf7a2e720640261ffabdcf0b63/extras/multiple_external.png -------------------------------------------------------------------------------- /extras/multiple_parasite.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matmunk/DS18B20/28df9a8c609ed5bf7a2e720640261ffabdcf0b63/extras/multiple_parasite.png -------------------------------------------------------------------------------- /extras/single_external.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matmunk/DS18B20/28df9a8c609ed5bf7a2e720640261ffabdcf0b63/extras/single_external.png -------------------------------------------------------------------------------- /extras/single_parasite.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matmunk/DS18B20/28df9a8c609ed5bf7a2e720640261ffabdcf0b63/extras/single_parasite.png -------------------------------------------------------------------------------- /keywords.txt: -------------------------------------------------------------------------------- 1 | DS18B20 KEYWORD1 2 | 3 | select KEYWORD2 4 | selectNext KEYWORD2 5 | selectNextAlarm KEYWORD2 6 | resetSearch KEYWORD2 7 | getTempC KEYWORD2 8 | getTempF KEYWORD2 9 | getResolution KEYWORD2 10 | setResolution KEYWORD2 11 | getPowerMode KEYWORD2 12 | getFamilyCode KEYWORD2 13 | getAddress KEYWORD2 14 | doConversion KEYWORD2 15 | getNumberOfDevices KEYWORD2 16 | hasAlarm KEYWORD2 17 | setAlarms KEYWORD2 18 | getAlarmLow KEYWORD2 19 | setAlarmLow KEYWORD2 20 | getAlarmHigh KEYWORD2 21 | setAlarmHigh KEYWORD2 22 | setRegisters KEYWORD2 23 | getLowRegister KEYWORD2 24 | setLowRegister KEYWORD2 25 | getHighRegister KEYWORD2 26 | setHighRegister KEYWORD2 27 | 28 | MODEL_DS1820 LITERAL1 29 | MODEL_DS18S20 LITERAL1 30 | MODEL_DS1822 LITERAL1 31 | MODEL_DS18B20 LITERAL1 32 | -------------------------------------------------------------------------------- /library.properties: -------------------------------------------------------------------------------- 1 | name=DS18B20 2 | version=1.0.0 3 | author=Mathias Munk Hansen 4 | maintainer=Mathias Munk Hansen 5 | sentence=Arduino library for the Maxim Integrated DS18B20 1-Wire temperature sensor. 6 | paragraph=This library is very simple and intuitive to use, and supports auto-discovering sensors with an optional high/low condition or manually addressing individual sensors. 7 | category=Sensors 8 | url=https://github.com/matmunk/DS18B20 9 | architectures=* 10 | includes=DS18B20.h 11 | depends=OneWire 12 | -------------------------------------------------------------------------------- /src/DS18B20.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | DS18B20::DS18B20(uint8_t pin) : 4 | oneWire(OneWire(pin)), 5 | numberOfDevices(0), 6 | globalResolution(0), 7 | selectedResolution(0), 8 | selectedPowerMode(0) 9 | { 10 | resetSearch(); 11 | sendCommand(SKIP_ROM, READ_POWER_SUPPLY); 12 | globalPowerMode = oneWire.read_bit(); 13 | 14 | while (selectNext()) { 15 | uint8_t resolution = getResolution(); 16 | 17 | if (resolution > globalResolution) { 18 | globalResolution = resolution; 19 | } 20 | 21 | numberOfDevices++; 22 | } 23 | } 24 | 25 | uint8_t DS18B20::select(uint8_t address[]) { 26 | if (isConnected(address)) { 27 | memcpy(selectedAddress, address, 8); 28 | 29 | if (readScratchpad()) { 30 | selectedResolution = getResolution(); 31 | 32 | sendCommand(MATCH_ROM, READ_POWER_SUPPLY); 33 | selectedPowerMode = oneWire.read_bit(); 34 | 35 | return 1; 36 | } 37 | } 38 | 39 | return 0; 40 | } 41 | 42 | uint8_t DS18B20::selectNext() { 43 | if (oneWireSearch(SEARCH_ROM)) { 44 | return select(searchAddress); 45 | } 46 | 47 | return 0; 48 | } 49 | 50 | uint8_t DS18B20::selectNextAlarm() { 51 | if (oneWireSearch(ALARM_SEARCH)) { 52 | return select(searchAddress); 53 | } 54 | 55 | return 0; 56 | } 57 | 58 | void DS18B20::resetSearch() { 59 | lastDiscrepancy = 0; 60 | lastDevice = 0; 61 | } 62 | 63 | float DS18B20::getTempC() { 64 | sendCommand(MATCH_ROM, CONVERT_T, !selectedPowerMode); 65 | delayForConversion(selectedResolution, selectedPowerMode); 66 | readScratchpad(); 67 | uint8_t lsb = selectedScratchpad[TEMP_LSB]; 68 | uint8_t msb = selectedScratchpad[TEMP_MSB]; 69 | 70 | switch (selectedResolution) { 71 | case 9: 72 | lsb &= 0xF8; 73 | break; 74 | case 10: 75 | lsb &= 0xFC; 76 | break; 77 | case 11: 78 | lsb &= 0xFE; 79 | break; 80 | } 81 | 82 | uint8_t sign = msb & 0x80; 83 | int16_t temp = (msb << 8) + lsb; 84 | 85 | if (sign) { 86 | temp = ((temp ^ 0xffff) + 1) * -1; 87 | } 88 | 89 | return temp / 16.0; 90 | } 91 | 92 | float DS18B20::getTempF() { 93 | return getTempC() * 1.8 + 32; 94 | } 95 | 96 | uint8_t DS18B20::getResolution() { 97 | switch (selectedScratchpad[CONFIGURATION]) { 98 | case RES_9_BIT: 99 | return 9; 100 | case RES_10_BIT: 101 | return 10; 102 | case RES_11_BIT: 103 | return 11; 104 | case RES_12_BIT: 105 | return 12; 106 | } 107 | return 0; 108 | } 109 | 110 | void DS18B20::setResolution(uint8_t resolution) { 111 | resolution = constrain(resolution, 9, 12); 112 | 113 | switch (resolution) { 114 | case 9: 115 | selectedScratchpad[CONFIGURATION] = RES_9_BIT; 116 | break; 117 | case 10: 118 | selectedScratchpad[CONFIGURATION] = RES_10_BIT; 119 | break; 120 | case 11: 121 | selectedScratchpad[CONFIGURATION] = RES_11_BIT; 122 | break; 123 | case 12: 124 | selectedScratchpad[CONFIGURATION] = RES_12_BIT; 125 | break; 126 | } 127 | 128 | if (resolution > globalResolution) { 129 | globalResolution = resolution; 130 | } 131 | 132 | writeScratchpad(); 133 | } 134 | 135 | uint8_t DS18B20::getPowerMode() { 136 | return selectedPowerMode; 137 | } 138 | 139 | uint8_t DS18B20::getFamilyCode() { 140 | return selectedAddress[0]; 141 | } 142 | 143 | void DS18B20::getAddress(uint8_t address[]) { 144 | memcpy(address, selectedAddress, 8); 145 | } 146 | 147 | void DS18B20::doConversion() { 148 | sendCommand(SKIP_ROM, CONVERT_T, !globalPowerMode); 149 | delayForConversion(globalResolution, globalPowerMode); 150 | } 151 | 152 | uint8_t DS18B20::getNumberOfDevices() { 153 | return numberOfDevices; 154 | } 155 | 156 | uint8_t DS18B20::hasAlarm() { 157 | uint8_t oldResolution = selectedResolution; 158 | setResolution(9); 159 | float temp = getTempC(); 160 | setResolution(oldResolution); 161 | return ((temp <= selectedScratchpad[ALARM_LOW]) || (temp >= selectedScratchpad[ALARM_HIGH])); 162 | } 163 | 164 | void DS18B20::setAlarms(int8_t alarmLow, int8_t alarmHigh) { 165 | setAlarmLow(alarmLow); 166 | setAlarmHigh(alarmHigh); 167 | writeScratchpad(); 168 | } 169 | 170 | int8_t DS18B20::getAlarmLow() { 171 | return selectedScratchpad[ALARM_LOW]; 172 | } 173 | 174 | void DS18B20::setAlarmLow(int8_t alarmLow) { 175 | alarmLow = constrain(alarmLow, -55, 125); 176 | selectedScratchpad[ALARM_LOW] = alarmLow; 177 | writeScratchpad(); 178 | } 179 | 180 | int8_t DS18B20::getAlarmHigh() { 181 | return selectedScratchpad[ALARM_HIGH]; 182 | } 183 | 184 | void DS18B20::setAlarmHigh(int8_t alarmHigh) { 185 | alarmHigh = constrain(alarmHigh, -55, 125); 186 | selectedScratchpad[ALARM_HIGH] = alarmHigh; 187 | writeScratchpad(); 188 | } 189 | 190 | void DS18B20::setRegisters(int8_t lowRegister, int8_t highRegister) { 191 | setAlarms(lowRegister, highRegister); 192 | } 193 | 194 | int8_t DS18B20::getLowRegister() { 195 | return getAlarmLow(); 196 | } 197 | 198 | void DS18B20::setLowRegister(int8_t lowRegister) { 199 | setAlarmLow(lowRegister); 200 | } 201 | 202 | int8_t DS18B20::getHighRegister() { 203 | return getAlarmHigh(); 204 | } 205 | 206 | void DS18B20::setHighRegister(int8_t highRegister) { 207 | setAlarmHigh(highRegister); 208 | } 209 | 210 | uint8_t DS18B20::readScratchpad() { 211 | sendCommand(MATCH_ROM, READ_SCRATCHPAD); 212 | 213 | for (uint8_t i = 0; i < SIZE_SCRATCHPAD; i++) { 214 | selectedScratchpad[i] = oneWire.read(); 215 | } 216 | 217 | return OneWire::crc8(selectedScratchpad, 8) == selectedScratchpad[CRC8]; 218 | } 219 | 220 | void DS18B20::writeScratchpad() { 221 | sendCommand(MATCH_ROM, WRITE_SCRATCHPAD); 222 | oneWire.write(selectedScratchpad[ALARM_HIGH]); 223 | oneWire.write(selectedScratchpad[ALARM_LOW]); 224 | oneWire.write(selectedScratchpad[CONFIGURATION]); 225 | sendCommand(MATCH_ROM, COPY_SCRATCHPAD, !selectedPowerMode); 226 | 227 | if (!selectedPowerMode) { 228 | delay(10); 229 | } 230 | } 231 | 232 | uint8_t DS18B20::sendCommand(uint8_t romCommand) { 233 | if (!oneWire.reset()) { 234 | return 0; 235 | } 236 | 237 | switch (romCommand) { 238 | case SEARCH_ROM: 239 | case SKIP_ROM: 240 | case ALARM_SEARCH: 241 | oneWire.write(romCommand); 242 | break; 243 | case MATCH_ROM: 244 | oneWire.select(selectedAddress); 245 | break; 246 | default: 247 | return 0; 248 | } 249 | 250 | return 1; 251 | } 252 | 253 | uint8_t DS18B20::sendCommand(uint8_t romCommand, uint8_t functionCommand, uint8_t power) { 254 | if (!sendCommand(romCommand)) { 255 | return 0; 256 | } 257 | 258 | switch (functionCommand) { 259 | case CONVERT_T: 260 | case COPY_SCRATCHPAD: 261 | oneWire.write(functionCommand, power); 262 | break; 263 | case WRITE_SCRATCHPAD: 264 | case READ_SCRATCHPAD: 265 | case READ_POWER_SUPPLY: 266 | oneWire.write(functionCommand); 267 | break; 268 | default: 269 | return 0; 270 | } 271 | 272 | return 1; 273 | } 274 | 275 | uint8_t DS18B20::oneWireSearch(uint8_t romCommand) { 276 | if (lastDevice || !sendCommand(romCommand)) { 277 | resetSearch(); 278 | return 0; 279 | } 280 | 281 | uint8_t lastZero = 0; 282 | uint8_t direction, byteNumber, bitNumber, currentBit, currentBitComp; 283 | 284 | for (uint8_t bitPosition = 0; bitPosition < 64; bitPosition++) { 285 | currentBit = oneWire.read_bit(); 286 | currentBitComp = oneWire.read_bit(); 287 | 288 | if (currentBit && currentBitComp) { 289 | lastDiscrepancy = 0; 290 | return 0; 291 | } 292 | 293 | byteNumber = bitPosition / 8; 294 | bitNumber = bitPosition % 8; 295 | 296 | if (!currentBit && !currentBitComp) { 297 | if (bitPosition == lastDiscrepancy) { 298 | direction = 1; 299 | } else if (bitPosition > lastDiscrepancy) { 300 | direction = 0; 301 | lastZero = bitPosition; 302 | } else { 303 | direction = bitRead(searchAddress[byteNumber], bitNumber); 304 | 305 | if (!direction) { 306 | lastZero = bitPosition; 307 | } 308 | } 309 | } else { 310 | direction = currentBit; 311 | } 312 | 313 | bitWrite(searchAddress[byteNumber], bitNumber, direction); 314 | oneWire.write_bit(direction); 315 | } 316 | 317 | lastDiscrepancy = lastZero; 318 | 319 | if (!lastDiscrepancy) { 320 | lastDevice = 1; 321 | } 322 | 323 | return 1; 324 | } 325 | 326 | uint8_t DS18B20::isConnected(uint8_t address[]) { 327 | if (!sendCommand(SEARCH_ROM)) { 328 | return 0; 329 | } 330 | 331 | uint8_t currentBit, currentBitComp, byteNumber, bitNumber; 332 | 333 | for (uint8_t bitPosition = 0; bitPosition < 64; bitPosition++) { 334 | currentBit = oneWire.read_bit(); 335 | currentBitComp = oneWire.read_bit(); 336 | 337 | if (currentBit && currentBitComp) { 338 | return 0; 339 | } 340 | 341 | byteNumber = bitPosition / 8; 342 | bitNumber = bitPosition % 8; 343 | oneWire.write_bit(bitRead(address[byteNumber], bitNumber)); 344 | } 345 | 346 | return 1; 347 | } 348 | 349 | void DS18B20::delayForConversion(uint8_t resolution, uint8_t powerMode) { 350 | if (powerMode) { 351 | while (!oneWire.read_bit()); 352 | } else { 353 | switch (resolution) { 354 | case 9: 355 | delay(CONV_TIME_9_BIT); 356 | break; 357 | case 10: 358 | delay(CONV_TIME_10_BIT); 359 | break; 360 | case 11: 361 | delay(CONV_TIME_11_BIT); 362 | break; 363 | case 12: 364 | delay(CONV_TIME_12_BIT); 365 | break; 366 | } 367 | } 368 | } 369 | -------------------------------------------------------------------------------- /src/DS18B20.h: -------------------------------------------------------------------------------- 1 | #ifndef DS18B20_H 2 | #define DS18B20_H 3 | 4 | #include "Arduino.h" 5 | #include 6 | 7 | #define SEARCH_ROM 0xF0 8 | #define READ_ROM 0x33 9 | #define MATCH_ROM 0x55 10 | #define SKIP_ROM 0xCC 11 | #define ALARM_SEARCH 0xEC 12 | #define CONVERT_T 0x44 13 | #define WRITE_SCRATCHPAD 0x4E 14 | #define READ_SCRATCHPAD 0xBE 15 | #define COPY_SCRATCHPAD 0x48 16 | #define RECALL 0xB8 17 | #define READ_POWER_SUPPLY 0xB4 18 | #define MODEL_DS1820 0x10 19 | #define MODEL_DS18S20 0x10 20 | #define MODEL_DS1822 0x22 21 | #define MODEL_DS18B20 0x28 22 | #define SIZE_SCRATCHPAD 9 23 | #define TEMP_LSB 0 24 | #define TEMP_MSB 1 25 | #define ALARM_HIGH 2 26 | #define ALARM_LOW 3 27 | #define CONFIGURATION 4 28 | #define CRC8 8 29 | #define RES_9_BIT 0x1F 30 | #define RES_10_BIT 0x3F 31 | #define RES_11_BIT 0x5F 32 | #define RES_12_BIT 0x7F 33 | #define CONV_TIME_9_BIT 94 34 | #define CONV_TIME_10_BIT 188 35 | #define CONV_TIME_11_BIT 375 36 | #define CONV_TIME_12_BIT 750 37 | 38 | class DS18B20 { 39 | public: 40 | DS18B20(uint8_t pin); 41 | uint8_t select(uint8_t address[]); 42 | uint8_t selectNext(); 43 | uint8_t selectNextAlarm(); 44 | void resetSearch(); 45 | float getTempC(); 46 | float getTempF(); 47 | uint8_t getResolution(); 48 | void setResolution(uint8_t resolution); 49 | uint8_t getPowerMode(); 50 | uint8_t getFamilyCode(); 51 | void getAddress(uint8_t address[]); 52 | void doConversion(); 53 | uint8_t getNumberOfDevices(); 54 | uint8_t hasAlarm(); 55 | void setAlarms(int8_t alarmLow, int8_t alarmHigh); 56 | int8_t getAlarmLow(); 57 | void setAlarmLow(int8_t alarmLow); 58 | int8_t getAlarmHigh(); 59 | void setAlarmHigh(int8_t alarmHigh); 60 | void setRegisters(int8_t lowRegister, int8_t highRegister); 61 | int8_t getLowRegister(); 62 | void setLowRegister(int8_t lowRegister); 63 | int8_t getHighRegister(); 64 | void setHighRegister(int8_t highRegister); 65 | private: 66 | OneWire oneWire; 67 | uint8_t globalResolution; 68 | uint8_t globalPowerMode; 69 | uint8_t numberOfDevices; 70 | uint8_t selectedAddress[8]; 71 | uint8_t selectedScratchpad[SIZE_SCRATCHPAD]; 72 | uint8_t selectedResolution; 73 | uint8_t selectedPowerMode; 74 | uint8_t searchAddress[8]; 75 | uint8_t lastDiscrepancy; 76 | uint8_t lastDevice; 77 | uint8_t readScratchpad(); 78 | void writeScratchpad(); 79 | uint8_t sendCommand(uint8_t romCommand); 80 | uint8_t sendCommand(uint8_t romCommand, uint8_t functionCommand, uint8_t power = 0); 81 | uint8_t oneWireSearch(uint8_t romCommand); 82 | uint8_t isConnected(uint8_t address[]); 83 | void delayForConversion(uint8_t resolution, uint8_t powerMode); 84 | }; 85 | 86 | #endif 87 | --------------------------------------------------------------------------------