Kleines Timingproblem beim DS1820

[Gast (Gast)]

Servus!

Irgendwo habe ich aber noch ein kleines Problem beim empfangen der Bits
vom DS1820. Leider kann ich immer nur Mist auslesen -> 11100000 usw.

Convert wurde gesendet, genau auch der Befehl zum Temperatur messen.
Aber irgendwie stimmt da was mit den Timings noch nicht so ganz.
Wahrscheinlich zwischen letzten Befehl senden und auslesen. Oder auch
beim Empfang der einzelnen Bits!? Entweder zulange oder zu kurz
gewartet. Ich weiß es nicht.

Das Datenblatt ist mir dabei auch nicht sehr hilfreich, zumindest finde
ich es einfach nicht genau. Im Forum hier, finden sich auch immer wieder
unterschiedliche Zeiten.

Wenn ich zwischen den einzelnen Bits empfangen ein _delay_us(80); drin
habe, kommt auch ein ziemlich wirrer Code raus, egal bei welchem Byte. 
Wenn ich es weg lasse, kommt anderer sinnloser Code raus.
Das 1. Byte soll laut Datenblatt ja nur 0x00 oder 0xFF sein, und sonst
nichts dazwischen.

Das Resetsignal wird korrekt empfangen, er ist also richtig
eingebaut und antwortet auch. Genauso empfange ich ja auch 1er und 0er
nur falsch.

Ich hatte das ganze gestern schon mal gepostet, aber irgendwie finde 
ich, passt es so gar nicht mehr zum Ausgangsproblem. Siehe-> 
Beitrag "Code gibt immer den gleichen Binärcode aus"

[Timmo H. (masterfx)]

Bei mir sah das so aus:

static const int   A = 6 ,
      B = 64,
      C = 60,
      D = 10,
      E = 9,
      F = 55,
      G = 0,
      H = 480,
      I = 70,
      J = 410;



void w1_wr_byte(char byte byte){
  unsigned char i;
  for(i = 0; i < 8; i++){
    w1_write_bit(byte & 0x01);
    byte >>= 1; 
  }
  
}


unsigned char w1_rd_byte(){
  unsigned char i, result=0;
  for (i = 0; i < 8; i++){
    result >>= 1;
    if (w1_read_bit())
      result |= 0x80;
  }
  return result;
}

void w1_write_bit(unsigned char bit){
  unsigned char  result;
  if(bit){
    PORTT &= ~0x01;
    DDRT |= 0x01;
    delay_us(A);
    DDRT &= ~0x01;
    delay_us(B);
  }
  else{
    DDRT |= 0x01;
    delay_us(C);
    DDRT &= ~0x01;
    delay_us(D);
  }
}

unsigned char w1_read_bit(unsigned char bus){
  BT_UBYTE result;
  
  PORTT &= ~0x01;
  DDRT |= 0x01;
  delay_us(A);
  DDRT &= ~0x01;
  delay_us(E);
  result = PORTT & 0x01;
  delay_us(F);

  return result;

}

So hatte das bei mir glaub ich geklappt (war auf einem HC12). 
Selektierst du jedes Device per ID?
Ansonsten hier nochmal in der Appnote gucken: 
http://www.maxim-ic.com/appnotes.cfm/appnote_number/126

[Gast (Gast)]

> Selektierst du jedes Device per ID?
Nein, es ist nur einer angeschlossen.

Wie lange wartest du vom letzten Befehl(0xBE) senden, bis zum auslesen 
der jeweiligen Bytes, und zwischen jedem Byte?

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

@Gast: Ich habe mir mal exemplarisch das Senden angesehen.

Der ganze Bitzyklus sollte normalerweise gut 60µs dauern, plus Erholzeit 
der Leitung. Du ziehst aber bei 0 für 90µs runter. Auch die 7µs sind 
etwas hoch, zumal die inhärente Verzögerung des Steuercodes drum herum 
auch mitzählt. Zum "Ausgleich" ist der Slot dann bei "1" zu kurz, nur 
rund 30µs.

Nach der 0-Phase sollte zudem explizit etwas Luft gelassen werden, damit 
der Widerstand die Leitung hochziehen kann - was bei längerer Leitung 
ein paar µs dauert. Dieser Aspekt fehlt übrigens auch in Peter 
Danneggers Code.

Üblicherweise kombiniert man übrigens Senden und Empfangen in einer 
Routine, weil es fast der gleiche Vorgang ist. Für den Empfang "sendet" 
man dann 0xFF.

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

Weiter im Text: Hier wohl unkritisch aber trotzdem falsch: wire_low() 
zieht u.U. kurz hoch bevor es runter geht. Generell wenn bei AVRs Open 
Drain realisiert werden soll: erst Ausgangsregister auf 0 setzen, dann 
auf Ausgang stellen, keinesfalls andersrum.

[Gast (Gast)]

Soweit mal Thx. Ich habe den Code mal so geändert wie beschrieben.

Aber die Frage habe ich von oben noch:
>Wie lange wartest man vom letzten Befehl(0xBE) senden, bis zum auslesen
>der jeweiligen Bytes, und zwischen jedem Byte?

senden (0xBE); //Temp messen
_delay_us(?); // Wartezeit nach dem senden (bisher 50)
int wert1 = empfang();
//_delay_us(?); // Zeit zum 2. Byte empfangen (bisher nicht vorhanden)
int wert2 = empfang();

Diese beiden Delays stimmen wahrscheinlich noch nicht, und besonders die 
sind mir nicht ganz klar.

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

Nach dem Start der Messung ist Geduld angesagt (750ms). Zwischen den 
Bytes ist jedoch kein zusätzliches Delay nötig.

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

Zu empfang():
- Es wird zu früh gesampelt. Empfohlen wird ja knapp unter 15µs
- Auch hier den 60µs Zyklus fahren, nicht warten bis inaktiv.
Und wenn du das hast, wirst du sehen, dass es einfacher ist, beim Senden 
auf Verdacht nach knapp 15µs zu sampeln und als Ergebnis zu 
akkumulieren. Also die selbe Routine für beides verwenden.

Hab nochmal reingesehen. Die 90µs sind durchaus ok, vor allem wenn der 
eigene Takt arg ungenau ist. Aber unter 60µs darf der Bitzyklus nicht 
liegen, egal ob 1 oder 0 oder Lesen oder Schreiben.

[Gast (Gast)]

Der Takt ist ziemlich genau, von einem externen Quarz mit 12 MHz.

Soweit empfange ich jetzt die korrekte Temperatur. :-) Thx dafür an 
alle.

Aber das 2. Byte empfange ich noch nicht ganz korrekt. Meist sowas wie 
11100000 oder 00001111. Eigentlich sollte das doch 00000000 oder 
11111111 sein, oder?