Stringkette bestimmter Länge über UART empfangen

[Foooob]

Hallo

Ich stehe vor folgendem Problem...
Mein AVR bekommt über die UART Zeichenketten, die immer 6 Zeichen lang sind (ohne Nullbyte). Diese Zeichenkette soll er in einen String speichern.

Sobald das erste Zeichen reinflattert soll der AVR dieses entgegennehmen und so lange warten bis die übrigen 5 Zeichen ebenfalls gespeichert sind. Erst dann soll er den String auswerten. Und erst wenn dieser String ausgewertet ist soll der nächste entgegengenommen werden.

Ich scheitere momentan vor allem daran, dass der AVR wirklich so lange wartet, bis er einen 6-stelligen String hat.

Das ganze sollte sollte wenn möglich in einer Interruptroutine ablaufen.

Ich habs schon mit diversen Arrays probiert, For-Schleifen, If-Bedingungen etc. aber nichts wollte funktionieren. Oft auch deswegen, dass der AVR dann Teile verschluckt hat.

So sollte das grobe Gerüst aussehen, bzw. hab ichs mir vorgestellt



'....
On Urxc Onrxd
Enable Urxc
Enable Interrupts

Dim S As String * 6
Dim S_array(7) As Byte At S Overlay

'.....
Main:
'....
Goto Main


Onrxd:
Incr N
S_array(n) = Udr
Return


So nimmt er immer sobald ein neues Zeichen kommt dieses im Array auf und schreibt es in den String. Und wenn ich da drumrum noch irgendwelche Konstrukte mache geht gar nichts mehr.

Ich hab mir gedacht, dass es am besten wäre, wenn der AVR so lange eingehende Zeichen aufnimmt bis er zum Nullbyte kommt und dort dann abbricht bzw. aus der Interrupt-Routine springt. Nur wie mach ich dem das klar? :-k

[PicNick]

na, is ja eh' super. du mußt nurmehr der hauptschleife sagen, wenn der string komplett is


'....
On Urxc Onrxd
Enable Urxc
Enable Interrupts

Dim S As String * 6
Dim S_array(7) As Byte At S Overlay
dim fertig as byte


'.....
Main:
if fertig = 1 then
print "da isser ja:", s
fertig = 0 ' quittieren
n = 0 ' zurücksetzen
end if

' ich mach inzwischen was anderes, muß aber natürlich immer wieder
' mal wieder nach oben zu "main" kommen, logo.

'....
Goto Main


Onrxd:
if fertig = 0 then
Incr N
S_array(n) = Udr
if S_array(n) = 0 then fertig = 1
end if
Return


Die "fertig" abfrage in "onrxd" ist dazu da , daß erst wieder was genommen wird, wenn die hauptroutinen den string zu kenntnis genommen hat. Ist sie zu schnell mit dem nächsten string, hat sie Pech gehabt.

Um das zu vermeiden, müßtest du einen Zwischenbuffer verwenden.
da wird's aber komplizierter. Schau mal, ob das so nicht eh' reicht.

[Foooob]

Funktioniert leider nicht so ganz :(
Schicke ich dem AVR nun einen 6 Zeichen langen String tut der AVR gar nichts...
Erst wenn ich ihm nochmal einen solchen String schicke reagiert er und gibt 8 Zeichen aus, zusammengewürfelt aus beiden Strings und alle weiteren Sendungen werden noch schlimmer

(1) Sende "LaLeLu" -> AVR tut nichts
(2) Sende "LaLeLu" -> AVR gibt "LaLeLuLa" aus
(3) Sende "LaLeLu" -> AVR tut nichts
(4) Sende "LaLeLu" -> AVR gibt "uLaLeLuL" zurück (wieder 8 Zeichen)
(5) Sende "LaLeLu" -> AVR tut nichts
(6) Sende "LaLeLu" -> AVR gibt "uLaLeLuL" zurück
...

Ab (3) bzw. (4) widerholt sich dann nur noch alles...klickt man einmal kommt nichts, klickt man nochmal kommt "uLaLeLuL" zurück usw. usf.

Irgendwie verschluckt der da ziemlich was. Die Strings wurden alle im Abstand von mehreren Sekunden gesendet.

[Foooob]

Ich muss das ganze total anders machen.
Das muss in etwa so ablaufen, dass das Programm an den AVR nur senden darf, wenn dieser ein OK gibt (dass sein FIFO-Puffer leer ist bzw. er den letzten eingehenden String voll verarbeitet hat).

Genauso darf der AVR nur senden, wenn der PC sein ok gibt (kann erst mal vernachlässigt werden, der hat ja einen größeres FIFO-Puffer und ist wesentlich schneller in der Ausführung).

Nunja, da muss ich nochmal das Datenblatt zur Hand nehmen obs dafür spezielle Register gibt um den FIFO-Puffer beim AVR auszulesen, bzw. Flags für dessen Zustand zu setzen.

Das ganze sollte dann in etwa so aussehen:




' Interrupt muss auf jeden Fall verwendet werden!
On Urxc Onrxd
Enable Urxc
Enable Interrupts


Main:

If N = 6 And S = "..." Then 'nur wenn String komplett und S = Blabla...
'Tue irgendwas....

Flag = 0 'Setze ein Flag, das dem PC sagt, dass er nun wieder senden darf
N = 0 'Setze den Zähler zurück, damit der alte String durch einen neuen überschrieben wird.
Waitms 500
End If


Goto Main


Onrxd:
'Zeichen dürfen nur entgegengenommen werden, wenn der AVR gerade keinen anderen String von der RS-232 verarbeitet. Ansonsten abbruch des Interrupts

Incr N 'Zähler für die aktuelle Länge des Strings
S_array(n) = Udr
If S_array(n) = 0 Then Flag = 1
'....

'Sobald ein Nullbyte kommt oder ein anderes vereinbartes Zeichen soll die Übertragung sofort abgebrochen werden und dem PC gesagt werden, dass er sämtliche Übertragungen erst mal einstellen soll bis ein OK kommt
Return



Hab ich die Semesterferien wohl was zu tun ;-)
Wenn irgendjemand ein paar Codeschnippsel, Methoden, Ratschläge oder Vorgehensweisen hat, (speziell wegen dem Problem mit dem String einlesen) wäre ich sehr dankbar.


EDIT: Ach ja, ich verwende einen ATmega128, sollte vielleicht auch gesagt sein.

[veit]

kannst du das programm am pc verändern?
schon oder?

sende vor jedem deiner strings ein startcommando, dann am besten gleich noch ne checksum am schluss und ein endcommando.

hab mir das auch selbst gestrickt, ist nicht schwer (me=anfänger)

[Foooob]

Ja ich kann die Strings am PC manipulieren wie ich will.

Das mit der Checksum hab ich mir auch schon überlegt. Start und Stopbyte bzw. Kommando brauche ich eigentlich nicht. Genau das wollte ich nämlich mit diesem 6-Zeichen-Code umgehen.
Win neuer String kann dann immer gesendet werden sobald N = 0 ist und muss immer mit dem 6. Zeichen enden, bzw. mit dem 7. als Nullbyte.
Wenn das allerdings weiterhin so Probleme macht wären Start- und Stopbytes eine Lösung, ja.

Wie hast du das denn gemacht, dass es zu keinem Bufferoverflow vom FIFO-Buffer kommt?
Ich werds demnächst mal so versuchen, dass der Mega an den PC Flags sendet, je nach Zustand des FIFO-Puffers. Ich muss nur noch schauen wie ich das in C# mache, dürfte aber kein großer Akt sein.
Wenn ich das habe ist ja schonmal gewährleistet dass der PC nur sendet wenn er auch darf, damit wäre schonmal ein Stein aus dem Weg.
Beim ATmega8 gibts ja so ein Register für den FIFO, dann wirds den beim 128 auch irgendwo geben.

Na, erst einmal Fasching feiern und morgen setz ich mich dann mal wieder hin ;-)

[PicNick]

Wenn deine 6 Bytes binäre Daten sind, also Bytes von 0-255, ist das mit den Steuerzeichen nix

[Foooob]

Nein, das sind schon Strings, sorry wenn ich vorhin Verwirrung gestiftet habe. Drum ja auch der Betreff "Stringkette..."

Also ich meine Start- und Stopzeichen mit Datenbytes dazwischen die als String kodiert sind ;-)

[veit]

Wenn deine 6 Bytes binäre Daten sind, also Bytes von 0-255, ist das mit den Steuerzeichen nix

bei mir sinds bytes von 0-255, falls das byte gleich einem start oder endcommando ist sendet man vorher ein escape-byte, erhöht den wert um 10 und beim empfang zieht man die 10 wieder ab und ignoriert das escape-byte

um den fifo buffer hab ich mich nie gekümmert, empfange so 8 - 10 bytes.
schaue mir beim empfang nur das txc-flag an sonst nix

[PicNick]

So ein transparent-Protokoll (ähnlich wie das von Veit) verwenden wir in unserem PC/µC Netzwerkprojekt
https://www.roboternetz.de/wissen/index.php/Network_Controller/PC_Praxis

[veit]

ohhm das was ich verwende nennt sich eSLIP und war irgendwie mal der vorgänger von tcp/ip oder sowas (würde mir sowas nie selbst ausdenken, zuwenig drin in der birne)

[PicNick]

..zuwenig drin in der birne..

*hehe* :mrgreen: diese Sachen kann keiner erfinden.
Die gibt's alle schon, da sind wir noch am Schnuller gehangen

[marvin42x]

Das besagte Netzwerkprojekt kann man sich hier etwas näher ansehen.
http://www.marvins-lab.roboterbastler.de
Hier entsteht eine Dokumentation die aber jetzt bereits einiges erhellendes zu bieten hat.

Netter Gruß

Ps. Sorry, bisschen Schleichwerbung muss schon sein :-)

[digitali]

Sobald das erste Zeichen reinflattert soll der AVR dieses entgegennehmen und so lange warten bis die übrigen 5 Zeichen ebenfalls gespeichert sind. Erst dann soll er den String auswerten. Und erst wenn dieser String ausgewertet ist soll der nächste entgegengenommen werden.

Ich scheitere momentan vor allem daran, dass der AVR wirklich so lange wartet, bis er einen 6-stelligen String hat.
.
.
.



Hallo,

mit nachfolgendem Code wartet der AVR zunaechst auf ein bestimmtes Zeichen oder eine Zeichenfolge. In meinem Beispiel horcht der AVR auf ein "a".
Anschliessend liest der AVR die naechsten anstehenden Zeichen ein und speichert diese in die Stringvariable "zeichen".
Das ganze ist eine Endlosschleife. Mit diesem Programmschnipsel habe ich erfolgreich in einem anderen Projekt die Daten einer GPS-Mouse (Koordinaten, Geschwindigkeit usw. ) eingelesen.
Der Code basiert auf einem Beispiel aus dem Buch von Claus Kuehnel "Programmieren der AVR-Risc...") - na, kennt hier ja jeder...



$lib "glcdKS108.lib"
$regfile = "m32def.dat"
$crystal = 16000000
$hwstack = 32
$swstack = 20
$framesize = 40
$baud = 4800
Config Graphlcd = 128 * 64sed , Dataport = Portc , Controlport = Portb , Ce = 1 , Ce2 = 0 , Cd = 4 , Rd = 3 , Reset = 2 , Enable = 5
Config Serialin = Buffered , Size = 10
Declare Function Read_string(byval T As Byte) As String
Declare Sub Wait_for_string(byval S As String)
Enable Interrupts
Dim Zeichen As String * 6

Setfont 6x8font
Cls
Lcdat 1 , 1 , "wait_for_string"

Do
Print "test"
Call Wait_for_string( "a")

'Zeichen = Read_string(8)

Print "Alles wird gut"
Lcdat 3 , 1 , "Zeichen a empfangen"
waitms 500
Loop

End

Sub Wait_for_string(byval S As String) As String
Local Ii As Byte
Local Cc As Byte
Ii = 1
M1:
Cc = Waitkey()
If Cc <> Mid(s , Ii , 1) Then
Goto M1
Else
Incr Ii
If Ii > Len(s) Then Goto M2
Goto M1
End If
M2:
End Sub

Function Read_string(byval T As Byte) As String
Local Cc As Byte
Local Ss As String * 10
Ss = ""
Do
Cc = Waitkey()
Ss = Ss + Chr(cc)
Loop Until Cc = ","
Read_string = Left(ss , T)
End Function

$include "6x8font.font"





Screenshot: http://www.elektronik-web.de/atmel/roboternetz/waitforstring.gif

Drahtigel: http://www.elektronik-web.de/atmel/roboternetz/wfs.jpg

Vielleicht hilft es ja etwas weiter...

Mit freundlichen Gruessen
Digitali

[Foooob]

Danke für die Hilfe!
Ich bin gerade dabei einen Code zu schreiben. Mir kamen auch einige gute Ideen dazu.

Habe noch eine kurze (recht primitive Frage)
Gibts in BASCOM kein Ungleich??

Ich würd gern ´ne While-Schleife machen bei der geprüft werden soll ob Udr ungleich "Y" ist, also sowas hier



While Udr ! "Y"
....
Wend


Aber weder ! noch not oder != funktionieren.
Kennt sowas BASCOM nicht? Kann doch nicht sein oder??

[digitali]

In der Bascom-Hilfe unter Stichwort "Language Fundamentals" gefunden:


----schnipp----

Relational Operators

= Equality X = Y
<> Inequality X <> Y
< Less than X < Y
> Greater than X > Y
<= Less than or equal to X <= Y
>= Greater than or equal to X >= Y

----schnapp----

[Foooob]

@ digitali
Vielen Dank für die Hilfe!
Deinen Code weiter oben habe ich mal analysiert und versucht nachzuvollziehen. Man! Der verwendet Schlüsselwörter die ich noch gar nicht kannte aber die einem das Leben echt vereinfachen ;-)

Ich habe aber noch einige Fragen zu denen ich unter anderem auch in der Bascom-Hilfe und im Datasheet nix fand.

1. Config Serialin = Buffered , Size = 10
Ich schätze mal hier setzt du den Eingangspuffer für die RS-232 auf 10 Bytes. Ich dachte der ist bei jedem Mega fest eingestellt und kann nicht verändert werden? Oder etwa doch?

2. Zeichen = Read_string(8)
Darfste ja eigentlich nicht auskommentieren. Aber ganz eine andere Frage: Was bewirkt diese Zeile? Sie ruft die Funktion read_string auf und übergibt ihr den Parameter für die Länge des Strings (hier 8), richtig?
Und die Zeile: Read_string = Left(ss , T) ist dann der Rückgabewert der Funktion read_string als String? Und dieser Rückgabewert ist dann gleich dem String Zeichen??
Wieso ist dann aber Zeichen 6 Stellen lang? Müsste es nicht 8 sein? Da wir ja den String Ss bis zum 8. Zeichen von links "ausschneiden".

3. Du schreibst Cc = ","
Das heist das Komma ist das Endezeichen? Hier verwendest du aber im Gegensatz zu der Zeile weiter oben nicht das Chr(), also Chr(Cc) = "," Wenn ich auf ein Endezeichen im ASCI-Standard warte könnte/sollte/müsste ich dann Chr(Cc) = "," schreiben?

Man, ich hätte glaub echt gleich von Anfang an die Dinger mit C programmieren sollen. Ich tu mir teilweise immer noch sehr schwer mit BASIC weil ich sonst immer nur mit C und C++ zu tun hab.

EDIT: Ich habe das Programm auf mein Board angepasst aber noch nicht getestet, da ich erst den Code verstehen will.

[digitali]

@ digitali
Vielen Dank für die Hilfe!
Deinen Code weiter oben habe ich mal analysiert und versucht nachzuvollziehen. Man! Der verwendet Schlüsselwörter die ich noch gar nicht kannte aber die einem das Leben echt vereinfachen ;-)

Ich habe aber noch einige Fragen zu denen ich unter anderem auch in der Bascom-Hilfe und im Datasheet nix fand.

1. Config Serialin = Buffered , Size = 10
Ich schätze mal hier setzt du den Eingangspuffer für die RS-232 auf 10 Bytes. Ich dachte der ist bei jedem Mega fest eingestellt und kann nicht verändert werden? Oder etwa doch?


Also in der Basom-Hilfe Stichwort "config serialin" steht nichts von einem fest eingestellten Wert. Im Original-Programm stand der Wert auf 100.



2. Zeichen = Read_string(8)
Darfste ja eigentlich nicht auskommentieren. Aber ganz eine andere Frage: Was bewirkt diese Zeile? Sie ruft die Funktion read_string auf und übergibt ihr den Parameter für die Länge des Strings (hier 8), richtig?
Und die Zeile: Read_string = Left(ss , T) ist dann der Rückgabewert der Funktion read_string als String? Und dieser Rückgabewert ist dann gleich dem String Zeichen??
Wieso ist dann aber Zeichen 6 Stellen lang? Müsste es nicht 8 sein? Da wir ja den String Ss bis zum 8. Zeichen von links "ausschneiden".


Ich hatte es auskommentiert, weil ich keine weiteren Zeichen nach dem Empfang von "a" eingelesen hatte. Wollte nur ad hoc zeigen, dass zumindest das wait_for_string so schon mal funktioniert.
Die Funktion read_string habe ich so aus dem Beispiel uebernommen und deren Werte auf die Schnelle nicht weiter angepasst. Sie liest dann die nachfolgenden 8 Werte ein und uebergibt diese der Stringvariable (die ich haette mit der Laenge 8 deklarieren muessen) "Zeichen".



3. Du schreibst Cc = ","
Das heist das Komma ist das Endezeichen? Hier verwendest du aber im Gegensatz zu der Zeile weiter oben nicht das Chr(), also Chr(Cc) = "," Wenn ich auf ein Endezeichen im ASCI-Standard warte könnte/sollte/müsste ich dann Chr(Cc) = "," schreiben?


Das Beispiel stammt, wie gesagt, aus einem Programm welches den Datenstrom einer GPS-Mouse einliest. Die einzelnen Werte innerhalb eines Datensatzes werden immer mit einem "," getrennt.
Beispiel:
$GPRMC,213926.206,V,0000.0000,N,00000.0000,E,,,140 606,,*18


Mit freundlichen Gruessen
Digitali

[Foooob]

Ich habe es gerade ausprobiert! Es funktioniert super!!
Ich habs eben auch mit großen Datenmengen probiert. Bei ´nem Puffer von 10 Bytes hat er hin und wieder noch einen Fehler reingehaun. Jetzt hab ich den Puffer auf 100 gesetzt und die Sache klappt 1A, er verschluckt auch nichts mehr.

Vielen Dank für den Code und die Erklärung zu meinen Fragen!

[Foooob]

Jetzt muss ich doch nochmal auf was zurückkommen...

Ich würde das ganze gern als Interrupt ausführen, aber das funktioniert nicht, nur frage ich mich wieso....

Wenn ich den Code nun so schreibe:




$regfile = "m128def.dat" 'ATmega128
$crystal = 11059200 'Quarz: 11059200 Hz
$hwstack = 32 'Hardware Stack
$swstack = 32 'Software Stack
$framesize = 32 'Framesize
$baud = 9600

Config Serialin = Buffered , Size = 100
Declare Function Read_string(byval Stringlaenge As Byte) As String
Declare Sub Wait_for_string(byval S As String)

Dim Zeichen As String * 8

Config Lcd = 20 * 4a , Chipset = Ks077
Config Lcdpin = Pin , Db4 = Porta.0 , Db5 = Porta.1 , Db6 = Porta.2 , Db7 = Porta.3 , E = Porta.4 , Rs = Porta.5
Config Lcdbus = 4
Waitms 100
Initlcd
Cursor Off

Do

Call Wait_for_string( "y")
Zeichen = Read_string(6)

Locate 2 , 1
Lcd Zeichen
Locate 3 , 10
Lcd "Hallo"

Loop

'***BEGIN***********AUSLESEN DER RS-232********************
Sub Wait_for_string(byval S As String) As String
Local Startpunkt As Byte
Local Empfangen As Byte
Startpunkt = 1
M1:
Empfangen = Waitkey()
If Empfangen <> Mid(s , Startpunkt , 1) Then
Goto M1

Else
Incr Startpunkt

If Startpunkt > Len(s) Then Goto M2

Goto M1
End If
M2:
End Sub

Function Read_string(byval Stringlaenge As Byte) As String
Local Empfangen As Byte
Local Ss As String * 10
Ss = ""
Do
Empfangen = Waitkey()
Ss = Ss + Chr(empfangen)
Loop Until Empfangen = ","
Read_string = Left(ss , Stringlaenge)
End Function
'***ENDE***********AUSLESEN DER RS-232********************

End


Dann funktioniert das Auslesen der RS-232 problemlos, allerdings wartet mein Programm dann logischerweise immer an der Stelle Call Wait_for_string( "y") bis ein String reingeflattert kommt. Erst dann würde er das "Hallo" anzeigen.
Das will ich jedoch nicht und so habe ich mir gedacht das einfach in einen Interrupt zu legen, der dann so ausschaut:




$regfile = "m128def.dat" 'ATmega128
$crystal = 11059200 'Quarz: 11059200 Hz
$hwstack = 32 'Hardware Stack
$swstack = 32 'Software Stack
$framesize = 32 'Framesize
$baud = 9600

Config Serialin = Buffered , Size = 100
Declare Function Read_string(byval Stringlaenge As Byte) As String
Declare Sub Wait_for_string(byval S As String)

Dim Zeichen As String * 8

On Urxc
Enable Urxc
Enable Interrupts

Config Lcd = 20 * 4a , Chipset = Ks077
Config Lcdpin = Pin , Db4 = Porta.0 , Db5 = Porta.1 , Db6 = Porta.2 , Db7 = Porta.3 , E = Porta.4 , Rs = Porta.5
Config Lcdbus = 4
Waitms 100
Initlcd
Cursor Off

Do

Locate 2 , 1
Lcd Zeichen
Locate 3 , 10
Lcd "Hallo"

Loop

'***BEGIN***********AUSLESEN DER RS-232********************
Sub Wait_for_string(byval S As String) As String
Local Startpunkt As Byte
Local Empfangen As Byte
Startpunkt = 1
M1:
Empfangen = Waitkey()
If Empfangen <> Mid(s , Startpunkt , 1) Then
Goto M1

Else
Incr Startpunkt

If Startpunkt > Len(s) Then Goto M2

Goto M1
End If
M2:
End Sub

Function Read_string(byval Stringlaenge As Byte) As String
Local Empfangen As Byte
Local Ss As String * 10
Ss = ""
Do
Empfangen = Waitkey()
Ss = Ss + Chr(empfangen)
Loop Until Empfangen = ","
Read_string = Left(ss , Stringlaenge)
End Function
'***ENDE***********AUSLESEN DER RS-232********************

Onrxd:
Call Wait_for_string( "y")
Zeichen = Read_string(6)
Return

End


Nun zeigt mein AVR das "Hallo" an, allerdings wertet er keine Zeichenkette von der UART aus....nur wieso??? Denn das interessante kommt jetzt, wenn ich die Zeile Zeichen = Read_string(6) (und nur diese) wieder oben in Do...Loop reinhaue sieht man wieder dass er auf das Interrupt (korrekt) reagiert.




$regfile = "m128def.dat" 'ATmega128
$crystal = 11059200 'Quarz: 11059200 Hz
$hwstack = 32 'Hardware Stack
$swstack = 32 'Software Stack
$framesize = 32 'Framesize
$baud = 9600

Config Serialin = Buffered , Size = 100
Declare Function Read_string(byval Stringlaenge As Byte) As String
Declare Sub Wait_for_string(byval S As String)

Dim Zeichen As String * 8

On Urxc
Enable Urxc
Enable Interrupts

Config Lcd = 20 * 4a , Chipset = Ks077
Config Lcdpin = Pin , Db4 = Porta.0 , Db5 = Porta.1 , Db6 = Porta.2 , Db7 = Porta.3 , E = Porta.4 , Rs = Porta.5
Config Lcdbus = 4
Waitms 100
Initlcd
Cursor Off

Do
Zeichen = Read_string(6)

Locate 2 , 1
Lcd Zeichen
Locate 3 , 10
Lcd "Hallo"

Loop

'***BEGIN***********AUSLESEN DER RS-232********************
Sub Wait_for_string(byval S As String) As String
Local Startpunkt As Byte
Local Empfangen As Byte
Startpunkt = 1
M1:
Empfangen = Waitkey()
If Empfangen <> Mid(s , Startpunkt , 1) Then
Goto M1

Else
Incr Startpunkt

If Startpunkt > Len(s) Then Goto M2

Goto M1
End If
M2:
End Sub

Function Read_string(byval Stringlaenge As Byte) As String
Local Empfangen As Byte
Local Ss As String * 10
Ss = ""
Do
Empfangen = Waitkey()
Ss = Ss + Chr(empfangen)
Loop Until Empfangen = ","
Read_string = Left(ss , Stringlaenge)
End Function
'***ENDE***********AUSLESEN DER RS-232********************

Onrxd:
Call Wait_for_string( "y")
Return

End


Nun nimmt er Strings von der RS-232 entgegen und gibt diese auch (fast) korrekt aus, allein das Startzeichen ("y") lässt er noch stehen aber das wäre ja nicht so wild. Nur dumm dass er jetzt erst wieder auf einen Rückgabewert der Funktion Read_string wartet und vorher nichts anderes macht.

Aber mein Verstand steigt schon beim 2. Codebeispiel aus. Wieso führt der AVR beim Interrupt das nicht wie gewüscht aus? Ich habe doch die 2 auszuführenden Anweisungen lediglich vom Hauptprogramm ins Interrupt gelegt??

[Foooob]

Nun Beginnt mein Problem von vorne wieder, denn ich habe ganz vergessen, das Einlesen der Daten als Interrupt zu handhaben :(

Nun bin ich wieder da wo ich anfangs war
Und finde trotz zig verschiedener getesteter Möglichkeiten keine zuverlässige Methode die Daten einzulesen, eben mit Interrupt ](*,)

[Foooob]

Jungs, Problem gelöst :)
Es lebe Ischarwaiting()

[kalletronic]

hi Foooob,
kannst du mal kurz beschreiben wie du das dann gelöst hast?
steh grad vor fast dem gleichen problem

[Eisbaeeer]

Jungs, Problem gelöst :)
Es lebe Ischarwaiting()

Könntest du noch angeben, wo du den Ischarwaiting eingesetzt hast?
Würde mir ungemein helfen.

Danke

[jo_robot]

Hi Foooob!
Mit was hast du denn das Programm am für den PC geschrieben?