Timing Probleme 1-Wire

[Anon A. (anon1234)]

Halli hallo...
ich habe jetzt wieder mit der Implementierung meiner 1-Wire 
Temperatursensoren DS18B20 weiter gemacht.
Das Protokoll habe ich eigentlich schon mehrfach durchgearbeitet und 
auch unterschiedliche Programmschnipsel und dachte eigentlich ich hätte 
es einigermaßen verstanden.
Nun zeigt der Test mit dem Logikanalysator leider, dass irgendwas schief 
läuft.
So wie ich es verstanden habe, ist die Theorie doch wie folgt:

WRITE 0:
 > pull bus low
 > wait >= 60µs
 > release bus
 > wait 10µs

WRITE 1:
 > pull bus low
 > wait <= 15µs
 > release bus
 > wait 64µs

Ich habe hierfür in 8051er assembler folgende funktionen geschrieben:

; write lsb of a to bus
; write 0:
;   - pull bus LOW
;   - wait >=60µs (60µs)
;   - release bus
;   - wait 10µs
; write 1:
;   - pull bus LOW
;   - wait <= 15µs (6µs)
;   - release bus
;   - wait 64µs
write:
  mov r0,a   ; save a
  jnz high_1
  mov r5,#3Ch   ; write 0:
  mov r6,#0h    ;   wait-time 60µs
  jmp wait_1 
  high_1:
    mov r5,#6h   ; write 1:
    mov r6,#0h   ;   wait-time 6µs
  wait_1:
    clr p2.4      ; pull bus LOW
    call initTimer
    jnb tf1,$     ; wait till timer-overflow
    setb p2.4     ; release bus
    clr tr1      ; stop timer
  mov a,r0    ; get a back
  jnz high_2
  mov r5,#0Ah    ; write 0:
  mov r6,#0h     ;   wait-time 10µs  
  jmp wait_2
  high_2:           
    mov r5,#40h   ; write 1:
    mov r6,#0h    ;   wait-time 64µs
  wait_2:
    call delay
  ret  

;------------------------------------------------------------------------
;Timer
;------------------------------------------------------------------------

;sets TimerValue to FFFFFFFF - time in µSeconds
;inits and starts Timer
initTimer:
  ; sets TimerValue to FFFFFFFF - time in µSeconds
   mov a,#0FFh
  clr cy
  subb a,r5
  mov tl1,a
  mov a,#0FFh
  subb a,r6
  mov th1,a
  
  ; inits the timer
  mov tmod,#00010000b 
  ; Timer 1 zählt jeden 12. Takt = 1MHz
  ; 0 = keine externe Zählersteuerung durch Torschaltung
  ; 0 = interner Zeitgeber
  ; 01 = 16 Bit-Zähler
  ; Timer 0
  ; 0000 = aus
  clr tf1  ; overflow-flag zurücksetzen
  setb tr1 ; Starten des Timers
  ret
 
;sets TimerValue to FFFFFFFF - time in µSeconds
;inits and starts Timer
;and waits till Timeroverflow
delay:
  call initTimer
  jnb TF1,$   ; notify TimerOverflow  
  clr tr1     ; stop timer
  ret

Das Timing wird hierbei über den Timer gesteuert. Ein Timer-Schritt 
entspricht 1µs. Es muss daher nur die Anzahl an µs in die Register r5 
und r6 geschrieben werden und der Timer angeschubst werden. Das 
funktioniert auch eigentlich soweit.
Wie man allerdings in dem angehängten bildern sieht, sind die zeiten, 
die der bus für eine 0 bzw. 1 auf low gezogen werden muss nicht richtig.

bei einer 0 sind es nur ca. 20µs die das signal auf low ist und bei 
einer 1 ganze 74µs..

jetzt ist meine frage :
1. ist einfach mein grundverständnis vom timing und somit auch mein 
programm falsch ?
2. oder liegt das problem nicht an meinem verständnis, sondern daran, 
dass vlt doch ein fehler in der zeitsteuerung mit den timern vorliegt?
3. warum erkennt der protocol-analyzer die 0-en, obwohl die zeit auch 
hier ja garnicht passt.

Im Anhang habe ich den kompletten Code angehängt, der einfach nur die 
Adresse des Sensors auslesen und ausgeben soll.
Außerdem hab ich mal das Datenblatt und die Screenshots vom 
Logikanalysator mit hochgeladen.

Wäre echt cool, wenn mir jemand helfen könnte :)
Gruß Anon1234

[Easylife (Gast)]

Ohne viel davon zu verstehen, aber folgende Stelle verstehe ich nicht:

  ; sets TimerValue to FFFFFFFF - time in µSeconds
   mov a,#0FFh
  clr cy
  subb a,r5
  mov tl1,a
  mov a,#0FFh
  subb a,r6
  mov th1,a

offenbar ist dein timer 32 bit breit, und du setzt 2x16-bit values über 
t11 und th1...?!

#0FFh ist aber nicht #FFFFh, was ich an dieser Stelle vermuten würde...
Wie breit sind denn die Register a, tl1, th1 in deinem System?

So wie es mir aussieht, setzt du den timer auf einen falschen Startwert 
(sowas wie 0x00ff00ff - r6<<16 - r5)

[Easylife (Gast)]

Ausserdem kannst du dir das ganze Gedöhns mit #0 in r6 schreiben, um 
dann später  subb a,r6 zu machen komplett sparen, solange dein delay < 
255 oder evtl. auch 65535us (falls die Register 16 bit breit sind) 
bleibt...

[Anon A. (anon1234)]

Easylife schrieb:
> Ohne viel davon zu verstehen, aber folgende Stelle verstehe ich
> nicht:  ; sets TimerValue to FFFFFFFF - time in µSeconds
>    mov a,#0FFh
>   clr cy
>   subb a,r5
>   mov tl1,a
>   mov a,#0FFh
>   subb a,r6
>   mov th1,a
>
> offenbar ist dein timer 32 bit breit, und du setzt 2x16-bit values über
> t11 und th1...?!
>
> #0FFh ist aber nicht #FFFFh, was ich an dieser Stelle vermuten würde...
> Wie breit sind denn die Register a, tl1, th1 in deinem System?
>
> So wie es mir aussieht, setzt du den timer auf einen falschen Startwert
> (sowas wie 0x00ff00ff - r6<<16 - r5)

danke für deine Schnelle antwort.
der kommentar ist falsch. FFFFFFFF müsste eigentlich FFFF heißen. Die 
beiden Register sind nämlich jeweils 8-Bit. Zusammen ergibt das dann 
einen 8-Bit Timer.

die Null vor dem #0FFh steht da nur, damit der kompiler den Wert FF als 
Wert erkennt. Muss man leider so schreiben, weil F ja ein buchstabe 
ist..

[Peter D. (peda)]

Der ganze Schrunz in Deinem initTimer: kostet natürlich auch massig 
Zeit.

Und ist außerdem falsch, Du mußt das 2-er Komplement bilden, also 
-delay.

Du kannst aber besser das Rechnen zur Laufzeit ganz sparen, der 
Assembler kann nämlich 16Bit Konstantenrechnung selber ausführen:

  delay_60us equ 60

  mov tl0, #low( -delay_60us )
  mov th0, #high( -delay_60us )

[Marc V. (Firma: Vescomp) (logarithmus)]

Anon Anon schrieb:
> 1. ist einfach mein grundverständnis vom timing und somit auch mein
> programm falsch ?

 Du machst das viel zu kompliziert.
 Bei 1-Wire ist:
 Schreiben:
    Log.1 = 10us Low, 60us Release.
    Log.0 = 60us Low, 10us Release.
 Lesen:
    Log.1 = 10us Low, 60us Release.

 Man hat also immer zuerst 10us Low, danach wird der Bus entweder
 weiter auf Low gehalten oder freigegeben.
 Die Antwort von Slave liest man nach weiteren 20us, auch wenn keine
 vorgesehen ist. Nach weiteren 30us wird der Bus für 10us freigegeben.

 Somit hast du nur 1 Stelle wo sich etwas ändert und das ist ganz
 einfach (auch in Software mit Loop und NOPs) zu realisieren.
 Also:
  Bus Low
    Delay 10us.
        Bus entsprechend bitzustand setzen.
    Delay 20us.
  Bus lesen.
    Delay 30us.
    Bus freigeben.
    Delay 10us.

 Das Ganze 8 mal im Loop.

 EDIT:
  Beim lesen einfach 0xFF senden.

[Anon A. (anon1234)]

Danke für die ganzen schnellen Antworten :) :)

Peter Dannegger schrieb:
> Du kannst aber besser das Rechnen zur Laufzeit ganz sparen, der
> Assembler kann nämlich 16Bit Konstantenrechnung selber ausführen:
> delay_60us equ 60
>
>   mov tl0, #low( -delay_60us )
>   mov th0, #high( -delay_60us )
das ist natürlich ziemlich cool, das kannte ich noch garnicht. Danke für 
den Tipp.

Peter Dannegger schrieb:
> Und ist außerdem falsch, Du mußt das 2-er Komplement bilden, also
> -delay.

Das ist mir gerade nicht klar, warum ich das machen soll. Verkompliziert 
das nicht eher alles.
Momentan subtrahiere ich ja mit subb die benötigte zeit von FFFF. Sollte 
doch eigentlich so funktionieren?

Marc Vesely schrieb:
> Man hat also immer zuerst 10us Low, danach wird der Bus entweder
>  weiter auf Low gehalten oder freigegeben.
>  Die Antwort von Slave liest man nach weiteren 20us, auch wenn keine
>  vorgesehen ist. Nach weiteren 30us wird der Bus für 10us freigegeben.

Danke für das Beispiel :)
Insgesamt würde es dann so aussehen oder?

; write lsb of a to bus
;   - pull bus LOW
;   - wait 10µs
;   - if HIGH
;       > release bus 
;    > wait 60µs
;   - if LOW
;       > wait 50µs
;    > release bus
;       > wait 10µs
;  - wait 20µs
;   - read bus
;   - save bus
;  - wait 30µs
;   - release bus
;  - wait 10µs

Die Idee mit den Nops finde ich allerdings nicht so elegant. wie mit dem 
Timer.. Ist halt die Frage, was hier zielführender ist.

[Marc V. (Firma: Vescomp) (logarithmus)]

Anon Anon schrieb:
> Insgesamt würde es dann so aussehen oder?

 Eher so:

w1_Read:
;***  a wird auf 0xFF gesetzt (zum lesen)
   mov a,#0FFh
;*** Und durchfallen auf w1_Write...

w1_Write:
;*** Wert zum schreiben in a
    mov  r5, 8             ;* 8 bits

w1_loop:
;   - pull bus LOW
;   - wait 10µs
;   - if HIGH              ;* Es wird bit 0 in a geprüft
;       > release bus

; ...
;***  Unnötiges raus
; ...

;  - wait 20µs
;   - read bus             ;* Bus wird IMMER gelesen !

;* Der gelesene bit wird nach rechts in a reingeschoben, bit0 wird
;* rausgeschoben, bit1 wird zum bit0 etc.
;   - save bus             ;* Shift bit right in a

;  - wait 30µs
;   - release bus
;  - wait 10µs

;*** Decrement r5 und jump nach w1_loop

 Diese routine gibt den gelesenen Byte in a zurück.

Anon Anon schrieb:
> Die Idee mit den Nops finde ich allerdings nicht so elegant. wie mit dem
> Timer.. Ist halt die Frage, was hier zielführender ist.

 Unwichtig.
 Mach es halt so, wie es dir am Besten erscheint.

[Marc V. (Firma: Vescomp) (logarithmus)]

Anon Anon schrieb:
> Das ist mir gerade nicht klar, warum ich das machen soll. Verkompliziert
> das nicht eher alles.

 Nein, wieso ?
 Der Compiler rechnet das für dich, wenn das verkomplizieren ist...

Anon Anon schrieb:
> Momentan subtrahiere ich ja mit subb die benötigte zeit von FFFF. Sollte
> doch eigentlich so funktionieren?

 Auch wieder nein.
 Der Compiler hätte es schon richtig gemacht, du nicht.
 Überlauf tritt erst beim FFFF -> 0 auf, nicht schon beim 0xFFFF.

 -60 ist eben (0 - 60) ;-D
 Das hat der PeDa gemeint.

[Route_66 H. (route_66)]

Anon Anon schrieb:
> Die Idee mit den Nops finde ich allerdings nicht so elegant. wie mit dem
> Timer.. Ist halt die Frage, was hier zielführender ist.

Bei solch kurzen Wartepausen sind NOP-Delays nicht so falsch, vor allem, 
wenn die beiden Timer bereits verwendet werden, z.B. für UART und Uhr.

[Anon A. (anon1234)]

Marc Vesely schrieb:
> Eher so:

Aah okay.. also das mit der Schleife hätte ich schon noch gemacht :D
aber das mit dem überflüssigen waits für LOW hatte ich nicht so 
geblickt. Jetzt wo ichs lese ist es aber klar.

[Peter D. (peda)]

Ich hab ja früher mal 8051 Assembler gemacht:

xtal  equ  11059                   ; kHz
w1_dio  equ  p2.3

w1w10  equ   10 * ( xtal / 100 ) / 120
w1w60  equ   60 * ( xtal / 100 ) / 120
w1w480  equ  480 * ( xtal / 100 ) / 120
w1w66  equ   66 * ( xtal / 100 ) / 120

;******************************  Generate a 1-Wire reset *****************/
;Input: none
;Output: CY = 1, if no 1-wire device found
;Used:  R2, CY
;
w1_reset:
  mov  r2, #w1w480 / 4      ;480 < t < 960
?w1r1:  clr  w1_dio
  nop
  djnz  r2, ?w1r1
  clr  ea
  setb  w1_dio
  mov  r2, #w1w66 / 2      ;60 < t < 75
  djnz  r2, $
  mov  c, w1_dio
  setb  ea
  mov  r2, #(w1w480 - w1w66) / 4  ;480 < t
?w1r2:  nop
  nop
  djnz  r2, ?w1r2
  orl  c, /w1_dio
  ret

;******************************  Read / Write Bit on 1-wire **************/
;Input  CY = bit
;Output  CY = bit
;Used  R2, CY
;
w1_bit_rd:
  setb  c
w1_bit_wr:
w1_bit_io:
  clr  ea
  clr  w1_dio
  mov  r2, #w1w10 / 2                  ; djnz = 2 cycle
  mov  w1_dio, c
  djnz  r2, $
  mov  c, w1_dio      ; sample within 15us
  mov  r2, #(w1w60 - w1w10) / 2
  djnz  r2, $
  setb  w1_dio
  setb  ea
  ret

;******************************  Read / Write byte ***********************/
;Input  R7 = byte
;Output R7 = byte
;Used  R2, R7, ACC, CY
;
w1_byte_rd:
  mov  r7, #0FFh
w1_byte_wr:
  mov  a, r7
  mov  r7, #8
?w1wr1:
  rrc  a      ; lsb first
  call  w1_bit_io
  djnz  r7, ?w1wr1
  rrc  a      ; last bit in
  mov  r7, a
  ret

[Anon A. (anon1234)]

Hallo nochmal...
danke für eure guten Antworten.
Es hat bei mir jetzt wieder mal ein bisschen gedauert, bis ich hier 
weitergemacht hab, aber nach euren guten Tipps habe ich jetzt ein paar 
Fortschritte.
Zuerst hab ich mein Glück noch einmal mit dem Timer versucht, musste 
dann aber feststellen, (wie ihr ja schon geschrieben hattet), dass die 
ganzen Befehle zum Einstellen und Starten des Timers schon viel zu viel 
Zeit verbraucht haben und somit beim Timing (logischer weise) nichts 
mehr gepasst hat.
Deswegen bin ich jetzt doch auf die Variante mit den Nops umgestiegen. 
Und hab mich da ein bisschen an das gehalten, was peda in seinem code 
mit den oben berechneten Konstanten gemacht hat.

Bei mir sieht der code jetzt wie folgt aus :

;------------------------------------------------------------------------
;READ / WRITE
;------------------------------------------------------------------------

; reads one Byte and saves it in r7
readByte:
  mov r7,#0FFh
  ; goes down to writeByte

; write the 8 bits of r7 to the bus
; uses r1 for a loop
writeByte:
  mov r2,#8
  write8BitsLoop_1:
    call write_read      ; write lsb of r7 a
    djnz r2,write8BitsLoop_1
    ret


; writes lsb to bus and / or reads bus into msb of r7

; pull bus low
; wait 10µs
; if lsb = HIGH
;   > release bus
; else 
;   > bus stays low
; wait 20µs
; read and save bus
; wait 30µs
; release bus 
; wait 10µs
write_read:
  clr p2.4  ; pull bus LOW
  mov r1,#wait10                ;
  wait10loop_1:            ; wait 10µs
    nop                ;
    djnz r1,wait10loop_1  ;
  mov a,r7
  jnb acc.0,read
  setb p2.4 ; release bus if r7.0 is HIGH
  read:            
    mov r1,#wait20           ; 
    wait20loop_1:            ; wait 20µs
      nop        ;
      djnz r1,wait20loop_1      ; 
    mov a,r7
    rr a  ; rotate a
    jb p2.4,high_1
    anl a,#01111111b ; set msb to 0
    jmp afterRead_1
    high_1:
      anl a,#11111111b ; set msb to 1
  afterRead_1:    
    mov r7,a
    mov r1,#wait30        ;
    wait30loop_1:         ; wait 30µs
      nop                  ;
      djnz r1,wait30loop_1     ;
    setb p2.4 ; release bus
    mov r1,#wait10         ;
    wait10loop_2:          ; wait 10µs
      nop        ;
      djnz r1,wait10loop_2          ;
    ret

Hiermit hat es bei mir geklappt einen READROM Befehl zu schicken und die 
Adresse des sensors zu lesen.
Die Adresse die ich hierbei mit dem Logikanalysator gelesen habe war die 
folgende

00101000 28h Family Code
01000101 LSB Serial Code
01111111 ...
10101111 ...
00000101 ...
00000000 ...
00000000 MSB Serial Code
10000100 CRC

Da der sogenannte Family Code mit 28h richtig ist, bin ich jetzt 
ersteinmal davon ausgegangen, dass die komplette Adresse richtig ist.
Im nächsten Schritt wollte ich jetzt Befehle wie MatchRom und dann 
ConvertT und ReadScratchpad an meinen Sensor (DS18B20) schicken.

Viele Grüße
Anon1234

[Anon A. (anon1234)]

Ich habe jetzt gerade mal das CRC nachberechnet
(Dafür gibt es hier ein ganz nettes Tool : 
http://www.datastat.com/sysadminjournal/maximcrc.cgi )
Und demzufolge ist meine Adresse richtig :)