Mehrere Dallas

[Torsten (Gast)]

Hallo zusammen,

sitze nun schon mehrere Tage daran mehrere Temperatursensoren von Dallas 
auszulesen.
Ich kann sie einzeln sowohl als auch mit dem March-Rom Befehl auslesen. 
Da ich aber ein System mit mehreren ca. 50 Temperatursensoren vor hab zu 
bauen wollte ich jetzt nicht jede ID von den Sensoren hinterlegen wegen 
dem Speicher.
Es gibt jetzt ja den Search-Rom Befehl.
Ich schreibe jetzt den Search-Rom Befehl auf die Leitung und lese 
anschließend die ID des Sensors ein. Anschließend Schreibe ich mit dem 
Match-Rom die Sensor ID auf die Leitung und sage dem der soll die 
Temperatur messen. Ein kurze Pause und ich spreche wieder den Sensor mit 
Match Rom an und lese die Sensor Daten mit dem Read-Scratchpad aus.
Wenn ich einen Sensor hab geht das. Wenn ich jetzt zwei Sensoren habe 
geht das nicht mehr. Auch die ID’s der Sensoren kommen nicht mehr 
richtig an, das ist ein wir war zwischen den beiden.

ID1:        10 0F B7 E4 02 08 00 BF
ID2:        10 52 BD 16 03 08 00 BB
ID1 und 2:  10 02 B5 04 02 08 00 BB
Und Temperaturwerter bekomme ich auch nur wirwar.

Hier mal mein Code

Zum suchen der Dallas und lesen der Temperaturwerter

               Bus_Reset();
    Byte_Schreiben(Search_Rom);
    Rom_Code_Einlesen();
    
    Byte_Schreiben(Match_Rom);
    for (int k=0; k<9; k++)
    {
      Byte_Schreiben(Rom_Code[k]);
    }
    Byte_Schreiben(Convert_T);
    _delay_ms(1000);

    Byte_Schreiben(Match_Rom);
    for ( int k=0; k<9; k++)
    {
      Byte_Schreiben(Rom_Code[k]);
    }
    
    Byte_Schreiben(Read_Scratchpad);    
    // 9 Byte großen Scratch Pad-Inhalt einlesen
    for (int k=0; k<9; k++)
    {
      Sensordaten[k] = Byte_Lesen();
    }

und hier die neben Funktionen

unsigned char Rom_Code_Einlesen(void)
{
  unsigned char i;
  Bus_Reset();
  Byte_Schreiben(Read_Rom); // "READ ROM"
  for (i = 0; i <= 8; i++) {
    Rom_Code[i] = Byte_Lesen();
        
  }
  return Rom_Code;
}

void Byte_Schreiben(unsigned char Daten)
{
  unsigned char i;
  for (i = 0; i < 8; i++) {
    Bit_Schreiben((Daten & (1<<i)) ? 1 : 0);
  }
}

uint16_t Byte_Lesen(void)
{
  unsigned char i;
  unsigned char Byte_Wert = 0;
  for (i = 0; i < 8; i++) {
    if( Bit_Lesen() == 1 )
    Byte_Wert |= (1 << i);
  }
  return Byte_Wert;
}

Oder mache ich da irgendwas gravierend falsch?.

MFG
Torsten

[Peter D. (peda)]

Torsten schrieb:
> Ich schreibe jetzt den Search-Rom Befehl auf die Leitung und lese
> anschließend die ID des Sensors ein.

Nein.
Nach dem Search-Befehl mußt Du den Search-Algorithmus lt. Datenblatt 
ausführen.
Der gibt Dir dann die nächste gefundene Adresse (8 Byte) und die 
Bit-Nummer den letzten Konflikts zurück. Diese beiden merkst Du Dir dann 
für die nächste Suche.
Nach jeder Suche ist der gefundene Sensor adressiert, d.h. man kann 
dessen Temperatur auslesen.
Wird kein Konflikt mehr zurück gegeben, dann sind alle Sensoren 
gefunden.

Beitrag "DS1820, DS18B20 in C"

[Torsten (Gast)]

Hallo,

also ich habe mit jetzt einen Search-Algorithmus geschrieben wo 
funktioniert, bekomme meine ganzen Dallas angezeigt.
Nur die Temperratur Berrechnung macht mir noch zu schaffen obwohl sie 
bei den anderen funktioniert hatte.

#define  SEARCH_FIRST  0xFF    // start new search
#define  PRESENCE_ERR  0xFF
#define  DATA_ERR  0xFE
#define LAST_DEVICE  0x00    // last device found

unsigned char id[8], diff;
char s[30];
unsigned char i;
unsigned int temp;

for( diff = SEARCH_FIRST; diff != LAST_DEVICE; )
{
  diff = w1_rom_search( diff, id );

  if( diff == PRESENCE_ERR )
  {
    uart_puts( "No Sensor found" );
    break;
  }
  if( diff == DATA_ERR )
  {
    uart_puts( "Bus Error" );
    break;
  }
  if( id[0] == 0x28 || id[0] == 0x10 )
  {  // temperature sensor
    uart_puts( "ID: " );
    for( i = 0; i < 8; i++ )
    {
      sprintf( s, "%02X ", id[i] );
      uart_puts( s );
    }      
  
  Byte_Schreiben(Convert_T);
  _delay_ms(800);
  Bus_Reset();
  Byte_Schreiben(Match_Rom);
  for (i=0; i<8; i++)
  {
    Byte_Schreiben(id[i]);
  }
  
  Byte_Schreiben( Read_Scratchpad );    // read command
  for (int y =0; y<9; y++)
  {
    Sensordaten[y] = Byte_Lesen();
    //temp = Byte_Lesen();      // low byte
  }
  SensorID1 = (Sensordaten[2]<<4);
    
  temp = Byte_Lesen();

  temp |= (uint)Byte_Lesen() << 8;    // high byte temp
  if( id[0] == 0x10 )      // 9 -> 12 bit
  temp <<= 3;
  
  sprintf( s, "  T: %04X = ", SensorID1); 
  uart_puts( s );

  sprintf( s, "%4d.%01døC", temp >> 4, (temp << 12) / 6553 );
  uart_puts( s );
    
        //Nur zum testen
  itoa(temp,Buffer150,10);
  uart_puts(Buffer150);
  uart_puts("\n");
  }
}

Ich bekomme die ID's der Sensoren angezeigt und auch meine zwei 
vergebenen bits. Nur bei der Temperratur bekomme ich nur schrott. Bei 
allen zeigt er mir 4095.1084.
Ein Auslese fehler kann es normal nicht sein, ich bekomme ja mein ID's
bleibt eigentlich nur ein Rechenfehler.

[Walter (Gast)]

lass dir halt mal die beiden Bytes einzeln ausgeben,
was ist das eigentlich für eine magische zAHL: 6553

[Torsten (Gast)]

Hallo,

ich habe meinen Temperaturmessung nochmals komplett überarbeitet und 
habe auch im Internt viel recherchiert und gelesen.
Jedoch habe ich jetzt noch einen fehler denn ich nicht finde.
Meine Kommastelle ist um eins nach links noch verkehrt.
Das heist anstatt 25,00 C bekomme ich 2,500 C angezeigt.

Hier mal noch mein Überarbeitetes Programm habe es jetzt aber nur für 
einen Fühler am Bus geschrieben.

#define THERM_DECIMAL_STEPS_12BIT 625 //.0625

// Buffer length must be at least 12bytes long! ["+XXX.XXXX C"]
  uint8_t temperature[2];
  int8_t digit;
  uint16_t decimal;
  //Reset, skip ROM and start temperature conversion
  Bus_Reset();
  Byte_Schreiben(Skip_Rom);
  Byte_Schreiben(Convert_T);
  //Wait until conversion is complete
  while(!Byte_Lesen());
  //Reset, skip ROM and send command to read Scratchpad
  Bus_Reset();
  Byte_Schreiben(Skip_Rom);
  Byte_Schreiben(Read_Scratchpad);
  //Read Scratchpad (only 2 first bytes)
  temperature[0]=Byte_Lesen();
  temperature[1]=Byte_Lesen();
  Bus_Reset();
  //Store temperature integer digits and decimal digits
  digit=temperature[0]>>4;
  digit|=(temperature[1]&0x7)<<4;
  //Store decimal digits
  decimal=temperature[0]&0xf;
  decimal*=THERM_DECIMAL_STEPS_12BIT;
  //Format temperature into a string [+XXX.XXXX C]
  sprintf(buffer, "%+d.%04u", digit, decimal);
        uart_puts(buffer);

[eProfi (Gast)]

Im Post 16:23 hast Du ja die 9 Bytes des Scratchpad schon gelesen und 
willst weitere Bytes für temp lesen.
Du musst die bereits gelesenen Bytes auswerten!

>  Byte_Schreiben( Read_Scratchpad );    // read command
>  for (int y =0; y<9; y++)
>  {
>    Sensordaten[y] = Byte_Lesen();
>    //temp = Byte_Lesen();      // low byte
>  }
>  SensorID1 = (Sensordaten[2]<<4);
>
>  temp = Byte_Lesen();
>  temp |= (uint)Byte_Lesen() << 8;    // high byte temp


Und sowas erzeugt eine riesen Bitschiebe-Orgie:
void Byte_Schreiben(unsigned char Daten)
{
  unsigned char i;
  for (i = 0; i < 8; i++) {
    Bit_Schreiben((Daten & (1<<i)) ? 1 : 0);
  }
}

uint16_t Byte_Lesen(void)
{
  unsigned char i;
  unsigned char Byte_Wert = 0;
  for (i = 0; i < 8; i++) {
    if( Bit_Lesen() == 1 )
    Byte_Wert |= (1 << i);
  }
  return Byte_Wert;
}

Besser:
void Byte_Schreiben(unsigned char Daten){
  unsigned char m=1; //Maske
  do{Bit_Schreiben((Daten & m) ? 1 : 0);}while(m*=2);
//wahrscheinlich geht sogar:
  do Bit_Schreiben(Daten & m);while(m*=2);
  //m ist nach 8 Durchläufen wegen Überlauf 0, also false
}

uint16_t Byte_Lesen(void){
  unsigned char m = 1, Byte_Wert = 0;
  do{if(Bit_Lesen()) Byte_Wert |= m;}while(m*=2);
  return Byte_Wert;
}

Lies Dir mal meinen Code durch (ist für DS18S20, evtl. musst Du ihn ein 
wenig anpassen):
Beitrag "Re: DS18S20 - extended resolution bei Temperaturen um 0°C"
weiter unten ist er ausführlich kommentiert.

Viel Erfolg!

[eProfi (Gast)]

Und warum ist Byte_Lesen(void)  uint16_t?