SHT11 und ATmega 128 -> Fehler bei negativen Temperaturen

[Max (Gast)]

Hallo,

ich habe einen SHT11 an einem ATmega 128 und versuche nun die Werte über 
die UART auszugeben.
Mit der Feuchte funktioniert dies einwandfrei, mit der Temperatur gibt 
es jedoch Probleme.
Prinzipell funktioniert die Ausgabe wie gewünscht, jedoch habe ich 
diesen Winter festgestellt, dass bei einer Temperatur unterhalb von -9,9 
Grad nur noch "Müll" (wirre Zeichen) ausgegeben werden.
Alles über -9,9Grad funktioniert problemlos.

Ich kann jedoch den Fehler in meinem Code nicht finden.
Evtl. kann ja jemand der gerade in der Materie ist mal drüberschauen?

Anbei die relevanten Auszüge aus meinem Programm:

**************************************************************************************************
main.c

int main(void)
{
  UART_Init();                            //Initalisierung der UART

  while(1)
   {
      SHT_FEHLERFLAG = 0;          //Fehlerflag auf 0 setzen
      UART_Ausgabe();                     //Senden der Temperatur und Feuchtigkeit
      delay_ms(1000);             //max. 2 Lesevorgänge pro sec
   }
}

void UART_Ausgabe (void)       
{
  float TEMPERATUR = 0x00;                //Floatvariable für die Temperatur
  
  TEMPERATUR = 0x00;                    //Floatvariable für die Temperatur = 0
  
  TEMPERATUR = SHT_Temperatur();           //Schreibe aktuelle Temperatur in Variable
  dtostrf(TEMPERATUR, 1, 1, TEMPERATUR_STR);   //Float to String Wandlung
  
  if(SHT_FEHLERFLAG == 0)          //Filter falls Sensor abgezogen (falsche Werte)
    {
     UART_Senden_String (TEMPERATUR_STR);    //Senden der aktuellen Temperatur
     UART_Senden_String (" ");               //Leerzeichen
     UART_Senden_Byte (176);                 //Ausgeben des °
     UART_Senden_String ("C");               //Anhängen der Einheit C
    }
}
***************************************************************************************************
main.h

char TEMPERATUR_STR[5];                  //Array für Temperatur
char FEUCHTE_STR[5];                     //Array für Feuchte
char SHT_FEHLERFLAG;           //Wenn 1= SHT nicht angeschlossen
***************************************************************************************************
sht.c

void SHT_Transstart (void)
{
  MAKE_DATA_OUTPUT;       //Datenpin des SHT11 als Ausgang
  MAKE_SCK_OUTPUT;        //Takt des SHT11 als Ausgang
  _delay_us(EINPEGELN);
  SET_DATA_PIN;           //Datenpin auf High
  _delay_us(EINPEGELN);
  RESET_SCK_PIN;          //Taktpin auf Low       
  _delay_us(EINPEGELN);
  SET_SCK_PIN;            //Taktpin auf High
  _delay_us(EINPEGELN);
  RESET_DATA_PIN;         //Datenpin auf Low
  _delay_us(EINPEGELN);
  RESET_SCK_PIN;          //Taktpin auf Low
  _delay_us(EINPEGELN);
  SET_SCK_PIN;            //Taktpin auf High
  _delay_us(EINPEGELN);
  SET_DATA_PIN;           //Datenpin auf High
  _delay_us(EINPEGELN);
  RESET_SCK_PIN;          //Taktpin auf Low
  _delay_us(EINPEGELN);
}

/******************************************************************************************/
/********************************Connectionreset an SHT11**********************************/
/******************************************************************************************/

void SHT_Connectionreset (void)
{
  unsigned char i = 0x00; //Variable für Zählschleife
  
  MAKE_DATA_OUTPUT;       //Datenpin des SHT11 als Ausgang
  MAKE_SCK_OUTPUT;        //Taktpin des SHT11 als Ausgang
  _delay_us(EINPEGELN);
  SET_DATA_PIN;           //Datenpin auf High
  RESET_SCK_PIN;          //Taktpin auf Low
  for(i=0;i<9;i++)        //Schleife wird 9x ausgeführt
   { 
    SET_SCK_PIN;          //Taktpin auf High     
    _delay_us(EINPEGELN);
    RESET_SCK_PIN;        //Taktpin auf Low
    _delay_us(EINPEGELN);
   }
  SHT_Transstart();       //Ausgeben der nachfolgenden Transmissionstart Sequenz
}

/******************************************************************************************/
/**************************Byte an SHT11 senden und ACK überprüfen*************************/
/******************************************************************************************/

char SHT_Write_byte (unsigned char value)
{ 
  unsigned char i     = 0x00;     //Variable für Bitmaskierung (Schleife)
  unsigned char error = 0x00;     //Variable für ACK- Rückgabewert
  
  MAKE_SCK_OUTPUT;                //Taktpin des SHT11 als Ausgang
  
  for (i=0x80;i>0;i/=2)           //Verschiebe Bits für Maskierung
  { 
     if (i & value)               //(maskiere value mit i)
      {                           //Wenn Bit = 1 ist, dann:
       SET_DATA_PIN;              //Datenpin auf High
       _delay_us(EINPEGELN);
      }          
     else                         //Wenn Bit = 0 ist, dann:
      {
       RESET_DATA_PIN;            //Datenpin auf Low         
       _delay_us(EINPEGELN); 
      }    
  _delay_us(EINPEGELN);                                
  SET_SCK_PIN;                    //Taktpin auf High (CLK)
  _delay_us(EINPEGELN);
  RESET_SCK_PIN;                  //Taktpin auf Low
  _delay_us(EINPEGELN);
  }
  
  _delay_us(EINPEGELN);
  SET_DATA_PIN;                   //Datenpin auf High            
  _delay_us(EINPEGELN);
  SET_SCK_PIN;                    //Taktpin auf High (ACK)        
  _delay_us(EINPEGELN);
  MAKE_DATA_INPUT;                //Datenpin des SHT11 als Eingang
  
  if ((SHT_DATA_PIN_IN & (1<<SHT_DATA_PIN)))  //Wenn Datenpin (ACK) = 1 dann:
  {
   error = 1;                     //setze "error" auf 1
  }
  else                            //ist ACK = Low (kein Fehler)
  {
   error = 0;                     //setze "error" auf 0
  }
  
  _delay_us(EINPEGELN);
  RESET_SCK_PIN;                  //Setze den Taktbin auf Low
  
  _delay_ms(400);                 //Warte auf das Wandlungsergebniss
   
  return (error);                 //"error" = 1, wenn Fehler aufgetreten (sonst 0)
}

/******************************************************************************************/
/**************Byte aus SHT11 lesen, ACK prüfen und ACK ausgeben (bei ACK = 1)*************/
/******************************************************************************************/

char SHT_Read_byte(unsigned char ack)
{ 
  unsigned char i   = 0x00;       //Variable für Bitmaskierung (Schleife)
  unsigned char val = 0x00;       //Variable für Bitlesefunktion
  
  MAKE_DATA_OUTPUT;               //Datenpin des SHT11 als Ausgang
  _delay_us(EINPEGELN);
  SET_DATA_PIN;                   //Datenpin auf Ausgang
  _delay_us(EINPEGELN);
  MAKE_DATA_INPUT;                //Datenpin des SHT11 als Eingang
                       
  for (i=0x80;i>0;i/=2)           //Verschiebe Bits für Maskierung
  {   
   SET_SCK_PIN;                   //Taktpin auf High (CLK)
   _delay_us(EINPEGELN);                
   if ((SHT_DATA_PIN_IN & (1<<SHT_DATA_PIN)))     //Wenn Datenpin = 1, dann:
    {
     val=(val | i);               //schreibe Wert in "val"
    }       
   RESET_SCK_PIN;                 //Taktpin auf Low
   _delay_us(EINPEGELN);
  }
  
  _delay_us(EINPEGELN);
  MAKE_DATA_OUTPUT;               //Datenpin des SHT11 als Ausgang
  _delay_us(EINPEGELN);
  
  if(!ack == 1)                   //Wenn für ACK eine 1 übergeben wurde, dann:
  {
   SET_DATA_PIN;                  //Datenpin auf High
  }
  else
  {
   RESET_DATA_PIN                 //Datenpin auf Low
  }
  
  _delay_us(EINPEGELN);
  SET_SCK_PIN;                    //Taktpin auf High (ACK)
  _delay_us(EINPEGELN);
  RESET_SCK_PIN;                  //Taktpin auf Low
  _delay_us(EINPEGELN);
  SET_DATA_PIN;                   //Datenpin auf High
  _delay_us(EINPEGELN);
  
return (val);
}

/******************************************************************************************/
/***********************Auslesen und Rückgeben (Float) der Temperatur**********************/
/******************************************************************************************/

float SHT_Temperatur (void)
{
  uint8_t  TEMP_MSB       = 0x00;         //Variable für Temperatur MSN (erstes Byte)    
  uint8_t  TEMP_LSB       = 0x00;         //Variable für Temperatur LSB (zweites Byte) 
  uint16_t TEMP_16B       = 0x00;         //Variable für 16 Bit Temperaturwert
  float    TEMP_FLOAT     = 0x00;         //Variable für Float Temperaturwert
  
  SHT_Connectionreset();                  //Ausführen eines Connectionresets
  SHT_Transstart();                       //Ausgeben der Transmissionstart Sequenz
  SHT_Write_byte(0x03);                   //Schreibe Byte für Temp. (Adr.000, Com. 00011)
  
  TEMP_MSB = SHT_Read_byte(0x01);         //Lese das Temperatur MSN aus (mit ACK -> nächstes Byte)
  TEMP_LSB = SHT_Read_byte(0x00);         //Lese das Temperatur LSB aus (ohne ACK -> ohne Checksumme)
  
  TEMP_16B = TEMP_MSB << 8;               //Füge das Temp. MSB ein und verschiebe es um 8 Stellen
  TEMP_16B = TEMP_16B | TEMP_LSB;         //Lege das Temp. LSB drüber, sodass ein 16 Bit Wert entsteht
  
  TEMP_FLOAT = TEMP_16B;                  //schreibe den "uint16_t" Wert in ein "float" Wert
  TEMP_FLOAT = TEMP_FLOAT * 0.01 - 40;    //Umrechnung des Wertes in eine Temperatur (nach Datenblatt)
  
  if(TEMP_FLOAT >= 100)          //Filter fals Sensor abgezogen (falsche Werte)
   {
    SHT_FEHLERFLAG = 1;
   }
  
  return(TEMP_FLOAT);                     //Rückgabe des Temperaturwertes ("float")
}
***************************************************************************************************
sht.h

void    SHT_Transstart      (void);
void    SHT_Connectionreset (void);
char    SHT_Write_byte      (unsigned char);
char    SHT_Read_byte       (unsigned char);
float   SHT_Temperatur      (void);
float   SHT_Feuchte         (void);

#define SHT_SCK_DDR      DDRE
#define SHT_DATA_DDR     DDRE

#define SHT_SCK_PORT     PORTE
#define SHT_DATA_PORT    PORTE

#define SHT_DATA_PIN_IN  PINE

#define SHT_SCK_PIN      PE3
#define SHT_DATA_PIN     PE2

#define SET_DATA_PIN     SHT_DATA_PORT = SHT_DATA_PORT | (1<<SHT_DATA_PIN);
#define SET_SCK_PIN      SHT_SCK_PORT = SHT_SCK_PORT | (1<<SHT_SCK_PIN);
#define RESET_DATA_PIN   SHT_DATA_PORT = SHT_DATA_PORT & ~(1<<SHT_DATA_PIN);      
#define RESET_SCK_PIN    SHT_SCK_PORT = SHT_SCK_PORT & ~(1<<SHT_SCK_PIN);

#define MAKE_DATA_OUTPUT SHT_DATA_DDR = SHT_DATA_DDR | (1<<SHT_DATA_PIN);
#define MAKE_DATA_INPUT  SHT_DATA_DDR = SHT_DATA_DDR & ~(1<<SHT_DATA_PIN); SHT_DATA_PORT = SHT_DATA_PORT & ~(1<<SHT_DATA_PIN);
#define MAKE_SCK_OUTPUT  SHT_SCK_DDR = SHT_SCK_DDR | (1<<SHT_SCK_PIN);

#define EINPEGELN        1      //Einpegelzeit zwischen Flankenwechsel in us

[Max (Gast)]

Kann es evtl. mit der Float zu Stringwandlung zusammen hängen?

The dtostrf() function converts the double value passed in val into an 
ASCII representationthat
will be stored under s.

Ein double value ist ja kein float, oder?

[Jörg W. (dl8dtl) (Moderator)]

Habe mir jetzt den SHT-11 nicht angesehen, aber das hier benutze
ich für einen SHT-21:

      v = ((uint16_t)b[0] << 8) | b[1];
      double t = -46.85 + 175.72 * (double)v / 65536.0;

b[0] und b[1] sind dabei die beiden Bytes des Temperaturmesswertes.