Dallas DS18B20 immer 0°C bzw. 32°F

Wie es in der Überschrift schon steht bekomme ich als Temperaturwert im 0° Celsius zurück. Am Temperatursensor scheint es nicht zu liegen ich hab mehrere ausprobiert die zeigen alle den gleichen Wert an.

Hat jemand eine Idee

Dann ist deine Verdrahtung falsch. Hast du einen Pullup-Widerstand (Datenpin 4,7 k gegen +5Volt) eingebaut ? Und wie sieht dein Sketch aus ?

Hallo,

da gibt es tausend Ideen. Nur ohne deine Schaltung und Code zu kennen wäre das nur wildes raten.

Hallo Haribo, schaue einmal ins Datenblatt Deines DS18B20. Dort gibt es Schaltpläne wie dieser genau zu verdrahten ist. Und schaue auch einmal nach ob es ein DS18B20 ist, und kein DS18S20 o.a.

Die Sketche laufen bei richtiger Verdrahtung fehlerfrei durch. Gruß und Spaß Andreas

Danke für die Antworten.
Ich hab mal versucht ein Photo von der Schaltung zum machen.

Hier der Sketch

/* DS18B20 Sensor an Arduino Uno */
#include <OneWire.h>
#include <DallasTemperature.h>

// Datenleitung an Pin10
#define ONE_WIRE_BUS 10

// oneWire Instanz erzeugen
OneWire oneWire(ONE_WIRE_BUS);

// Referenz zu DallasTemperature
DallasTemperature sensors(&oneWire);

//Adresse des Sensors
DeviceAddress insideThermometer = { 0x28, 0x75, 0xD8, 0xB5, 0x05, 0x00, 0x00, 0x28 };

// einmalig 
void setup() 
{
 Serial.begin(9600); 

 // Bibliothek starten
 sensors.begin();
 // Resolution auf 10 bit setzen
 sensors.setResolution(insideThermometer, 10);
}



// Funktion zur Ausgabe der Temperatur
void printTemperature(DeviceAddress deviceAddress)
{
 float tempC = sensors.getTempC(deviceAddress);
 if (tempC == -127.00) {
 Serial.print("Erroring temperature");
 } else {
 Serial.print("C");
 Serial.print(tempC);
 Serial.print(" F: ");
 Serial.print(DallasTemperature::toFahrenheit(tempC));
 } 
}



// Dauerschleife
void loop() 
{
 //Serielle Ausgabe
 delay(2500);
 Serial.print("Getting Temperatures...\n\r");
 sensors.requestTemperatures();
 
 Serial.print("Inside Temperature is: ");
 printTemperature(insideThermometer);
 Serial.print("\n\r\n\r");
}

Prüfe nochmal deinen Sketch. Der gemessene Wert des Sensor wird nicht auf dem SerialMonitor angezeigt. Der Wert läuft ins leere. Leider kann ich grad kein Beispiel zeigen, da ich keinen Zugriff auf meine Dateien habe. In den Beispielen der Library wirst du fündig. Edit: Beispiel

Ich habs nicht getestet würde aber wohl Serial.print(Temperature(insideThermometer)); schreiben

Hallo,
“DeviceAddress insideThermometer = { 0x28, 0x75, 0xD8, 0xB5, 0x05, 0x00, 0x00, 0x28 };”

Wie bist Du an die ID gekommen. Ist es die Deines Sensor, oder die aus dem Sketch?
Und wenn ich es richtig sehe, muß der Widerstand auf PLUS.
Gruß und Spaß
Andreas

Das Bild ist sehr undeutlich, ich würde allerdings sagen, der Widerstand geht auf Plus.

Ja der Widerstand geht auf Plus.

Ich hab jetzt eine weiteren Sketsch ausprobiert.

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

const unsigned long BAUD_RATE = 9600;
const unsigned char ONE_WIRE_BUS = 4;

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

void setup() {
  sensoren.begin();
  Serial.begin(BAUD_RATE);
  Serial.print("Anzahl Sensoren: ");
  Serial.println(sensoren.getDeviceCount());
  Serial.print("Modus ist: ");
  if (sensoren.isParasitePowerMode()) {
    Serial.println("Parasitär");
  } else {
    Serial.println("Normal");
  }
}

void loop() {
  sensoren.requestTemperatures();
  float temperatur = sensoren.getTempCByIndex(0);
  Serial.println(temperatur);
  delay(1000);
}

So wie es aussieht wird der Sensor nicht erkannt.

Anzahl Sensoren: 0
Modus ist: Normal
0.00
0.00
0.00
0.00
0.00
0.00
0.00

Versuch mal die Temperatur über index 0 anstatt device address einzulesen

Hallo,
Freunde, das kann´s doch nicht sein… für mich sieht der Widerstand nach Minus aus.

Wenn Du einen neuen Sketch anlegst und nachfolgendes kopierst:

#include <OneWire.h>
#include <Wire.h>
OneWire  ds(10);  // on pin 10

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

  void loop() {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;
    if ( !ds.search(addr))
    if (OneWire::crc8(addr, 7) != addr[7]) {
      Serial.println("CRC is not valid!");
      return;
  }
  Serial.println();
   switch (addr[0]) {
   Serial.println("Device is not a DS18x20 family device.");
      return;
  }
  ds.reset();
  ds.select(addr);
  ds.write(0x44,1);       
 //   delay(500);
  present = ds.reset();
  ds.select(addr);   
  ds.write(0xBE);       
 for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }
  unsigned int raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // count remain gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    if (cfg == 0x00) raw = raw << 3;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw << 2; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms
    // default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (float)raw / 16.0;
  Serial.print(celsius,1);
  Serial.print(" Grad");
  delay(1000);
}

und auf den Arduino lädst, dann läuft der Sensor!
Wenn nicht- dann ist das Ding defekt, oder falsch verdrahtet.
Gruß und Spaß
Andreas

Nach genauem Hinsehen würde ich auch sagen, dass der Widerstand auf Masse geht.

ElEspanol: Nach genauem Hinsehen würde ich auch sagen, dass der Widerstand auf Masse geht.

Neeee.... ;)

Hallo,

meine Meinung ist, wenn die Bsp. der Lib nicht funktionieren, dann liegt der Fehler in der Schaltung. Weil die Lib gibt es schon sehr lange.

h4rib0:
Ich hab jetzt eine weiteren Sketsch ausprobiert.

Wo bekommst Du solchen nicht funktionierenden Scheißdreck an Sketch eigentlich her?
Warum hältst Du Dich nicht an funktionierende Beispielprogramme zur Library?

Und warum informierst Du Dich exakt NULL darüber, wie so ein Sensor funktioniert?

Hier mal eine kurze Zusammenfassung wie die Temperaturmessung mit Deinem Sensor abläuft, es handelt sich um einen dreistufigen Ablauf

Stufe1: Du forderst in Deinem Sketch eine Temperaturkonversion vom Sensor an
Typischer Code bei Verwendung der Dallastemperature-Library: sensors.requestTemperatures();

Stufe 2: Du wartest die Konversionszeit ab, während der der Sensor die Temperatur in Daten konvertiert.
Stufe2 kann bei neueren Versionen der Dallastemperature Library (neuer als ca. 5 Jahre alt) entfallen

Stufe 3: Du liest die konvertierte Temperaturdaten aus dem Sensor aus

Im Fall, dass Du eine weniger als 5 Jahre alte Dallastemperature Library verwendest und Stufe 2 wegläßt, ist Stufe 3 eine blockierende Funktion: Die Funktion blockiert den Programmablauf dann beim Auslesen der Daten automatisch bis zum Ablauf der Konversionszeit und bis die Temperaturdaten tatsächlich zur Abholung bereitstehen und liefert diese dann ggf. mit Verzögerung zurück.

Der Sensor braucht die Konversionszeit (Dauer hängt von der Auflösung ab), ohne geht es nicht.
Und ohne einen Request (Anforderung zur Temperaturkonversion zu senden funktioniert die Library auch nicht.

h4rib0:
So wie es aussieht wird der Sensor nicht erkannt.

Das halte ich für unwahrscheinlich.

So wie es aussieht, fordert Dein Sketch nie eine Temperaturkonversion an und deshalb kannst Du nie etwas anderes als 0 auslesen.

Ein Aufruf von requestTemperatures() kommt in Deinen Sketchen überhaupt nicht vor.

Du hältst den Ablauf nicht ein:

Mit einer uralten Library -wäre der Ablauf:

  • Request zur Temperaturkonversion an den Sensor senden
  • Konversionszeit abwarten
  • Temperaturdaten auslesen

Mit einer weniger als 5 Jahre alten Library ist auch diese alternative Ablauflogik möglic:h

  • Request zur Temperaturkonversion an den Sensor senden
  • Temperaturdaten auslesen (die Funktion liefert die Daten aber erst nach Ablauf der Konversionszeit (blockiert also das Programm bis zu 750 Millisekunden lang

Hier habe ich Dir noch einen Link auf ein einfaches Beispielprogramm zur Dallastemperature Library herausgesucht:
https://github.com/milesburton/Arduino-Temperature-Control-Library/blob/master/examples/Simple/Simple.pde
Dieser Beispiel-Sketch ist für neuere Dallastemperature Libraries, weil es nach requestTemperatures(); kein Abwarten bis zum Ende der Konversionszeit gibt, sondern der nachfolgende Aufruf von getTempCByIndex(0)); dann so lange blockiert, bis der Sensor ausreichend Konversionszeit bekommen hat.

Vielleicht kannst Du Deinen Sketch darauf aufbauen?

Hallo,

also laut meiner Logik ist es völlig egal wie alt die Dallas Lib ist. Sie funktionieren alle. Neuere wurden nur weiter verbessert. Wenn man dessen Bsp. verwendet und nicht irgendwelchen Schrott von irgendwelchen Internetseiten die das dann erklären wollen. In sofern bleibe ich dabei das seine Schaltung fehlerhaft ist. Ich verstehe auch nicht warum er immer nur Code ausprobiert anstatt mal seine Schaltung zu überprüfen. Davon erwähnt er nie etwas. Kann ich wirklich nicht nachvollziehen.

Genau. Bleibt also noch: Verdrahtungsfehler Sensor kaputt Pullup kaputt Kabelbruch Breadboardkontakte Troll Arduino kaputt

Sollte nun vom TO alles nacheinander abgearbeitet werden, Fehler ausgrenzen, eingrenzen, Teile austauschen, Digitaleingang anderen verwenden, Arduino auf korrekte Funktion testen, Widerstand nachmessen, am besten in der Schaltung, etc., dann wird es funktionieren. Viel Spass dabei

hallo Ich habe das gleiche Problem. Allerdings werden bei mir die Daten über einen ATTiny84A-Pu ausgelesen und dann über das nRF24L01 Modul an einen Arduino Uno gesendet. Angeschlossen sollte alles richtig sein. (Mehrmalige Kontrolle) Bei einem Test ohne das Kommunikationsmodul hat alles problemlos funktioniert. Deshalb gehe ich davon aus, dass der Fehler bei mir beim Auslesen liegen muss.

Hallo, also der Sensor ist am ATTiny84A-Pu angeschlossen? Ohne nRF24L01 bekommst Du die richtigen Werte geliefert? Funktioniert denn die grundsätzliche Kommunikation zwischen ATTiny84A-Pu und Arduino Uno? Gruß und Spaß Andreas