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?

[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/in...ller/PC_Praxis