OW Archives | ArunEworld

“One Wire” refers to a communication protocol developed by Dallas Semiconductor (now Maxim Integrated) that allows multiple devices to communicate over a singleWire using a master-slave architecture. It enables bidirectional communication and power delivery over a singleWire, simplifying wiring and reducing hardware complexity in certain applications.

The protocol operates by sending and receiving data serially using a singleWire, which also serves as a ground reference. Each device on the One Wire network has a unique 64-bit address, allowing the master device to identify and communicate with individual slaves. Additionally, One Wire devices can be powered directly from the data line, eliminating the need for separate power connections in some cases.

One Wire is commonly used in applications where minimizing wiring and hardware complexity is essential, such as temperature sensing, identification (e.g., RFID tags), and small-scale data logging. It’s particularly popular in applications where running multiple wires is impractical or cost-prohibitive, such as in distributed sensor networks or in situations where space is limited.

Overall, One Wire offers a simple and cost-effective solution for connecting multiple devices over a single wire, making it a valuable tool in various embedded systems and IoT applications.

Above image link
This protocol is serial communication protocol
Its developed by Dallas Semiconductor.

Component	Description
ESP32 Microcontroller	A powerful microcontroller with built-in Wi-Fi and Bluetooth capabilities.
DS18B20 Temperature Sensors	Digital temperature sensors manufactured by Maxim Integrated, known for high accuracy readings.
OneWire Library	Provides functions for communication over the OneWire bus, essential for interfacing with DS18B20 sensors.
DallasTemperature Library	Simplifies communication with DS18B20 sensors by providing high-level functions and features.

Code

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

#define ONE_WIRE_BUS 22
#define TEMPERATURE_PRECISION 12 // Lower resolution

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

int numberOfDevices;
DeviceAddress tempDeviceAddress;

void setup(void) {
  Serial.begin(115200);
  Serial.println("Dallas Temperature IC Control Library Demo");
  sensors.begin();
  numberOfDevices = sensors.getDeviceCount();
  Serial.print("Locating devices...");
  Serial.print("Found ");
  Serial.print(numberOfDevices, DEC);
  Serial.println(" devices.");
  Serial.print("Parasite power is: ");
  if (sensors.isParasitePowerMode()) Serial.println("ON");
  else Serial.println("OFF");
  for(int i=0;i<numberOfDevices; i++) {
    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);
      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");
    }
  }
  delay(5000);
}

void printTemperature(DeviceAddress deviceAddress) {
  float tempC = sensors.getTempC(deviceAddress);
  Serial.print("Temp C: ");
  Serial.println(tempC);
  Serial.print("Temp F: ");
  Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
}

void loop(void) { 
  Serial.print("Requesting temperatures...");
  sensors.requestTemperatures();
  Serial.println("DONE");
  for(int i=0;i<numberOfDevices; i++) {
    if(sensors.getAddress(tempDeviceAddress, i)) {
      Serial.print("Temperature for device: ");
      Serial.println(i,DEC);
      printTemperature(tempDeviceAddress);
      delay(3000);
    }
  }
}

void printAddress(DeviceAddress deviceAddress) {
  for (uint8_t i = 0; i < 8; i++) {
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
}

Code Explanation

Code Section	Explanation
`#include <OneWire.h>`	Includes the OneWire library for communication with devices using the OneWire protocol.
`#include <DallasTemperature.h>`	Includes the Dallas Temperature library for interfacing with Dallas/Maxim temperature ICs.
`#define ONE_WIRE_BUS 22`	Defines the GPIO pin (pin 22) where the OneWire data wire is connected to the ESP32.
`#define TEMPERATURE_PRECISION 12`	Defines the resolution for temperature readings (12 bits for lower resolution).
`OneWire oneWire(ONE_WIRE_BUS);`	Initializes a OneWire object with the specified GPIO pin.
`DallasTemperature sensors(&oneWire);`	Initializes a DallasTemperature object using the previously created OneWire object.
`int numberOfDevices;`	Declares a variable to store the number of temperature devices found on the bus.
`DeviceAddress tempDeviceAddress;`	Declares a variable to store the address of a found temperature device.
`void setup(void)`	Begins the setup function, which is called once when the program starts. Initializes serial communication and the sensor library.
`Serial.begin(115200);`	Starts serial communication with a baud rate of 115200.
`sensors.begin();`	Initializes the Dallas Temperature library.
`numberOfDevices = sensors.getDeviceCount();`	Retrieves the number of temperature devices found on the OneWire bus.
`for(int i=0;i<numberOfDevices; i++)`	Loops through each temperature device found on the bus.
`sensors.getAddress(tempDeviceAddress, i)`	Retrieves the address of the i-th device and stores it in `tempDeviceAddress`.
`sensors.setResolution(tempDeviceAddress, TEMPERATURE_PRECISION);`	Sets the resolution of the temperature device to the defined precision.
`void printTemperature(DeviceAddress deviceAddress)`	Declares a function to print the temperature of a device with the given address.
`void loop(void)`	Begins the loop function, which runs continuously after setup.
`sensors.requestTemperatures();`	Requests temperature readings from all connected devices on the bus.
`for(int i=0;i<numberOfDevices; i++)`	Loops through each temperature device found on the bus.
`printTemperature(tempDeviceAddress);`	Prints the temperature of the i-th device.
`void printAddress(DeviceAddress deviceAddress)`	Declares a function to print the address of a device.

Functionality of

Initialization: The interface initializes the OneWire communication by defining the GPIO pin to which the OneWire data wire is connected. It also initializes the DallasTemperature library, which simplifies communication with DS18B20 sensors.
Device Detection: Upon initialization, the interface detects the number of DS18B20 sensors connected to the OneWire bus. It retrieves the unique address of each sensor and sets their resolution if detected.
Temperature Reading: The interface periodically requests temperature readings from all connected DS18B20 sensors. It then retrieves the temperature data and converts it to Celsius and Fahrenheit scales for further processing or display.

Arduino-Core Get Start (Soon)

ESP32 Arduino Core Interface

ArduinoCore Interface Basics

ArduinoCore Interface WiFi

ArduinoCore Interface – LED

ArduinoCore Interface ADC

ArduinoCore Interface DS18B20

ESP32 Arduino Core Projects

ArduinoCore Project – WebServer

Others

Arduino-Core Sitemap

Arduino-Core All Post