ESP32 DS18B20 Temperature Sensor With Arduino IDE (Single, Multiple, Web Server) - Random Nerd Tutorials

22/3/2021 ESP32 DS18B20 Temperature Sensor with Arduino IDE (Single, Multiple, Web Server) | Random Nerd Tutorials
 Menu 
ESP32 DS18B20 Temperature Sensor with Arduino

IDE (Single, Multiple, Web Server)
This is a in-depth guide for the DS18B20 temperature sensor with ESP32 using
Arduino IDE. We’ll show you how to wire the sensor, install the required libraries,
and write the code to get the sensor readings from one and multiple sensors.
Finally, we’ll build a simple web server to display the sensor readings.
You might also like reading other DS18B20 guides:
ESP8266 DS18B20 Temperature Sensor with Arduino IDE

ESP32/ESP8266 DS18B20 Temperature Sensor with MicroPython
ESP32 with Multiple DS18B20 Temperature Sensors
DS18B20 Temperature Sensor with Arduino
Introducing DS18B20 Temperature Sensor
https://randomnerdtutorials.com/esp32-ds18b20-temperature-arduino-ide/?fbclid=IwAR1s6pcDKTPkJk0rpJIu2hik00LcV4-NVzRq2ekG0a9cfpKc9Zs2t… 1/50
The DS18B20 temperature sensor is a one-wire digital temperature sensor. This

means that it just requires one data line (and GND) to communicate with your
ESP32.
It can be powered by an external power supply or it can derive power from the
data line (called “parasite mode”), which eliminates the need for an external
power supply.
Each DS18B20 temperature sensor has a unique 64-bit serial code. This allows
you to wire multiple sensors to the same data wire. So, you can get temperature
from multiple sensors using just one GPIO.
The DS18B20 temperature sensor is also available in waterproof version.
Here’s a summary of the most relevant specs of the DS18B20 temperature

sensor:
Communicates over one-wire bus communication

Power supply range: 3.0V to 5.5V
Operating temperature range: -55ºC to +125ºC
Accuracy +/-0.5 ºC (between the range -10ºC to 85ºC)
For more information consult the DS18B20 datasheet.
Parts Required
To follow this tutorial you need the following parts:
ESP32 (read Best ESP32 development boards)

DS18B20 temperature sensor (one or multiple sensors) – waterproof
version
4.7k Ohm resistor
Jumper wires
Breadboard
You can use the preceding links or go directly to MakerAdvisor.com/tools to nd

all the parts for your projects at the best price!
Schematic – ESP32
As mentioned previously, the DS18B20 temperature sensor can be powered
through the VDD pin (normal mode), or it can derive its power from the data line
(parasite mode). You can chose either modes.
If you’re using an ESP32 folllow one of these two schematic diagrams.
Parasite Mode
Normal Mode
Preparing Your Arduino IDE

We’ll program the ESP32 using Arduino IDE, so make sure you have the ESP32
add-on installed before proceeding:
Install ESP32 Board in Arduino IDE (Windows, Mac OS X, and Linux

instructions)
Installing Libraries
To interface with the DS18B20 temperature sensor, you need to install the One
Wire library by Paul Sto regen and the Dallas Temperature library. Follow the
next steps to install those libraries.
1. Open your Arduino IDE and go to Sketch > Include Library > Manage

Libraries. The Library Manager should open.
2. Type “onewire” in the search box and install OneWire library by Paul
Sto regen.
3. Then, search for “Dallas” and install DallasTemperature library by Miles

Burton.
After installing the libraries, restart your Arduino IDE.
Code (Single DS18B20)

After installing the required libraries, you can upload the code to the ESP32. The
following code reads temperature from the DS18B20 temperature sensor and
displays the readings on the Arduino IDE Serial Monitor.
/*********
Rui Santos
Complete project details at https://RandomNerdTutorials.com
*********/
#include <OneWire.h>
#include <DallasTemperature.h>
// GPIO where the DS18B20 is connected to

const int oneWireBus = 4;
// Setup a oneWire instance to communicate with any OneWire devices

OneWire oneWire(oneWireBus);
( );
// Pass our oneWire reference to Dallas Temperature sensor

DallasTemperature sensors(&oneWire);
void setup() {
// Start the Serial Monitor
Serial.begin(115200);
// Start the DS18B20 sensor
sensors.begin();
}
void loop() {
sensors.requestTemperatures();
float temperatureC = sensors.getTempCByIndex(0);
fl d ( )
View raw code
There are many di erent ways to get the temperature from DS18B20
temperature sensors. However, if you’re using just one single sensor, this is one
of the easiest and simplest ways.
How the Code Works

Start by including the OneWire and the DallasTemperature libraries.
Create the instances needed for the temperature sensor. The temperature
sensor is connected to GPIO 4 .
// GPIO where the DS18B20 is connected to

const int oneWireBus = 4;

OneWire oneWire(oneWireBus);

In the setup() , initialize the Serial Monitor at a baud rate of 115200.
Initialize the DS18B20 temperature sensor:
sensors.begin();
Before actually getting the temperature, you need to call the

requestTemperatures() method.
https://randomnerdtutorials.com/esp32-ds18b20-temperature-arduino-ide/?fbclid=IwAR1s6pcDKTPkJk0rpJIu2hik00LcV4-NVzRq2ekG0a9cfpKc9Zs… 10/50
Then, get the temperature in Celsius by using the getTempCByIndex() method

as shown below:
float temperatureC = sensors.getTempCByIndex(0);
Or use the getTempFByIndex() to get the temperature in Fahrenheit.
float temperatureF = sensors.getTempFByIndex(0);
The getTempCByIndex() and the getTempFByIndex() methods accept the

index of the temperature sensor. Because we’re using just one sensor its index is
0. If you want to read more than one sensor, you use index 0 for one sensor,
index 1 for other sensor and so on.
Finally, print the results in the Serial Monitor.
Serial.print(temperatureC);
Serial.println("ºC");
Serial.print(temperatureF);
Serial.println("ºF");
New temperature readings are requested every 5 seconds.
delay(5000);
Demonstration
After uploading the code, you should get your sensor readings displayed in the
Serial Monitor:
Getting Temperature from Multiple DS18B20

Temperature Sensors
The DS18B20 temperature sensor communicates using one-wire protocol and

each sensor has a unique 64-bit serial code, so you can read the temperature
from multiple sensors using just one single GPIO. You just need to wire all data
lines together as shown in the following schematic diagram:
Code (Multiple DS18B20s)

Then, upload the following code. It scans for all devices on GPIO 4 and prints the
temperature for each one. (This sketch is based on an example provided by the
DallasTemperature library).
/*********
Rui Santos
*********/
// Data wire is plugged TO GPIO 4

#define ONE_WIRE_BUS 4
// Setup a oneWire instance to communicate with any OneWire devices (not just
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.

// Number of temperature devices found

int numberOfDevices;
// We'll use this variable to store a found device address

DeviceAddress tempDeviceAddress;
void setup(){
// start serial port
View raw code
Demonstration
In this example, we’re using three DS18B20 temperature sensors. This is what we
get on the Arduino IDE Serial Monitor.
We have a dedicated article on how to interface multiple DS18B20 temperature

sensors with the EPS32. Just follow the next tutorial:
ESP32 with Multiple DS18B20 Temperature Sensors
Display DS18B20 Temperature Readings in a Web

Server
To build the web server we’ll use the ESPAsyncWebServer library that provides an
easy way to build an asynchronous web server. Building an asynchronous web
server has several advantages. We recommend taking a quick look at the library
documentation on its GitHub page.
Installing the ESPAsyncWebServer library

The ESPAsyncWebServer library is not available to install in the Arduino IDE
Library Manager. So, you need to install it manually.
Follow the next steps to install the ESPAsyncWebServer library:
1. Click here to download the ESPAsyncWebServer library. You should have a

.zip folder in your Downloads folder
2. Unzip the .zip folder and you should get ESPAsyncWebServer-master folder
3. Rename your folder from ESPAsyncWebServer-
master to ESPAsyncWebServer
4. Move the ESPAsyncWebServer folder to your Arduino IDE installation
libraries folder
Installing the Async TCP Library
The ESPAsyncWebServer library requires the AsyncTCP library to work. Follow

the next steps to install that library:
1. Click here to download the AsyncTCP library. You should have a .zip folder
in your Downloads folder
2. Unzip the .zip folder and you should get AsyncTCP-master folder
3. Rename your folder from AsyncTCP-master to AsyncTCP
4. Move the AsyncTCP folder to your Arduino IDE installation libraries folder
5. Finally, re-open your Arduino IDE
Code (DS18B20 Async Web Server)

Open your Arduino IDE and copy the following code.
/*********
Rui Santos
22/3/2021
p p ESP32
j DS18B20 Temperature Sensor
p with Arduino IDE (Single, Multiple, Web Server) | Random Nerd Tutorials
*********/
// Import required libraries

#ifdef ESP32
#include <WiFi.h>
#include <ESPAsyncWebServer.h>
#else
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <Hash.h>
#include <ESPAsyncTCP.h>
#endif
// Data wire is connected to GPIO 4


View raw code
Insert your network credentials in the following variables and the code will work
straight away.
const char* ssid = "REPLACE_WITH_YOUR_SSID";

const char* password = "REPLACE_WITH_YOUR_PASSWORD";
How the Code Works

In the following paragraphs we’ll explain how the code works. Keep reading if
you want to learn more or jump to the “Demonstration” section to see the nal
result.
Importing libraries
First, import the required libraries for the ESP32 board:
#include <WiFi.h>
Instantiate DS18B20 Sensor
De ne the GPIO that the DS18B20 data pin is connected to. In this case, it’s
connected to GPIO 4 .
Instantiate the instances needed to initialize the sensor:


Setting your network credentials
Insert your network credentials in the following variables, so that the ESP8266
can connect to your local network.
const char* ssid = "REPLACE_WITH_YOUR_SSID";

const char* password = "REPLACE_WITH_YOUR_PASSWORD";
Create an AsyncWebServer object on port 80.
AsyncWebServer server(80);
Read Temperature Functions
Then, we create two functions to read the temperature.
The readDSTemperatureC() function returns the readings in Celsius degrees.
String readDSTemperatureC() {
// Call sensors.requestTemperatures() to issue a global temperature and Request
float tempC = sensors.getTempCByIndex(0);
if(tempC == -127.00){
Serial.println("Failed to read from DS18B20 sensor");
return "--";
} else {
Serial.print("Temperature Celsius: ");
Serial.println(tempC);
}
return String(tempC);
}
In case the sensor is not able to get a valid reading, it returns -127. So, we have
an if statement that returns two dashes (–-) in case the sensor fails to get the
readings.
if(tempC == -127.00){
Serial.println("Failed to read from DS18B20 sensor");
return "--";
The reaDSTemperatureF() function works in a similar way but returns the

readings in Fahrenheit degrees.
The readings are returned as string type. To convert a oat to a string, use the
String() function.
Building the Web Page
The next step is building the web page. The HTML and CSS needed to build the
web page are saved on the index_html variable.
In the HTML text we have TEMPERATUREC and TEMPERATUREF between % signs.

This is a placeholder for the temperature values.
This means that this %TEMPERATUREC% text is like a variable that will be replaced
by the actual temperature value from the sensor. The placeholders on the HTML
text should go between % signs.
We’ve explained in great detail how the HTML and CSS used in this web server
works in a previous tutorial. So, if you want to learn more, refer to the next
project:
DHT11/DHT22 Temperature and Humidity Web Server with Arduino IDE
Processor
Now, we need to create the processor() function, that will replace the
placeholders in our HTML text with the actual temperature values.
String processor(const String& var){

//Serial.println(var);
if(var == "TEMPERATUREC"){
return readDSTemperatureC();
}
else if(var == "TEMPERATUREF"){
return readDSTemperatureF();
}
return String();
}
When the web page is requested, we check if the HTML has any placeholders. If it
nds the %TEMPERATUREC% placeholder, we return the temperature in Celsius by
calling the readDSTemperatureC() function created previously.
if(var == "TEMPERATUREC"){
return readDSTemperatureC();
}
If the placeholder is %TEMPERATUREF% , we return the temperature in Fahrenheit.
else if(var == "TEMPERATUREF"){

return readDSTemperatureF();
}
setup()
In the setup() , initialize the Serial Monitor for debugging purposes.
Initialize the DS18B20 temperature sensor.
sensors.begin();
Connect to your local network and print the ESP32 IP address.
WiFi.begin(ssid, password);
Serial.println("Connecting to WiFi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
// Print ESP8266 Local IP Address

Serial.println(WiFi.localIP());
Finally, add the next lines of code to handle the web server.
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){

request->send_P(200, "text/html", index_html, processor);
});
server.on("/temperaturec", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readDSTemperatureC().c_str());
});
server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readDSTemperatureF().c_str());
});
When we make a request on the root URL, we send the HTML text that is stored
in the index_html variable. We also need to pass the processor function, that
will replace all the placeholders with the right values.
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){

request->send_P(200, "text/html", index_html, processor);
});
We need to add two additional handlers to update the temperature readings.

When we receive a request on the /temperaturec URL, we simply need to send
the updated temperature value. It is plain text, and it should be sent as a char,
so, we use the c_str() method.
server.on("/temperaturec", HTTP_GET, [](AsyncWebServerRequest *request){

request->send_P(200, "text/plain", readDSTemperatureC().c_str());
});
The same process is repeated for the temperature in Fahrenheit.
server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){

request->send_P(200, "text/plain", readDSTemperatureF().c_str());
});
Lastly, we can start the server.
server.begin();
Because this is an asynchronous web server, we don’t need to write anything in

the loop() .
void loop(){
That’s pretty much how the code works.
Demonstration
After uploading the code, open the Arduino IDE Serial Monitor at a baud rate of
115200. Press the ESP32 on-board RST button and after a few seconds your IP
address should show up.
In your local network, open a browser and type the ESP32 IP address.
Now you can see temperature in Celsius and Fahrenheit in your web server. The
sensor readings update automatically without the need to refresh the web page.
Wrapping Up
We hope you’ve found this tutorial useful. We have guides for other sensors and
modules with the ESP32 that you may like:
ESP32 with BME280 (Pressure, Temperature and Humidity)
ESP32 Built-In Hall E ect Sensor

ESP32 OLED Display with Arduino IDE
ESP32 DHT Temperature and Humidity Sensor with Arduino IDE
If you want to learn more about the ESP32 take a look at our course, or check or
ESP32 free resources:
Learn ESP32 with Arduino IDE

More ESP32 Projects and Tutorials
Thanks for reading.
[eBook] Build Web Servers with ESP32 and

ESP8266 (2nd Edition)
Build Web Server projects with the ESP32 and ESP8266 boards to control outputs
and monitor sensors remotely. Learn HTML, CSS, JavaScript and client-server
communication protocols DOWNLOAD »
Recommended Resources
Build a Home Automation System from Scratch » With Raspberry Pi,

ESP8266, Arduino, and Node-RED.
Home Automation using ESP8266 eBook and video course » Build IoT and
home automation projects.
Arduino Step-by-Step Projects » Build 25 Arduino projects with our course,

even with no prior experience!
What to Read Next…
ESP8266 NodeMCU Digital Inputs and Digital Outputs (Arduino IDE)
ESP8266 NodeMCU Web Server with BME680 – Weather Station (Arduino

IDE)
ESP32 Flash Memory – Store Permanent Data (Write and Read)
ESP8266 with BME280 using Arduino IDE (Pressure, Temperature,

Humidity)
ESP32 Web Server – Arduino IDE
ESP32 with BME280 Sensor using Arduino IDE (Pressure, Temperature,

Humidity)
Enjoyed this project? Stay updated by subscribing our weekly

newsletter!
Your Email Address
 SUBSCRIBE
32 thoughts on “ESP32 DS18B20 Temperature Sensor

with Arduino IDE (Single, Multiple, Web Server)”
Kelvin
July 15, 2019 at 8:26 pm
Make sense!
Reply
Trull
September 2, 2019 at 7:14 am
The above code works really well on my Heltec Lora ESP32 board at
240MHz, but the onewire library breaks down if you reduce the speed of
the processor to save energy or for compatibility with other interfaces.
Current thinking seems to be this is because the onewire interface is
bitbashed and processor interrupts smooth operation.
Reply
Peter Laneville
October 28, 2019 at 2:01 pm
I’ve used the one sensor example and it works ne.
When I add a second sensor as depicted and run the multiple sensor
code it can’t nd any sensors (“Location devices…Found 0devices”).
Any Idea what might be happening?
Reply
Sara Santos
October 29, 2019 at 11:14 am
Hi Peter.
I don’t know what can be the problem.
Please double-check your wiring and that each sensor works ne
individually before hooking up the two sensors at the same time.
Regards,
Sara
Reply
Peter Laneville
October 29, 2019 at 11:24 pm
Sara;
Got both sensors working with one of the Dallas examples but they still
refuse to work with the multiple sensor code above???
I’ll do some more analysis tomorrow to try to determine what may be

happening.
Reply
Peter Laneville
October 30, 2019 at 5:52 pm
Sara;
I’ve checked the sensor waveform with an oscilloscope and data looks
good (clean transitions between 3.3 and 0 V).
I’ve noticed that the Dallas example also returns 0 devices found using
the “sensors.getDeviceCount()” command but the example then does an
address assignment by index and nds both devices and then continues
by reading the temperatures.
In the multiple sensor code above it looks like the code extracts the
address for each device found in a loop but since no devices are found….
Seems like either the DS18B20 sensors I have are defective (in not
correctly responding to the .getdevicecount command or the library has
an issue with the same command.
Anyway I’m moving forward as I can now read the sensor temperatures.
Reply
Thomas Engelhardt
June 5, 2020 at 8:17 pm
I had the same experience and I can say for sure the sensors work ne
as I used them together with an Arduino Nano just before.
The lib apparently has an issue.
Reply
Abdul Fatah
February 20, 2020 at 8:39 am
well good explanation

i just uploaded the code and using DHT11 temprature sensor it gives
error A fatal error occurred: Failed to connect to ESP32: Invalid head of
packet (0x46)
how to remove the error
Reply
Sara Santos
Hi.
Can you follow this and see if it solves your problem?
https://rntlab.com/question/failed-to-connect-to-esp32-invalid-head-of-
packet-0x2e/
Regards,
Sara
Reply
DamienF
May 12, 2020 at 5:48 pm
Great tutorial, thanks for sharing. I incorporated for demo purposes most
of your code into a larger RTOS-based project and it works well. Running
on a nodeMCU ESP32-S on my local LAN wi .
Reply
Sara Santos
May 13, 2020 at 9:27 am
Great
Reply
Marcelo F
June 28, 2020 at 8:06 pm
Hi Sara,
I build that and i had for one DS180B20, the temperature -127C
Reply
Sara Santos
June 29, 2020 at 10:53 am
Hi.
That usually means that there’s some issue with the wiring or power.
Regards,
Sara
Reply
Marcelo
June 29, 2020 at 11:33 am
Hi, i double check the wire (polarity PSU) and it is ok. I am using 5V
(~4.6V).
Reply
Sara Santos
June 29, 2020 at 2:13 pm
Are you using the same GPIO we use in this project?
Reply
Marcelo
June 29, 2020 at 2:20 pm
Hi Sara,
I am using NodeMCU-32, I changed to GPIO4 and still not working.
I was using GPIO34 before.
David
July 13, 2020 at 3:09 am
Thanks for the hint about the wiring. In my case, it was indeed a wiring
error. Same symptom (T=-127C) and sure enough, after I corrected a
wiring error it was xed. Thanks.
Reply
Ace
August 9, 2020 at 7:18 pm
Is 4.7kOhm resistor is required for DS18B20 temperature sensor

waterproof version too?
Reply
RC
November 12, 2020 at 7:32 pm
For reliable operation, yes, use the 4.7k resistor on the waterproof
sensor also. I do.
Reply
Dunc
February 1, 2021 at 10:32 pm
I could not get it to run properly (kept getting -127) until I added the
resistor.
Reply
Felipe
September 7, 2020 at 8:28 pm
Hello, i’d like to know if its possible and how to add a chart/graph of how
the temperatures increases/decreases in real time.
Reply
Sara Santos
Hi.
Take a look at this tutorial: https://randomnerdtutorials.com/esp32-
esp8266-plot-chart-web-server/
Regards,
Sara
Reply
Paul Nix
Hello, I would like to know wath can be the maximum cable length by 3,3v
supply from the esp32, and secondly if the use of 5v supply on the sensor
would be an issue for the esp32 input (witch is a 3,3v per datasheet).
Thank you
Reply
Elias Giannopoulos
Dear Paul,
I have use 12 meters cable with 3.3V without any di erence using 1m
cable (sensors in same area gives same measurements +- sensor error).
I have use UTP cat6 cable, using 3 non twisted wires. Orange, green ,
blue.
Reply
Paul Nix
Thank you for your reply Elias. My sensors are ordered, I will try it
soon.
Reply
Strobistar
October 31, 2020 at 8:34 am
Hello!
Great tutorials for a learner!
I used your ESP32 tutorial and the serial output
(https://randomnerdtutorials.com/esp32-multiple-ds18b20-temperature-
sensors/) which worked great! My ve sensors are reporting back IDs and
I can see the measurements!
However, it seems that the webserver code above does only show one
temperature value although in the code, the ReadTemperature issue a
global temperature and Requests to all devices on the bus.
I am guessing that “ oat tempC = sensors.getTempCByIndex(0);” is
causing this, I’m imagining I could but a while loop around this, however
the imprints into the html is not in a while loop either.
Thanks for your advice!
Reply
Sara Santos
October 31, 2020 at 11:30 am
Hi.
You would need to create multiple variables to get the temperature
from the multiple sensors.
Then, modify the HTML to display multiple sensor readings.
Regards,
Sara
Reply
Strobistar
October 31, 2020 at 11:48 am
Hi Sara,
it has been more than 20 years that I looked into programming code,
but indeed, I worked now with static variables and all my ve sensors
are now dumping their load into html.
As I’m already made the same project on a Raspberry pi (which had

limitations in to quickly reading too many sensors at once, I’m curious
to know whether the ESP32 su ers from the same symptoms.
Thank you and have a nice day!
Reply
Robert FOLKES
November 9, 2020 at 7:10 pm
Firstly a big thank you for these random nerd tutorials, my ‘smart pool’
project has temperature sensors, async web interface and email
reporting based originally on your excellent examples. However a
comment and a question:
The DS18B20 is terribly slow at converting temperatures (up to about

700mS) however you don’t have to wait for this process. If you call
sensors.setWaitForConversion(false) at startup, you can do lots of useful
other stu between your sensors.requestTemperatures() and
sensors.getTempC(tempDeviceAddress) you just need to make sure there

is an adequate time delay (say 1S).
One of my DS18B20s sits on the roof and we had a bad electrical storm a
couple of days ago. The webserver kept working, my email reports failed
as did some temperature sensors. I rebooted, then all the temperature
sensors failed – but the email reports came a back. I assumed the ESP
was partially fried, but when I did a full power cycle and software
upload,everything came back as usual – MIRACLE! All very strange, but
this does raise the question: what is best practice when connecting to an
external DS18B20s? This seems a good place to start
https://www.eevblog.com/forum/beginners/protecting-pic-inputs-
connected-to-ds18b20/msg182951/?
PHPSESSID=j8beh30uf8qsfraitsui45n6t6#msg182951 Further comment
appreciated.
Reply
Amr Khalifa
Hi
I used two senors and when i uploaded the webserver codes i had
readings from only one sensor displayed on the webserver.
Any information on how to get readings from both sensors ?
Thanks
Reply
Strobistar
Hi!
This code is to show only the rst sensor reading in both °C and °F (see
this line: oat tempC = sensors.getTempCByIndex(0);)
So either loop through your sensors, or work with the “mac” addresses
and launch those in the visualisation.
Good luck!
Reply
Dan
Solved !!!! By reading all comments and doing some minors

modi cations….
This is my code, with Wemos D1 mini (just Celsius) :
“// Import required libraries
#ifdef ESP32
#include <WiFi.h>
#de ne ONE_WIRE_BUS 15 // ESP32
#else
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <Hash.h>
#include <ESPAsyncTCP.h>
#de ne ONE_WIRE_BUS 4 // D2
#endif


// Replace with your network credentials

const char* ssid = “Andy_2.4G”;
const char* password = “andy1603”;
String StrTempC;
String StrTempF;
// Create AsyncWebServer object on port 80

AsyncWebServer server(80);
String readDSTemperatureC() {
// Call sensors.requestTemperatures() to issue a global temperature and
Requests to all devices on the bus
oat tempC = sensors.getTempCByIndex(0);
if(tempC == -127.00) {
Serial.println(“Failed to read from DS18B20 sensor”);
return “–“;
} else {
Serial.print(“Temperature Celsius: “);
Serial.println(tempC);
}
}
String readDSTemperatureF() {
// Call sensors.requestTemperatures() to issue a global temperature and
Requests to all devices on the bus
oat tempF = sensors.getTempFByIndex(0);
if(int(tempF) == -196){
Serial.println(“Failed to read from DS18B20 sensor”);
return “–“;
} else {
Serial.print(“Temperature Fahrenheit: “);
Serial.println(tempF);
}
return String(tempF);
}
const char index_html[] PROGMEM = R”rawliteral(
html {
font-family: Arial;
display: inline-block;
margin: 0px auto;
text-align: center;
}
h2 { font-size: 3.0rem; }
p { font-size: 3.0rem; }
.units { font-size: 1.2rem; }
.ds-labels{
font-size: 1.5rem;
vertical-align:middle;
padding-bottom: 15px;
}
ESP DS18B20 Server
Temperature Celsius
%TEMPERATUREC%
°C
setInterval(function ( ) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById(“temperaturec”).innerHTML =
this.responseText;
}
};
xhttp.open(“GET”, “/temperaturec”, true);
xhttp.send();
}, 1000) ;
setInterval(function ( ) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById(“temperaturef”).innerHTML =
this.responseText;
}
};
xhttp.open(“GET”, “/temperaturef”, true);
xhttp.send();
}, 1000) ;
)rawliteral”;
// Replaces placeholder with DHT values
String processor(const String& var){
//Serial.println(var);
if(var == “TEMPERATUREC”){
//return String(sensors.getTempCByIndex(0));
return StrTempC;
}
else if(var == “TEMPERATUREF”){
//return String(sensors.getTempFByIndex(0));
return StrTempF;
}
return String();
}
void setup(){
// Serial port for debugging purposes
Serial.println();
// Start up the DS18B20 library

sensors.begin();
// Connect to Wi-Fi
WiFi.begin(ssid, password);
Serial.println(“Connecting to WiFi”);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(“.”);
}
Serial.println();
// Print ESP Local IP Address

Serial.println(WiFi.localIP());
// Route for root / web page

server.on(“/”, HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, “text/html”, index_html, processor);
});
server.on(“/temperaturec”, HTTP_GET, [](AsyncWebServerRequest

*request){
request->send_P(200, “text/plain”, String(StrTempC).c_str());
});
// Start server
server.begin();
}
void loop(){
StrTempC = readDSTemperatureC();
Serial.print(StrTempC);
Serial.print(” “);
StrTempF = readDSTemperatureF();
Serial.println(StrTempF);
}”
THANKS FOR GREAT INFO !!!
Reply
Leave a Comment
Name *
Email *
Website
Notify me of follow-up comments by email.
Notify me of new posts by email.
Post Comment
Visit Maker Advisor – Tools and Gear

for makers, hobbyists and DIYers »
Home Automation using ESP8266

eBook and video course » Build IoT and
home automation projects.
Build a Home Automation System

from Scratch » With Raspberry Pi,
ESP8266, Arduino, and Node-RED.
About Support Terms Privacy Policy Refunds MakerAdvisor.com Join the Lab
Copyright © 2013-2021 · RandomNerdTutorials.com · All Rights Reserved

ESP32 DS18B20 Temperature Sensor With Arduino IDE (Single, Multiple, Web Server) - Random Nerd Tutorials

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ESP32 DS18B20 Temperature Sensor With Arduino IDE (Single, Multiple, Web Server) - Random Nerd Tutorials

Uploaded by

Copyright:

Available Formats

22/3/2021 ESP32 DS18B20 Temperature Sensor with Arduino IDE (Single, Multiple, Web Server) | Random Nerd Tutorials

ESP32 DS18B20 Temperature Sensor with Arduino

You might also like reading other DS18B20 guides:

ESP8266 DS18B20 Temperature Sensor with Arduino IDE

Introducing DS18B20 Temperature Sensor

The DS18B20 temperature sensor is a one-wire digital temperature sensor. This

The DS18B20 temperature sensor is also available in waterproof version.

Here’s a summary of the most relevant specs of the DS18B20 temperature

Communicates over one-wire bus communication

For more information consult the DS18B20 datasheet.

ESP32 (read Best ESP32 development boards)

You can use the preceding links or go directly to MakerAdvisor.com/tools to nd

If you’re using an ESP32 folllow one of these two schematic diagrams.

Preparing Your Arduino IDE

Install ESP32 Board in Arduino IDE (Windows, Mac OS X, and Linux

1. Open your Arduino IDE and go to Sketch > Include Library > Manage

3. Then, search for “Dallas” and install DallasTemperature library by Miles

After installing the libraries, restart your Arduino IDE.

Code (Single DS18B20)

// GPIO where the DS18B20 is connected to

// Setup a oneWire instance to communicate with any OneWire devices

// Pass our oneWire reference to Dallas Temperature sensor

How the Code Works

// GPIO where the DS18B20 is connected to

// Setup a oneWire instance to communicate with any OneWire devices

// Pass our oneWire reference to Dallas Temperature sensor

In the setup() , initialize the Serial Monitor at a baud rate of 115200.

Initialize the DS18B20 temperature sensor:

Before actually getting the temperature, you need to call the

Then, get the temperature in Celsius by using the getTempCByIndex() method

float temperatureC = sensors.getTempCByIndex(0);

Or use the getTempFByIndex() to get the temperature in Fahrenheit.

float temperatureF = sensors.getTempFByIndex(0);

The getTempCByIndex() and the getTempFByIndex() methods accept the

Finally, print the results in the Serial Monitor.

New temperature readings are requested every 5 seconds.

Getting Temperature from Multiple DS18B20

The DS18B20 temperature sensor communicates using one-wire protocol and

Code (Multiple DS18B20s)

// Data wire is plugged TO GPIO 4

// Pass our oneWire reference to Dallas Temperature.

// Number of temperature devices found

// We'll use this variable to store a found device address

View raw code

We have a dedicated article on how to interface multiple DS18B20 temperature

ESP32 with Multiple DS18B20 Temperature Sensors

Display DS18B20 Temperature Readings in a Web

Installing the ESPAsyncWebServer library

Follow the next steps to install the ESPAsyncWebServer library:

1. Click here to download the ESPAsyncWebServer library. You should have a

Installing the Async TCP Library

The ESPAsyncWebServer library requires the AsyncTCP library to work. Follow

Code (DS18B20 Async Web Server)

// Import required libraries

// Data wire is connected to GPIO 4

// Setup a oneWire instance to communicate with any OneWire devices

// Pass our oneWire reference to Dallas Temperature sensor

View raw code

const char* ssid = "REPLACE_WITH_YOUR_SSID";

How the Code Works

First, import the required libraries for the ESP32 board:

Instantiate DS18B20 Sensor

Instantiate the instances needed to initialize the sensor: