Problem beim abfragen von 2 DHT22

[Fritz B. (kleinfritzchen)]

Hallo,
ich hab etwas Code geschrieben um die Temperatur und die Luftfeuchte von 
2 DHT22 auszulesen und auf einem 4-Zeiligen Display anzuzeigen.
Das auslesen der einzelnen Sensoren funktoniert aber es wird immer nur 
der erste angezeigt. Wenn ich diesen auskommentiere wird der zweite 
angezeigt aber nicht beide zusammen.
ich bin langsam am verzweifeln...
hier mal der Code:

/*
 * LCDTEST5.asm
 *
 *  Created: 20.04.2014 16:14:50
 *   Author: Fritz
 */ 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Steureung eines LCD
;;
;;PortD ausgang:
;;0 - Db0
;;1 - Db1
;;2 - Db2
;;3 - Db3
;;4 - Db4
;;5 - Db5
;;6 - Db6
;;7 - Db7
;;
;;PortB ausgang:
;;0 - RS
;;1 - E
;;2 - Kontroll LED1
;;3 - Leer
;;4 - Leer
;;5 - Leer
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;;;;;;;;;;;AVRinit;;;;;;;;;;;;
.include "m8adef.inc"



;Reset and Interrupt vector             ;VNr.  Beschreibung
  rjmp  main  ;1   POWER ON RESET
  reti    ;2   Int0-Interrupt
  reti    ;3   Int1-Interrupt
  reti    ;4   TC2 Compare Match
  reti    ;5   TC2 Overflow
  reti    ;6   TC1 Capture
  reti    ;7   TC1 Compare Match A
  reti    ;8   TC1 Compare Match B
  reti    ;9   TC1 Overflow
  reti    ;10  TC0 Overflow
  reti    ;11  SPI, STC Serial Transfer Complete
  reti    ;12  UART Rx Complete
  reti    ;13  UART Data Register Empty
  reti    ;14  UART Tx Complete
  reti    ;15  ADC Conversion Complete
  reti    ;16  EEPROM Ready
  reti    ;17  Analog Comparator
  reti    ;18  TWI (I²C) Serial Interface
  reti    ;19  Store Program Memory Ready
;------------------------------------------------------------------------

main:

  ldi r16, LOW(RAMEND)    ;Stackinit
  out SPL, r16
  ldi r16, HIGH(RAMEND)
  out SPH, r16

  ldi  r16,0b00000101
  out  DDRC,r16
  out  PORTC,r16
.def  temp  = r16
.def  temp2  =  r20
.def  temp3  = r21  
.def  DHTmaske  = r22
.equ   LCD_PORT = PORTD
.equ   LCD_DDR  = DDRD
.equ  LCDS_PORT = PORTD
.equ  LCDS_DDR  = DDRD
.equ  LCD_RS  = 1
.equ  LCD_RW  = 2
.equ  LCD_E  = 3
.equ  RH_H  =0x0060
.equ  RH_2  =0x0065
;.equ  RH_L  =0x0061
;.equ  Temp_H  =0x0062
;.equ  Temp_L  =0x0063
;.equ  checksumme  =0x0064
.equ sensor1  =0x45
.equ sensor2  =0x19


.def  arg    = r17    ;argument for calling subroutines
.def  arg2  = r18    ;argument for mathematics
.def  return  = r19    ;return value from subroutines
.def  byte  = r25

  
;;;;;;LCDinit;;;;;;

      ;wartezeit zur initialisirung des 
      ldi temp,200
      rcall waitMs
      rcall  LCD_init


  ldi ZL,LOW(text*2)
  ldi ZH,HIGH(text*2)
  ldi arg,0x00
  rcall  LCD4ZTxt

  ldi YH,HIGH(RH_2)
  ldi YL,LOW(RH_2)
  ldi  DHTmaske,0x01
    ldi arg,0x46
  rcall  LCD_pos
    rcall  DHT_lesen
  
  rcall wait2s
  
  ldi DHTmaske,0x04  
;  out  DDRC,DHTmaske
;  out PORTC,DHTmaske
  ldi YH,HIGH(RH_H)
  ldi YL,LOW(RH_H)

    ldi arg,0x1a
    rcall  LCD_pos
    rcall DHT_lesen




;      ldi  temp,1
;  rcall  waitMs


  
;  mov  arg,byte
;  rcall LCD_number
;  ldi  arg,0x40
;  rcall LCD_pos
;  mov  arg,byte
;  rcall  LCD_alsBit
;    ldi  arg,0x14
;  rcall LCD_pos
;  ldi  arg,0x43
;  rcall  LCD_alsBit

;  rcall DHT_lesen
  

;;;;;;Main;;;;;;
                ;durch diese Routine
  
Auto:              ;takt das nächste zeichen auf dem display

  ;rcall  LCD_clear        ;zu sehen sein
  
  ;inc LCDtoSend
  wdr


rjmp Auto



;;;;;;Routinen;;;;;;


;***********************************************************************************
; the following source is from AVRbeginners.net .great work- well documented
; the advantage of read the busyflag in 4-bit mode is, no delay's needed
;***********************************************************************************
LCD_command8:  ;used for init (we need some 8-bit commands to switch to 4-bit mode!)
  in  temp, LCD_DDR    ;we need to set the high nibble of DDRD while leaving
          ;the other bits untouched. Using temp for that.
  sbr  temp, 0b11110000  ;set high nibble in temp
  out  LCD_DDR, temp    ;write value to DDRD again
  in  temp, LCD_PORT    ;then get the port value
  cbr  temp, 0b11110000  ;and clear the data bits
  cbr  arg, 0b00001111  ;then clear the low nibble of the arg
          ;so that no control line bits are overwritten
  or  temp, arg    ;then set the data bits (from the arg) in the
          ;Port value
  out  LCD_PORT, temp    ;and write the port value.
  sbi  LCDS_PORT, LCD_E    ;now strobe E
  nop
  nop
  nop
  cbi  LCDS_PORT, LCD_E
  in  temp, LCD_DDR    ;get DDRD to make the data lines input again
  cbr  temp, 0b11110000  ;clear data line direction bits
  out  LCD_DDR, temp    ;and write to DDRD
  ret

LCD_putchar:
  push  arg    ;save the argmuent (it's destroyed in between)
  in  temp, LCD_DDR    ;get data direction bits
  sbr  temp, 0b11110000  ;set the data lines to output
  out  LCD_DDR, temp    ;write value to DDRD
  in  temp, LCD_PORT    ;then get the data from PortD
  
;.if LCDS_DDR == LCD_DDR    ;if the same port
  
  cbr  temp, 0b11111110  ;clear ALL LCD lines (data and control!)
;.else
;  cbr  temp, 0b11110000
;.endif
  ;cbr  temp, 0b11111110  ;clear ALL LCD lines (data and control!)
  
  cbr  arg, 0b00001111  ;we have to write the high nibble of our arg first
          ;so mask off the low nibble
  or  temp, arg    ;now set the arg bits in the Port value
  out  LCD_PORT, temp    ;and write the port value
  sbi  LCDS_PORT, LCD_RS    ;now take RS high for LCD char data register access
  sbi  LCDS_PORT, LCD_E    ;strobe Enable
  nop
  nop
  nop
  cbi  LCDS_PORT, LCD_E
  pop  arg    ;restore the arg, we need the low nibble now...
  cbr  temp, 0b11110000  ;clear the data bits of our port value
  swap  arg    ;we want to write the LOW nibble of the argument to
          ;the LCD data lines, which are the HIGH port nibble!
  cbr  arg, 0b00001111  ;clear unused bits in argument
  or  temp, arg    ;and set the required argument bits in the port value
  out  LCD_PORT, temp    ;write data to port
  sbi  LCDS_PORT, LCD_RS    ;again, set RS
  sbi  LCDS_PORT, LCD_E    ;strobe Enable
  nop
  nop
  nop
  cbi  LCDS_PORT, LCD_E
  cbi  LCDS_PORT, LCD_RS
  in  temp, LCD_DDR
  cbr  temp, 0b11110000  ;data lines are input again
  out  LCD_DDR, temp
    ret

LCD_command:  ;same as LCD_putchar, but with RS low!
  push  arg
  in  temp, LCD_DDR
  sbr  temp, 0b11110000
  out  LCD_DDR, temp
  in  temp, LCD_PORT
  ;cbr  temp, 0b11111110
;.if LCDS_DDR == LCD_DDR    ;if the same port then
  cbr  temp, 0b11111110  ;clear ALL LCD lines (data and control!)
;.else
;  cbr  temp, 0b11110000  
;.endif
  cbr  arg, 0b00001111
  or  temp, arg

  out  LCD_PORT, temp
  sbi  LCDS_PORT, LCD_E
  nop
  nop
  nop
  cbi  LCDS_PORT, LCD_E
  pop  arg
  cbr  temp, 0b11110000
  swap  arg
  cbr  arg, 0b00001111
  or  temp, arg
  out  LCD_PORT, temp
  sbi  LCDS_PORT, LCD_E
  nop
  nop
  nop
  cbi  LCDS_PORT, LCD_E
  in  temp, LCD_DDR
  cbr  temp, 0b11110000
  out  LCD_DDR, temp
  ret

LCD_getchar:
  in  temp, LCD_DDR    ;make sure the data lines are inputs
  andi  temp, 0b00001111  ;so clear their DDR bits
  out  LCD_DDR, temp
  sbi  LCDS_PORT, LCD_RS    ;we want to access the char data register, so RS high
  sbi  LCDS_PORT, LCD_RW    ;we also want to read from the LCD -> RW high
  sbi  LCDS_PORT, LCD_E    ;while E is high
  nop
  in  temp, PinD    ;we need to fetch the HIGH nibble
  andi  temp, 0b11110000  ;mask off the control line data
  mov  return, temp    ;and copy the HIGH nibble to return
  cbi  LCDS_PORT, LCD_E    ;now take E low again
  nop        ;wait a bit before strobing E again
  nop  
  sbi  LCDS_PORT, LCD_E    ;same as above, now we're reading the low nibble
  nop
  in  temp, PinD    ;get the data
  andi  temp, 0b11110000  ;and again mask off the control line bits
  swap  temp      ;temp HIGH nibble contains data LOW nibble! so swap
  or  return, temp    ;and combine with previously read high nibble
  cbi  LCDS_PORT, LCD_E    ;take all control lines low again
  cbi  LCDS_PORT, LCD_RS
  cbi  LCDS_PORT, LCD_RW
  ret          ;the character read from the LCD is now in return

LCD_getaddr:  ;works just like LCD_getchar, but with RS low, return.7 is the busy flag
  in  temp, LCD_DDR
  andi  temp, 0b00001111
  out  LCD_DDR, temp
  cbi  LCDS_PORT, LCD_RS
  sbi  LCDS_PORT, LCD_RW
  sbi  LCDS_PORT, LCD_E
  nop
  in  temp, PinD
  andi  temp, 0b11110000
  mov  return, temp
  cbi  LCDS_PORT, LCD_E
  nop
  nop
  sbi  LCDS_PORT, LCD_E
  nop
  in  temp, PinD
  andi  temp, 0b11110000
  swap  temp
  or  return, temp
  cbi  LCDS_PORT, LCD_E
  cbi  LCDS_PORT, LCD_RW
  ret

LCD_wait:        ;read address and busy flag until busy flag cleared
  
  rcall  LCD_getaddr
  andi  return, 0x80
  brne  LCD_wait
  ret


LCD_delay:
  clr  r2
  LCD_delay_outer:
  clr  r3
    LCD_delay_inner:
    dec  r3
    brne  LCD_delay_inner
  dec  r2
  brne  LCD_delay_outer
  ret

LCD_init:     
;**** for the most LCD you must write 3times a dummy command before you change to 4Bit***
;this is corrected by www.bellibot.com :-)) - before !you have only one LineLCD ***
  
  ldi  temp, 0b00001110  ;control lines are output, rest is input
  in temp,LCD_DDR
  andi temp,0b00001111    ;LCD pins input
  out LCD_DDR,temp
  in temp,LCDS_DDR
  ori     temp, (1<<LCD_RS)|(1<<LCD_RW)|(1<<LCD_E) ;controllpins output
  out  LCDS_DDR, temp
  
  rcall  LCD_delay    ;
  ldi  arg, 0x30      ;
  rcall  LCD_command8    

  rcall  LCD_delay
  ldi  arg, 0x30    ;NOW: 2 lines, 5*7 font, 4-BIT MODE!     ** DUMMY ***
  rcall  LCD_command8    ;
  
  
  rcall  LCD_delay    
  ldi  arg, 0x30      
  rcall  LCD_command8    

  rcall  LCD_delay    ;first, we'll tell the LCD that we want to use it
  ldi  arg, 0x20      ;in 4-bit mode.
  rcall  LCD_command8    ;LCD is still in 8-BIT MODE while writing this command!!!

  
  rcall  LCD_delay
  ldi  arg, 0x28    ;NOW: 2 lines, 5*7 font, 4-BIT MODE!     ** this change to 4bit 2 lines **
  rcall  LCD_command    ;after this point you don't can change anything 'show HD44780 Datasheet'

  rcall  LCD_wait
  ldi  arg, 0x0F    ;now proceed as usual: Display on, cursor on, blinking
  rcall  LCD_command
  
  rcall  LCD_wait
  ldi  arg, 0x01    ;clear display, cursor -> home
  rcall  LCD_command
  
  rcall  LCD_wait
  ldi  arg, 0x06    ;auto-inc cursor
  rcall  LCD_command
  ret

;******************************************
; clear Displays
LCD_clear:
           push arg
       ldi   arg, 0b00000001      ; Display clear
           rcall LCD_command
           rcall  LCD_wait
           pop arg
       ret
 
 ; Cursor Home
LCD_home:
           push arg
       ldi   arg, 0b00000010      ; Cursor Home
           rcall LCD_command
           rcall  LCD_wait
           pop arg
       ret

;set cursor pos
;Start Adresse für ein 4 x 20 Zeichen Display
;Zeile 1: 0x00
;Zeile 2: 0x40
;Zeile 3: 0x14
;Zeile 4: 0x54
LCD_pos:
    sbr arg,0b10000000 ; Set DD-RAM-Adress
    rcall LCD_command
    rcall  LCD_wait
    ret

;*****************************************************
; Display at the position in arg the string starting at Z (null-term.)
;
LCD4ZTxt:
  sbr arg,0b10000000 ; Set DD-RAM-Adress
  rcall LCD_command
  rcall  LCD_wait
LCD4ZTxt1:
  lpm ; Get a char
  tst R0 ; Null-Char?
  breq LCD4ZTxtR
  mov arg,R0
  rcall LCD_putchar ; display the cahr
  rcall  LCD_wait
  adiw ZL,1 ; next char
  rjmp LCD4ZTxt1 ; do it again
LCD4ZTxtR:
  ret
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen hexadezimal ausgeben
;
; Übergabe:            Zahl im Register arg
; veränderte Register: keine
;
lcd_number_hex:
           swap  arg
           rcall lcd_number_hex_digit
           swap  arg
 
lcd_number_hex_digit:
           push  arg
 
           andi  arg, $0F
           cpi   arg, 10
           brlt  lcd_number_hex_digit_1
           subi  arg, -( 'A' - '9' - 1 ) ; es wird subi mit negativer Konstante verwendet, weil es kein addi gibt
lcd_number_hex_digit_1:
           subi  arg, -'0'               ; ditto
           rcall  lcd_putchar
           rcall  LCD_wait
           pop   arg
           ret
;*********************************************************************
;
; Eine 8 Bit Zahl dezimal ohne Vorzeichen ausgeben
;
; Übergabe:            Zahl im Register arg
; veränderte Register: keine
;
lcd_number:
           push  temp            ; die Funktion verändert temp2, also sichern
                                  ; wir den Inhalt, um ihn am Ende wieder
                                  ; herstellen zu können
 
           mov   arg2,arg     ; das Register temp1 frei machen
                                  ; abzählen wieviele Hunderter
                                  ; in der Zahl enthalten sind
           ldi   arg, '0'
lcd_number_1:
           subi  arg2, 100       ; 100 abziehen
           brcs  lcd_number_2     ; ist dadurch ein Unterlauf entstanden?
           inc   arg            ; Nein: 1 Hunderter mehr ...
           rjmp  lcd_number_1     ; ... und ab zur nächsten Runde
;
                                  ; die Hunderterstelle ausgeben
lcd_number_2:
           rcall LCD_putchar
           rcall LCD_wait
       subi  arg2, -100      ; 100 wieder dazuzählen, da die
                              ; vorherhgehende Schleife 100 zuviel
                  ; abgezogen hat
 
                                  ; abzählen wieviele Zehner in
                  ; der Zahl enthalten sind
           ldi   arg, '0'
lcd_number_3:
           subi  arg2, 10        ; 10 abziehen
           brcs  lcd_number_4     ; ist dadurch ein Unterlauf enstanden?
           inc   arg            ; Nein: 1 Zehner mehr ...
           rjmp  lcd_number_3     ; ... und ab zur nächsten Runde
 
                              ; die Zehnerstelle ausgeben
lcd_number_4:
           rcall LCD_putchar
           rcall LCD_wait
       subi  arg2, -10       ; 10 wieder dazuzählen, da die
                              ; vorhergehende Schleife 10 zuviel
                  ; abgezogen hat
 
                                  ; die übrig gebliebenen Einer
                  ; noch ausgeben
           ldi   arg, '0'       ; die Zahl in temp2 ist jetzt im Bereich
           add   arg, arg2     ; 0 bis 9. Einfach nur den ASCII Code für
           rcall LCD_putchar         ; '0' dazu addieren und wir erhalten dierekt
           rcall LCD_wait                       ; den ASCII Code für die Ziffer
 
           pop   temp            ; den gesicherten Inhalt von temp2 wieder herstellen
           ret                    ; und zurück 

;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen binär ausgeben
;
; Übergabe:            Zahl im Register temp1
; veränderte Register: keine
 
; eine Zahl aus dem Register temp1 binär ausgeben
LCD_alsBit:
     push arg      ; temp1 gesichert
       push temp2
     push temp3
 
     mov temp2, arg;
 
     ldi temp3, 8;      ; 8 Bits werden ausgelesen
lcd_number_loop:           
     dec temp3;
     rol temp2;         ; Datenbits ins Carry geschoben ...
     brcc lcd_number_bit_carryset_0; 
     brcs lcd_number_bit_carryset_1;
           rjmp lcd_number_loop;
 
lcd_number_bit_carryset_0:   
     ldi arg, '0'     ; Bit low ausgeben
           rcall LCD_putchar
     tst temp3;
     breq lcd_number_ende;
     rjmp lcd_number_loop;
 
lcd_number_bit_carryset_1:
           ldi arg, '1'     ; Bit high ausgeben
           rcall LCD_putchar
           tst temp3;
     breq lcd_number_ende;
     rjmp lcd_number_loop;
 
lcd_number_ende:
     pop temp3
     pop temp2
     pop arg
     ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;    Ab hier  Routinen zum auslesen und verarbeiten
;    des Sensors DHT22 (AM2302)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


text:
      .db  "Temperatur / Rel.FeuOut:",0
ok:  
  .db  "ok",0
fehler:
  .db "Fehler! ",0

fehlender_Sensor:
  .db  "kein Sensor",0


WAIT_40us:          ;selbserklärend
    push  r16
    ldi  r16,35
loop1:    dec r16
    nop
    nop
    brne  loop1
    pop r16
    ret
wait2s:
  push  r16
  push  r17
  push  r18
  ldi  r16,250
lo_p:  ldi  r17,220
lo__p:  ldi  r18,12
lo___p:  dec r18
  brne lo___p
  dec r17
  brne lo__p
  dec r16
  brne  lo_p
  pop  r18
  pop  r17
  pop  r16
  ret


waitMs:  push  r16  ;r16 retten
  push  r17  ;r17 retten
  push  r18  ;r18 retten
;  ldi  r16,1  ;Laufvariable ca x ms bei 3,6MHz
lop1:  ldi  r17,0x38  ;Laufvariable loop1
loop2:  ldi  r18,5  ;Laufvariable loop3
loop3:  dec  r18  ;Zähler 3 -1, hier Kalibrierung auf MCU Takt
  brne  loop3  ;Solange nicht NULL
  dec  r17  ;Zähler 2 -1
  brne  loop2  ;Solange nicht NULL
  dec  r16  ;Zähler1 -1
  brne  lop1  ;Solange nicht NULL
  pop  r18  ;r18 wiederherstellen
  pop  r17  ;r17 wiederherstellen
  pop  r16  ;r16 wiederherstellen
  ret    ;Rücksprung
    
DHT_lesen:
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;  Initialisieren der Startsequenz
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
  nop
  nop
  nop
  ldi temp,0x00
  ldi arg,0x00
  out  PORTC,arg
  ldi r16,6    ;6 mS
  rcall waitMs  ;min 1ms warten
;  ldi  arg,13  ;40 µs warten
;lo_:
;  dec arg
;  brne  lo_

  out  PortC,DHTmaske  ;über DHT auf 1 setzen (ist Pin an dem der Sensor hängt)
  ldi  arg,8
lo__:      ;20 µs warten
  dec arg
  brne  lo__
  ldi arg,0x00
;  cbi  PORTC,2
  out DDRC,arg  ;SensorPin auf eingang schalten
low1:        ; hier wird auf ein Nullsignal des Sensors gewartet
  in  arg,PINC
  inc temp
;  breq  KeinSensor
  and  arg,DHTmaske
  breq  low1
high1:
  in arg,PINC
  and  arg,DHTmaske
  brne  high1
low2:        ; hier wird auf das 2te Nullsignal des Sensors gewartet
  in  arg,PINC
  and  arg,DHTmaske
  breq  low2
high2:
  in arg,PINC
  and  arg,DHTmaske
  brne  high2
low3:        ; hier wird auf das 3te Nullsignal des Sensors gewartet
  in  arg,PINC
  and  arg,DHTmaske
  breq  low3  ;ab hier beginnen die Daten

  rcall DHT_bytlesen
  std  y+0,  byte
  rcall DHT_bytlesen
  std  y+1,byte
  rcall  DHT_bytlesen
  std y+2,byte
  rcall  DHT_bytlesen
  std  y+3,byte
  rcall DHT_bytlesen
  std  y+4,byte

  

;  mov  r21,return
;  ldi arg,0x00
;  rcall  LCD_pos
;  LDd  arg,y+0
;  rcall LCD_alsBit
;  ldi arg,0x40
;  rcall  LCD_pos
;  LDd  arg,y+1
;  rcall  LCD_alsBit
;ldi arg,0x14
;  rcall  LCD_pos
;  LDd  arg,y+2
;  rcall  LCD_alsBit
;ldi arg,0x54
;  rcall  LCD_pos
;  LDd  arg,y+3
;  rcall  LCD_alsBit
;ldi arg,0x0a
;  rcall  LCD_pos
;  LDd  arg,y+4
;  rcall  LCD_alsBit
;  ldi arg,0x1e
;  rcall LCD_pos


;Checksumme überprüfen
;  rcall LCD_pos
  ldd arg,y+0
  ldd  arg2,y+1
  add  arg,arg2
  ldd arg2,y+2
  add arg,arg2
  ldd  arg,y+3
  add  arg,arg2
  ldd  arg2,y+4
  cp arg,arg2
  breq fehler_
;  ldi ZH,HIGH(ok*2)
;  ldi  ZL,LOW(ok*2)
;  ldi arg,0x4a
;  rcall LCD4ZTxt
  rjmp  weitt
fehler_:
  ldi  ZH,HIGH(fehler*2)
  ldi ZL,LOW(fehler*2)
;  ldi arg,0x4a
  rcall LCD4ZTxt

weitt:  
;  ldi arg,0x1d
;  rcall LCD_pos  ;Position für die Luftfeuchte
    rcall umwandeln
    ldi  arg,0x25    ;% und "RH" anfügen
      rcall LCD_putchar
      rcall  LCD_wait
    ldi arg,' '
      rcall LCD_putchar
      rcall  LCD_wait
        ldi arg,' '
      rcall LCD_putchar
      rcall  LCD_wait
    

;  ldi arg,0x5d
;  rcall LCD_pos  ;Position für die Temperatur
    inc  r28
    inc r28
    ldi  r29,0x00
    rcall umwandeln
    ldi arg,0xdf  ;grad zeichen
      rcall LCD_putchar
      rcall  LCD_wait
    ldi arg,0x43  ;grosses C
      rcall LCD_putchar
      rcall  LCD_wait
  ret


;Routine zum erkennen der steigenden Flanke ohne Interrupt
steigendeFlanke:
  CLT
  ldi  return,0x00
anf:
  in  arg,PINC
  inc  return
  andi  arg,0x04
  breq  anf
  brtc  keinTflag
  ret        ;rücksprung nach 2ten mal 1 geunden
keinTflag:
  SET        ;hier wird das T Flag verwendet umzu 
  rjmp  anf    ;ob im zweiten durchlauf die 1 immer noch anliegt

fallendeFlanke:
  CLT
  ldi  return,0x00
anf_:
  in  arg,PINC
  inc return
  andi  arg,0x04
  brne  anf_
  brtc  keinTflag_
  ret        ;rücksprung nach 2ten mal 1 geunden
keinTflag_:
  SET        ;hier wird das T Flag verwendet umzu 
  rjmp  anf_    ;ob im zweiten durchlauf die 1 immer noch anliegt


;;;;;;;;;;;Byte lesen;;;;;;;;;;;;;;;;
DHT_bytlesen:

  ldi  temp,0x08
  ldi byte,00
;  mov temp2,DHTmaske  ;Pin an dem der DHT22 haengt
runde:        ;erkennen der Steigenden Flanke
  in  arg,PINC
  and  arg,DHTmaske  ;Pin an dem der DHT22 haengt
  breq  runde  
  ldi  arg,14  ;40us warten
wart:
  dec arg
  brne  wart
  in arg,PINC
  and arg,DHTmaske  ;Pin an dem der DHT22 haengt
  brbs  1, c_null
  sec
c_null:
  ldi arg,0x00
  rol  byte  ;
  adc  byte,arg  ;addiert null bei Z=0 und 1 bei z=1 ueber Carry
nulltest:      ;Hier wird wieder auf das naechste Low  gewartet
  in arg,PINC
  and arg,DHTmaske  ;Pin an dem der DHT22 haengt
  brne nulltest
  dec temp
  brne runde
  ret 
  
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  Weerte als dezimal Zahl ausgeben
; in Register Y (r28/r29) steht die Adresse für das erste 
;  umzuwandelnde Byte (High Byte)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

umwandeln:
;  ldi arg,0x1e
;  rcall LCD_pos
  ldi temp,$00    ;hunderter
  ldi  temp2,0x00    ;rest
  ldi  arg,0x00
  ldd  arg2,y+0
;  ldi arg,0x5e
;  rcall LCD_pos
;  ldd arg,y+1
;  rcall  LCD_alsBit
;  ldi arg,0x00  
  ror arg2      ;bit 9 auf 1 testen
  brcc  nicht_gesetzt
  ldi arg,0x02
  add  temp,arg
  ldi temp2,0x38    ;56 zum Rest addieren(von 256)
nicht_gesetzt:
  ror arg2      ; Bit 10 überprüfen
  brcc  nicht_gesetzt2
  ldi  arg,0x05
  add temp,arg
  ldi  arg,0x0c    ;12 (von 512) zum Rest addieren
  add  temp2,arg
nicht_gesetzt2:
  ldd  arg2,y+1
  rol arg2
  brcc  nicht_gesetzt3
  inc temp
  ldi arg,28    ;Rest von 1(28) addieren
  add temp2,arg
nicht_gesetzt3:
  rol arg2
  brcc  nicht_gesetzt4
  ldi arg,64
  add temp2,arg
nicht_gesetzt4:
    rol arg2
  brcc  nicht_gesetzt5
  ldi arg,32
  add temp2,arg
nicht_gesetzt5:
  rol arg2
  brcc  nicht_gesetzt6
  ldi arg,16
  add temp2,arg
nicht_gesetzt6:
  rol arg2
  brcc  nicht_gesetzt7
  ldi arg,8
  add temp2,arg
nicht_gesetzt7:
  rol arg2
  brcc  nicht_gesetzt8
  ldi arg,4
  add temp2,arg
nicht_gesetzt8:
  rol arg2
  brcc  nicht_gesetzt9
  ldi arg,2
  add temp2,arg
nicht_gesetzt9:
  rol arg2
  brcc  nicht_gesetzt0
  inc temp2
nicht_gesetzt0:
  subi temp2,100        ; 100 abziehen
  brcs  dht_number_2    ; ist dadurch ein Unterlauf entstanden?
  inc temp          ; Nein: 1 Hunderter mehr ...
  rjmp  nicht_gesetzt0    ; ... und ab zur nächsten Runde
              ; die Hunderterstelle ausgeben

                                  
dht_number_2:
    
           ldi arg,48
       add arg,temp
       rcall LCD_putchar
           rcall LCD_wait
       subi  temp2, -100    ; 100 wieder dazuzählen, da die
                                ; vorherhgehende Schleife 100 zuviel
                          ; abgezogen hat
     
                                ; abzählen wieviele Zehner in
                ; der Zahl enthalten sind
           ldi   arg, '0'
dht_number_3:
           subi  temp2, 10        ; 10 abziehen
           brcs  dht_number_4     ; ist dadurch ein Unterlauf enstanden?
           inc   arg            ; Nein: 1 Zehner mehr ...
           rjmp  dht_number_3     ; ... und ab zur nächsten Runde
 
                              ; die Zehnerstelle ausgeben
dht_number_4:
           rcall LCD_putchar
           rcall LCD_wait
       subi  temp2, -10     ; 10 wieder dazuzählen, da die
                               ; vorhergehende Schleife 10 zuviel
                        ; abgezogen hat
      ldi  arg,0x2e    ; Punkt einfügen
      rcall LCD_putchar
      rcall  LCD_wait
   
                                  ; die übrig gebliebenen Einer
                  ; noch ausgeben
           ldi   arg, '0'       ; die Zahl in temp2 ist jetzt im Bereich
           add   arg, temp2     ; 0 bis 9. Einfach nur den ASCII Code für
           rcall LCD_putchar         ; '0' dazu addieren und wir erhalten dierekt
           rcall LCD_wait                       ; den ASCII Code für die Ziffer
 
    



  ret

[D. V. (mazze69)]

- Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Tsss...

[Fritz B. (kleinfritzchen)]

tschulkdigung hier die Datei: