Temperatursteuerung DS18S20 und Arduino

[Sven L. (eet)]

Guten Tag,
ich programmiere eine Temperatursteuerung mit einem DS18S20 und einem 
Arduino Uno. Für das von mir geschriebene Programm habe ich ein Programm 
aus dem Internet gefunden und angepasst. Das Programm funktioniert. Nur 
habe ich ein kleines Verständnisproblem mit der Auslesung der Temperatur 
und der Konvertierung in die notwendige Kommazahl.

Den betreffenden Quellcode habe ich eingefügt. Der Quellcode setzt sich 
aus drei Quelltexten zusammen. Quelltext 1 und 3 sind für mich zu 100% 
nachvollziehbar. Nur die Berechnung der Temperatur aus Quelltext 2 ist 
für mich problematisch.


Quelltext 1

void loop(void) {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;

  if ( !ds.search(addr)) {
    Serial.println("Keine weiteren Adressen.");
    Serial.println();
    ds.reset_search();
    delay(250);
    return;
  }
  
  Serial.print("ROM =");
  for ( i = 0; i < 8; i++) {
    Serial.print(' ');
    Serial.print(addr[i], HEX);
  }
  if (OneWire::crc8(addr, 7) != addr[7]) {
    Serial.println("CRC nicht gültig!!");
    return;
  }
  Serial.println();
  switch (addr[0]) { // the first ROM byte indicates which chip
    case 0x10:
      Serial.println("Gerät ist aus der DS18S20 Familie.");  
      type_s = 1;
      break;
    case 0x28:
      Serial.println("Gerät ist aus der DS18B20 Familie.");
      type_s = 0;
      break;  
    default:
      Serial.println("Gerätefamilie nicht erkannt");
      return;
  }
  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1); // startet Konvertierung, mit power-on am Ende
  delay(1000);       // 750ms sollten ausreichen
  // man sollte ein ds.depower() hier machen, aber ein reset tut das auch
  present = ds.reset();
  ds.select(addr);
  ds.write(0xBE);         // Wert lesen
  Serial.print("  Data = ");
  Serial.print(present, HEX);
  Serial.print(" ");
  for ( i = 0; i < 9; i++) { //  9 Bytes
    data[i] = ds.read();
    Serial.print(data[i], HEX);
    Serial.print(" ");
  }
  Serial.print(" CRC=");
  Serial.print(OneWire::crc8(data, 8), HEX);
  Serial.println();

Also verstanden habe ich, dass sich die Temperatur aus zwei Bytes 
zusammen setzt. Das ist das Byte 0 und das Byte 1, welches der 
Microcontroller vom Zwischenspeicher (scratchpad) des DS18S20 erhalten 
hat. Byte 1 ist zuständig für das Vorzeichen (MSB) und Byte 0 stellt die 
Zahl an sich dar(LSB). Aber welchen Einfluss haben Byte 6 (COUNT REMAIN) 
und Byte 7 (COUNT PER °C) und warum? Warum ist der Quellcode so gewählt, 
wie er unten aufgeführt ist? Speziell interessiert mich der Bereich bis 
zur Verwendung der Variablen "cfg", da dieser den DS18S20 beschreibt. 
Der untere Bereich ist für den DS18B20 zuständig. Es wäre nett, wenn ihr 
mir den oberen erklären könntet. Über den unteren freue ich mich 
ebenfalls. Ich bin nicht so der Programmierer, also es wäre 
wahrscheinlich hilfreich, wenn ihr es so einfach wie möglich erklärt.

Quelltext 2

  // Convert the data to actual temperature
  // because the result is a 16 bit signed integer, it should
  // be stored to an "int16_t" type, which is always 16 bits
  // even when compiled on a 32 bit processor.
  int16_t 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);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;      // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 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;

Quelltext 3

  //fahrenheit = celsius * 1.8 + 32.0;
  Serial.print("  Temperatur = ");
  Serial.print(celsius);
  Serial.print(" Celsius, ");
  //Serial.print(fahrenheit);
  //Serial.println(" Fahrenheit");
  lcd.setCursor(0, 1);        // LCD Display ausgeben
  lcd.print("                ");
  lcd.setCursor(0, 1);
  lcd.print(celsius);
  lcd.print((char)223);       // Grad Symbol ausgeben
  lcd.print("C  ");
  //lcd.print(fahrenheit);
  //lcd.print((char)223);
  //lcd.print("F");
}

Vielen Dank im Voraus und ich wünsche ein frohes neues Jahr! :)

[Martin B. (Gast)]

Das ist in der Formel zur Berechnung der Temperatur aus dem Datenblatt 
begründet.

Die heisst:

TEMPERATURE=TEMP_READ-0,25+(COUNT_PER_C-COUNT_REMAIN)/COUNT_PER_C

COUNT_PER_C ist laut Datenblatt immer 16, also:

TEMPERATURE=TEMP_READ - 0,25 + (16 - COUNT_REMAIN) / 16

Um ganzzahlig rechnen zu können multipliziert man beide Seiten  mit 16:

16 * TEMPERATURE=16*TEMP_READ – 4 + 16 - COUNT_REMAIN

Jetzt muss man noch berücksichtigen, dass das letzte rechte Bit von 
TEMP_READ

die Wertigkeit 2 hoch -1 hat. Dann ist raw << 3 gleich TEMP_READ * 16

und mit (raw & 0xFFF0) + 12 - data[6] erhält man 16 * TEMPERATURE.

Die Temperatur als float-Wert ist dann celsius = (float)raw / 16.0;

[Sven L. (eet)]

Vielen Dank für deine Antwort. Ich konnte die Berechnung nachvollziehen.

Nur was ich immer noch nicht so ganz verstehe ist für was sind COUNT 
REMAIN,
COUNT PER °C  zuständig und was hat es mit der Bedingung
(data[7] == 0x10)auf sich?

[Martin B. (Gast)]

OK, ich dachte, es geht nur um die Formel.

Zunächst zur Abfrage if (data[7] == 0x10): Die ist nach meinem 
Verständnis für DS18S20 und  DS18B20 überflüssig, denn der Wert ist bei 
beiden immer 0x10. Vielleicht, ist die Abfrage für einen alten DS1820 
gedacht. In dessen Datenblatt ist  kein 0x10 festgelegt. Die 
Unterscheidung zwischen DS18S20 und DS18B20 wird im Programm an Hand des 
Rom Codes gemacht und die Variable type_s entsprechend gesetzt.  Die 
wird im „Quelltext 2“ auch abgefragt und dann auf die Berechnung für 
DS18S20 oder DS18B20 verzweigt.

COUNT_PER_C gibt die Auflösung der in COUNT_REMAIN enthaltenen Grad 
Bruchteile an. Der Wert ist fix 16, also handelt es sich um eine 
Auflösung von 1/16  = 0,0625 (Grad Celsius). Wenn man also einen höher 
aufgelösten Wert als im  Temperaturregister (der ist gerundet) haben 
will, dann muss man COUNT_REMAIN  verwenden. Man löscht das gerundete 
letzte Bit (das war nach dem Shift die Operation (raw & 0xFFF0)  ) und 
berechnet den Temperaturwert nach der Formel aus dem Datenblatt.

Fragt man sich jetzt noch, wieso werden nicht wie beim DS18B20 alle 11 
Datenbit in das insgesamt 16 Bit lange Temperaturregister geschrieben?
Das denke ich, ist historisch begründet. Der DS18S20 ist der Ersatz für 
den DS1820. Er muss also auch softwarekompatibel sein und liefert die 
1/16 Grad in COUNT_REMAIN und eine 16 in COUNT_PER_C.

Das Messverfahren ist in älteren Dallas Application Notes beschrieben. 
Z. B. in Application Note Nr. 68 und 128.

Aber: Das alles betrifft nur eine (mögliche) Auflösung. Die Genauigkeit 
wird mit +-0,5 Grad angegeben.

[Sven L. (eet)]

Verstehe ich das jetzt richtig für den DS18S20:

Der Wert Temp_Read bestehend aus Byte 0 und 1 besitzt eine Auflösung von 
0,5 Grad Celsius. Verwende ich hingegen die in Quelltext 2 verwendete 
Formel für die Temperatur erhalte ich einen Temperaturwert mit der 
Auflösung von 0,0625 Grad Celsius.

Oder warum hat die 0,0625 ansonsten für den DS18S20 eine wichtige Rolle? 
Für das auf- oder abrunden auf 0,5 Grad Celsius benötige ich ja keine 
0,0625 Grad Celsius Auflösung.

[Sven L. (eet)]

Sven L. schrieb:
>
> Der Wert Temp_Read bestehend aus Byte 0 und 1 besitzt eine Auflösung von
> 0,5 Grad Celsius. Verwende ich hingegen die in Quelltext 2 verwendete
> Formel für die Temperatur erhalte ich einen Temperaturwert mit der
> Auflösung von 0,0625 Grad Celsius.
>

Ich habe gerade einen Blick in das Datenblatt geworfen und es stimmt so 
wie ich es oben beschrieben hatte. Meine Frage erübrigt sich also.

Martin B. vielen Dank, dass du alle meine Fragen beantwortet hast.