mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik DS18B20 probleme mit Pull-Up


Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo liebe Comunity,

ich weiß zu den DS18x20 gibts gefühlt bereits 1000 Beiträge, aber ich 
hab auch nach langem Suchen nichts gefunden was mir hilft

Ich betreibe einen DS18B20 an einem ATmeag16 mit 4MHz. Das ganze ist auf 
einem STK500.
Der DS18B20 ist am PD6 mit seiner Dateinleitung. Als Versorgung greife 
ich auf die Versorgung vom STK500 zurück. Also extern versorgt und nicht 
Parasitär.

Beim Reset sollte er ja nachdem ich auf Low gezogen hab, er auch 
anschließend mit low antworten. Tut er aber nicht.
Hier noch die von mir verwendete Resetroutine:
uint8_t ds1820_reset(uint8_t used_pin)
{
  uint8_t err=100;
  DS1820_DDR |= 1<<used_pin;            // define as ouput
  DS1820_PORT &= ~(1<<used_pin);          //Pull low
  delay_us(480);        ;          // 480 us
  DS1820_DDR &= ~(1<<used_pin);            // define as input
  DS1820_PORT |= 1<<used_pin;            //Pullup on
  delay_us(80);                    // 80 us
  err = (DS1820_PIN & (1<<used_pin)) >> used_pin;  // no presence detect --> err=1 otherwise err=0
  delay_us(400);                   // 400 us
  if( (DS1820_PIN & (1<<used_pin)) == 0 ){      // short circuit --> err=2
    err = 2;
  }
  return err;
}

used_pin übergebe ich richtig in der Hauptschleife, daran sollte es 
meiner Meinung nach nicht liegen.

Vielen dank für eure mühen, bei diesem vermutlich mittlerwile leidigem 
Thema.

grüße

Johannes

Autor: Klaus (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Äh! bissel schwirig deine Routine nachzuvollziehen. Aber Naja.

Hast Du ein Oszi?

Wenn ja dann solltest sowas sehen als presence-impuls wie im Anhang.

Autor: Torsten S. (tse)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Der interne AVR-Pullup reicht nicht aus. Es muß unbedingt ein R von ~4k7 
gegen + sein.

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nein ich habe leider kein Oszi.

Danke für den Hinweis mit dem externen Pull-Up.

Jetzt funktionierts vielen Dank!

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So nachdem ich das mit dem Reset hinbekommen habe, habe ich fleißig 
weiter gemacht.

Ich kann nun auf das Scratchpad schreiben und die Werte danach auch 
erfolgreich zurücklesen.

Ich habe eine Routine die aus den beiden Temperaturbytes einen floatwert 
erzeugt und richtig ausgibt. Getestet habe ich das mit Dummybytes.

Mein Problem ist nun, wenn ich mit Skip-Rom (0xCC) und dann start 
conversion (0x44) eine Temperaturwandlung starte, liefert er mir nie 
eine Null zurück (er liefert so lange Null bis er fertig ist). An der 
Ausleseroutine sollte es nicht liegen, da diese bei den anderen 7 byte 
ja auch Funktioniert.

Versuchsweise habe ich die Wartezeit von 750ms selbst erzeugt und danach 
die Temperatur ausgelesen.

Dann erhalte ich den Wert 127,9375°C. Das entspricht dann lauter einsen 
auser die 5 bit fürs vorzeichen die sind Null. Das ist in soweit 
komisch, dass das nicht der Standartwert ist (auslesen ohne 
Temperaturconversion 85°C).

Hier noch der Sourcecode:


//----------------------------------------
// Reset DS18S20
//----------------------------------------
uint8_t ds1820_reset(uint8_t used_pin)
{
  uint8_t err=100;
  DS1820_DDR |= 1<<used_pin;            // define as ouput
  DS1820_PORT &= ~(1<<used_pin);          //Pull low
  _delay_us(480);        ;          // 480 us
  DS1820_DDR &= ~(1<<used_pin);            // define as input
  DS1820_PORT |= 1<<used_pin;            //Pullup on
  _delay_us(80);                    // 66 us
  err = (DS1820_PIN & (1<<used_pin)) >> used_pin;  // no presence detect --> err=1 otherwise err=0
  _delay_us(400);                   // 240 us
  if( (DS1820_PIN & (1<<used_pin)) == 0 ){      // short circuit --> err=2
    err = 2;
  }
  return err;
}
//-----------------------------------------
// Write one bit to DS18S20
//-----------------------------------------
void ds1820_wr_bit(uint8_t wrbit,uint8_t used_pin)
{
  if (wrbit ==0)  {
    DS1820_DDR |= 1<<used_pin;          // define as ouput
      DS1820_PORT &= ~(1<<used_pin);        //Pull low
    _delay_us(60);
    DS1820_DDR &= ~(1<<used_pin);        // define as input
      DS1820_PORT |= 1<<used_pin;          //Pullup on
    _delay_us(4);
  }
  if (wrbit ==1)  {
    DS1820_DDR |= 1<<used_pin;          // define as ouput
      DS1820_PORT &= ~(1<<used_pin);        //Pull low
    _delay_us(10);
    DS1820_DDR &= ~(1<<used_pin);        // define as input
      DS1820_PORT |= 1<<used_pin;          //Pullup on
    _delay_us(54);
  }
}
//-----------------------------------------
// Read one bit from DS18S20
//-----------------------------------------
uint8_t ds1820_re_bit(uint8_t used_pin)
{
  uint8_t rebit;
  DS1820_DDR |= 1<<used_pin;              // define as ouput
    DS1820_PORT &= ~(1<<used_pin);            //Pull low
  _delay_us(2);
  DS1820_DDR &= ~(1<<used_pin);            // define as input
  DS1820_PORT |= 1<<used_pin;              //Pullup on
  _delay_us(10);
  rebit = (DS1820_PIN & (1<<used_pin)) >> used_pin;   //Read bit
  _delay_us(48);
  return rebit;                
}
//-----------------------------------------
// Read 1 byte from DS18S20
//-----------------------------------------
uint8_t ds1820_re_byte(uint8_t used_pin)
{
  uint8_t rebyte =0x00;
  uint8_t rebit;
  uint8_t i;

  for (i=0;i<8;i++)
  {
    rebit=ds1820_re_bit(used_pin);
    _delay_us(2);                  //be on the save side
    if (rebit==1){
      rebyte|=(1<<i);
    }
  }
  return(rebyte);
}
//-----------------------------------------
// Write 1 byte to DS18S20
//-----------------------------------------
void ds1820_wr_byte(uint8_t wrbyte,uint8_t used_pin)
{
  uint8_t i;
  for (i=0; i<8; i++) // writes byte, one bit at a time
  {      
    ds1820_wr_bit((wrbyte & 0b00000001),used_pin);
    wrbyte = wrbyte >> 1;
  }
  _delay_us(5);
}
//-----------------------------------------
// Read temperature
//-----------------------------------------
float  ds1820_read_temp(uint8_t used_pin)  
{
  uint8_t error;
  uint16_t i=0;
    uint8_t scratchpad[9];
  float temp=0;

  scratchpad[0]=0;
  scratchpad[1]=0;
  scratchpad[2]=0;
  scratchpad[3]=0;
  scratchpad[4]=0;
  scratchpad[5]=0;
  scratchpad[6]=0;
  scratchpad[7]=0;
  scratchpad[8]=0;

  error=ds1820_reset(used_pin);
                                  //1. Reset
  if (error==0){
      ds1820_wr_byte(0xCC,used_pin);                //2. skip ROM
      ds1820_wr_byte(0x44,used_pin);                //3. ask for temperature conversion

     for (i = 0;i < 760;i++){                    //4. wait until conversion is finished 
        _delay_ms(1);  
    }

  //  while (ds1820_re_byte(used_pin)!=0xFF){            //4. wait until conversion is finished 
  //    _delay_us(10);
  //    i++;
  //  }

      error=ds1820_reset(used_pin);                //5. Reset
      ds1820_wr_byte(0xCC,used_pin);                //6. skip ROM
      ds1820_wr_byte(0xBE,used_pin);                //7. Read entire scratchpad 9 bytes
    
      for (i=0; i<9; i++)                       //8. Get scratchpad byte by byte
      {
         scratchpad[i]=ds1820_re_byte(used_pin);           //9. read one DS18S20 byte
      }

  //  scratchpad[1]=0b00000010;                  // Testbytes for Temperatur calculation
  //  scratchpad[0]=0b01010001;
  }
  if((scratchpad[1]&0xF8)==0x00){        .
    temp = (float)(((scratchpad[1]<<8)+scratchpad[0]));          
    temp *= 0.0625;

  }else{                  
    uint8_t tmp;
    tmp =scratchpad[0];                    
    tmp= ~ tmp;
    tmp= tmp >> 1;
    temp = (-1)*(tmp+1);
    if ((scratchpad[0]&0b00000001)==1){
      temp=temp+0.5;
  }

  }

//  temp=scratchpad[2];                        // Return Scratchpad Byte X for Controll

  return temp;
  
}
//-----------------------------------------
// Initialize DS18S20
//-----------------------------------------
uint8_t  ds1820_init(uint8_t used_pin)  
{
  uint8_t error;
  error=ds1820_reset(used_pin);                  //1. Reset
  if (error==0){
      ds1820_wr_byte(0xCC,used_pin);                //2. skip ROM
      ds1820_wr_byte(0x44,used_pin);                //3. ask for temperature conversion
     for (i = 0;i < 1000;i++){                  //4. wait until conversion is finished 
      _delay_us(900);
    }
    error=ds1820_reset(used_pin);                //5. Reset
      ds1820_wr_byte(0xCC,used_pin);                //6. skip ROM
      ds1820_wr_byte(0xBE,used_pin);                //7. Read entire scratchpad 9 bytes
    }
    return error;
     
}

Kann mir jemand helfen und mir sagen was ich Falsch mache?

Aufgerufen wird die Funktion ds1820_read_temp und die sollte dann die 
Temperatur als Float zurückgeben.

Kann mir jemand helfen und mir sagen was ich Falsch mache?

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann mir denn keiner Weiterhelfen?

Es ist zum verzweifeln wenn man schon soo knapp davor ist, weil wie 
gesagt die meisten Funktionen funktionieren ja...

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Lass mal das setzen mit den Pullups weg. Außer beim Reset.

Schalte mit DDR nur auf Eingang bzw. Ausgang, weil der externe 
Pullup-Widerstand sowieso den Bus auf High zieht. Wenn du denn Pullup 
einschaltest verhinderst Du das der Sensor den Bus auf Low ziehen kann.
Also das wirkt sich negativ auf die Kommunikation aus.

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für den Tip.
Hab mal die Internen Pull-Ups raus.

Das Problem bleibt das gleiche. Die beiden Bytes mit der Temperatur sind 
voll 1, außer die 5 vorzeichenbits, die sind 0.
Und die restlichen 7 Byte kann ich Problemlos auslesen???

Die Wartezeit hab ich mal absichtlich weit unter 750ms gesetzt, dann 
steht 85° drin also der defaultwert.

Das heißt er tut auf jedenfall was, mnur leider nur Murks.

Noch längere Wartezeit hat auch nichts gebracht.

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@johannes

Erklär mir mal die 2 teilen kurz da steh ich gerade auf dem Schlauch

uint8_t error;
uint8_t scratchpad[9];

und das uint8_t ds1820_re_bit(uint8_t used_pin) irgendwie verbiegts mir 
gerade die Gehirnwindungen.

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,

also,

uint8_t error;

benötige ich um mir den Rückgabewert der Resetfunktion zu merken (Wenn 
reset erfolgreich dann 0). Und nur wenn der auch erfolgreich war, Starte 
ich anschliesend eine Temperaturmessung.

uint8_t scratchpad[9];

Benutze ich um das Komplette Scratchpad in ein Array einzulesen, auch 
wenn ich vorerst nur die ersten 2 Byte brauche (LSB und MSB).

uint8_t ds1820_re_bit(uint8_t used_pin)

mit der Funktion lese ich dann innerhalb der Funktion

ds1820_re_byte(used_pin)

einzelne Bits aus dem Sensor aus. Das used_pin kommt daher, dass ich aus 
dem Hauptprogramm ledeglich

temperatur = ds1820_read_temp(PD6);

aufrufe und die Funktion dann den als used_pin erhaltenen PIN in die 
tieferen Funktionen herunterreicht.

Sinn und zweck dahinter ist, später mal mehrere Sensoren an verschiedene 
Pins zu hängen und einfach anhand der Übergebenen Parameter abzufragen.

Ich hoffe ich hab das einigermaßen klären können, wenn nicht bitte 
sagen, ich stehe Rede und Antwort in der Hoffung das ich mal auf 
Vernünftige Werte komme :D

Danke schonmal

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bei deiner RESET routine
> DS1820_PORT |= 1<<used_pin;            //Pullup on  raus machen
Dann bleibt es beim Push-Pull-Ausgang auf LOW


Johannes schrieb:
> //-----------------------------------------
>
> // Read one bit from DS18S20
>
> //-----------------------------------------
>
> uint8_t ds1820_re_bit(uint8_t used_pin)
>
> {
>
>   uint8_t rebit;
>
>   DS1820_DDR |= 1<<used_pin;              // define as ouput
>
>     DS1820_PORT &= ~(1<<used_pin);            //Pull low
>
>   _delay_us(2);
>
>   DS1820_DDR &= ~(1<<used_pin);            // define as input
>
>   DS1820_PORT |= 1<<used_pin;              //Pullup on
>
>   _delay_us(10);
>
>   rebit = (DS1820_PIN & (1<<used_pin)) >> used_pin;   //Read bit
>
>   _delay_us(48);
>
>   return rebit;
>
> }

Tja ich denke das du hier das Timing nicht ein hälst.
Zum einlesen eines bits muss das DDR-Register immer auf Eingang 
geschaltet sein ohne Pullup.

Der Zeitschlitz muss mind. 60µs und max. 120µs lang sein.

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
uint8_t  damit komm ich nicht klar, weil du es für fast alles verwendest

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Zu Bit einlese:

Aber ich muss doch als Master erstmal für min. 1us auf Low ziehen damit 
er mir das nächste Bit gibt.

und nach 2us Pull-down schalte ich ja auf Eingang und bleibe dann auch 
bis zum nächsten bit.

Oder habe ich da was falsch verstanden?

Die Pull-Ups hab ich mal raus.

Ändert leider auch nichts.

So schaut die Read-bit funktion nun aus

uint8_t ds1820_re_bit(uint8_t used_pin)
{
  uint8_t rebit;
  DS1820_PORT &= ~(1<<used_pin);            //Pull low
  DS1820_DDR |= 1<<used_pin;              // define as ouput            

  _delay_us(2);

  DS1820_DDR &= ~(1<<used_pin);            // define as input
//  DS1820_PORT |= 1<<used_pin;              //Pullup on
  
  _delay_us(10);

  rebit = (DS1820_PIN & (1<<used_pin)) >> used_pin;   //Read bit
  _delay_us(60);
  return rebit;                
}


Also so sinds nun 72us pro Zeitschlitz
Erst 2 Master Pull LOW
dann auf Eingang umschalten(ohne Pull-Up)
nach 10us dann den Wert Prüfen
Anschliesend nochmal 60us warten bis zum nächsten bit

Außerdem kann ich ja die Bytes 2-8 richtig einlesen. Oder kann es sein 
das dort das Timing leicht unterschiedlich ist??

Oder stimmt da noch was nicht?


Zu den uint8_t:

Die benutze ich aus gewohnheit, da ich mir viel über das Tutorial hier 
angeeignet habe und da eben vorgeschlagen wird, diese verschiedenen 
Integertypen mit ablesbarer länge, zu nehmen.

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
probiers mal so

uint8_t ds1820_re_bit(uint8_t used_pin)
{
  uint8_t rebit;
   DS1820_DDR &= 1<<used_pin;
// define as ouput hier wird  der port auf low gezogen
// Startsignal für den Sensor zum senden

  _delay_us(2);

  DS1820_DDR |= (1<<used_pin);            // define as input

  _delay_us(10);       // sollte mind. 15µs sein

  rebit = (DS1820_PIN & (1<<used_pin)) >> used_pin;   //Read bit
  _delay_us(60);     // 105µs warten

  DS1820_DDR |= (1<<used_pin);  //Datenleitung wider auf high
  return rebit;
}

Ich hoffe, das dass mit dem setzen der Datenleitung richtig ist da ich
eher in Assembler programmiere.

Autor: Torsten S. (tse)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Gut gemeinte Ratschläge:

- schmeiß die Zuweisung des Ports aus ds1820_re_bit() raus. Mach das nur 
einmal, und zwar bevor Du das ganze Byte liest/schreibst weil der AVR 
die Bitschieberei überhaupt nicht mag und aufwändigen Code erzeugt. Und 
das kritische Timing durcheinander bringt.

- weg mit float! Die Temperautur ist ein int16_t, egal ob DS18B20 oder 
DS18S20.

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Torsten S. schrieb:
> schmeiß die Zuweisung des Ports aus ds1820_re_bit() raus. Mach das nur
> einmal, und zwar bevor Du das ganze Byte liest/schreibst weil der AVR
> die Bitschieberei überhaupt nicht mag und aufwändigen Code erzeugt. Und
> das kritische Timing durcheinander bringt.

Sorry, aber da steh ich jetzt voll auf dem Schlauch.

Wie soll ich dass denn nur am Anfang vom Byte machen? Ich dachte ich 
muss zum Initieren eines einzelnen Bits immer den Bus als Master kurz 
auf Low ziehen.

Weil ich hab ja keinen Takt oder so an dem ich mich ansnsten orientieren 
könnte.

@Klaus:

Bist du dir sicher das ich mindestens 15us warten muss? Ich habs als 
maximal interpretiert.

Aus dem Datenblatt:
>Output data from the DS18B20 is valid for 15µs after the falling edge that 
>initiated the read time slot. Therefore,
>the master must release the bus and then sample the bus state within 15µs >from 
the start of the slot.

Ich habs mal mit deiner Bit-Lese-Routine probiert. Ich bekomm dann nur 
noch 0 zurück auch bei den Bytes die ich zuvor richtig lesen konnte.

P.S.

 DS1820_DDR &= 1<<used_pin;

sollte glaube ich eher

 DS1820_DDR &= ~(1<<used_pin);

dass sein damit garantiert eine 0 drin steht.

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Joahnnes kennst dich mit Assembler aus???

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So kleines Uptdate

Ich habe die Tiemings nun genau auf die Vorschläge aus den 
Applications-Notes von Maxim eingestellt.

Ich kann das komplette Scratchpad lesen.

Ich kann in die User-Data-Bytes schreiben und erfolgreich zurücklesen

Wenn ich eine Messung starten lasse, >750ms Warte, dann Resete und die 
Daten zurücklese, sind alle Daten im Scratchpad richtig, aber als 
Temperator stehen 127.9375°C drin.
Das entsppricht:

LSB: 1 1 1 1 1 1 1 1
MSB: 0 0 0 0 0 1 1 1

Was nicht geht ist außerdem wenn ich nicht die feste Zeit warte sondern 
den Messungsstatus über den PIN abfrage, behauptet er, er sei bereits 
fertig, also ich habe bereits beim ersten mal die 1 zurücklesen können.
Das ist vielleicht auch irgendwie der Knackpunkt, warum liefert er 
sofort 1 zurück?

Das Rücklesen an sich muss nun richtig sein, da ich ja die anderen 7 
Byte richtig lesen kann und ich mich ja an die Application-Notes halte.

grüße

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich glaub so kommen wir nicht weiter! Ähm könntest du deinen Quellcode 
posten.

Auf welchem µC soll es den laufen?

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
------------------------------------------------------------------------ 
------------
; Startet die Temperaturmessung aller angeschlossenen Sensoren
;----------------------------------------------------------------------- 
-------------

wire_converT:
   ldi   temp, 0x44
   rcall  wire_wByte
_conv:
   rcall  wire_read_bit
   brcc  _conv
ret

So sieht es bei mir aus wenn ich zum Messen auffordere

Autor: Johannes (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
So hier mal die Sources.

Die lcd.c und lcd.h hab ich nicht angehängt, da es die gleichen wie im 
tutorial sind und hier eh keine Rolle spielen.
Denke ich.

Lg

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ach ja und laufen soll das ganze auf einem ATmega 16
momentan auf einem STK500 Entwicklungsboard mit 4MHZ takt.

danke für die Routine, aber Assembler ist für mich absolutes Neuland

Autor: Klaus (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
@Johannes

Hat jetzt lange gedauert aber musste mich mit AVR Studio 5 etwas 
herumschlagen wegen den Zeiten.

Ich habe es mal auf ATmega 32 getestet und hab deine Routinen etwas 
angepasst.

Wenn du es ausprobieren willst bitte ein neues Projekt anlegen.

Also die temp variable in Main wird die Temperatur enthalten als int.

Wenn da z.b. 250 heraus kommen sollte sind das 25,0 °C.

Eigentlich wollte ich in AVR-Studio 4 das ganze machen aber scheint ein 
Bug zu haben.

Bsp.
err = (DS1820_PIN & (1<<used_pin))  >> used_pin;

err erhalte ich immer 3  anstatt den Wert 0 oder 1.
Liegt aber daran das an Port D  PIND1  eine LED angeschlossen ist

Teste es lieber in AVR Studio 5

Optimize auf -O1 stellen sonst klappts mit dem Timing nicht

Schau es dir einfach mal an.


Achso ganz vergessen hauptsächlich ds1820_re_bit, ds1820_reset   hab ich 
verändert.

Autor: Klaus (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
@Johannes

So hier deine Funktionierenden Routinen.

Viel Spass damit!

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Johannes!


Wie siehts aus funktioniert die Sache jetzt???

Autor: Ich auch Techniker (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Johannes!

hier noch eine kleine Änderung! Jetzt sollte die Temperaturmessung  mit 
0.1 °C schritten gehen.

Habs heute erst gemerkt das was ich hier losgelassen habe nicht ok war.

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielleicht hilft euch das hier weiter:

 Temp_read = (scratchpad[0]) * 0.5 ;

    Count_Remain = scratchpad[6];
    Count_PER_C = scratchpad[7];
    temp = (float)Temp_read -0.25 + ((Count_PER_C - Count_Remain) / 
Count_PER_C)  ;

Für negative Temperaturen müsste man scratchpad[1] einer Variablen zu 
weisen und prüfen ob FFh drinne steht.

Wenn FFh ein Flag setzen für die Ausgabe des minus Zeichen.
Dann das Zweierkomplement bilden mit scratchpad[0]) und
denn Rest normal weiter rechnen lassen.

Die Berechnung oben löst die Temperatur in 0,1 °C schritten auf.

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Misst! falscher Tread! Sorry

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.