### Complete Setup Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

A comprehensive example illustrating the complete setup and configuration of the DallasTemperature library, including hardware definition, runtime configuration, initialization, and basic usage.

```cpp
#include <OneWire.h>
#include <DallasTemperature.h>

// Define compile-time features
#define REQUIRESALARMS true
#define REQUIRESNEW false

// Hardware configuration
#define ONE_WIRE_PIN 4
#define PULLUP_PIN 3

OneWire oneWire(ONE_WIRE_PIN);
DallasTemperature sensors(&oneWire, PULLUP_PIN);

void setup() {
  Serial.begin(9600);
  
  // Runtime configuration before begin()
  sensors.setWaitForConversion(true);      // Blocking mode
  sensors.setCheckForConversion(true);     // Polling enabled
  sensors.setAutoSaveScratchPad(true);     // Auto EEPROM save
  
  // Initialize bus and discover devices
  sensors.begin();
  
  // Set resolution for all devices
  sensors.setResolution(12);
  
  Serial.print("Initialized ");
  Serial.print(sensors.getDeviceCount());
  Serial.println(" devices");
}

void loop() {
  // Trigger temperature measurement
  sensors.requestTemperatures();
  
  // Read all devices
  for (uint8_t i = 0; i < sensors.getDeviceCount(); i++) {
    float tempC = sensors.getTempCByIndex(i);
    Serial.print("Device ");
    Serial.print(i);
    Serial.print(": ");
    Serial.print(tempC);
    Serial.println("C");
  }
  
  delay(1000);
}
```

--------------------------------

### Global Resolution Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Example demonstrating how to set the resolution for all connected temperature sensors simultaneously.

```cpp
sensors.setResolution(12);  // All devices to 12-bit
```

--------------------------------

### Per-Device Resolution Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Example showing how to set the resolution for a specific temperature sensor using its address.

```cpp
sensors.begin();
DeviceAddress sensor0;
sensors.getAddress(sensor0, 0);

// Set device 0 to 10-bit, recalculate global resolution
sensors.setResolution(sensor0, 10);

// Or set without recalculating
sensors.setResolution(sensor0, 10, true);
```

--------------------------------

### Device Detection by Library

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/DEVICES.md

Example of how the DallasTemperature library automatically detects devices during setup.

```cpp
void setup() {
  sensors.begin();  // Automatically detects:
                    // 1. Device family code
                    // 2. Valid CRC on address
                    // 3. Power supply mode (parasite/external)
                    // 4. Sensor type (DS18 vs other)
}
```

--------------------------------

### isConnected Example (with scratchpad)

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example demonstrating how to verify a device is connected and retrieve its scratchpad data.

```cpp
uint8_t scratchpad[9];
if (sensors.isConnected(addr, scratchpad)) {
  Serial.print("Temperature raw: ");
  Serial.println((scratchpad[1] << 8) | scratchpad[0]);
}
```

--------------------------------

### blockTillConversionComplete (resolution, start) Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example of blocking until conversion completes with a timeout, using a starting timestamp.

```cpp
sensors.setWaitForConversion(false);
request_t req = sensors.requestTemperatures();
sensors.blockTillConversionComplete(12, req.timestamp);
```

--------------------------------

### isConversionComplete Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example of using isConversionComplete() to wait for temperature conversion to finish.

```cpp
sensors.requestTemperatures();
while (!sensors.isConversionComplete()) {
  yield();
}
float temp = sensors.getTempCByIndex(0);
```

--------------------------------

### DeviceAddress Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/types.md

Example demonstrating how to obtain and use a DeviceAddress to retrieve temperature readings.

```cpp
DeviceAddress sensor0;
if (sensors.getAddress(sensor0, 0)) {
  // sensor0[0] is family code
  // sensor0[1-6] is serial number
  // sensor0[7] is CRC checksum
  float temp = sensors.getTempC(sensor0);
}
```

--------------------------------

### AlarmHandler Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/types.md

Example demonstrating how to define and register a custom AlarmHandler function.

```cpp
void myAlarmHandler(const uint8_t* deviceAddress) {
  Serial.print("Alarm triggered on device: ");
  for (int i = 0; i < 8; i++) {
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
  Serial.println();
}

sensors.setAlarmHandler(&myAlarmHandler);
sensors.processAlarms();  // Calls myAlarmHandler for each alarming device
```

--------------------------------

### isConnected Example (without scratchpad)

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example demonstrating how to verify if a device is accessible and responding on the bus.

```cpp
if (sensors.isConnected(addr)) {
  Serial.println("Device is connected and responding");
}
```

--------------------------------

### getWaitForConversion Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example showing how to check if blocking mode is enabled for temperature conversions.

```cpp
if (sensors.getWaitForConversion()) {
  Serial.println("Blocking mode enabled");
}
```

--------------------------------

### begin() Initialization Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Demonstrates setting configuration parameters before calling begin() and the initialization process.

```cpp
void begin(void)

```

```cpp
OneWire oneWire(4);
DallasTemperature sensors(&oneWire);

void setup() {
  Serial.begin(9600);
  
  // Configure before begin()
  sensors.setWaitForConversion(true);
  sensors.setCheckForConversion(true);
  sensors.setAutoSaveScratchPad(true);
  
  // Initialize
  sensors.begin();
  
  Serial.print("Found ");
  Serial.print(sensors.getDeviceCount());
  Serial.println(" devices");
}

```

--------------------------------

### setWaitForConversion Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example demonstrating how to disable blocking during temperature conversion and manage the delay manually.

```cpp
sensors.setWaitForConversion(false);
request_t req = sensors.requestTemperatures();
// Do other work...
delay(800);
float temp = sensors.getTempCByIndex(0);
```

--------------------------------

### getAddress Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example demonstrating how to retrieve the 8-byte address of a device by its index.

```cpp
DeviceAddress addr;
if (sensors.getAddress(addr, 0)) {
  Serial.print("Device 0: ");
  for (uint8_t i = 0; i < 8; i++) {
    Serial.print(addr[i], HEX);
  }
}
```

--------------------------------

### Usage Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example demonstrating how to use the request_t structure to check the success of a temperature request and proceed.

```cpp
request_t req = sensors.requestTemperatures();
if (req) {
  // Request successful
  sensors.blockTillConversionComplete(12, req);
}
```

--------------------------------

### Basic Usage Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/README.md

This code example demonstrates how to include the necessary libraries, initialize the sensor, and read temperature in Celsius.

```cpp
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is connected to GPIO 4
#define ONE_WIRE_BUS 4

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

void setup(void) {
  Serial.begin(9600);
  sensors.begin();
}

void loop(void) {
   sensors.requestTemperatures(); 

   delay(750); 

   float tempC = sensors.getTempCByIndex(0);
   Serial.print("Temperature: ");
   Serial.print(tempC);
   Serial.println("°C");
   delay(1000);
}
```

--------------------------------

### getCheckForConversion Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example demonstrating how to check if polling for conversion completion is enabled.

```cpp
bool polling = sensors.getCheckForConversion();
```

--------------------------------

### setPullupPin Example Configuration

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Shows how to configure an external pull-up pin for parasite power control.

```cpp
void setPullupPin(uint8_t pullupPin)
```

```cpp
OneWire oneWire(2);
DallasTemperature sensors(&oneWire, 3);  // Pin 3 controls pullup
sensors.begin();

// Or set later:
DallasTemperature sensors(&oneWire);
sensors.setPullupPin(3);
sensors.begin();

```

--------------------------------

### setAutoSaveScratchPad Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Demonstrates how to control automatic EEPROM saving after scratchpad writes.

```cpp
void setAutoSaveScratchPad(bool flag)
```

```cpp
sensors.setAutoSaveScratchPad(true);
sensors.setHighAlarmTemp(addr, 30);    // Automatically saved to EEPROM

```

```cpp
sensors.setAutoSaveScratchPad(false);
sensors.setHighAlarmTemp(addr, 30);    // Not saved yet
// ... perform multiple operations ...
sensors.saveScratchPad(addr);           // Save once when done

```

--------------------------------

### requestTemperatures Synchronous Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example of synchronously requesting temperature measurements from all devices.

```cpp
// Synchronous (blocks)
sensors.requestTemperatures();
float temp = sensors.getTempCByIndex(0);
Serial.println(temp);
```

--------------------------------

### validAddress Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example demonstrating how to verify if a device address has a valid CRC.

```cpp
DeviceAddress addr = {0x28, 0xFF, 0x1, 0x2, 0x3, 0x4, 0x5, 0xAB};
if (sensors.validAddress(addr)) {
  Serial.println("Valid address");
}
```

--------------------------------

### Resolution Settings

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Example of setting the resolution for all connected temperature sensors.

```cpp
sensors.setResolution(10);  // Set all devices to 10-bit
```

--------------------------------

### request_t Asynchronous Usage Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/types.md

Example demonstrating asynchronous temperature measurement workflow using request_t and blockTillConversionComplete().

```cpp
sensors.setWaitForConversion(false);  // Non-blocking mode
request_t req = sensors.requestTemperatures();

// Do other work while conversion happens
delay(500);

// Wait for completion using the request object
sensors.blockTillConversionComplete(12, req);
float temp = sensors.getTempCByIndex(0);
```

--------------------------------

### validFamily Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example demonstrating how to check if a device address belongs to a supported family.

```cpp
if (sensors.validFamily(addr)) {
  Serial.println("Supported temperature sensor");
}
```

--------------------------------

### blockTillConversionComplete (resolution) Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example of blocking until temperature conversion completes using a specified bit resolution.

```cpp
sensors.requestTemperatures();
sensors.blockTillConversionComplete(12);  // Max delay for 12-bit
```

--------------------------------

### request_t Synchronous Usage Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/types.md

Example of synchronous usage of requestTemperatures(), checking the result before proceeding.

```cpp
request_t req = sensors.requestTemperatures();
if (req.result) {
  Serial.println("Conversion request sent");
  float temp = sensors.getTempCByIndex(0);
}
```

--------------------------------

### setWaitForConversion Asynchronous Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Example demonstrating asynchronous behavior where requestTemperatures() returns immediately, requiring a manual delay before reading temperature.

```cpp
sensors.setWaitForConversion(false);
request_t req = sensors.requestTemperatures();
// Do other work...
delay(800);  // Manual delay
float temp = sensors.getTempCByIndex(0);
```

--------------------------------

### Boolean Method Examples

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/errors.md

Examples demonstrating the usage of boolean methods like isConnected() and getAddress(), and error checking for readScratchPad().

```cpp
if (sensors.isConnected(addr)) { ... }           // Device is responding
if (sensors.getAddress(addr, 0)) { ... }         // Address found
if (!sensors.readScratchPad(addr, sp)) { ... }   // Bus error
```

--------------------------------

### setWaitForConversion Synchronous Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Example demonstrating the default synchronous behavior of requestTemperatures() where the function blocks until conversion is complete.

```cpp
sensors.setWaitForConversion(true);  // Default
sensors.requestTemperatures();        // Blocks ~750ms for 12-bit
float temp = sensors.getTempCByIndex(0);
```

--------------------------------

### requestTemperatures Asynchronous Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example of asynchronously requesting temperature measurements and handling the result later.

```cpp
// Asynchronous (non-blocking)
sensors.setWaitForConversion(false);
request_t req = sensors.requestTemperatures();
delay(800);  // Manual delay
float temp = sensors.getTempCByIndex(0);
```

--------------------------------

### request_t Manual Timeout Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/types.md

Example showing how to implement a manual timeout for a temperature conversion request using the request_t timestamp.

```cpp
request_t req = sensors.requestTemperaturesByIndex(0);
if (req.result) {
  unsigned long deadline = req.timestamp + 800;  // 800ms timeout
  while (millis() < deadline) {
    if (!sensors.isConversionComplete()) {
      yield();
    }
  }
}
```

--------------------------------

### Alarm Usage Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Demonstrates how to set high and low alarm thresholds and check if an alarm condition is met.

```cpp
// Setup alarm thresholds
sensors.setHighAlarmTemp(addr, 30);   // Alert if > 30°C
sensors.setLowAlarmTemp(addr, 15);    // Alert if < 15°C

// Read measurements
sensors.requestTemperatures();

// Check for alarm
if (sensors.hasAlarm(addr)) {
  Serial.println("ALERT!");
  float temp = sensors.getTempC(addr);
  Serial.println(temp);
}
```

--------------------------------

### blockTillConversionComplete (resolution, request_t) Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example of using the convenience overload for blocking until conversion completes with a request_t struct.

```cpp
sensors.setWaitForConversion(false);
request_t req = sensors.requestTemperatures();
// Do work...
sensors.blockTillConversionComplete(12, req);
```

--------------------------------

### setCheckForConversion Polling Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Example for non-parasite mode using setCheckForConversion(true) to poll the DQ line for conversion completion.

```cpp
sensors.setCheckForConversion(true);   // Poll DQ line
sensors.setWaitForConversion(true);
sensors.requestTemperatures();          // Returns when conversion done
```

--------------------------------

### setCheckForConversion Fixed Delay Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Example for parasite mode using setCheckForConversion(false) to rely on fixed delays for conversion completion.

```cpp
sensors.setCheckForConversion(false);  // Use fixed delays
sensors.setWaitForConversion(true);
sensors.requestTemperatures();          // Waits full duration
```

--------------------------------

### External Power Configuration

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Basic setup for the DallasTemperature library when using external power for the sensor.

```cpp
DallasTemperature sensors(&oneWire);
sensors.begin();
```

--------------------------------

### setCheckForConversion Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Example of disabling per-bit polling for conversion completion and using fixed delays instead.

```cpp
sensors.setCheckForConversion(false);  // Use fixed delays instead
```

--------------------------------

### processAlarms() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Demonstrates how to register an alarm handler and then process alarms. The `onAlarm` function is called for each device that has an alarm condition.

```cpp
void onAlarm(const uint8_t* addr) {
  Serial.print("Alarm on device: ");
  for (int i = 0; i < 8; i++) {
    Serial.print(addr[i], HEX);
  }
}

sensors.setAlarmHandler(&onAlarm);
sensors.processAlarms();  // Calls onAlarm() for each alarming device
```

--------------------------------

### Multiple Sensors

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

This example shows how to detect and read temperatures from multiple DS18B20 sensors connected to the same bus.

```cpp
void setup() {
  sensors.begin();
  
  uint8_t count = sensors.getDeviceCount();
  Serial.print("Found ");
  Serial.print(count);
  Serial.println(" sensors");
}

void loop() {
  sensors.requestTemperatures();
  
  for (uint8_t i = 0; i < sensors.getDeviceCount(); i++) {
    float temp = sensors.getTempCByIndex(i);
    Serial.print("Sensor ");
    Serial.print(i);
    Serial.print(": ");
    Serial.println(temp);
  }
  
  delay(1000);
}
```

--------------------------------

### resetAlarmSearch() and alarmSearch() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Demonstrates how to reset the alarm search state and then iterate through all devices that have an alarm condition.

```cpp
DeviceAddress alarmAddr;
sensors.resetAlarmSearch();
while (sensors.alarmSearch(alarmAddr)) {
  Serial.print("Alarm device: ");
  for (uint8_t i = 0; i < 8; i++) {
    Serial.print(alarmAddr[i], HEX);
  }
}
```

--------------------------------

### Reading and Interpreting ScratchPad Data

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/types.md

Example demonstrating how to read the scratchpad from a device, extract temperature, alarm thresholds, configuration, and verify the CRC.

```cpp
uint8_t scratchpad[9];
sensors.readScratchPad(addr, scratchpad);

// Extract temperature raw value
int16_t tempRaw = (scratchpad[1] << 8) | scratchpad[0];

// Extract alarm thresholds
int8_t highAlarm = (int8_t)scratchpad[2];
int8_t lowAlarm = (int8_t)scratchpad[3];

// Extract configuration
uint8_t config = scratchpad[4];
uint8_t resolution = (config >> 6) & 0x3;  // Get resolution bits

// Verify integrity
if (scratchpad[8] == OneWire::crc8(scratchpad, 8)) {
  Serial.println("Scratchpad CRC valid");
}
```

--------------------------------

### getResolution()

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Get the current global bit resolution.

```cpp
uint8_t getResolution()
```

```cpp
uint8_t res = sensors.getResolution();
Serial.println(res);
```

--------------------------------

### Parasite Power Configuration

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Setup for the DallasTemperature library when using parasite power, including control for the strong pullup.

```cpp
// With external pullup control
DallasTemperature sensors(&oneWire, 3);  // Pin 3 controls strong pullup
sensors.begin();
```

--------------------------------

### Family Code Reference

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/DEVICES.md

Example code to determine the device family code from its address.

```cpp
DeviceAddress addr;
sensors.getAddress(addr, 0);

switch (addr[0]) {
  case 0x10:  // DS18S20 / DS1820
    Serial.println("DS18S20 (9-bit fixed)");
    break;
  case 0x22:  // DS1822
    Serial.println("DS1822");
    break;
  case 0x28:  // DS18B20 / MAX31820
    Serial.println("DS18B20");
    break;
  case 0x3B:  // DS1825 / MAX31850
    Serial.println("DS1825 (Thermocouple)");
    break;
  case 0x42:  // DS28EA00
    Serial.println("DS28EA00 (Daisy-chain)");
    break;
  default:
    Serial.println("Unknown device");
}
```

--------------------------------

### millisToWaitForConversion()

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Get conversion time for current global resolution.

```cpp
uint16_t millisToWaitForConversion()
```

```cpp
uint16_t delayMs = sensors.millisToWaitForConversion();
```

--------------------------------

### getLowAlarmTemp Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Reads the low alarm threshold for a specific device. Returns the threshold in °C.

```cpp
int8_t lowAlarm = sensors.getLowAlarmTemp(addr);
```

--------------------------------

### getResolution(const uint8_t*)

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Get the bit resolution of a specific device.

```cpp
uint8_t getResolution(const uint8_t* deviceAddress)
```

```cpp
uint8_t res = sensors.getResolution(addr);
if (res > 0) {
  Serial.print("Device resolution: ");
  Serial.println(res);
}
```

--------------------------------

### getUserDataByIndex() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Retrieves a 16-bit user data value for a device specified by its index, combining the functionality of `getAddress()` and `getUserData()`.

```cpp
int16_t data = sensors.getUserDataByIndex(0);
```

--------------------------------

### Extended Resolution Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/DEVICES.md

Demonstrates how the DallasTemperature library automatically handles the calculation of higher precision temperature readings for the DS18S20 sensor using its COUNT_REMAIN and COUNT_PER_C registers.

```cpp
// DS18S20 can be read with higher precision
// using COUNT_REMAIN and COUNT_PER_C registers
// The library handles this automatically in calculateTemperature()
float tempC = sensors.getTempC(ds18s20_addr);  // High precision result
```

--------------------------------

### hasAlarmHandler() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Checks if an alarm handler has been registered. If one exists, `processAlarms()` is called.

```cpp
if (sensors.hasAlarmHandler()) {
  sensors.processAlarms();
}
```

--------------------------------

### Error Sentinels

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Example of checking for a disconnected device using the DEVICE_DISCONNECTED_C sentinel value.

```cpp
float temp = sensors.getTempC(addr);
if (temp == DEVICE_DISCONNECTED_C) {
  Serial.println("Device error");
} else {
  Serial.println(temp);
}
```

--------------------------------

### setUserDataByIndex() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

A convenience method to store a 16-bit user data value for a device identified by its index in the discovered device list.

```cpp
sensors.setUserDataByIndex(0, 5000);
```

--------------------------------

### getHighAlarmTemp Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Reads the high alarm threshold for a specific device. Returns the threshold in °C or DEVICE_DISCONNECTED_C if the device is not connected.

```cpp
int8_t highAlarm = sensors.getHighAlarmTemp(addr);
Serial.print("High alarm: ");
Serial.println(highAlarm);
```

--------------------------------

### setResolution() Returns false

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/errors.md

Example of checking the return value of setResolution() to detect configuration issues.

```cpp
if (!sensors.setResolution(addr, 12)) {
  Serial.println("Unable to configure resolution");
}
```

--------------------------------

### toFahrenheit() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Converts a temperature value from Celsius to Fahrenheit using the formula °F = °C × 1.8 + 32.

```cpp
float tempC = 20.5;
float tempF = DallasTemperature::toFahrenheit(tempC);
```

--------------------------------

### hasAlarm(deviceAddress) Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Checks if a specific device has triggered its alarm condition (temperature outside the set thresholds).

```cpp
sensors.requestTemperatures();
if (sensors.hasAlarm(addr)) {
  Serial.println("Alarm condition detected!");
}
```

--------------------------------

### getUserData() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Retrieves a 16-bit user data value previously stored in the device's scratchpad memory. The value is reconstructed from the HIGH_ALARM_TEMP (MSB) and LOW_ALARM_TEMP (LSB) registers.

```cpp
int16_t data = sensors.getUserData(addr);
Serial.println(data);
```

--------------------------------

### Solution: Always initialize the bus

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Shows the correct way to initialize the sensor bus by calling begin() before reading temperatures.

```cpp
// Correct
sensors.begin();
float temp = sensors.getTempCByIndex(0);
```

--------------------------------

### setUserData() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Stores an arbitrary 16-bit value into the device's scratchpad memory, utilizing the HIGH_ALARM_TEMP and LOW_ALARM_TEMP registers. Auto-saving to EEPROM is enabled if `setAutoSaveScratchPad(true)` has been called.

```cpp
sensors.setUserData(addr, 1000);  // Store arbitrary 16-bit value
```

--------------------------------

### hasAlarm() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Checks if any device on the bus has an alarm condition. Performs an alarm search and returns true if at least one device is in alarm.

```cpp
if (sensors.hasAlarm()) {
  Serial.println("At least one device in alarm");
}
```

--------------------------------

### begin() Method

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Searches the 1-Wire bus for connected devices, validates their addresses, counts total and DS18-family devices, and determines if parasite power mode is in use.

```cpp
sensors.begin();
uint8_t deviceCount = sensors.getDeviceCount();
Serial.println(deviceCount);  // Prints number of devices
```

--------------------------------

### setAlarmHandler() Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Registers a callback function (`alarmCallback`) to be invoked when an alarm condition is detected on a device. The callback receives the device's address.

```cpp
void alarmCallback(const uint8_t* deviceAddress) {
  Serial.print("Alarm detected on: ");
  for (int i = 0; i < 8; i++) {
    Serial.print(deviceAddress[i], HEX);
  }
}

sensors.setAlarmHandler(&alarmCallback);
```

--------------------------------

### Resetting to Factory Defaults

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Demonstrates how to reset all configuration settings to their factory defaults by re-initializing the OneWire instance.

```cpp
sensors.setOneWire(&newOneWire);  // Resets all state variables
```

--------------------------------

### Solution: Wait long enough

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Provides the correct approach by ensuring sufficient time is allowed for temperature conversion, especially in blocking mode.

```cpp
// Correct (12-bit takes ~750ms)
sensors.requestTemperatures();  // Already waits if blocking enabled
float temp = sensors.getTempCByIndex(0);
```

--------------------------------

### DallasTemperature Constructor Options

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Illustrates different ways to construct the DallasTemperature object.

```cpp
DallasTemperature sensors;

```

```cpp
DallasTemperature sensors(&oneWire);

```

```cpp
DallasTemperature sensors(&oneWire, 3);

```

--------------------------------

### Pitfall: Forgetting to call begin()

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Illustrates the incorrect usage of not calling the begin() method before attempting to read sensor data.

```cpp
// Wrong
DallasTemperature sensors(&oneWire);
float temp = sensors.getTempCByIndex(0);  // Returns error
```

--------------------------------

### Compile-Time Features

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Configuration options available in the DallasTemperature.h header file.

```cpp
#define REQUIRESALARMS true   // Include alarm methods (default)
#define REQUIRESNEW false     // Custom new/delete operators
```

--------------------------------

### File Organization

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/README.md

The directory structure for the Arduino Temperature Control Library.

```bash
output/
├── README.md                              ← This file
├── INDEX.md                               ← Master index & navigation
├── QUICK_REFERENCE.md                     ← Quick start & essentials
├── DEVICES.md                             ← Device specifications
├── api-reference/
│   └── DallasTemperature.md               ← Complete class API
├── types.md                               ← Type definitions
├── errors.md                              ← Error codes & faults
└── configuration.md                       ← Config options & defaults

```

--------------------------------

### Solution: Always validate

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

Shows the correct practice of checking the returned temperature against error sentinels before using or printing the value.

```cpp
// Correct
float temp = sensors.getTempC(addr);
if (temp != DEVICE_DISCONNECTED_C) {
  Serial.println(temp);
}
```

--------------------------------

### setOneWire(OneWire*) Method

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Replaces the current OneWire instance and resets device count. Call begin() after this method to search for devices.

```cpp
OneWire oneWire(4);
sensors.setOneWire(&oneWire);
sensors.begin();
```

--------------------------------

### Basic Temperature Reading

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/QUICK_REFERENCE.md

This code snippet demonstrates how to include the necessary libraries, initialize the sensor, and read the temperature from the first sensor found on the bus in Celsius.

```cpp
#include <OneWire.h>
#include <DallasTemperature.h>

OneWire oneWire(4);                    // Data wire on pin 4
DallasTemperature sensors(&oneWire);

void setup() {
  Serial.begin(9600);
  sensors.begin();                      // Find devices on bus
}

void loop() {
  sensors.requestTemperatures();        // Measure temperature
  float tempC = sensors.getTempCByIndex(0);
  Serial.println(tempC);
  delay(1000);
}
```

--------------------------------

### millisToWaitForConversion(uint8_t)

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Get the maximum conversion time for a given resolution.

```cpp
static uint16_t millisToWaitForConversion(uint8_t bitResolution)
```

```cpp
uint16_t delayMs = DallasTemperature::millisToWaitForConversion(12);
Serial.println(delayMs);  // Prints: 750
```

--------------------------------

### REQUIRESALARMS Preprocessor Define

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Example of how to define REQUIRESALARMS to false in DallasTemperature.h to disable alarm functionality.

```cpp
#ifndef REQUIRESALARMS
#define REQUIRESALARMS true
#endif
```

```cpp
#define REQUIRESALARMS false
#include <DallasTemperature.h>
```

--------------------------------

### recallScratchPad() Returns false

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/errors.md

Example of checking the return value of recallScratchPad() to detect a timeout.

```cpp
#include <OneWire.h>
#include <DallasTemperature.h>

OneWire oneWire(4);
DallasTemperature sensors(&oneWire);

void setup() {
  Serial.begin(9600);
  sensors.begin();
}

void loop() {
  sensors.requestTemperatures();
  
  for (uint8_t i = 0; i < sensors.getDeviceCount(); i++) {
    DeviceAddress addr;
    if (!sensors.getAddress(addr, i)) {
      Serial.println("Address lookup failed");
      continue;
    }
    
    float tempC = sensors.getTempC(addr);
    
    // Check for specific faults
    if (tempC == DEVICE_DISCONNECTED_C) {
      Serial.println("Device disconnected");
    } 
    else if (tempC == DEVICE_FAULT_OPEN_C) {
      Serial.println("Thermocouple open");
    }
    else if (tempC == DEVICE_FAULT_SHORTGND_C) {
      Serial.println("Thermocouple shorted to ground");
    }
    else if (tempC == DEVICE_FAULT_SHORTVDD_C) {
      Serial.println("Thermocouple shorted to supply");
    }
    else if (tempC == DEVICE_POWER_ON_RESET_C) {
      Serial.println("Device power-on reset - needs initialization");
    }
    else if (tempC == DEVICE_INSUFFICIENT_POWER_C) {
      Serial.println("Insufficient power - check power supply");
    }
    else {
      // Valid temperature reading
      Serial.print("Temperature: ");
      Serial.print(tempC);
      Serial.println("C");
    }
  }
  
  delay(1000);
}
```

--------------------------------

### REQUIRESNEW Preprocessor Define

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Example of how to define REQUIRESNEW to true in DallasTemperature.h to enable custom memory operators.

```cpp
#ifndef REQUIRESNEW
#define REQUIRESNEW false
#endif
```

```cpp
#define REQUIRESNEW true
#include <DallasTemperature.h>

void setup() {
  // Now you can use new/delete
  DallasTemperature* sensors = new DallasTemperature(&oneWire);
  sensors->begin();
  // ... use sensors ...
  delete sensors;
}
```

--------------------------------

### request_t Operator Overload Example

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/types.md

Illustrates the usage of the overloaded operator bool() for implicit casting of request_t objects.

```cpp
request_t req = sensors.requestTemperatures();
if (req) {  // Equivalent to: if (req.result)
  // Process request
}
```

--------------------------------

### Configuration for DS1825

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/DEVICES.md

Example of setting resolution for DS1825, which automatically handles the MODE bit for thermocouple operations.

```cpp
// DS1825 detection in resolution
uint8_t resolution = sensors.getResolution(addr);
// Automatically handles MODE bit for thermocouple

// Writing configuration
bool success = sensors.setResolution(addr, 12);
// Preserves thermocouple MODE bit
```

--------------------------------

### Overriding Constant Parameters

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/configuration.md

Shows how to override default constant parameters by defining them before including the library.

```cpp
#define MAX_CONVERSION_TIMEOUT 1000
#define MAX_INITIALIZATION_RETRIES 5
#define INITIALIZATION_DELAY_MS 100

#include <DallasTemperature.h>

```

--------------------------------

### DEVICE_FAULT_SHORTVDD_C Definition and Catch

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/errors.md

Defines the error code for a thermocouple shorted to VDD and provides an example of how to check for this condition.

```cpp
#define DEVICE_FAULT_SHORTVDD_C -252
```

```cpp
float temp = sensors.getTempC(addr);
if (temp == DEVICE_FAULT_SHORTVDD_C) {
  Serial.println("Thermocouple shorted to Vdd");
}
```

--------------------------------

### DallasTemperature(OneWire*, uint8_t) Constructor

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Initializes DallasTemperature with a OneWire instance and configures an external pullup pin for parasite power control.

```cpp
OneWire oneWire(2);
DallasTemperature sensors(&oneWire, 3);  // Pin 3 controls external pullup
sensors.begin();
```

--------------------------------

### recallScratchPad

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Loads EEPROM data back into the scratchpad. Waits up to 20ms for the operation to complete.

```cpp
bool recallScratchPad(const uint8_t* deviceAddress = nullptr)
```cpp
sensors.recallScratchPad(addr);
float tempC = sensors.getTempC(addr);
```
```

--------------------------------

### DEVICE_INSUFFICIENT_POWER_C Definition and Catch

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/errors.md

Defines the error code for insufficient power and provides an example of how to check for it and potential recovery steps.

```cpp
#define DEVICE_INSUFFICIENT_POWER_C -250
```

```cpp
float temp = sensors.getTempC(addr);
if (temp == DEVICE_INSUFFICIENT_POWER_C) {
  Serial.println("Voltage too low - check power supply");
  // For parasite power: check/strengthen pullup
  // For external power: verify power supply voltage
}
```

--------------------------------

### DEVICE_POWER_ON_RESET_C Definition and Catch

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/errors.md

Defines the error code for a device power-on reset and provides an example of how to handle it by triggering a temperature conversion.

```cpp
#define DEVICE_POWER_ON_RESET_C -251
```

```cpp
float temp = sensors.getTempC(addr);
if (temp == DEVICE_POWER_ON_RESET_C) {
  Serial.println("Device needs initialization");
  sensors.requestTemperatures();  // Trigger first conversion
  delay(750);
  temp = sensors.getTempC(addr);
}
```

--------------------------------

### getDeviceCount() Method

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Returns the count of all devices found during the last begin() call, including non-DS18-family devices.

```cpp
sensors.begin();
uint8_t count = sensors.getDeviceCount();
Serial.print("Found ");
Serial.print(count);
Serial.println(" devices");
```

--------------------------------

### saveScratchPad

Source: https://github.com/milesburton/arduino-temperature-control-library/blob/master/_autodocs/api-reference/DallasTemperature.md

Copies the scratchpad to EEPROM on a device. Uses strong pullup if needed, with a 20ms delay.

```cpp
bool saveScratchPad(const uint8_t* deviceAddress = nullptr)
```cpp
sensors.writeScratchPad(addr, scratchpad);
sensors.saveScratchPad(addr);
```
```