DS18B20 Temperaturberechnung

[Stefan U. (unti)]

Hallo

Weiß zufällig jemand nach welcher Formel die Temperatur beim DS18B20 
berechnet wird.

MfG Unti

[(prx) A. K. (prx)]

Wert/16

[Stefan U. (unti)]

?????????????????

[Roland .. (rowland)]

Digitalwert * 0,0625 = T [°C]

[Stefan U. (unti)]

Achso :)

Danke

[Brat (Gast)]

Roland ... schrieb:

> Digitalwert * 0,0625 = T [°C]

Funktioniert bei negativen Temperaturen nicht.

Ansonsten: http://datasheets.maximintegrated.com/en/ds/DS18B20.pdf

[(prx) A. K. (prx)]

Brat schrieb:
>> Digitalwert * 0,0625 = T [°C]
>
> Funktioniert bei negativen Temperaturen nicht.

Weshalb nicht?

[Stefan U. (unti)]

In dem Datenblatt steht nichts wie man die Temperatur berechnet ==> 
KEINE FORMEL !!!!!!!!!!

[Karl H. (kbuchegg)]

Im Datenblatt ist genau aufgeschlüsselt, wie die Bits zu interpretieren 
sind und welche Bedeutung sie haben.
Die gehen halt davon aus, dass jemand der µC programmiert, selbst in der 
Lage ist, die Umrechnung in der Programmiersprache seiner Wahl korrekt 
zu implementieren.

[Brat (Gast)]

Stefan Untner schrieb:

> In dem Datenblatt steht nichts wie man die Temperatur berechnet ==>
> KEINE FORMEL !!!!!!!!!!

Wenn du zu faul bist, das Datenblatt zu lesen und zu verstehen, dann 
such' dir ein anderes Betätigungsfeld.

[Karl H. (kbuchegg)]

Das hier (Bild), zusammen mit der Information, dass 2-er Komplement 
verwendet wird, ist alles was man benötigt um daraus die Temperatur zu 
berechnen. Jeder Informatik-Student kann das fehlerfrei nach der Hälfte 
seines ersten Studien-Semesters interpretieren. Nämlich, dass er den aus 
High und Low-Byte zusammengesetzten Wert (wenn seine Maschine 2-er 
Komplement verwendet, was sehr wahrscheinlich ist), einfach nur durch 16 
Dividieren muss. Denn genau das ist es, was durch die 4 Nachkommabits 
(deren Exponent negativ ist) ausgesagt wird.

[Peter D. (peda)]

Brat schrieb:
>> Digitalwert * 0,0625 = T [°C]
>
> Funktioniert bei negativen Temperaturen nicht.

Also bei mir funktionierts:

(int16_t)0xFFF8 = -8
-8 * 0,0625 = -0,5°C

Man sollte natürlich das Datenblatt lesen können:
"The temperature data is stored as a 16-bit sign-extended two’s 
complement number"

[Karl H. (kbuchegg)]

Brat schrieb:
> Roland ... schrieb:
>
>> Digitalwert * 0,0625 = T [°C]
>
> Funktioniert bei negativen Temperaturen nicht.

Doch, das funktioniert schon.

Man muss nur aufpassen, wenn man Vorkomma und Nachkommaanteil selbst 
getrennt wegen der Ausnutzung von Integer Operationen ausrechnet.
Setzt man aber Floating Point Operationen ein, dann kommt da auch das 
richtige Ergebnis raus.

[Brat (Gast)]

Karl Heinz schrieb:
> Brat schrieb:
>> Roland ... schrieb:
>>
>>> Digitalwert * 0,0625 = T [°C]
>>
>> Funktioniert bei negativen Temperaturen nicht.
>
> Doch, das funktioniert schon.

Du interpretierst in die Antwort von Roland mehr hinein, als tatsächlich 
in ihr enthalten ist :)

[Karl H. (kbuchegg)]

Brat schrieb:
> Karl Heinz schrieb:
>> Brat schrieb:
>>> Roland ... schrieb:
>>>
>>>> Digitalwert * 0,0625 = T [°C]
>>>
>>> Funktioniert bei negativen Temperaturen nicht.
>>
>> Doch, das funktioniert schon.
>
> Du interpretierst in die Antwort von Roland mehr hinein, als tatsächlich
> in ihr enthalten ist :)

Nämlich?
Die Antwort ist IMHO (fast) völlig korrekt.
Erwähnenswert wäre eventuell noch, dass 'Digitalwert' einen Datentyp 
haben sollte, der prinzipiell ein Vorzeichen zulässt (ein int16_t in C), 
aber das ist dann schon wieder ein technisches Detail der verwendeten 
Programmiersprache.

[Stefan Untner (Gast)]

möchte mich für ("In dem Datenblatt steht nichts wie man die Temperatur 
berechnet ==> KEINE FORMEL !!!!!!!!!!") entschuldigen.
War schon sehr gestersst und etwas genervt. Bin allerdings keine 
Informatikstudent sondern kompletter Anfänger und verstehe deswegen nur 
die Hälfte von dem was ihr Antwortet.
(z.B.: (int16_t)0xFFF8 = -8
        -8 * 0,0625 = -0,5°C
)
bitte um erklärung
ich brauche wirklich dringend eure Hilfe

MfG Unti

[(prx) A. K. (prx)]

In Worten: Der Wert im DS18B20 gibt die Temperatur in sechzehntel Grad 
Celsius an. Mit Vorzeichen im Zweierkomplement, also als int16_t. 
Division durch Sechzehn liefert also Grad Celsius.

[Mirki (Gast)]

Wert durch 16 teilen....wurde doch schon zweimal erwähnt...

[Cyblord -. (cyblord)]

Stefan Untner schrieb:
> möchte mich für ("In dem Datenblatt steht nichts wie man die Temperatur
> berechnet ==> KEINE FORMEL !!!!!!!!!!") entschuldigen.
> War schon sehr gestersst und etwas genervt. Bin allerdings keine
> Informatikstudent sondern kompletter Anfänger und verstehe deswegen nur
> die Hälfte von dem was ihr Antwortet.
> (z.B.: (int16_t)0xFFF8 = -8
>         -8 * 0,0625 = -0,5°C
> )
> bitte um erklärung
> ich brauche wirklich dringend eure Hilfe
>
> MfG Unti

Wo ist denn nun noch dein Problem?

Das was im Register steht, geteilt durch 16 ist deine Temperatur.

Dann gabs Beispiele wie man das auf 8-Bittern am besten rechnen lässt.

Dein Problem beschränkt sich leider nicht auf den DS18B20, sondern liegt 
wohl ebenfals in der nur sehr mäßgen Beherrschung deiner 
Programmiersprache. Ändere das doch einfach mal.

[Wolfgang-G (Gast)]

cyblord ---- schrieb:
> wohl ebenfals in der nur sehr mäßgen Beherrschung deiner
> Programmiersprache.
Sagt er doch selbst
>Ändere das doch einfach mal.
fehlt nur noch: Wenn Du die Programmiersprache beherrscht--> noch einmal 
melden.
Das klingt doch schon mehr oder weniger überheblich.

[Cyblord -. (cyblord)]

Wolfgang-G schrieb:
> cyblord ---- schrieb:
>> wohl ebenfals in der nur sehr mäßgen Beherrschung deiner
>> Programmiersprache.
> Sagt er doch selbst
Na und dann?

>>Ändere das doch einfach mal.
> fehlt nur noch: Wenn Du die Programmiersprache beherrscht--> noch einmal
> melden.
> Das klingt doch schon mehr oder weniger überheblich.

Nun das ist eben Vorraussetzung, dass man die Programmiersprache 
beherrscht. Denn du siehst ja, die Tipps helfen gar nichts, die Antwort 
auf seine Frage hat er bekommen, aber hilfts ihm weiter? Nein natürlich. 
Also ist mir ziemlich egal wie das klingt, es ist halt einfach wahr.

gruß cyblord

[Gerry L. (Gast)]

Hier die angepasste Version von Peter Dannegger welche Negative 
Temperaturen und im 0.1 Format ausgibt.
Such dir das passende raus.

Hilft dir am Anfang mehr als die Hinweise aufs Datenblatt.

/************************************************************************/
/*                  */
/*      Access Dallas 1-Wire Devices      */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      [e-mail]                                  */
/*                                                                      */
/************************************************************************/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

#include "../konfig.h"

#if USE_D1820_SENSOR

#include "../main.h"

#if DEBUG
#include "../uart/uart.h"
#endif

#include "1wire.h"

/*********************************************************************/
void one_wire_init(void) {
  /*********************************************************************/
  W1_SPANNUNG_DDR |= (1 << W1_SPANNUNG);    // W1_SPANNUNG als Ausgang setzen
  W1_SPANUNG_PORT |= (1 << W1_SPANNUNG);    // W1_SPANNUNG Pin High
}
/*********************************************************************/
void one_wire_spannung_aus(void) {
  /*********************************************************************/
  W1_SPANUNG_PORT &= ~(1 << W1_SPANNUNG);   // Pin Low
}
/*********************************************************************/
void one_wire_spannung_ein(void) {
  /*********************************************************************/
  W1_SPANUNG_PORT |= (1 << W1_SPANNUNG);    // W1_SPANNUNG Pin High
}

/******************************************************************/
uint8_t w1_reset(void) {
  /******************************************************************/
  uint8_t err;

  W1_OUT &= ~(1 << W1_PIN);
  W1_DDR |= 1 << W1_PIN;
  _delay_us(480);

  cli();
  W1_DDR &= ~(1 << W1_PIN);
  _delay_us(66);
  err = W1_IN & (1 << W1_PIN);        // no presence detect
  sei();

  _delay_us(480 - 66);

  if ((W1_IN & (1 << W1_PIN)) == 0)    // short circuit
    err = 1;

  return err;
}
/******************************************************************/
uint8_t w1_bit_io(uint8_t b, uint8_t pull) {
  /******************************************************************/

  cli();

  W1_DDR |= 1 << W1_PIN;

  _delay_us(2);
  if (b)
    W1_DDR &= ~(1 << W1_PIN);

  _delay_us(10 - 2);
  if ((W1_IN & (1 << W1_PIN)) == 0)
    b = 0;

  _delay_us(60 - 10);
  if (pull) {
    W1_OUT |= (1 << W1_PIN);
    W1_DDR |= (1 << W1_PIN);
  } else
    W1_DDR &= ~(1 << W1_PIN);
  _delay_us(10);

  sei();

  return b;
}
/******************************************************************/
uint16_t w1_byte_wr(uint8_t b) {
  /******************************************************************/

  uint8_t i = 8, j;

  uint8_t cnv = (b == CONVERT_T);

  do {
    j = w1_bit_io(b & 1, cnv && i == 1);
    b >>= 1;
    if (j)
      b |= 0x80;
  } while (--i);

  return b;
}
/******************************************************************/
uint16_t w1_byte_rd(void) {
  /******************************************************************/

  return w1_byte_wr(0xFF);
}
/******************************************************************/
uint8_t w1_rom_search(uint8_t diff, uint8_t idata *id) {
  /******************************************************************/

  uint8_t i, j, next_diff;
  uint8_t b;

  if (w1_reset())
    return PRESENCE_ERR;      // error, no device found

  w1_byte_wr(SEARCH_ROM);      // ROM search command
  next_diff = LAST_DEVICE;      // unchanged on last device

  i = 8 * 8;
  do {
    j = 8;
    do {
      b = w1_bit_io(1, 0);      // read bit
      _delay_us(2);
      if (w1_bit_io(1, 0)) {      // read complement bit
        if (b)          // 11
          return DATA_ERR;      // data error
      } else {
        if (!b) {        // 00 = 2 devices
          if (diff > i || ((*id & 1) && diff != i)) {
            b = 1;        // now 1
            next_diff = i;      // next pass 0
          }
        }
      }
      w1_bit_io(b, 0);           // write bit
      *id >>= 1;
      if (b)          // store bit
        *id |= 0x80;
      i--;
    } while (--j);
    id++;          // next byte
  } while (i);

  return next_diff;        // to continue search
}

/******************************************************************/
void w1_command(uint8_t command, uint8_t idata *id) {
  /******************************************************************/
  uint8_t i;

  w1_reset();
  if (id) {
    w1_byte_wr(MATCH_ROM);      // to a single device
    i = 8;
    do {
      w1_byte_wr(*id);
      id++;
    } while (--i);
  } else {
    w1_byte_wr(SKIP_ROM);      // to all devices
  }
  w1_byte_wr(command);
}
/******************************************************************/
uint8_t start_meas(void) {
  /******************************************************************/
  if (W1_IN & 1 << W1_PIN) {
    w1_command(CONVERT_T, NULL );
    W1_OUT |= 1 << W1_PIN;
    W1_DDR |= 1 << W1_PIN;      // parasite power on
    return 1;
  } else {
    return 0;
  }
}
/******************************************************************/
uint8_t read_meas(void) {
  /******************************************************************/
  uint8_t id[8], diff;
  unsigned char scratchpad[9];
  int temp;

  DS1820_count = 0;

  for (diff = SEARCH_FIRST; diff != LAST_DEVICE;) {

    diff = w1_rom_search(diff, id);

    if (diff == PRESENCE_ERR) {          // No Sensor found
#      if DEBUG
    uart_puts_P(PSTR("No Sensor" CR));
#      endif
      return 87;
      break;
    }

    if (diff == DATA_ERR) {            // Bus Error
#      if DEBUG
    uart_puts_P(PSTR("Bus Error" CR));
#      endif
      return 86;
      break;
    }

    if (id[0] == 0x28 || id[0] == 0x10) {                            // temperature sensor prüfung ob Ds1820 Version S oder B

      w1_byte_wr(READ);                                              // read command

      for (temp = 0; temp < 9; temp++)
        scratchpad[temp] = w1_byte_rd();                            // Scratchpad füllen (9 Bytes)

      if (id[0] == 0x10) {                                           // DS18S20
        if (scratchpad[1]) {                                         // Negativer Temperaturwert
          scratchpad[0] ^= 0xFF;                                     // Einer-Komplement
          scratchpad[0]++;                                           // inkrementieren
        }
        scratchpad[0] >>= 1;                                         // rechtes Bit für 0,5 °C rausschieben (durch 2 teilen)

                                                                    // Temperatur mit 0,1 °C Genauigkeit berechnen
        temp = (int) scratchpad[0] * 100 - 25 + (int) (scratchpad[7] - scratchpad[6]) * 100 / scratchpad[7];
        if (scratchpad[1])                                           // Negativer Temperaturwert
          temp *= -1;
        temp /= 10;                                                 // Zweite Nachkommastelle abtrennen
      } else {                                                       // 0x28: DS18B20
        if (scratchpad[1] & 0xF8) {                                 // Negativer Temperaturwert
          scratchpad[0] ^= 0xFF;                                     // Einer-Komplement
          scratchpad[0]++;                                           // inkrementieren
          scratchpad[1] ^= 0xFF;                                     // Einer-Komplement
          temp = -(((int) scratchpad[1] << 8) | (int) scratchpad[0]) * 10 / 16;
        } else {
          temp = (((int) scratchpad[1] << 8) | (int) scratchpad[0]) * 10 / 16;
        }
      }

      if (temp == 850) {
        return 85;
      } else {
        uint8_t i = 0;

        itoa(temp, DS1820[DS1820_count].temperatur, 10);                              // die Zahl in einen String umwandeln
        while (DS1820[DS1820_count].temperatur[i])                                    // die Position der terminierende /0 finden
          i++;
        DS1820[DS1820_count].temperatur[i] = DS1820[DS1820_count].temperatur[i - 1];  // die Nachkommastelle nach rechts schieben
        DS1820[DS1820_count].temperatur[i - 1] = '.';                                  // statt dessen ein Dezimaltrennzeichen einfügen
        DS1820[DS1820_count].temperatur[++i] = 0;                                      // Am Ende wieder eine /0 anfügen
      }

      DS1820_count++;                                                                  // Terminator
    }

  }

  return 1;

}

#endif

[Stefan U. (unti)]

Meine Frage wäre da noch was genau ist bzw. macht int16_t

[Karl H. (kbuchegg)]

Stefan Untner schrieb:
> Meine Frage wäre da noch was genau ist bzw. macht int16_t


Ein int16_t ist ein Datentyp. Der Name sagt es schon, es ist ein 
INteger,  mit Vorzeichen (wegen dem fehlenden u), der aus 16 Bit 
besteht.

int8_t      8 Bit, mit Vorzeichen
uint8_t     8 Bit, ohne Vorzeichen
int16_t     16 Bit, mit Vorzeichen
uint16_t    16 Bit, ohne Vorzeichen
int32_t     32 Bit, mit Vorzeichen
uint32_t    32 Bit, ohne Vorzeichen

auf einem AVR ist int16_t dasselbe wie ein plain vanilla 'int'

[Stefan U. (unti)]

danke
und was heist dann (int16_t)0xFFF8 = -8

[Karl H. (kbuchegg)]

Stefan Untner schrieb:
> danke
> und was heist dann (int16_t)0xFFF8 = -8

der Wert 0xFFF8 wird auf einen int6_t umgecastet. In dieser Form (also 
als uint16_t) repräsentiert dieses Bitmuster den Zahlenwert -8

Das ist also die logische Beschreibung von
* nimm deine 2 Bytes, die du vom Sensor bekommst und steck sie 
Endian-richtig in einen int16_t hinein. (zb kriegst du vom Sensor die 
Bytes 0xFF und 0xF8. Steckst du die in einen int16_t, so dass dieser 
dann bytemässig als 0xFFF8 aufgebaut ist, dann ist das dasselbe, als wie 
wenn du der int16_t Variable den Wert -8 zugewiesen hättest. Das 16 Bit 
Bitmuster (im 2-er Komplement) für -8 ist genau 0xFFF8

* lässt du dir diesen int16_t zb mittels

  int16_t wert = (int16_t)0xFFF8;
  printf( "%d", wert )

ausgeben, dann steht an der Anzeige daher -8.
0xFFF8 als 16 Bit Zahl im 2-er Komplement interpretiert, ist nichts 
anders als die Bitrepräsentierung von -8 innerhalb des Rechners.

[Hmm.. (Gast)]

Als "C-Götter" könntet ihr doch einfach ihm mal ein kurzen 
(funktionierenden) C-Schnipsel posten! Wurd Euch weder arm machen noch 
Schmerzen zufügen!

[Karl H. (kbuchegg)]

Hmm.. schrieb:
> Als "C-Götter" könntet ihr doch einfach ihm mal ein kurzen
> (funktionierenden) C-Schnipsel posten! Wurd Euch weder arm machen noch
> Schmerzen zufügen!

Nö.
Entweder ER baut das oder er kauft sich ein fertiges Thermometer.
Aber wenn ER das bauen will, dann soll auch ER das bauen. Und dazu 
gehört nun mal dazu, dass man die dazu notwendige Technik und Kentnisse 
auch erlernt.
Wenn man nix kann, trotzdem aber etwas machen will, dann kann man 
vielleicht zu DSDS gehen und für ein paar Lacher bei den Zusehern 
sorgen. Aber in der Technik funktioniert das nicht.

Es reicht eben nicht, nur mit dem Wunsch Fische fangen zu wollen, zum 
Fluss zu gehen. Man muss auch ein Netz mitbringen und es benutzen 
können. - alte indianische Weisheit.

[Cyblord -. (cyblord)]

Hmm.. schrieb:
> Als "C-Götter" könntet ihr doch einfach ihm mal ein kurzen
> (funktionierenden) C-Schnipsel posten! Wurd Euch weder arm machen noch
> Schmerzen zufügen!

Nun es kommt stark darauf an was er damit tun will. Wo steht denn das? 
Beschreibt er denn überhaupt ein Projekt? Er stellt eine Frage und 
bekommt eine Antwort.

Hier funktionierendes SchnipseL:
Eine Möglichkeit um den Temperaturwert in 1/10 Grad zu bekommen wäre 
z.B.:

int16_t convertTemp(int32_t raw) {
  raw=raw*10;
  raw=raw/16;
  return (int16_t)raw;
}

Und aus der Praxis, so nutze ich den DS18B20 für meine Anwendung sehr 
oft.
Und nun? Bringt ihm das was?

[Stefan U. (unti)]

Das bringt mir leider nicht viel. Mein Hauptproblem ist, wenn ich das 
richtig verstehe, dass ich das LSB als erstes gesendet bekomme, ich aber 
das MSB zuerst auswerten muss. Bin ich da schon auf dem richtigen Weg 
???
und zu cyblord, ich will mit einem Temperatursensor Temperaturen messen. 
:P

[Karl H. (kbuchegg)]

Stefan Untner schrieb:
> Das bringt mir leider nicht viel. Mein Hauptproblem ist, wenn ich das
> richtig verstehe, dass ich das LSB als erstes gesendet bekomme, ich aber
> das MSB zuerst auswerten muss. Bin ich da schon auf dem richtigen Weg
> ???

Nein.
Dein erster Schritt ist es, MSB und LSB (nachdem du sie hast) zu einer 
16-Bit Zahl in einem int16_t zusammen zu setzen.

Danach interessiert dich MSB und LSB nicht mehr. Du hast dann bereits 
die 16 Bit Zahl (inklusive Vorzeichen), mit der weiter gearbeitet wird.

[Cyblord -. (cyblord)]

Stefan Untner schrieb:
> Das bringt mir leider nicht viel. Mein Hauptproblem ist, wenn ich das
> richtig verstehe, dass ich das LSB als erstes gesendet bekomme, ich aber
> das MSB zuerst auswerten muss. Bin ich da schon auf dem richtigen Weg
> ???

Dermaßen Holzweg...

Das sind ja verschiedene Schritte. 1 Schritt: Lese die 16 Bit Temperatur 
aus dem Sensor. Klar, das sind 2 Bytes, die musst du zu einem 16 Bit 
Wert zusammenbauen, und dann z.B. in einer int16_t Variable speichern.

Als 2. Schritt kommt dann die Berechnung welche die Temperatur in °C 
berechnet.

> und zu cyblord, ich will mit einem Temperatursensor Temperaturen messen.
> :P
Lustig. Dann bist du ja jetzt fertig. Schon vor der Berechnung hast du 
bereits die Temperatur gemessen.
Wahrscheinlich willst du die Temp. aber noch auf einem LCD ausgeben, 
d.h. du musst das ganze noch in einen String umwandeln, mit Komma und 
allem. Aber hey, so lustig wie du bist, schaffst du das sicher alleine. 
Du hast ja nur 20 Posts gebraucht um dir erklären zu lassen wie man eine 
Zahl durch 16 teilt. Nur um dann am Ende anzukommen mit deiner LSB/MSB 
Geschichte. Lächerlich.

Mal ehrlich, dein Wissenstand reicht eigentlich momentan für keine 
ernsthafte Anwendung aus. Wenns schon an Bytes to Int scheitert und am 
Verstehen von einfachsten Vorgehensweisen, Datentypen, Zahlenformaten, 
dann solltest du in diesem Bereich dringend etwas nachholen. Und danach 
den DS18B20 nochmal rauskramen.

gruß cyblord

[Karl H. (kbuchegg)]

Karl Heinz schrieb:
> Stefan Untner schrieb:
>> Das bringt mir leider nicht viel. Mein Hauptproblem ist, wenn ich das
>> richtig verstehe, dass ich das LSB als erstes gesendet bekomme, ich aber
>> das MSB zuerst auswerten muss. Bin ich da schon auf dem richtigen Weg
>> ???
>
> Nein.
> Dein erster Schritt ist es, MSB und LSB (nachdem du sie hast) zu einer
> 16-Bit Zahl in einem int16_t zusammen zu setzen.
>
> Danach interessiert dich MSB und LSB nicht mehr. Du hast dann bereits
> die 16 Bit Zahl (inklusive Vorzeichen), mit der weiter gearbeitet wird.


Der Teil hier aus dem Code ...

      if (id[0] == 0x10) {                                           // DS18S20
        if (scratchpad[1]) {                                         // Negativer Temperaturwert
          scratchpad[0] ^= 0xFF;                                     // Einer-Komplement
          scratchpad[0]++;                                           // inkrementieren
        }
        scratchpad[0] >>= 1;                                         // rechtes Bit für 0,5 °C rausschieben (durch 2 teilen)

                                                                    // Temperatur mit 0,1 °C Genauigkeit berechnen
        temp = (int) scratchpad[0] * 100 - 25 + (int) (scratchpad[7] - scratchpad[6]) * 100 / scratchpad[7];
        if (scratchpad[1])                                           // Negativer Temperaturwert
          temp *= -1;
        temp /= 10;                                                 // Zweite Nachkommastelle abtrennen
      } else {                                                       // 0x28: DS18B20
        if (scratchpad[1] & 0xF8) {                                 // Negativer Temperaturwert
          scratchpad[0] ^= 0xFF;                                     // Einer-Komplement
          scratchpad[0]++;                                           // inkrementieren
          scratchpad[1] ^= 0xFF;                                     // Einer-Komplement
          temp = -(((int) scratchpad[1] << 8) | (int) scratchpad[0]) * 10 / 16;
        } else {
          temp = (((int) scratchpad[1] << 8) | (int) scratchpad[0]) * 10 / 16;
        }
      }

... ist in meinen Augen hauptsächlich eines: übermässig kompliziert und 
unnötig aufgeblasen.
Warum? Weil genau diese 2-Teilung 'zusammensetzen der Bytes' und 
'nachbearbeitung des daraus entstehenden 16-Bit Wertes' achtlos und 
sinnloserweise über Bord geworfen wurde. Daraus resultiert dann die 
scheinbare Komplexität.

[Cyblord -. (cyblord)]

An sich ist auch die ganze DS18B20 lib für den Anfang nicht nötig. Wenn 
man eine 1Wire lib hat, dann reicht:

Reset
Skip Rom
Start

Warten 1s

Reset
Skip Rom
Read Byte 1
Read Byte 2

Und schon hat man seine 2 Temp. Bytes. Natürlich, kein CRC, nur ein 
Sensor erlaubt usw. usw. Trotzdem reicht es erstmal und man wird nicht 
durch den ganzen Scratchpad-Code verwirrt.

gruß cyblord

[Karl H. (kbuchegg)]

cyblord ---- schrieb:

> Und schon hat man seine 2 Temp. Bytes. Natürlich, kein CRC, nur ein
> Sensor erlaubt usw. usw. Trotzdem reicht es erstmal und man wird nicht
> durch den ganzen Scratchpad-Code verwirrt.

Ja, kann man machen.
Im verlinkten Code wird das Scratchpad ja nur deshalb zur Gänze 
ausgelesen, damit man die erweiterte Genauigkeit benutzen kann.

Wobei ich in den meisten Fällen sowieso nicht viel davon halte, eine 
Temperatur (zb Raumtemperatur) in Zehntelgrad anzugeben. Denn die 
Zehntel stimmen sowieso nicht für den Raum als Ganzes gesehen. Gerade 
bei Temperaturen wird so dermassen viel Schindluder mit Nachkommastellen 
getrieben, das wird eigentlich nur noch von Wahlprognosen übertroffen. 
Der kleinste Lufthauch (durch eine sich schliessende Tür) und die 
Temperatur im Raum 'sinkt' um 3 Zehntel Grad, wenn der DS 'günstig' 
montiert ist. Etwas das ich nicht sinnvoll messen kann, will ich auch 
nicht auf der Anzeige haben.

Für einen DS18B20 reicht ein einfaches

  ....
  // ... Scratchpad auslesen, wie im Beispiel
  for (temp = 0; temp < 9; temp++)
    scratchpad[temp] = w1_byte_rd();                            // Scratchpad füllen (9 Bytes)

  // Bytes zusammensetzen
  int16_t Temperatur = (int16_t)( ( scratchpad[1] << 8) | scratchpad[0] );

  // in Grad umrechnen
  Temperatur = Temperatur / 16;

meiner Meinung nach aus. Will man unbedingt Zehntelgrad haben, dann eben

...
  // in Grad umrechnen
  Temperatur = Temperatur * 10 / 16;
...

und entsprechender Anpassung der Ausgabe.

[Stefan U. (unti)]

Ich wollte dich wirklich nicht beleidigen cyblord. Falls ich das doch 
getan habe tut es mir leid. Das was ich geschrieben habe ("und zu 
cyblord, ich will mit einem Temperatursensor Temperaturen messen. :P") 
war als kleinen Scherz gedacht, ich wollte dich damit keinenfalls 
beleidigen.

[Hortel (Gast)]

Mal eine dumme Frage zur Auflösung: Wenn ich z.B. nur 10 statt 12 bit 
Auflösung haben will, sind laut Datenblatt bit 1 und 0 undefined. 
Bedeutet das, daß ich dann bei der Temperaturberechnung diese bits 
vorher auf 0 setzen muß? Oder den gelesenen Wert um 2 nach rechts 
shiften und das Ergebnis einfach durch 4 statt 16 teilen?

[Michael (Gast)]

Stefan Untner schrieb:
> und zu cyblord, ich will mit einem Temperatursensor Temperaturen messen.

Das macht der DS18B20 fast von selbst. Dein Problem ist das Auslesen der 
Messdaten und die formatierte Anzeige. ;-)

[Karl H. (kbuchegg)]

Hortel schrieb:
> Mal eine dumme Frage zur Auflösung: Wenn ich z.B. nur 10 statt 12 bit
> Auflösung haben will, sind laut Datenblatt bit 1 und 0 undefined.
> Bedeutet das, daß ich dann bei der Temperaturberechnung diese bits
> vorher auf 0 setzen muß? Oder den gelesenen Wert um 2 nach rechts
> shiften und das Ergebnis einfach durch 4 statt 16 teilen?

Weder, noch.

Durch die Division durch 16 fallen die Bits dann sowieso weg, sodass sie 
im Endergebnis nicht aufscheinen.

Interessant ist diese Information nur dann, wenn du den Teil 'Grad = 
Division durch 16' etwas komplexer gestaltest, so dass du eben den bei 
der Division entstehenden Rest auch noch auswertest, so dass du auf 
Zehntel Grad kommen könntest.

Ich sach mal so.
Wenn du eine gewisse Anzahl an Flaschen hast und auf eine Palette genau 
10 Flaschen passen, dann dividierst du die Anzahl der Flaschen durch 10.
Soweit so gut.
Willst du nur wissen, wieviele Paletten du brauchst (= Anzahl an ganzen 
Grad), dann ist es wurscht, ob die Einerstelle deiner Anzahl an Flaschen 
korrekt ist oder nicht. Ob die korrekte Anzahl an Flaschen 92 oder 96 
ist, spielt keine Roll, du brauchst in jedem Fall 10 Paletten (x / 10) + 
1.
Die Einerstelle wird erst dann interessant, wenn du wissen willst, wie 
'voll' die letzte Palette ist, ändert aber nichts daran, dass du 10 
Paletten brauchst.

[Lutz (Gast)]

Jetzt bin ich aber verunsichert: Wenn ich z.B. aus Zeitgründen eine 10 
bit  Auflösung einstelle, sind laut Datenblatt die beiden LSB 
undefiniert. Ich interpretiere das so, daß die LSB sowohl 0 als auch 1 
sein können; unabhängig vom Meßwert/Temperatur.
Wenn ich aber jetzt trotzdem durch 16 teile, werte ich doch diese beiden 
bits mit aus oder nicht? Ich hätte bzw. habe bis jetzt auch gedacht, daß 
ich die undefinerten bits nach rechts rausshifte und den Teiler dann 
entsprechend der Wertigkeit setze:
12 bit: Teilen durch 16
11 bit: 1 rechts shiften und durch 8
10 bit: 2 rechts shiften und durch 4
9 bit: 3 rechts shiften und durch 2

[Josef D. (jogedua)]

Lutz schrieb:
...werte ich doch diese beiden bits mit aus oder nicht?...

Nein:
Bei der Integer-Division ergibt doch
1/16=0, ... , 15/16=0,
16/16=1, 17/16=1, ...
Da spielen die untersten 4 Bit keine Rolle.

[Lutz (Gast)]

Auch, wenn ich vorher den Wert in einer float-Variablen anstatt in einem 
int16_t speichere?

// Bytes zusammensetzen
  float Temperatur = (float)( ( scratchpad[1] << 8) | scratchpad[0] );

// in Grad umrechnen
  Temperatur = Temperatur / 16;

Mit float (Programmgröße, Laufzeit) ist zwar nicht so schön, aber wenn 
man es sich leisten kann ...

[Karl H. (kbuchegg)]

Lutz schrieb:
> Auch, wenn ich vorher den Wert in einer float-Variablen anstatt in einem
> int16_t speichere?

Dann natürlich nicht.
(Und darum ist es immer gut, konkreten Code zu posten. Inklusive 
Datentypen der beteiligten Variablen)

Das tiefer liegende 'Problem', besteht darin, dass es dem Compiler 
piep-schnurz egal ist, welchem Datentyp du ein Ergebnis zuweist. Wenn es 
darum geht, zu bestimmen wie eine Operation durchzuführen ist, dann 
gelten einzige und alleine die Datentypen der beteilgten Operanden.

In

  int16_t  temp;

  temp = ..... Byte zusammensetzen
  temp = temp / 16;

gibt es die Berechnung

    ... temp / 16;

temp ist ein Integer. 16 ist ein Integer. Also wird die Division als 
Integer-Division durchgeführt. Dass dieses Ergebnis danach unter 
Umständen einem float zugewiesen wird

  int16_t  temp;
  float    Temperatur;

  temp = ..... Byte zusammensetzen
  Temperatur = temp / 16;

ist für die Division unerheblich. Erst das Ergebnis der Division wird ja 
zugewiesen und daher wird auch erst dieses Ergebnis in einen float 
umgewandelt.

Bei einer Integer Division entstehen aber keine Kommastellen. Es hat sie 
nie gegeben, daher tauchen sie auch im Ergebnis nicht auf.

Im obigen Code war bisher immer nur von Integer-Operationen die Rede. 
float kam da überhaupt noch nicht vor. Das hier

>

> // Bytes zusammensetzen
>   float Temperatur = (float)( ( scratchpad[1] << 8) | scratchpad[0] );
> 
> // in Grad umrechnen
>   Temperatur = Temperatur / 16;
>

verändert natürlich alles, da in

     ... Temperatur / 16;

Temperatur bereits ein float ist. Daher wird diese Division als 
Gleitkomma-Division durchgeführt. Und die liefert selbstverständlich 
Nachkommastellen. Wenn also in Temperatur schon die 'undefined bits' mit 
drinnen waren, dann tauchen auch im Ergebnis davon abhängige 
'undefined'-Anteile auf. Ergo: damit du dir hier nichts einhandelst, 
solltest du die Bits aus dem Status 'undefined' heraus holen und gezielt 
zb auf 0 setzen. Oder die Berechnung entsprechend modifizieren, so dass 
zuerst die undefined BIts 'rechts rausfallen' und dann eben durch etwas 
entsprechend kleineres dividieren.

> Mit float (Programmgröße, Laufzeit) ist zwar nicht so schön,
> aber wenn man es sich leisten kann ..

Sagtest du nicht:
> Jetzt bin ich aber verunsichert: Wenn ich z.B. aus Zeitgründen
> eine 10 bit Auflösung einstelle

Ja was denn nun? Aus Zeitgründen eine 10 Bit Auflösung, aber eine 
Floating Point Division ist kein Zeitproblem?

[Lutz (Gast)]

Puh, da bin ich ja beruhigt.
Natürlich hast du recht. Mein Fehler; bei konkret gepostetem Code hätten 
wir nicht aneinander vorbeigetippt.

Das Beispiel float und Laufzeit paßt prinzipiell nicht gut zusammen, ich 
weiß. Aber es war halt nur ein (schlechtes) Beispiel.
Spitzfindig betrachtet könnte ich aber auch behaupten, daß der 
Zeitoverhead einer float-Berechnung bei diversen MHz um ebenfalls 
diverse Zehnerpotenzen niedriger ist als die "gewonnene" Conversiontime 
des Sensors (187.5 ms bei 10 bit zu 700 ms bei 12 bit; also 512.5 ms 
Zeitgewinn minus ein paar µs mehr Laufzeit) ...

Und so ein gaaaaaaanz bischen hatte ich auch das im Hinterkopf, was nur 
für 12 bit Auflösung gilt:
Karl Heinz schrieb:
> Brat schrieb:
>> Roland ... schrieb:
>>
>>> Digitalwert * __0,0625__ = T [°C]
>>
>> Funktioniert bei negativen Temperaturen nicht.
> ...
> Setzt man aber Floating Point Operationen ein, dann kommt da auch das
> richtige Ergebnis raus.

[Karl H. (kbuchegg)]

Ich geb dir in allem Recht Lutz.

Einen Punkt möchte ich noch ins Spiel bringen, weil er gerne übersehen 
wird.

>  ist als die "gewonnene" Conversiontime des Sensors
> (187.5 ms bei 10 bit zu 700 ms bei 12 bit; also 512.5 ms Zeitgewinn

Der Sensor schreibt mir allerdings auch nicht vor, dass ich exakt nach 
'bis zu 700ms nach Start der Conversion' mir das Ergebnis abholen 
muss. Ich darf mir da beliebig viel Zeit lassen. Zb kann ich auch 
diese Reihenfolge wählen

  Schleife
  {
    Ergebnis abholen
    nächste Wandlung starten

    Ergebnis aufbereiten, umrechnen und anzeigen
    irgendwas anderes machen
  }

so dass die letzten beiden Programmpunkte in die Zeit fallen, die der 
Sensor zum arbeiten braucht. Wenn die beiden Punkte eine erkleckliche 
Zeit beanspruchen, dann wirken sich die erzwungenen 700ms praktisch gar 
nicht mehr aus.

In meiner Heizungssteuerung mach ich das so. Da messe ich nur alle 10 
Sekunden. Mehr macht nicht Sinn, da sich eine Raumtemperatur eh nicht so 
schnell ändert. Die 10 Sekunden werden mit einem Timer gemacht. Durch 
den Timer angestossen hole ich mir das letzte Ergebnis und starte sofort 
den DS neu. Der hat dann 10 Sekunden Zeit, in aller Ruhe zu wandeln, bis 
ich mir das Ergebnis dieser Wandlung abhole und gleich wieder die 
nächste starte.

[Jens S. (jens_s56)]

Mein Taschenrechner spinnt:
0xFFF8 / 16 (0x10) = 4095 = 0xFFF

irgendwie kapiert der die negative Zahl nicht.

wenn ich die Bits toggle komme ich in den positiven Bereich, aber mit 
den 4 letzten Bits klappt das nicht ;-(

[Mike (Gast)]

Lutz schrieb:
> Mit float (Programmgröße, Laufzeit) ist zwar nicht so schön, aber wenn
> man es sich leisten kann ...

Und welchen Vorteil versprichst du dir davon?
Deine Temperatur wird sich bei einem DS18B20 immer im Bereich -55 ... 
+1xx°C bewegen. Der Genauigkeitsverlust bei Float zugunsten einer 
höheren Dynamik gegenüber einem Ganzzahlformat bringt dir also überhaupt 
nichts.

[Jens S. (jens_s56)]

Ist ja schön, aber ich muss es ja irgendwie aufs LCD bringen, dazu muss 
ich eben die Zahlen handeln.
Nützt ja nichts eine Temperaturmessung anzustoßen und das Ergebnis im 
schwarz/grauen Gehäuse zu verstecken ;-)

Dim Wert as Integer rem -32768,0 bis +32767,0

Das ist schon klar

Auch *100/16 (oder *25/4) dann sind es 100derstel Grad,
Aber jetzt muss ich irgendwie mit den negativen Zahlen klar kommen.

Und da ich nicht Informatik studiert habe und es schon über 20 Jahre her 
ist und ....

Ich nehme Bascom, C ist mir zu anstrengend

Zitat: Deine Temperatur wird sich bei einem DS18B20 immer im Bereich -55 
...
+1xx°C bewegen.
ist bekannt, niedrigere und hörere Temp kommen bei mir zu Hause nicht 
vor

Zitat: Der Genauigkeitsverlust bei Float zugunsten einer
höheren Dynamik gegenüber einem Ganzzahlformat bringt dir also überhaupt
nichts.

Was bedeutet die Dynamik bei Float und wie komme ich auf die Zahl?

[Wolfgang A. (Gast)]

Jens S. schrieb:
> Jetzt muss ich erst mal die Dynamic von Float googeln....

Bei einer 32-Bit Float Zahl im IEEE Format gehen 8 Bit für den Exponent 
flöten, d.h. für den Zahlenwert bleiben dir noch 24 Bit incl. 
Vorzeichen. Bei einer 32-Bit Integer hättest du 8 Bit mehr, da es dir 
bei Temperaturangaben wenig nützt wenn du um 0 rum eine höhere Auflösung 
zur Verfügung hättest.
http://de.wikipedia.org/wiki/Gleitkommazahl#Exponent

Und nicht vergessen:
Floatzahlen sind nur eine Teilmenge der Rationalen Zahlen
http://de.wikipedia.org/wiki/Rationale_Zahl

Jens S. schrieb:
> Und da ich nicht Informatik studiert habe und es schon über 20 Jahre her
> ist und ....

Wenn der Sinn eines Informatikstudiums wäre, richtig mit negativen 
Zahlen umzugehen, wäre das einfach traurig. Dafür gibt es in Schulen die 
Unterstufe ;-)

[Jens S. (jens_s56)]

Ich wusste gar nicht das man jetzt an Grundschulen (Unterstufe) 
Informatik hat, muss mal meinen Sohn fragen.
Ich habe Sek II, aber nicht in Informatik

Wie wäre es denn hiermit:

Negative Zahl  vom DS18B20:
(0xFE6F ExOR 0xFFFF) + 0x0001 = 0x0191

Danach ist es das selbe wie mit positiven Zahlen

Wozu as LONG ? ich dachte der Temperaturbereich geht nur bis 125°C

[Wolfgang A. (Gast)]

Jens S. schrieb:
> Wozu as LONG ?

Um die Float Variable einer gleich großen Integer Variablen gegenüber 
zu stellen. Und die Zeiten von 6-Byte Float-Formaten sind IMHO vorbei.

Jens S. schrieb:
> an Grundschulen (Unterstufe) Informatik
Nicht Grundschule sondern Unterstufe (= Sekundarstufe I)
http://de.wikipedia.org/wiki/Unterstufe

und nicht Informatik, sondern negative Zahlen ;-)

[Jens S. (jens_s56)]

Ich muss feststellen vor 20-30 Jahren hat man durch aus mit negativen 
Zahlen im Dezimalsystem gerechnet!

Auch Zehnerpotenz ist ein Begriff, wie Primzahl und Bruchrechnung

Nur bestand der "Informatik-Unterricht" aus 5x VC-20 und einem C64 und 
zwei Datasetten !
Sowie Monitoren die man besser als Röhrenfernseher bezeichnet hätte.
Dazu gab es ein Buch von Data-Becker...

Aber lassen wir das, kann ja auch nichts dafür, das die damaligen 
Lehrkräfte ihr Wissen 1:1 aus solchen Büchern lehrten und das noch nicht 
auf dem Lehrplan stand sondern freiwillige Sonder-AG war!

Ja, ich weiß, die vom Gymnasium haben schon immer auf die anderen herab 
geschaut.... Aber Berufsausbildung und Berufserfahrung ist gleichwertig!

[Jens S. (jens_s56)]

Ohne mich wieder im Bildungssystem zu verlieren, folgender Code konnte 
ich erfolgreich simulieren, der Sensor ist noch nicht da.

DIM Wert_aus_ds1820 As Integer
DIM Temperatur As Singel
DIM Sign As Bit
Config Lcd ... bla bla bla

Do
 Sensor aufwecken, und Wert_aus_ds1820 speichern
 Gosub  auswerten 
 bla, bla,bla
Loop
End


auswerten:
 Rem Wert_aus_ds1820 = &B1111_1100_1001_0000 ' Beispielcode
  ' Auswertung für  DS18B20, nicht für DS1820, nicht für DS18S20 !
 Sign = 0                      ' 0 = + | 1 = negative Zahl
If Wert_aus_ds1820 = 0 Then
'  --  >= Null Grad
  Temperatur = Wert_aus_ds1820
Else
  If Wert_aus_ds1820.15 <> 0 Then     ' negativ?
      Sign = 1
      For I = 0 To 15                                       'ExOR 0xFFFF
      Toggle Wert_aus_ds1820.i
      Next
    Incr Wert_aus_ds1820                                    ' +1
  End If
 Temperatur = Wert_aus_ds1820 / 16 '  --  >= positiv
End If
  Locate 2 , 1
 If Sign = 1 Then : Lcd "-" : Else : Lcd "+" : End If
 Lcd Temperatur

wie gesagt, der DS18B20 ist noch in der Post.

[Jens S. (jens_s56)]

Oder ganz kurz:

auswerten:

 Temperatur = Wert_aus_ds1820 / 16
   Text = Str(temperatur) : Replacechars Text , "." , ","
  Locate 2 , 1 : Lcd Text : Return

Return