Wartezeit für nächstes Zeichen oder Abbruch - sichere Software Uart AVR Tiny Assembler

[Frank (Gast)]

An einem Tiny48 hängt ein serieller Funkchip, wenn was auf dem Äther los 
ist löst PCINT5 das einlesen aus.

Funktionierte früher gut als ich noch Handys ausgelesen habe, geht jetzt 
im Test auch solange ich am Ende ein ccr setze.

Sollte aber irgenwie kein ccr gesendet werden oder nicht erkannt werden 
wegen Störung, Reichweite oder fremden Sender -> Endlosschleife bei 
getchar1

Was mache ich jetzt? Timer oder Delay-Counter setzen um ne halbe Sekunde 
zu warten ob noch ein Buchstabe kommt?

Grüße, Frank



UART_in füllt eine Adresse im Sram - ccr ist Abbruch:

UART_in:        ; lesen komplett, aber schreibt  
  push  r16            ; nur bis Puffer voll in Speicher!
  clr    r16
UART_in2:
  rcall  upUartIn
  cpi    uart,  ccr  ; Ende erreicht?
  breq  last_in_char
  cpi    uart,  clf  ; clf ignore
  breq  UART_in2
  cpi    r16,  25
  brge  UART_in2
  inc    r16
  st    y+,  uart
  rjmp  UART_in2          ;ueberspringen:  
last_in_char:
  clr    r16
  st    y,  r16
  pop    r16
  ret

upUartIn holt die Zeichen rein:

upUartIn:    
  push  r17
  ldi     r17,9    ; 8 data bit + 1 stop bit
getchar1:   
  sbic    PINA,5    ; Wait for start bit
  rjmp    getchar1
  rcall  UART_delay  ; 0.5 bit delay
getchar2:   
  rcall  UART_delay  ; 1 bit delay
  rcall  UART_delay
  clc      ; clear carry
  sbic    PINA,5    ; if RX pin high
  sec      ; set carry
  dec     r17    ; If bit is stop bit
  breq    getchar3  ; return
;else
  ror     uart    ; shift bit into uartbyte
  rjmp    getchar2  ; go get next
getchar3:   
   pop    r17
  ret

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Du brauchst "drumrum" einen "Timeout-Zähler", der in einem 
Timerinterrupt eine Variable herunterzählt und wenn die 0 ist brichst du 
den Empfang ab. Und bei jedem empfangenen Zeichen setzt du den Zähler 
auf einen Wert, der einer halben Sekunde entspricht.

Oder viel, viel besser: du stellst deinen Programmierstil auf eine 
Automatenschreibweise um.
Die Hauptschleife wird dauernd möglichst schnell durchlaufen. Und pro 
Durchlauf wird geschaut, ob was an der seriellen Schnitte angekommen 
ist. Wenn ja: verarbeiten. Wenn nein: weiter. "Weiter" bedeutet z.B. 
Tastenabfrage, Zähler verwalten, Abläufe koordinieren. Auf diese Art 
wird der Controller nicht durch das "Warten" auf irgendwas blockiert, 
weil ja nie "gewartet" wird...

[Peter D. (peda)]

Lothar M. schrieb:
> Oder viel, viel besser: du stellst deinen Programmierstil auf eine
> Automatenschreibweise um.

Oder man macht die SW-UART als Interrupt.
Oder man nimmt einfach den ATmega48 mit HW-UART.

[Frank (Gast)]

soldele danke für die schnellen Antworten ;)

habe jetzt ein Sekundendelay eingesetzt das prüft ob ein Zeichen 
empfangen wird und dann sofort beendet.

Kein Zeichen -> eine Sekunde warten und rausspringen
Start-Bit -> delay abbrechen und Zeichen einlesen

upUartIn:    
  push  r23
  ldi     r23,9        ; 8 data bit + 1 stop bit

  rcall  uartin_dly

  sbic    PINA,5        ; Wait for start bit
  rjmp  upUartIn_abbruch

  rcall  UART_delay      ; 0.5 bit delay
 
getchar2:   
  rcall  UART_delay      ;  1 bit delay
  rcall  UART_delay
  clc              ;  clear carry
  sbic    PINA,5        ;  if RX pin high
  sec              ;  set carry
  dec     r23          ;  If bit is stop bit
  breq    getchar3      ;   return
;else
  ror     uart        ;   shift bit into uartbyte
  rjmp    getchar2      ;   go get next

getchar3:   
   pop    r20
   pop    r23
  ret

upUartIn_abbruch:
  ldi     uart, ccr
   pop    r23
  ret

Ihr habt natürlich recht man könnte das auch Interrupt oder 
Hardware(interrupt) steuern.

Bei dem Projekt ist das aber nicht notwendig, ein mal im Jahr verbindet 
sich jemand mit dem System um Daten auszulesen und Einstellungen zu 
ändern.
In der kurzen Zeit muss das System dann nichts anderes machen. Hier wird 
eh nur alle 60 Sekunden der Taupunkt bestimmt und evtl. ein Relais 
geschaltet.

So ich werde jetzt einen schönen alten AT Befehlsatz für die 
Kommunikation aufbauen - war mal wieder schön in die niederen Gefilde 
der Uart zu kucken ;)