DS18B20 Temperatursensor Arduino Tutorial (4 Beispiele)

Dieses Tutorial enthält alles, was Sie über die Verwendung von DS18B20 1-Wire digitalen Temperatursensoren mit Arduino wissen müssen.

Für dieses Tutorial verwenden wir die DallasTemperature in Kombination mit der OneWire Arduino-Bibliothek. Diese Bibliotheken machen die Kommunikation mit einem oder mehreren Sensoren sehr einfach. Im ersten Teil dieses Artikels finden Sie die Spezifikationen und Informationen zu den verschiedenen Typen von DS18B20-Sensoren. Anschließend sehen wir uns an, wie man den Sensor mit dem Arduino verbindet.

Im ersten Codebeispiel zeige ich Ihnen, wie Sie Temperaturmessungen von einem einzelnen Sensor vornehmen und das Ergebnis im Serial Monitor anzeigen. Die folgenden Beispiele erklären, wie man mehrere Sensoren mit einem einzigen Arduino-Pin ausliest. Zum Schluss zeige ich Ihnen, wie Sie die Temperatur auf einem I2C LCD anzeigen können.

überblick

Materialien

Hardware-Komponenten

DS18B20 digital temperature sensor (TO-92)	× 3	Amazon
Waterproof DS18B20 (Alternative)	× 1	Amazon
DS18B20 breakout board (Alternative)	× 1	Amazon
Arduino Uno	× 1	Amazon
Breadboard	× 1	Amazon
Jumper wires	~ 15	Amazon
4.7 kΩ pull-up resistor	× 1	Amazon
16×2 character I2C LCD	× 1	Amazon
USB cable type A/B	× 1	Amazon

Software

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Über den DS18B20 1-Wire Temperatursensor

Der DS18B20 ist ein digitaler Temperatursensor, hergestellt von Maxim Integrated (ehemals Dallas Semiconductor). Er ist einer der beliebtesten Temperatursensoren auf dem Markt und bietet eine recht hohe Genauigkeit (±0,5 °C) über einen großen Temperaturbereich (-55 °C bis +125 °C). Da die Betriebsspannung des Sensors 3,0 bis 5,5 V beträgt, kann er sowohl mit dem Arduino (der mit 5 V arbeitet) als auch mit Geräten wie dem ESP32 und Raspberry Pi verwendet werden, die 3,3 V GPIO-Pins haben.

Ein Hauptvorteil dieses Sensors ist, dass er nur einen digitalen Pin des Arduino für die Kommunikation benötigt. Der Sensor kommuniziert mit dem Dallas Semiconductor 1-Wire^®Protokoll. Dieses Protokoll funktioniert ähnlich wie I2C, jedoch mit niedrigeren Datenraten und größerer Reichweite.

Ein weiterer Vorteil ist, dass jeder DS18B20-Sensor einen einzigartigen 64-Bit-Seriencode besitzt, der es ermöglicht, mehrere Sensoren am selben 1-Wire-Bus zu betreiben. So können Sie Daten von mehreren Sensoren, die zusammen an nur einem Arduino-Pin angeschlossen sind, auslesen (siehe Codebeispiele weiter unten).

Die Auflösung des Sensors kann programmatisch auf 9, 10, 11 oder 12 Bit eingestellt werden. Dies entspricht Temperaturinkrementen von 0,5 °C, 0,25 °C, 0,125 °C bzw. 0,0635 °C. Die Standardauflösung beim Einschalten ist 12 Bit.

Weitere Spezifikationen finden Sie in der folgenden Tabelle.

DS18B20 digitale Temperatursensor-Spezifikationen

Versorgungsspannung	3,0 bis 5,5 V
Ruhe-Strom	1 μA
Aktiver Strom	1,5 mA
Messbereich	-55 °C bis +125 °C (-67 °F bis +257 °F)
Genauigkeit (Thermometerfehler)	±0,5 °C von -10 °C bis +85 °C ±1 °C von -30 °C bis +100 °C ±2 °C von -55 °C bis +125 °C
Auflösung	9 Bit bis 12 Bit (programmierbar)
Konvertierungszeit	< 750 ms (12-Bit-Auflösung)
Kommunikationsprotokoll	1-Wire® Busprotokoll
Gehäuse	3-poliges TO-92
Hersteller	Maxim Integrated
Kosten	Check price

Weitere Informationen finden Sie auch im Datenblatt hier:

DS18B20 Datasheet

Typen von DS18B20-Sensoren

Der Sensor ist üblicherweise in drei Bauformen erhältlich. Der gebräuchlichste Typ ist der 3-pin TO-92 package, der wie ein Transistor aussieht.

DS18B20 as TO-92 package — DS18B20 im TO-92-Gehäuse (source)

Dieser Sensortyp wird manchmal auf einer breakout board montiert, die eine Power-LED und den erforderlichen 4,7 kΩ Pull-up-Widerstand enthalten kann. Achten Sie immer auf die Beschriftungen auf der Platine, da die Reihenfolge der Pins je nach Hersteller unterschiedlich sein kann.

DS18B20 Breakout board — DS18B20 Breakout-Board (source)

Schließlich können Sie den Sensor auch als wasserdichte Sonde mit bereits angebrachtem Kabel kaufen. Diese Bauform ist nützlich, wenn Sie etwas in größerer Entfernung, unter Wasser oder unter der Erde messen möchten.

DS18B20 as waterproof probe — DS18B20 als wasserdichte Sonde (source)

Beachten Sie, dass das Kabel des wasserdichten Sensors meist mit PVC ummantelt ist, daher wird empfohlen, es unter 100 °C zu halten.

Verdrahtung – Anschluss des DS18B20 an einen Arduino

Den DS18B20 an den Arduino anzuschließen ist recht einfach, da nur 3 Pins verbunden werden müssen. Beginnen Sie damit, den GND-Pin mit Masse zu verbinden und den V_DDPin mit dem 5 V-Ausgang des Arduino zu verbinden.

Als nächstes verbinden Sie den mittleren Pin (DQ) mit einem der digitalen Pins des Arduino. In diesem Fall habe ich den digitalen Pin 2 verwendet. Außerdem müssen Sie einen 4,7 kΩ Pull-up-Widerstand zwischen dem DQ-Pin und 5 V hinzufügen. Dieser hält den Leerlaufzustand des 1-Wire-Busses auf High.

DS18B20-digital-temperature-sensor-with-Arduino-connections-wiring-diagram-schematic-circuit-tutorial — Verdrahtungsdiagramm des DS18B20 digitalen Temperatursensors mit Arduino Uno

Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt.

DS18B20-digital-temperature-sensor-pinout — Pinbelegung des DS18B20

Beachten Sie, dass Pin 1 (GND) der linke Pin ist, wenn die flache Seite des Sensors (mit dem aufgedruckten Text) zu Ihnen zeigt.

Anschlüsse des DS18B20 digitalen Temperatursensors

DS18B20	Arduino
Pin 1 (GND)	GND
Pin 2 (DQ)	Pin 2 Arduino und über 4,7 kΩ Widerstand zu 5V
PIN 3 (V_DD)	5V

Ein wasserdichter DS18B20-Sensor wird auf die gleiche Weise angeschlossen. Die Farben der Kabel können jedoch je nach Hersteller unterschiedlich sein. Das Massekabel (GND) ist typischerweise schwarz oder blau, das Versorgungskabel (VDD) meist rot, und das Signalkabel (DQ) oft gelb oder weiß. Ich empfehle dringend, immer das Datenblatt Ihres Sensors zu prüfen, wenn Sie unsicher sind.

Anschlüsse des wasserdichten DS18B20 digitalen Temperatursensors

Wasserdichter DS18B20	Arduino
Schwarzes Kabel (GND)	GND
Gelbes Kabel (DQ)	Pin 2 Arduino und über 4,7 kΩ Widerstand zu 5V
Rotes Kabel (V_DD)	5V

Installation der DallasTemperature und OneWire Arduino-Bibliotheken

Das 1-Wire-Kommunikationsprotokoll ist etwas komplex und erfordert viel Code, um die Kommunikation zu verarbeiten. Deshalb verwenden wir die Arduino-Temperature-Control-Library von Miles Burton, um die Programmierung dieser Sensoren deutlich zu vereinfachen.

Um die Bibliothek zu installieren, gehen Sie zu Tools > Manage Libraries (Strg + Shift + I unter Windows) in der Arduino IDE. Der Library Manager öffnet sich und aktualisiert die Liste der installierten Bibliotheken.

Installing an Arduino library step 1 open Library Manager — Library Manager

Sie können nach ‘ds18b20’ suchen und die DallasTemperature Bibliothek von Miles Burton auswählen. Wählen Sie die neueste Version und klicken Sie dann auf Installieren.

DallasTemperature library in Library Manager — **DallasTemperature** Bibliothek im Library Manager

Die DallasTemperature-Bibliothek basiert auf der OneWire Arduino library, die Sie ebenfalls installieren müssen. Diese Bibliothek kümmert sich um das 1-Wire-Kommunikationsprotokoll.

Suchen Sie nach ‚onewire‘ und wählen Sie die OneWire Bibliothek von Jim Studt aus.

OneWire library in Library Manager — **OneWire** Bibliothek im Library Manager

DS18B20 Temperatursensor mit Arduino Beispielcode

Mit dem folgenden Beispielcode können Sie die Temperatur von einem DS18B20-Sensor auslesen und im Serial Monitor anzeigen.

/* DS18B20 1-Wire digital temperature sensor with Arduino example code. 
   https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();
}

void loop() {
  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

  // Fetch the temperature in degrees Celsius for device index:
  float tempC = sensors.getTempCByIndex(0); // the index 0 refers to the first device
  // Fetch the temperature in degrees Fahrenheit for device index:
  float tempF = sensors.getTempFByIndex(0);

  // Print the temperature in Celsius in the Serial Monitor:
  Serial.print("Temperature: ");
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");

  // Print the temperature in Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("F");

  // Wait 1 second:
  delay(1000);
}

Sie sollten die folgende Ausgabe im Serial Monitor (Strg + Shift + M) sehen.

Serial Monitor output — Serial Monitor Ausgabe

Stellen Sie sicher, dass die Baudrate des Serial Monitors ebenfalls auf 9600 eingestellt ist.

Funktionsweise des Codes

Der erste Schritt ist das Einbinden der benötigten Arduino-Bibliotheken:

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

Als nächstes habe ich definiert, an welchen Pin des Arduino der DQ-Pin des Sensors angeschlossen ist. Die Anweisung #define kann verwendet werden, um einem konstanten Wert einen Namen zu geben. Der Compiler ersetzt alle Verweise auf diese Konstante durch den definierten Wert, wenn das Programm kompiliert wird. Überall, wo Sie ONE_WIRE_BUS erwähnen, ersetzt der Compiler es beim Kompilieren durch den Wert 2.

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

Danach habe ich ein neues Objekt der OneWire-Klasse erstellt und den DQ-Pin an dessen Konstruktor übergeben. Außerdem müssen Sie ein Objekt der DallasTemperature-Klasse erstellen und das oneWire-Objekt als Parameter übergeben.

Beachten Sie, dass ich das DallasTemperature-Objekt ’sensors‘ genannt habe, Sie können aber auch andere Namen verwenden.

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

Im Setup-Teil des Codes starten wir die serielle Kommunikation mit einer Baudrate von 9600. Danach initialisiere ich den Bus mit der Funktion begin().

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();
}

Im Loop-Teil des Codes starten wir mit dem Befehl, dass alle Sensoren am Bus eine Temperaturmessung starten.

  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

Anschließend verwende ich die Funktionen getTempCByIndex(deviceIndex) und getTempFByIndex(deviceIndex), um die Temperatur in Grad Celsius bzw. Fahrenheit abzurufen. In diesem Fall ist nur ein Sensor am Bus angeschlossen. Da die Zählung bei Null beginnt, setze ich den Index für unseren Sensor auf 0.

  // Fetch the temperature in degrees Celsius for device index:
  float tempC = sensors.getTempCByIndex(0); // the index 0 refers to the first device
  // Fetch the temperature in degrees Fahrenheit for device index:
  float tempF = sensors.getTempFByIndex(0);

Zum Schluss werden die Temperaturen im Serial Monitor ausgegeben:

  // Print the temperature in Celsius in the Serial Monitor:
  Serial.print("Temperature: ");
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");
  // Print the temperature in Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("F");

Da die Temperaturumwandlung im 12-Bit-Modus bis zu 750 ms dauern kann, habe ich zwischen den Messungen eine Sekunde Verzögerung eingefügt.

Mehrere DS18B20 Sensoren mit Arduino verwenden

Wie im Einführungsteil erwähnt, können Sie die Temperatur von mehreren DS18B20-Sensoren mit nur einem Arduino-Pin auslesen. Unten finden Sie zwei Beispielcodes. Mit dem ersten Beispiel können Sie die Temperatur der angeschlossenen Sensoren über ihren Index auslesen. Da alle Sensoren am selben 1-Wire-Bus angeschlossen sind, hat der erste Sensor den Index 0, der zweite den Index 1 usw.

Im zweiten Beispiel zeige ich Ihnen, wie Sie die einzigartige 64-Bit-Adresse jedes Sensors auslesen. Diese Adresse kann dann verwendet werden, um jeden Sensor einzeln auszulesen.

Verdrahtung – Anschluss mehrerer DS18B20 Sensoren an den Arduino

Das Anschließen mehrerer DS18B20-Sensoren an den Arduino ist genauso einfach wie bei nur einem Sensor. Alle Sensoren werden parallel geschaltet, d.h. alle gleichen Pins sind miteinander verbunden. Wie zuvor werden die GND-Pins mit Masse verbunden, die V_DDPins mit 5 V und die DQ-Pins mit Pin 2 des Arduino. Vergessen Sie nicht den 4,7 kΩ Pull-up-Widerstand zwischen dem DQ-Pin und 5 V.

Multiple DS18B20 1-Wire digital temperature sensors connected to an Arduino — Mehrere DS18B20 1-Wire digitale Temperatursensoren, die an einen Arduino angeschlossen sind

Mehrere DS18B20 Sensoren mit Arduino Beispielcode

Mit dem folgenden Beispiel können Sie die Temperatur jedes Sensors über seinen Index auslesen und im Serial Monitor anzeigen.

/* Multiple DS18B20 1-Wire digital temperature sensors with Arduino example code. M
   https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"


// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

int deviceCount = 0;
float tempC;
float tempF;

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();

  // Locate the devices on the bus:
  Serial.println("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");
}

void loop() {
  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

  // Display temperature from each sensor
  for (int i = 0;  i < deviceCount;  i++) {
    Serial.print("Sensor ");
    Serial.print(i + 1);
    Serial.print(" : ");
    tempC = sensors.getTempCByIndex(i);
    tempF = sensors.getTempFByIndex(i);
    Serial.print(tempC);
    Serial.print(" \xC2\xB0"); // shows degree symbol
    Serial.print("C  |  ");
    Serial.print(tempF);
    Serial.print(" \xC2\xB0"); // shows degree symbol
    Serial.println("F");
  }

  Serial.println();
  delay(1000);
}

Die Ausgabe im Serial Monitor sollte wie folgt aussehen:

Multiple-DS18B20-temperature-sensors-Serial-Monitor-output — Mehrere DS18B20 Sensoren Serial Monitor Ausgabe

Funktionsweise des Codes

Der Code in diesem Beispiel ist größtenteils derselbe wie zuvor.

Im Setup-Teil habe ich eine zusätzliche Funktion hinzugefügt, die die Anzahl der Geräte zählt, die am 1-Wire-Bus angeschlossen sind.

  // Locate the devices on the bus:
  Serial.println("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");

Im Loop-Teil des Codes verwende ich eine for loop, um einen Codeabschnitt zu durchlaufen, der die Temperatur für jeden Sensor am Bus über seinen Index abruft.

  // Display temperature from each sensor
  for (int i = 0;  i < deviceCount;  i++) {
    Serial.print("Sensor ");
    Serial.print(i + 1);
    Serial.print(" : ");
    tempC = sensors.getTempCByIndex(i);
    tempF = sensors.getTempFByIndex(i);
    Serial.print(tempC);
    Serial.print(" \xC2\xB0"); // shows degree symbol
    Serial.print("C  |  ");
    Serial.print(tempF);
    Serial.print(" \xC2\xB0"); // shows degree symbol
    Serial.println("F");
  }

Sensoren nach Adresse auslesen

Um die Sensoren über ihre individuelle Adresse auszulesen, müssen wir zuerst wissen, welche Adresse jeder Sensor hat. Dafür können Sie den folgenden Beispielsketch verwenden.

Der Sketch gibt die Adressen der angeschlossenen Sensoren im Serial Monitor aus. Um zu wissen, welcher Sensor welcher ist, können Sie jeweils nur einen Sensor anschließen oder nacheinander einen neuen Sensor hinzufügen. Dann können Sie jeden Sensor, der am 1-Wire-Bus angeschlossen ist, beschriften.

DS18B20 Adressfinder

/* Multiple DS18B20 1-Wire digital temperature sensors with Arduino example code. More info: https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

// Create variables:
int deviceCount = 0; // variable to store the number of devices connected
DeviceAddress deviceAddress; // variable to store the device address

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();

  // Locate the devices on the bus:
  Serial.println("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");

  Serial.println("Printing addresses...");
  for (int i = 0;  i < deviceCount;  i++) {
    Serial.print("Sensor ");
    Serial.print(i + 1);
    Serial.print(" : ");
    sensors.getAddress(deviceAddress, i);
    printAddress(deviceAddress);
  }
}

void loop() {
}

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

Die Ausgabe im Serial Monitor sollte ungefähr so aussehen:

Schreiben Sie nun die Adressen aller Sensoren auf, da Sie diese im nächsten Beispiel benötigen.

Sensoren nach Adresse auslesen Arduino Beispielcode

Mit dem folgenden Beispiel können Sie die Temperatur jedes Sensors auslesen, indem Sie seine eindeutige Adresse angeben.

/* Read multiple DS18B20 1-Wire digital temperature sensors by address. 
   More info: https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};
byte sensor2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB};
byte sensor3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21};

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();
}

void loop() {
  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

  Serial.print("Sensor 1: ");
  printTemperature(sensor1); // call the printTemperature function with the address of sensor1 as input
  Serial.print("Sensor 2: ");
  printTemperature(sensor2);
  Serial.print("Sensor 3: ");
  printTemperature(sensor3);

  Serial.println(); // prints an empty line
  delay(1000);
}

void printTemperature(DeviceAddress address) {
  // Fetch the temperature in degrees Celsius for device address:
  float tempC = sensors.getTempC(address);
  // Fetch the temperature in degrees Fahrenheit for device address:
  float tempF = sensors.getTempF(address);
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");

  // Print the temperature in Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("F");
}

Beachten Sie, dass Sie die Adressen in den Zeilen 17 bis 19 durch die Adressen ersetzen müssen, die Sie mit dem vorherigen Beispielcode gefunden haben.

// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};
byte sensor2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB};
byte sensor3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21};

Sie sollten die folgende Ausgabe im Serial Monitor sehen.

Code-Erklärung

Die Adresse jedes Sensors besteht aus 64 Bit. Im Code geben wir die Adresse als Array aus acht 8-Bit-Bytes an.

// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};
byte sensor2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB};
byte sensor3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21};

Der Setup-Teil des Codes ist derselbe wie in den vorherigen Beispielen.

Im Loop rufen wir die printTemperature(DeviceAddress address) Funktion auf. In dieser benutzerdefinierten Funktion verwenden wir getTempC(address) und getTempF(address), um die Temperatur von einem Sensor auszulesen, dessen Adresse als Parameter übergeben wird.

void printTemperature(DeviceAddress address) {
  // Fetch the temperature in degrees Celsius for device address:
  float tempC = sensors.getTempC(address);
  // Fetch the temperature in degrees Fahrenheit for device address:
  float tempF = sensors.getTempF(tempC);
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");

  // Print the temperature in Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("F");
}

Weitere Funktionen der DallasTemperature Arduino-Bibliothek

Die DallasTemperature-Bibliothek enthält noch einige weitere nützliche Funktionen, die ich in den obigen Beispielen noch nicht behandelt habe. Ich habe daher einige davon unten aufgelistet:

setResolution()

Mit dieser Funktion kann die Auflösung der Temperatur-zu-Digital-Umwandlung eingestellt werden. Wie im Einführungsteil erwähnt, kann diese auf 9, 10, 11 oder 12 Bit gesetzt werden, was Temperaturinkrementen von 0,5 °C, 0,25 °C, 0,125 °C bzw. 0,0625 °C entspricht.

Sie fragen sich vielleicht, warum man die Auflösung ändern sollte – ist höher nicht immer besser? Ein Vorteil einer niedrigeren Auflösung ist, dass die Temperatur-zu-Digital-Umwandlung deutlich weniger Zeit benötigt. Das bedeutet, dass Sie in der gleichen Zeit mehr Temperaturmessungen durchführen können.

Aus dem Datenblatt habe ich folgende Informationen entnommen:

Auflösung	Temperaturinkrement	Maximale Konvertierungszeit
9 Bit	0,5 °C	93,75 ms
10 Bit	0,25 °C	187,5 ms
11 Bit	0,125 °C	375 ms
12 Bit	0,0625 °C	750 ms

Die DallasTemperature-Bibliothek erlaubt es, die Auflösung mit der Funktion setResolution() einzustellen. Diese Funktion kann im Setup- oder Loop-Teil Ihres Codes verwendet werden.

Sie können die Auflösung für alle angeschlossenen Sensoren wie folgt einstellen:

// Set the resolution for all devices to 9, 10, 11, or 12 bits:
sensors.setResolution(9);

Oder Sie stellen sie individuell für einen bestimmten Sensor ein, indem Sie seine Adresse angeben:

// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};

// Set the resolution of a specific device to 9, 10, 11, or 12 bits:
sensors.setResolution(sensor1, 9);

toFahrenheit()

Diese Funktion wandelt die Temperatur von Grad Celsius in Fahrenheit um.

float tempC = sensors.getTempCbyIndex(0);
float tempF = DallasTemperature::toFahrenheit(tempC);

setHighAlarmTemp() und setLowAlarmTemp()

Diese Funktionen setzen die internen Alarmtemperaturen für ein Gerät in Grad Celsius.

bool hasAlarm()

Diese Funktion gibt true zurück, wenn ein Gerät eine Alarmbedingung hat. Siehe das AlarmHandler.ino Sketch für ein Beispiel zur Verwendung dieser Funktion.

Anzeige der DS18B20 Temperaturwerte auf einem I2C LCD

Wenn Sie ein eigenständiges Projekt ohne Computer bauen möchten, ist es praktisch zu wissen, wie man die Temperaturwerte auf einem LCD-Display anzeigen kann.

Mit dem folgenden Beispielcode können Sie die Temperaturwerte auf einem 16×2 Zeichen I2C LCD anzeigen.

Der Anschluss des I2C LCD ist sehr einfach, wie im Verdrahtungsdiagramm unten zu sehen ist. Für weitere Informationen können Sie mein ausführliches Tutorial hier ansehen: How to control a character I2C LCD with Arduino. Wenn Sie stattdessen ein Standard-LCD ohne I2C verwenden möchten, schauen Sie sich diesen Artikel an: How to use a 16×2 character LCD with Arduino

DS18B20 with 16x2 character I2C LCD and Arduino — DS18B20 mit 16×2 Zeichen I2C LCD und Arduino

Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt:

I2C LCD Anschlüsse

I2C Zeichen LCD	Arduino
GND	GND
VCC	5 V
SDA	A4
SCL	A5

Um ein I2C LCD zu verwenden, müssen Sie die LiquidCrystal_I2C Arduino-Bibliothek installieren.

Öffnen Sie den Library Manager in der Arduino IDE und suchen Sie nach ‚liquidcrystal_i2c‘. Scrollen Sie dann nach unten und suchen Sie die Bibliothek von Frank de Brabander. Wählen Sie die neueste Version aus und klicken Sie auf Installieren.

Installing the LiquidCrystal_I2C Arduino library — Installation der LiquidCrystal_I2C Arduino-Bibliothek

DS18B20 mit I2C LCD Beispielcode

/* DS18B20 1-Wire digital temperature sensor with 16x2 I2C LCD and Arduino example code. 
  https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"
#include "LiquidCrystal_I2C.h"

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

LiquidCrystal_I2C lcd(0x27, 16, 2);

// Degree symbol:
byte Degree[] = {
  B00111,
  B00101,
  B00111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

void setup() {
  // Start up the library:
  sensors.begin();
  // Start the LCD and turn on the backlight:
  lcd.init();
  lcd.backlight();
  // Create a custom character:
  lcd.createChar(0, Degree);
}

void loop() {
  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

  // Fetch the temperature in degrees Celsius for device index:
  float tempC = sensors.getTempCByIndex(0); // the index 0 refers to the first device

  // Print the temperature on the LCD;
  lcd.setCursor(0,0);
  lcd.print("Temperature:");
  lcd.setCursor(0,1);
  lcd.print(tempC);
  lcd.write(0); // print the custom character
  lcd.print("C");

  // Wait 1 second:
  delay(1000);
}

Sie sollten die folgende Ausgabe auf dem LCD sehen:

DS18B20 LCD Display Output — LCD Display Ausgabe

Fazit

In diesem Tutorial habe ich Ihnen gezeigt, wie Sie DS18B20 1-Wire digitale Temperatursensoren mit Arduino verwenden. Ich hoffe, Sie fanden es nützlich und informativ.

Wenn Sie mehr über andere Temperatursensoren erfahren möchten, schauen Sie sich die untenstehenden Artikel an.

Wenn Sie Fragen haben, hinterlassen Sie bitte einen Kommentar unten.

Benne de Bakker