1-Wire Protokollablauf

[Anon A. (anon1234)]

Hallo allesamt
Ich möchte ein bisschen mit 1-Wire Sensoren rumbasteln und habe daher 
ein paar Fragen zum Protokoll.
Ich habe momentan noch keinen Logikanalysator und habe deswegen das 
Protokoll schon mal weitesgehend durchgearbeitet und Aktivitätsdiagramme 
für meine Programme gezeichnet.
Ich erhoffe mir davon, dass ich dann die meisten Fehler garnicht erst 
mache :)
Mein Diagramme habe ich in den Anhang gepackt?
Kennt sich irgendjemand mit dem Thema aus? Und könnte vielleicht einmal 
drüber gucken, ob ich in diesem Schritt schon Fehler gemacht habe, oder 
ob ichs richtig verstanden habe?
Konkret handelt es sich momentan um den Temperatur-Sensor DS18B20, von 
dem ich in meinen Diagrammen auch einige Funktionen benutze.

Geplant ist momentan, dass ich vorher jeweils nacheinander immer einen 
Sensor an die Schaltung anschließe, die ID auslese und diese dann später 
hart im Programm codiere. Deshalb starte ich auch direkt mit dem Match 
Rom - Befehl.

Was mir momentan allerdings nicht klar ist, ist wie ich es schaffe die 
ID des angeschlossenen Sensors auszulesen? So weit ich weiß nutzt man 
hierfür den den READ ROM - Befehl (bzw. SEARCH ROM bei mehreren 
Sensoren): Allerdingsist mir nicht klar, wie genau der Sensor hierauf 
antwortet.

Kennst sich jemand mit dem Thema aus?
Im Anhang habe ich auch noch mal meine Quellen angehängt.

Viele Grüße Anon1234

[Michael R. (Firma: Brainit GmbH) (fisa)]

schau mal hier: Beitrag "Vereinfache/Kompakte Libary für D18B20"

Deine Ablaufdiagramme sind "nett" aber berücksichtigen keine Fehlerfälle 
(der Regelfall macht 90% des Codes aus, die Fehlerfälle die anderen 90% 
:-)

1wire ist nicht ganz trivial (vor allem das Enumerieren), und wenn man 
es so genial macht wie Peter Danegger, wird es noch un-trivialer...

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

Michael Reinelt schrieb:
> (der Regelfall macht 90% des Codes aus, die Fehlerfälle die anderen 90%
> :-)

 Komisch, bei mir ist das genau umgekehrt.

[Michael R. (Firma: Brainit GmbH) (fisa)]

Marc Vesely schrieb:
> Michael Reinelt schrieb:
>> (der Regelfall macht 90% des Codes aus, die Fehlerfälle die anderen 90%
>> :-)
>
>  Komisch, bei mir ist das genau umgekehrt.

Du hast recht, bei mir schwankt es auch. Vor allem abhängig von meiner 
Lederallergie.

[Anon A. (anon1234)]

Michael Reinelt schrieb:
> schau mal hier: Beitrag "Vereinfache/Kompakte Libary für D18B20"
>
> Deine Ablaufdiagramme sind "nett" aber berücksichtigen keine Fehlerfälle
> (der Regelfall macht 90% des Codes aus, die Fehlerfälle die anderen 90%
> :-)

Alles klar, danke für den Tipp,
das werde ich mir dann mal angucken.
Um was für Fehlerfälle handelt es sich dann hier?
Sind dass dann Arbitrationfehler auf dem Bus, oder einfachh Fehler beim 
Enumerieren.
Davon hab ich nämlich in den Datenblättern nichts gelesen. Weißt du wo 
ich mich darüber informieren kann?

[Michael R. (Firma: Brainit GmbH) (fisa)]

Anon Anon schrieb:
> Um was für Fehlerfälle handelt es sich dann hier?

z.B. Kurzschluss-Erkennung beim detektieren des "presence pulse", oder 
beim enumerieren bit und komplementärbit beide 1.

Mehr gibts aber glaub ich eh nicht.

[Anon A. (anon1234)]

Michael Reinelt schrieb:
> schau mal hier: Beitrag "Vereinfache/Kompakte Libary für D18B20"

Die Libary sieht ganz gut aus :)
Aber weiß jemand wo ich diese Header-Dateien herbekomme:
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <util/delay.h>
#include <util/atomic.h>

[Michael R. (Firma: Brainit GmbH) (fisa)]

Anon Anon schrieb:
> Aber weiß jemand wo ich diese Header-Dateien herbekomme:
> #include <stdlib.h>
> #include <stdint.h>
> #include <math.h>
> #include <util/delay.h>
> #include <util/atomic.h>

Die Frage wundert mich, weil das sind nur Standard-Header der 
GCC-AVR-Toolchain...

Lass mich die Frage umdrehen: Wie sieht deine Entwicklungsumgebung aus? 
Womit compilierst du normalerweise?

[Anon A. (anon1234)]

Michael Reinelt schrieb:
> Lass mich die Frage umdrehen: Wie sieht deine Entwicklungsumgebung aus?
> Womit compilierst du normalerweise?

Ich entwickle und compiliere mit Keil µVision. Allerdings mit einem 
8051-Derivat. mit AVR kenne ich mich momentan noch nicht aus.
(Also den Code kann ich schon lesen und verstehen, aber mehr hab ich 
mich da auch noch nicht reingearbeitet)

[Michael R. (Firma: Brainit GmbH) (fisa)]

Anon Anon schrieb:
> Ich entwickle und compiliere mit Keil µVision. Allerdings mit einem
> 8051-Derivat.

Sorry, damit kenn ich mich jetzt wieder gar nicht aus...

> #include <stdlib.h>
sollte der keil auch haben, sogar im Standard-Include-Pfad
> #include <stdint.h>
detto
> #include <math.h>
wird nur für float-berechnungen verwendet
> #include <util/delay.h>
das ist sehr AVR-Spezifisch, brauchst aber nur für die _dely_us() 
funktion, und es wird sicher was vergleichbares bei dir geben
> #include <util/atomic.h>
wird dzt. gar nciht verwendet

[Anon A. (anon1234)]

hey...
hat zwar etwas gedauert, weil ich die letzte woche nicht so viel hatte, 
aber
ich habe jetzt mal einen beispiel-code für den at89s52 geschrieben :
meint ihr das passt jetzt so? die kurzschluss-abfrage habe ich jetzt 
auch eingebaut.

;------------------------------------------------------------------------
;Programdescription
;------------------------------------------------------------------------
;---
;Program:
; Test for two DS18B20 1-Wire Temperature Sensor,
; which addresses are already defined in the code
;---
;Date: 09/2014
;Programmer: Wall.Of.Death 
;---
;Used subroutines: 
; none
;---
;Used registers, ports and memory addresses:
; 
; Port 2.0 = DataLine of 1-Wire-Bus
;
; R0 is temp storage for everything
; R1 is loopIndex_1
; R2 is loopIndex_2
; R3 is reserved
; R4 is reserved
; R5 and R6 are reserved for delay/timer 
;   >> delaytime is set by R5 and R6 (R5 is LSB)
;   >> timer time till overflow = R5 and R6 together as a 16Bit value in µseconds
; R7 is reserved as 1-Byte-Buffer for READ and WRITE on bus
;
; 20h.0 is reserved to temporary save the states of the bus
; 20h.1 is reserved as 1-Bit-Buffer for READ and WRITE on the bus
; 
; 7ch is read temperature (LSB)
; 7dh is read temperature (MSB)
; 7eh is current 1-Wire address index
; 7fh is 1-Wire devices count
;
; internal storage from 80h to FFh is reserved for 1-wire addresses
; every address is a 64 bit address
; first address is from 80h to 87h
; second address is from 88h to 90h
; ...
;---
;comments:
;  TODO 8Byte addresses
;    read
;    addresses
;
;changesLog:
;  date        description
;  XX.09.2014  v1.0 communication with DS18B20-sensors, untested
;---
;------------------------------------------------------------------------
;Initialization of constants
;------------------------------------------------------------------------
;
;
;------------------------------------------------------------------------
;Interrupt-Vector
;------------------------------------------------------------------------
;
org 0      ; begin of interrupt-vector >> reset

jmp 0100h  ; jmp initTimer

org 001bh  ; interrupt-Timer
 
org 0100h  ; end of interrupt-vector 
;
;------------------------------------------------------------------------
;Initialization on-chip-periphery 
;------------------------------------------------------------------------
;------------------------------------------------------------------------
;Programm-Code
;------------------------------------------------------------------------ 

$include(at89s53.inc)

; init sets addresses of 1-Wire devices
init:
  mov 7eh,#80h  ; 7eh = first address where 1-wire-addresses get saved
  mov 7fh,#2    ; number of 1-Wire devices  
  mov r0,#80h
  ; Device 1
    mov @r0,#12h
  inc r0
  mov @r0,#34h
  inc r0
  mov @r0,#56h
  inc r0
  mov @r0,#78h
  inc r0
  mov @r0,#90h
  inc r0
  mov @r0,#98h
  inc r0
  mov @r0,#76h
  inc r0
  mov @r0,#54h
  inc r0
  ; Device 2
    mov @r0,#0FFh
  inc r0
  mov @r0,#00h
  inc r0
  mov @r0,#0FFh
  inc r0
  mov @r0,#00h
  inc r0
  mov @r0,#0FFh
  inc r0
  mov @r0,#00h
  inc r0
  mov @r0,#0FFh
  inc r0
  mov @r0,#00h
  inc r0

; main
main:
  call getTemperature 
  call saveTemperature ; TODO
  call temperatureOut ; TODO
  call resetAddress 
  jmp main
  
; resets 1-wire-addresscounter to first address if all devices are iterated
resetAddress:
  mov a,7fh  ; devices / 1-wire-addresses count
  mov b,#8   ; 8 Bytes per address
  mul ab     ; 
  add a,#80h ; e.g. #80h + (#8*#2) = #90h  >> #80h = first address ; 8Bytes per address ; 2 addresses 
  cjne a,7eh,notLastAddress
  mov 7eh,#80h ; address was last address >> reset to first
  ret
  notLastAddress:
    ret

; returns the Temperature of the selected device
getTemperature:
  call initializationProcedure 
  jb 20h.0,getTemperature  ; no PRESENCE was detected
  call matchRom 
  call convertT 
  call readScratchpad ; TODO
  ret

;  
saveTemperature:  
ret

;  
temperatureOut:  
ret

;------------------------------------------------------------------------
;1-wire functions
;------------------------------------------------------------------------

; sends a RESET and waits 240µs for a PRESENCE
; returns 0 if PRESENCE is detected
; returns 1 if PRESENCE is not detected
initializationProcedure:
  clr p2.0     ; RESET :
  mov r5,#0E0h   ;  pull bus low
  mov r6,#1h     ;  for 480µs
  call delay   ;
  setb p2.0    ; PRESENCE
  mov r5,#0F0h   ;  wait for 240µs 
  mov r6,#0h     ;
  call initTimer ;        
  waitLoop_1:
    jnb p2.0,fallingEdge_1 ; during this time detect a falling Edge
      jb TF1,noFallingEdge_1 ; or stop after the time
    jmp waitLoop_1
  fallingEdge_1:
    clr tr1   ; stop timer
    clr 20h.0 ; save bus-state 
      jmp detectShortcut_1
  noFallingEdge_1:
    clr tr1    ; stop timer
    setb 20h.0 ; save bus-state
    jmp detectShortcut_1
  detectShortcut_1:
    mov r5,#9Ah    ; wait for 410µs
    mov r6,#1h     ;
    call initTimer ;
    jnb p2.0, main   ; if shortcut is selected jmp back to main
    ret
    
; writes the MATCH ROM (55h) signal and the the 8Byte address
matchRom:
  mov r7,#55h     ; MATCH ROM 
  call writeByte  ;
  mov r2,#8
  write8BytesLoop_1:  ; write 1-wire address
    mov r0,7eh      ;    load current byte of the address
    mov a,@r0       ;    
    mov r7,a        ;
    call writeByte  ;    write current byte of the address
    inc 7eh         ;    inc "1-wire-addresspointer"
    djnz r2,write8BytesLoop_1 
    ret
    
;------------------------------------------------------------------------
;DS18B20 - functions
;------------------------------------------------------------------------    


; writes the CONVERT T (44h) signal for DS18B20
convertT:
  mov r7,#44h       ; CONVERT T
  call writeByte
  ret
  
; reads the first two bytes of the scratchpad
readScratchpad:
  mov r7,#0BEh      ; READ SCRATCHPAD 
  call writeByte    
  call readByte   ; only the first 2 bytes of the ccratchpad include 
  mov 7ch,r7    ; temperature information
  call readByte
  mov 7dh,r7
  ret

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

; write the 8 bits of r7 to the bus
; uses r1 for a loop
writeByte:
  mov r1,#8
  write8BitsLoop_1:
    mov a,r7
    anl a,#00000001b    ; get lsb of a
    call write      ; write lsb of a
    mov a,r7    ; rotate r7  
    rr a      ; to get next bit
    mov r7,a     ;
    djnz r1,write8BitsLoop_1
    ret

; read the next 8 bits from the bus and write them into r7
; uses r1 for a loop
readByte:
  mov r7,#0  
  mov r1,#8
  read8BitsLoop_1:
    mov a,r7  ; 
    rl a    ; rotate a
    call read      ; read bit from bus
    jb 20h.1,high_2    ;
    orl a,#00000000b  ; bit was low  
    jmp readByte_
    high_2:        ; bit was high  
      orl a,#00000001b
    readByte_:
      mov r7,a
      djnz r1,read8BitsLoop_1
      ret

; write lsb of a to bus
write:
  jnz high_1
  mov r5,#3Ch   ; LOW
  mov r6,#0h    ;  >= 60µs
  jmp write_ 
  high_1:
    mov r5,#0Fh   ; HIGH
    mov r6,#0h    ;  <= 15µs
  write_:
    clr p2.0      ; pull bus LOW
    call initTimer
    jnb tf1,$
    setb p2.0     ; release bus
    clr tr1
  ret  

; read bus and write to 20h.0
read:
  clr p2.0      ;
  mov th1,#0FFh    ; pull bus LOW for min. 1µs
  mov tl1,#0EFh    ;
  call initTimer    ;
  jnb tf1,$
  clr tf1
  setb p2.0      ; release bus
  mov th1,#0FFh  ; 
  mov tl1,#0F2h  ; "start" timer again  
  waitLoop_2:
    jnb p2.0,fallingEdge_2 ; during the next max 14µs detect signal on bus
      jb TF1,noFallingEdge_2 ; or stop after the time
    jmp waitLoop_2
  fallingEdge_2:
    clr tr1   ; stop timer
    clr 20h.0 ; save bus-state (LOW)
    setb p2.0
      ret
  noFallingEdge_2:
    clr tr1    ; stop timer
    setb 20h.0 ; save bus-state (HIGH)
    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

end

ich gehe davon aus, dass die adressen für die ds18b20-Geräte bekannt 
sind und diese
im code später fest-codiert werden.
allerdings weiß ich noch nicht, wie ich die adressen am einfachsten 
auslesen kann.
Das prinzip vom search-rom habe ich nämlich momentan noch nicht ganz 
verstanden.
kann mir hier jemand weiter helfen?
alternativ habe ich überlegt mit den fertigen libraries von arduino die 
addressen auszulesen.

[Uwe B. (derexponent)]

Anon Anon schrieb:
> Das prinzip vom search-rom habe ich nämlich momentan noch nicht ganz
> verstanden.

mit "SearchRom 0xF0" kannst du den ROM-Code von allen Slaves am Bus 
ermitteln das erfordert aber einiges an Software

einfacher ist der Befehl "ReadROM 0x33" der ließt direkt den
ROM-Code vom angeschlossenen Slave aus
(allerdings darf zu diesem Zeitpunkt nur EIN Slave am Bus hängen)

Ablauf.
1. Reset Sequenz
2. den Befehl "ReadRom" senden
3. 8Bytes lesen (das ist dann der 48bit ROM-Code vom Slave)

Gruss Uwe

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

Für einen einzelnen Sensor (pro Leitung) benötigt man die Adresse 
überhaupt nicht. Da tut es auch SKIP ROM. Wär sinnvoll, damit 
anzufangen.

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

Anon Anon schrieb:
> ich habe jetzt mal einen beispiel-code für den at89s52 geschrieben :

Längerer Code passt besser in einen Anhang.

[Anon A. (anon1234)]

Uwe B. schrieb:
> einfacher ist der Befehl "ReadROM 0x33" der ließt direkt den
> ROM-Code vom angeschlossenen Slave aus
> (allerdings darf zu diesem Zeitpunkt nur EIN Slave am Bus hängen)
>
> Ablauf.
> 1. Reset Sequenz
> 2. den Befehl "ReadRom" senden
> 3. 8Bytes lesen (das ist dann der 48bit ROM-Code vom Slave)

Hi Uwe,
danke für die schnelle und gute Antwort.
Das werde ich dann nacher gleich mal ausprobieren :)
Du meinst aber sicherlich 64Bit oder?

A. K. schrieb:
> Längerer Code passt besser in einen Anhang.

Alles klar, denke ich nächstes mal dran :)

[Uwe B. (derexponent)]

Anon Anon schrieb:
> Du meinst aber sicherlich 64Bit oder?


ja...sorry war ein Tipfehler

ROM-Code = 8 Bytes (64bit)

8bit  : Family Code
48bit : Ser-Nr
8bit  : CRC

P.S. im Datasheet vom Dallas DS1820 ist ein Beispiel
beschrieben wie man einen ROM-Search implementiert
(in Textform)

kannst da ja mal nachlesen falls du das auch
implementieren willst