Praxisbericht DS18B20 Temperatursensor mit Praxisbeispiel

[BAXL]

In diesem Thema geht es um die Temperaturmessung mit einem Dallas DS18B20 Sensor

Die Temperaturmessung ist eine der häufigsten Anwendungen mit einem Arduino. Es gibt eine Vielzahl Möglichkeiten die Temperatur mit einem Arduino zu messen. Temperaturabhängige Widerstände wie Heißleiter (NTC - negativer TemperaturCoeffizient), das sind Widerstände die bei Temperaturanstieg ihren Widerstandswert erhöhen, Kaltleiter (PTC - positiver TemperaturCoeffizient), deren Widerstand sich bei Temperaturanstieg verringert, Platin- und Siliziumwiderstände, bei denen man über eine Messchaltung quasi über den fließenden Strom durch eine Spannungsfallmessung die Temperatur auswertet.

Das kann im Einzelnen eine sehr aufwändige Messschaltung erfordern. Es gibt aber auch Temperaturmesssensoren, die in kompakter Form die Messschaltung quasi in einem Bauteil enthalten. Dazu gehört auch der TMP35 / TMP 36 oder der LM 35 (DZ). Diese Sensoren liefern als Messergebnis bereits eine Spannung, die proportional zur gemessenen Temperatur ist. Diese Spannung liest man über einen analogen Messkanal ein und rechnet die Spannung in eine Temperatur um. In diesem Thema möchte ich mich aber nur auf den Dallas DS18B20 Messsensor konzentrieren und habe die anderen Varianten nur kurz und nicht komplett vollständig erwähnt.

Der Dallas DS18B20 ist ein Messensor, der sich besonders gut für Microcontrolleranwendungen eignet, weil dieser die gemessene Temperatur bereits als digitalen Wert liefert. Es gibt ihn in zwei typischen Bauformen, einmal in einem TO-Gehäuse, das sieht wie ein einfacher Transistor aus und in einer Tauchhülse mit Anschlusskabel. Beide Varianten haben ihren Einsatzzweck.

Angeschlossen wird der DS18B20 in den häufigsten Fällen mit drei Anschlüssen, Plus, Masse und eine Datenleitung. Die Datenleitung ist ein digitaler Ausgang, der das Messergebnis seriell an den Microcontroller übermitteln kann. Damit die Datenübermittlung funktioniert, muß man zwischen Plus und dem Datenausgang einen 4,7 Kiloohm Widerstand legen.

Es gibt zwei Varianten des DS18B20, die unterschiedlich angeschlossen werden, aber im Prinzip gleich funktionieren. Einmal die Variante, bei der tatsächlich Plus, Masse und die Datenleitung getrennt angklemmt werden und eine Varainte, die nur zwei Anschlüsse besitzt. Diese Sonderform wird im parasitären Modus betrieben, d.h., sie benötigt keine direkte Verbindung zu Plus. Masse und die Datenleitung müssen aber angeschlossen werden.

Damit diese parasitäre DS18B20 Sensortype funktioniert, muß trotzdem ein 4,7 Kiloohm Widerstand zwischen Plus und die Datenleitung gelegt werden. Die Elektronik im Sensor zieht in den Ruhephasen (wenn sie nicht angesprochen wird) quasi den Betriebsstrom über den 4k7 Widerstand und "lädt" sich darüber auf. Das aber nur der Vollständigkeit halber, weil ich selbst nur den Typ mit drei Anschlüssen verwende.

Eines der größten Vorteile der DS18B20 Sensoren ist die Möglichkeit, mehrere dieser Sensoren parallel zu betreiben. D.h., man benötigt jeweils nur Plus und Masse und kann die Datenausgänge aller verwendeten Sensoren gemeinsam an einen Digitaleingang eines Microcontrollers anschließen.

Um die Messwerte der einzelnen Sensoren gterennt abrufen zu können, hat jeder Sensor eine eigene Adresse, über die er angesprochen werden kann und auf Anforderung den Messwert übermittelt. Die Adressen sehen in hexadezimaler Schreibweise etwa so aus : {0x28, 0xAA, 0xD9, 0xA6, 0x3B, 0x14, 0x01, 0x16}.

 

[BAXL]

Anschließen und auslesen

Kommen wir nun zum Anschluss am Arduino. Der Plusanschluß des DS18B20 kommt an +5V vom Arduino und der Masseanschluß an GND. Die Datenleitung kann man z.B. am Digitalport 5 oder 2 oder so des Arduinos anklemmen. Natürlich den 4k7 Widerstand zwischen dem Digitalport und +5V nicht vergessen.

Um den DS18B20 bedienen zu können benötigt man wieder entsprechende Bibliotheken / Librarys, die man fertig aus dem Internet bekommt. Zentrale Bliblithek ist dabei die One Wire Bibliothek, die die Datenkommunikation über einen Draht abwickelt, daher auch der Name OneWire für EinDraht.

Die Bibliothek wird im Programm ganz an den Anfang gesetzt, also noch vor void loop() und vor void setup() und auch noch bevor man die erforderlichen Variablen deklariert. Eingebunden wird die OneWire Bibliothek mit dem Befehl: #include <wire.h>
Für die Dallas DS18B20 Temperatursensoren benötigt man noch eine weitere Bibliothek die man mit dem Befehl: #include <DallasTemperature.h> einbindet.

Kompakt sieht das dann so aus:
#include <Wire.h>
#include <DallasTemperature.h>

Nun definieren wir weitere Varaiblen um den Eindrahtbus und die Dallas Sensoren bedinen zu können. Je nach dem auf welchen Digitalport die Datenleitung angeschlossen ist, muß das angegeben werden. In meinem Beispiel wäre das Digitalport 5. Verwendet man einen anderen Digitalport, z.B. Port 2, muß die 2 eben angegeben werden.

#define ONE_WIRE_BUS 5 // der Eindrahtbus für die DS18B20 liegen auf Digitalport 5

Die Dallassensoren können die Messwerte mit unterschiedlicher Auflösung ermitteln. Es stehen dabei Auflösungen von 9, 10, 11 und 12 Bit zur Verfügung. Je höher die Zahl, umso höher ist die Auflösung der Messung.

• 9 Bit: 0,5 ° C
• 10 Bit: 0,25 ° C
• 11 Bit: 0,125 ° C
• 12 Bit: 0,0625 ° C

Je höher die eingestellte Auflösung ist, umso länger dauert auch der Wandlungsprozess, d.h. die Zeit (Messdauer), nach der der Messwert an den Arduino zurückgeliefert wird.

Es wird übrigens angegeben, dass der DS18B20 eine Messgenauigkeit/Abweichung (nicht Auflösung!) von 0,5°C zur tatsächlichen Temperatur hat. Diese Genauigkeit ist zwischen -10 bis +85 Grad Celsius.

Es stellt sich die Frage, welche Auflösung man für die gewünschte Anwendung benötigt, bzw. was sinnvoll ist. Die Messdauer zwischen 12 Bit und 9 Bit Auflösung ist auch ohne Stoppuhr deutlich spürbar. Es wird angegeben, dass die Wandlungszeit zwischen ca. 95ms (9 Bit) bis 750ms (12 Bit) beträgt. Man sollte das im Programmablauf einkalkulieren und zwischen zwei Messaufrufen entsprechend genug Zeit einplanen. Ich habe festgestellt, dass ich bei höheren Auflösungen durchaus bis zu 1000ms Pause lassen musste, um gescheite Messwerte zu bekommen.

Damit man die Auflösung im Programm nur an einer Stelle ändern muß, definiert man einen Wert dafür.

#define DS18B20_Aufloesung 10 // Die Auflösung kann 9, 10, 11, oder 12 betragen

Beabsichtigt man im Programm mehrere Sensoren abzufragen und man möchte die Messwerte genau dem Sensor zuordnen können, empfiehlt es sich die Adressen der Sensoren vorher auszulesen (dazu später mehr) und diese Adressen in ein Array abzulegen. Das Array definiert man mit dem Befehl:

DeviceAddress DS18B20_Adressen; // in diesem Array werden die Adressen der DS18B20 Sensoren hinterlegt

Jetzt müssen die Objekte für die Messung deklariert werden. Zuerst brauchen wir ein Objekt, das den Eindrahtbus händelt und daraus wird das Objekt für die DS18B20 erzeugt. Die zweite Vereinbarung für die DS18B20 ist deshalb nötig, weil es auch andere Perepheriegeräte gibt, die auf einem Eindrahtbus laufen können und dafür ebenfalls die OneWire Bibliothek verwenden. Die Vereinbarungen lauten:

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

Für den Fall, dass mehrere Sensoren gleichzeitig an einem Bus laufen sollen, müssen nun die Adressen angegeben werden.

ACHTUNG! Die nun folgenden Adressen sind die von meinen DS18B20 und sind nur als Beispiel zu betrachten. Die Adressen für Deine DS18B20 müssen erst noch ermittelt werden!

DeviceAddress Sensor1 = {0x28, 0xAA, 0x20, 0xD0, 0x3B, 0x14, 0x01, 0xE2};
DeviceAddress Sensor2 = {0x28, 0xAA, 0xD9, 0xA6, 0x3B, 0x14, 0x01, 0x16};
DeviceAddress Sensor3 = {0x28, 0xAA, 0x9B, 0x9E, 0x19, 0x13, 0x02, 0x7F};
DeviceAddress Sensor4 = {0x28, 0xAA, 0x5A, 0xD6, 0x3B, 0x14, 0x01, 0x3B};
... // hier können noch weitere Sensoren deklariert werden

Aus praktischen Erwägungen, die ich der Übersichtlichkeit halber hier nicht ausführlich erläutere, definieren wir noch eine Variable für die Anzahl der maximal angeschlossenen Sensoren. Der aufmerksame Leser wird den Grund aber schnell selbst bemerken.

#define Anzahl_Sensoren_DS18B20 3 // Anzahl der angeschlossenen Sensoren - Mögliche Werte: '0','1','2' ...

Die Zahl 3 ergibt sich aus einer Beispielanwendung von mir, bei der ich 3 Sensoren angeschlossen habe. Bei Dir können es mehr, aber auch weniger sein.

Es kann durchaus vorkommen, dass ein Sensor mal kaputt geht, oder nicht richtig angeschlossen wurde, dann bekommt der Arduino natürlich keinen vernünftigen Messwert zurückgeliefert. Damit wir das auch im Programm erkennen können, definieren wir einfach einen fiktiven wert, der als Messung nie auftauchen kann und nennen den:

const float No_Val = 999.99; // Wert falls der Sensor nicht vorhanden oder defekt ist

Zum Speichern der eingelesenen temperaturen lege ich ebenfalls ein Datenarray an und nenne das:

float Temperatur[3] = {No_Val, No_Val, No_Val};

Das Array hat in meinem Fall drei Speicherplätze und wird am Start erstmal mit No_Val gefüllt, was dem Zahlenwert 999.99 entspricht.


Als nächstes kümmern wir uns um die Setuproutine void setup()

In der Setuproutine "starten" wir das DS18B20 Objekt und setzen wir die Messauflösung der angeschlossenen Sensoren. Der Einfachheit halber benutze ich eine gemopste Schleife aus einem Beispielprogramm.

myDS18B20.begin(); // Objekt starten

Die folgende Schleife benötigt nicht die konkreten Adressen der angeschlossenen DS18B20 Sensoren, sondern geht automatisch alle angeschlossenen Sensoren der Reihe nach durch. Diese Besonderheit, in gewissen Situationen nicht die genauen Adressen bereits zu kennen, wird uns später noch zu Nutze sein. Im Moment ist das nur eine ganz einfache Methode, um mit ganz wenig Code auf einen Rutsch alle angeschlossenen Sensoren auf die gewünschte Auflösung zu setzen.

for (byte i = 0 ; i < myDS18B20.getDeviceCount(); i++) {
if (myDS18B20.getAddress(DS18B20_Adressen, i)) {
myDS18B20.setResolution(DS18B20_Adressen, DS18B20_Aufloesung);
}
}

In der Hauptschleife void loop() können nun die Messwerte der Sensoren abgerufen werden. Dazu wären eigentlich nur die folgende Programmzeile nötig:

myDS18B20.requestTemperaturesByAddress(SensorNr);
messwert = myDS18B20.getTempC(SensorNr);

Für SensorNr setzt man einen der oben deklarierten Sensoren ein, also Sensor1, oder Sensor2, oder Sensor3, die Variable messwert müsste dann vorher ( vor void setup() ) auch noch als Datentyp float definiert werden, was etwa so aussieht:

float messwert = 0;

Die oben gezeigten Zeilen sind aus einem fertigen Programm quasi herausgerissen worden und sollen nur zeigen, was auf jeden Fall in einem Programm enthalten sein muß, damit man mehrere DS18B20 temperatursensoren gezielt mit einer definierten Auflösung auslesen kann. Es geht auch etwas einfacher, wenn in einer Anwendung nur ein einziger DS18B20 angeschlossen ist und das auch so bleiben soll, d.h., dass nicht geplant ist noch weitere Sensoren anzuschließen und gezielt auslesen zu wollen.

Weitere Erläuterungen und Beispielprogramme folgen...

 

[BAXL]

Die Adressen von DS18B20 Sensoren ermitteln

Wenn man die DS18B20 geliefert bekommt, weiß man nicht welche Adressen sie haben, das steht leider nirgendwo drauf. Dafür gibt es aber einen ganz einfachen Trick. Mit einem einfachen Programm veranlasst man die Sensoren ihre Adresse zu übermitteln. Diese lässt man sich auf dem seriellen Monitor am PC anzeigen und schreibt sie sich auf. Natürlich muß man sich merken, welche Adresse zu welchem Sensor gehört.

Wer schreibfaul ist macht sich eine Textdatei und kopiert sich die ausgegebenen Werte vom seriellen Monitor in die Textdatei und speichert die. Natürlich muß man die Sensoren irgendwie eindeutig beschriften und die beschriftung auch in die Textdatei übernehmen. Klingt jetzt doof, aber so mach einer übersieht das im Eifer des Gefechtes.

Das Programm ist ein Beispielprogramm der OneWire Bibliothek, weshalb ich das nicht ausführlicher zerlege und erläutere.

Lediglich die Zeile

OneWire ds(3); // Anschluss an PIN 3

ist erwähnenswert. Hier muß man selbstverständlich die Pinnummer angeben, an die man die Datenleitung des DS18B20 anschließt. Ich empfehle immer nur einen einzigen Sensor anzuschließen und das Programm dann zu starten. Klemmt man sofort mehrere Sensoren an weiß man wieder nicht welche Adresse zu welchem Sensor gehört .

Beim Anschließen, ich weiß, ich wiederhole mich, nicht vergessen zwischen Plus und der Datenleitung einen 4k7 Widerstand zu legen.

#include <OneWire.h>

OneWire  ds(3);  // Anschluss an PIN 3

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

void discoverOneWireDevices(void) {
  byte i;
  byte present = 0;
  byte data[12];
  byte addr[8];

  Serial.print("Nach 1 Leitung Sensor suchen\n\r");
  while(ds.search(addr)) {
    Serial.print("\n\rGefunden \'1-Wire\' fuehler mit der Adresse:\n\r");
    for( i = 0; i < 8; i++) {
      Serial.print("0x");
      if (addr[i] < 16) {
        Serial.print('0');
      }
      Serial.print(addr[i], HEX);
      if (i < 7) {
        Serial.print(", ");
      }
    }
    if ( OneWire::crc8( addr, 7) != addr[7]) {
        Serial.print("CRC is not valid!\n");
        return;
    }
  }
  Serial.print("\n\r\n\rDas war es... mehr kommmt nicht:)\r\n");
  ds.reset_search();
  return;
}

void loop(void) {
  // nothing to see here
}

 

[BAXL]

Ein kurzes Intermezzo zur Adressierung der Sensoren.

Die DS18B20 Sensoren haben jeder eine eigene eindeutige Adresse. Das ist wichtig, damit sich die Sensoren auf dem gemeinsamen Datenbus nicht ins Gehege kommen und man einen Sensor gezielt und einzeln ansprechen kann. Dazu ist es möglich, wie bereits in den Vorposts beschrieben, jedem Sensor die Adresse zu entlocken. Die eindeutige Zuordnung des Sensors zur Adresse ist bei Applikationen erforderlich, in denen man genau wissen muß, von welchem Sensor die Temperaturmessung kommt.

Ein Beispiel ist mein Solarsteuerungsprojekt. Da soll immer eine Umwälzpumpe anspringen, wenn die Temperatur am Solarkollektor höher ist, als die Temperatur im Wasserkessel. Dazu muß ich zur sinnvollen Auswertung schon wissen welche Messung vom Kollektor und welche vom Kessel kommt. Da ist es obligat, die Sensoradressen zu kennen und an der richtigen Stelle im Programm abzurufen.

Wenn es egal ist, welche Temperatur von welchem Sensor kommt, kann man sich die Sache auch einfacher machen, ohne die Sensoradressen zu kennen. Ein Spezialfall ist auch, wenn nur ein einziger Sensor Bestandteil der Applikation ist und eine Erweiterung auf mehrere Sensoren von vornherein ausgeschlossen wird.

 

[BAXL]

Anwendungsfall: Nur ein DS18B20 in einer Applikation

Verwendet man nur einen DS18B20 in einer Applikation kann man sich im Prinzip das vorherige Auslesen der Adresse sparen. Das hat zudem den Vorteil, falls ein Sensor ausgetauscht werden muß, muß man nicht jedesmal den Code an die neuen Adresse anpassen und erneut den Arduino beschreiben.

Das alternative Verfahren, zum Auslesen einer Temperatur, habe ich in einer eigenen Anwendung verwendet. In der Anwendung betreibe ich mehrere Arduinos als Messtellen und sende die Temperatur zu einer Zentrale, die diese Temperaturen auf einem Display darstellt. Alarmanlage/Smart Home mit Arduino - vorbereitende Experimente

Um den Sensor bedienen zu können, müssen wieder einige Deklarationen im Programm vorgenommen werden, die da lauten:

// Einbinden eines Dallas DS18B20 Temperatursensors
#include <DallasTemperature.h> // Library für Dallas Temperatursensoren
#define ONE_WIRE_BUS 5 // der Eindrahtbus für die DS18B20 liegen auf Digitalport 5
#define DS18B20_Aufloesung 11 // Die Sensoren sollen eine 11 Bit Auflösung liefern

OneWire oneWire(ONE_WIRE_BUS); // Erstellen einer Instanz
DallasTemperature myDS18B20(&oneWire);
float messwert = 0;


In die void setup() muß folgende Programmzeile eingefügt werden:

myDS18B20.begin(); // Start des DS18B20 Sensors

In void loop() wird die Temperatur dann wie folgt ausgelesen:

myDS18B20.requestTemperatures(); // DS18B20 anweisen eine Temperatur zu messen
messwert = myDS18B20.getTempCByIndex(0); // Messwert des ersten verfügbaren Sensors (Index 0) abrufen

Das war es im Wesentlichen schon. Innerhalb eines Programms sieht das dann so aus:

// Programm zur Übermittlung eines Schalterzustandes mit einem 2,4 GHz NRF24 Modul

// Die Betriebsspannung vom NRF24 Modul MUSS!! an 3,3V vom Arduino angeschlossen werden
// ACHTUNG!!! ca 10 nF Elko zwischen 3,3V und Masse schalten um die Übertragung zu stabilisieren

// Bibliotheken zur Bedienung des NRF24 Moduls
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

// Einbinden eines Dallas DS18B20 Temperatursensors
#include <DallasTemperature.h>      // Library für Dallas Temperatursensoren
#define ONE_WIRE_BUS 5              // der Eindrahtbus für die DS18B20 liegen auf Digitalport 5
#define DS18B20_Aufloesung 11       // Die Sensoren sollen eine 11 Bit Auflösung liefern

OneWire oneWire(ONE_WIRE_BUS);      // Erstellen einer Instanz
DallasTemperature myDS18B20(&oneWire);

float Raumtemperatur;                   // Variablen für die Temperaturwerte der Messstellen definieren

// Variablen und Instanzendefinition für das NRF Modul
RF24 radio(8, 9);                 // CE, CSN - die Zahlen geben die Digitalports am Arduino an,  Instatz um das Modul zu starten
const byte address[6] = "00001";  //Adresse, auf dem die Empfangsdaten gesendet werden sollen. Der Empfänger benötigt dieselbe Adresse!
int button_state = 0;
int tempTrans = 0;
int button_pin = 7;               // Signalpin zum Einlesen des Schaltsignals (Taster, Bewegungsmelder etc.)

// Variablen zur Zeitmessung
  unsigned long MessIntervallms = 5000; // Messintervall ca. 5s
  unsigned long startzeit;              // Merker für die Systemzeit beim Eintreten einer bewegung
  unsigned long vergangene_zeit;        // ausgerechneter Wert zwischen Merker und aktueller Systemzeit

void setup() {
  Serial.begin(9600);             // Start des seriellen Ausgabe per USB an einen PC
  pinMode(button_pin, INPUT);     // Port zum Einlesen des Schalterzustandes konfigurieren
  radio.begin();                  // Start der 2,4 GHz Wireless Kommunikation
  radio.openWritingPipe(address); // Setzen der Sendeadresse zur Übermittlung der Daten
  radio.setPALevel(RF24_PA_HIGH); // Leistung des NRF Moduls je nach Entfernung kann man von  MIN bis MAX einstellen (MAX,HIGH,LOW,MIN)
  radio.stopListening();          // Das angeschlossene Modul wird als Sender konfigurieret

  myDS18B20.begin(); // Start des DS18B20 Sensors

}
void loop()
{
  button_state = digitalRead(button_pin); // Einlesen des Schalterzustandes
  Serial.println(button_state);           // Kontrollausgabe des Schalterzustandes am PC-Monitor

  // Temperatur alle 5s einlesen
  vergangene_zeit = millis() - startzeit;     // Abfrage ob Wartezeit um ist.
      if (vergangene_zeit > MessIntervallms)  // Wenn die Wartezeit vorrüber ist
      {
          Raumtemperatur = LeseTemperaturDS();      
          startzeit = millis(); // Neue Startzeit setzen
          Serial.print("Temperatur: "); Serial.println(Raumtemperatur);
      }


  tempTrans = Raumtemperatur*100;
  int message[2] = {int(tempTrans),int (button_state)};
  radio.write(&tempTrans, sizeof(tempTrans));

  delay(50);
}

// Funktion zum Auslesen eines !einzigen! DS Sensors ohne Adresse, Der Wert wird drei mal eingelesen und der Mittelwert gebildet
float LeseTemperaturDS()
{
  int x = 0;
  float messwert = 0;
  for (x = 1; x < 4; x++)
  {
    myDS18B20.requestTemperatures(); // DS18B20 anweisen eine Temperatur zu messen
    messwert = messwert + myDS18B20.getTempCByIndex(0); // Messwert des ersten verfügbaren Sensors (Index 0) abrufen
    delay(10);
  }
  return messwert / 3;
// Ende LeseTemperaturDS
}

 

[BAXL]

Einfache Anwendung als Raumthemometer

Um die Sache etwas einfacher und übersichtlicher darzustellen, habe ich rasch eine ganz simple Schaltung zusammengesteckt. Ich verwende in der Schaltung einen Arduino Uno, ein 1602 LCD Display, einen x-beliebigen DS18B20 (dessen Adresse ich nicht kenne), einen 4k7 Widerstand und ein paar Steckbrücken. Das Programm macht nichts weiter als alle 1,5s die Temperatur vom DS18B20 abzurufen und auf dem 1602 Display darzustellen. Wir haben damit ein einfaches Raumthermometer .

Das dazugehörige Programm ist minimalistisch und recht übersichtlich.

// Einfache Schaltung mit einem DS18B20 und einem 1602 Display als Raumthermometer

// Deklaration zur Bedinung eines 1602 LCD Displays
#include <Wire.h>
#include <LiquidCrystal_I2C.h> // LiquidCrystal_I2C Bibliothek einbinden
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Einbinden eines Dallas DS18B20 Temperatursensors
#include <DallasTemperature.h>      // Library für Dallas Temperatursensoren
#define ONE_WIRE_BUS 5              // der Eindrahtbus für die DS18B20 liegen auf Digitalport 5
#define DS18B20_Aufloesung 11       // Die Sensoren sollen eine 11 Bit Auflösung liefern

OneWire oneWire(ONE_WIRE_BUS);         // Erstellen einer ONE_Wire Instanz
DallasTemperature myDS18B20(&oneWire); // Erstellen einer DS18B20 Instanz
float Temperatur = 0; // Variable zur Übernahme des Temperaturmesswertes

void setup() {
   lcd.init(); //Im Setup wird der LCD gestartet
  lcd.backlight(); //Hintergrundbeleuchtung einschalten (lcd.noBacklight(); schaltet die Beleuchtung aus).
  lcd.setCursor(0,0);
  lcd.print("DS18B20 Test");
  delay(1500);
  lcd.clear();
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Temperatur:");
}

void loop() {
  myDS18B20.requestTemperatures(); // DS18B20 anweisen eine Temperatur zu messen
  Temperatur = myDS18B20.getTempCByIndex(0); // Messwert des ersten verfügbaren Sensors (Index 0) abrufen  
  lcd.setCursor(0,1);
  lcd.print(Temperatur); lcd.print("\xDF" "C ");
  delay(1500);
}

 

[BAXL]

Reservepost für evtl. weitere Ausführungen. Es darf aber ab hier im Thema geschrieben werden.