Uart Überprüfung Gerät angeschlossen?

[Elektronikanfänger (Gast)]

Hallo
Meine Frage: Kann man überprüfen, ob ein Gerät überhaupt am Uart 
angeschlossen ist?

Beispiel: Mein Mikrocontroller sendet Daten über Uart an Gerät. Dieses 
antwortet dann in einer bestimmten Art. Die empfangenen Zeichen landen 
im Flash.
Wenn ich nun Zeichen von Mikrocontroller sende und es ist kein Gerät 
angeschlossen, was kommt beim Mikrocontroller an? Die Daten als Echo 
oder nichts?

Ich verwende ATMega32.

[Benedikt K. (benedikt)]

Nichts.

Eine sichere Erkennung ist unmöglich, außer man bekommt eine bekannte 
Antwort auf einen gesendeten Befehl.

[Sven P. (Gast)]

Kommt ganz drauf an, was das "andere" Gerät sendet... früher gabs genau 
zu diesem Zweck verdrahtete Handshake-Leitungen. Quasi eine Drahtbrücke 
im Stecker.

[Elektronikanfänger (Gast)]

Ich poste einfach mal hier weiter.
Wollte fragen, ob ich den Sprung "jmp ende" (siehe Quelltext) machen 
darf oder lieber doch nicht.
Ein "ret"-Befehl würde dann wegfallen. Kenne mich mit dem Stack nicht so 
gut aus.

main:

  ldi temp1, low(RAMEND)
  out SPL, temp1
  ldi temp1, high(RAMEND)
  out SPH, temp1

  ...

ende:

  call temperature_to_LCD
  call check_temperature_alert
  call ...            ; muss nicht ausgeführt werden, wenn Handy
                      ; nicht verbunden

jmp   ende

;----------------------------------------


temperature_alert:

  push temp1

  ...

  call call_phone_number1
  call control_call_phone_number1

  ...
  pop temp1
ret

;-----------------------------------------

control_call_phone_number1:

  push temp1
  push SRAM_register
  clr try_again

  ; SRAM auslesen und kontrollieren, gelesenes Byte in SRAM_register
  ; X-Zeiger wird in read_SRAM erhoeht

next_try:
  call read_SRAM
  mov temp1, SRAM_register    ; UART Daten lesen
  cpi SRAM_register, 'A'
  brne error_call_pn1        ; branch if not equal


no_error_call_pn1:
  call clear_line4        ; LCD
  pop SRAM_register
  pop temp1
ret


error_call_pn1:
; wenn Register "try_again=5", dann Handy nicht verbunden
; springen nach call temperature_to_LCD d.h. nach Marke "ende"

  inc try_again
  ldi temp1, 5
  cp try_again, temp1          ; compare with 5
  breq not_connected          ; equal --> no mobile

  call call_phone_number1
  rjmp next_try



not_connected:
  call no_mobile_connected
  pop SRAM_register
  pop temp1
jmp ende          --> besser nicht machen????
;ret

[Moritz E. (devmo)]

theoretisch könnte das gehen, aber absolut unsinnig

dein ganzer code ist sehr unstruktiert und chaotisch, besser macht man 
es so:

mainloop:

call routine1


rjmp mainloop

routine1:

   tu dies

   tu jenes

   IF FallA jump Skip_FallA

       NICHTFall A:
       tu was anderes (fehlerbehandlung)
       jump Ende_routine1

   Skip_FallA:

       FallA:
       da alles ok,

       mache hier die eigentliche aufgabe





Ende_routine1:

ret


bei solchen if then else verzweigungen sollte man einen codeblock für 
den NICHT fallA mit branchbefehl oder jmp überspringen der zum fallA 
führt. wenn NICHT FallA gilt, wird dieser Skip nicht ausgeführt, und es 
geht direkt im anschluss an den Bedingungstest zum NICHT FallA teil, an 
dessen ende dann wiederrumm ein Skip des FallA steht (hier jump Ende)

Für die Bedingungstests gibts zwei konstrukte: die logischen branch 
befehle wie brne, mit denen du nach compare oder sonstigem z.b. den 
gegenteiligen fall per Skip-sprung überspringst.
und dann gibt es den oft hilfreichen Skip if bit set, mit denen du 
einzelne Flags checken kannst:

Routine2

SBRS  Register, Bitnummer
rjmp SkipBitistgesetzt

  (hier der teil für den fall das Bit gesetzt ist)

   rjmp SkipBitnichtgesetzt:
SkipBitistgesetzt:

   (hier den teil für den fall das bit nicht gesetzt=

SkipBitnichtgesetzt:

  ...

ret


wenn du dich an die üblichen programmkonstruke der hochsprachen hälst 
vermeidet man die berüchtigten unlessbaren assemblerschweinerein. IF 
THEN ELSE kann man mit obigen Modellen nachbauen, Switchcase ebenso,

for A do X kann man so machen:

Loop:
  IF FallA, jump break_loop

       schleifeninhalt X

  rump loop

break_loop:
...
weiter




do X while A dann so:

loop2:

       schleifeninhalt X

   if A jump loop2

...
weiter


wenn man ein switchcase für flags haben will, lässt es sich elegant so 
machen:


Skip if bit A cleared
    call bitAset
    jump break
Skip if bit B cleared
    call bitBset
    jump break
... weitere skip if

break:


besonders vermeidest du so, das es zu jedem routinenanfang mehrere 
returns an verschiedenen sprungzielen gibt, was sehr undurchsichtig ist 
und eine fehlerquelle sein kann.

programmteile die einzelne routinen darstellen solltest du auch deshalb 
nie mit jump ansteuern, auch wenn die routine immer nur zur selben 
stelle zurückkehrt. besonders aber lass die finger von 
stack-pfuschereien, das kann sehr sporadische fehler geben die erst nach 
ein paar wochen auftauchen.