UART Auswertung

- XON / XOFF kann man weglassen; das ist eigentlich für was anderes 
gedacht.
- "Name der Variable" hat eine feste Länge? Wenn nicht, brauchst Du noch 
eine Längenangabe, damit man weiß, wo die "Daten" anfangen.
- Je nach Sicherheitsbedarf kann man noch eine Prüfsumme hinter 
dranhängen.

Gruß Dietrich

1

          for (s; s<= strlen(UARTString); s++){

2

            // restlichen Zeichen "löschen"

3

            UARTString[s] = STRINGEND;

4

          }

Häng einfach EIN \0 Zeichen an deine empfangenen Zeichen hinten drann 
und du hast einen String.
Abgesehen davon macht strlen sowieso nicht das, was du denkst was es 
macht. Denn um strlen anwenden zu können, müsstest du schon einen String 
haben.

String-Verarbeitung in C

> Der UARTString enthält ja den Wert der Variable und bei jedem \0
> geht der String zur Auswertung und wird dann über einen strcmp
> verglichen. Die Länge ergibt sich daher von [0] bis an die
> Stelle des erste \0 oder nicht?

Kann man machen.
Ist aber auf der UART Strecke unpraktisch.

"Hour=20"

ist viel einfacher. Vor allen Dingen ist es für den Sindern viel 
einfacher zu erzeugen. Zb. für den ersten Tester, der ein Mensch vor 
einem Terminal ist.

Man kann dein Protokoll so aufbauen, wie du das machen willst. Würd ich 
aber ehrlich gesagt nicht tun. STX/ETX ist nett, aber eigentlich nicht 
wirklich notwendig. Denn wenn du das Protokoll so aufbaust, dass du ein 
sichtbares ASCII Zeichen als Endekennung hast, tust du dich in der 
Testphase (in der du mit einem Terminalprogramm höchstselbst die 
Kommandos zum µC schickst) viel leichter.

Hour 12<Return>
Minu 28<Return>
Day 5<Return>
Month 12<Return>
Year 2012<Return>

und du hast perfekt ein Datum übertragen. Und aus
Date 5,12,2012<Return>
kann man ebenfalls das einzustellende Datum sauber rausholen, ohne dass 
man auf nicht sichtbare Sonderzeichen angewiesen ist. Durch den <Return> 
(die Taste kann auf deiner Tastatur auch mit 'Enter' beschriftet sein, 
es ist die größe winkelförmige am rechten Rand deiner Haupttastatur, ist 
immer klar, wo ein Kommando aufhört. Und das wird seit mindestens 50 
Jahren genau so benutzt.

Ich würd ehrlich gesagt strikt trennen zwischen:
Eine Zeile (denn um etwas anderes handelt es sich ja nicht, bei eine 
String, der mit einem \n (oder \r) aufhört) empfangen und dessen 
Zerlegung bzw. Auswertung.

Hallo Martin,

Wenn Du ein Protokoll zwischen PC und uC entwickelst, damit ein Mensch 
über den PC mit dem uC sprechen kann, dann solltest Du möglichst auf 
Steuer-/Sonderzeichen verzichten. Wenn aber eine Software auf dem PC mit 
einer Software auf dem uC sprechen soll, dann muss ich meinem 
geschätzten Kollegen Buchegger widersprechen.
STX/ETX bieten eine einfache undmit wenig Code zu realisierende 
Möglichkeit die Kommunikation zweier Systeme zu synchronisieren.
Man kann beide Seiten mit wichtigen Dingen beschäftigen und auch 
beliebige Störungen einstreuen. Ohne STX wird erst einmal alles 
Verworfen.
Ein ETX schließt die Kommunikation ab. Wenn die Anzahl der Daten den 
Puffer überschreiten, wird die Kommunikation abgebrochen, und man wartet 
wieder auf STX. Dauert die Kommunikation zu lange (Unterbrechung) wartet 
man wieder auf STX.
Überträgt man nach dem STX zuerst einmal die zu erwartende Länge der nun 
kommenden Daten, weiß man sowohl die Zeit, bis ETX kommen sollte, also 
auch die Anzahl Zeichen bis ETX kommt. Auch hier kann man dann einfach 
wieder auf 'Warte auf STX' zurück fallen, wenn eines der beiden nicht 
stimmt, bzw. zusätzlich einen Fehlercode an die Gegenstation senden.
Ein Fehlercode wäre dann das Steuerzeichen NAK (0x15) vielleicht auch 
gefolgt von einem Code 1...255 der sagt, welcher Fehler.

Der Vorteil ist einfach, dass man mit STX und ETX einen Datenrahmen hat, 
der sehr einfach auszuwerten ist. Und wenn man Programme wie HTerm 
einsetzt, dann kann man diese in der Phase der Entwicklung auch sehr gut 
von Hand erzeugen.

Gruß, Ulrich

Martin schrieb:
> Kann mir jemand noch helfen, ich komme einfach nicht weiter, wie ich so
> einen String auswerte.
> Ich denke das einfachste wird einfach sein, wie vorgeschlagen
> Variable=Wert, aber wie zerlege ich das und werte es aus?

zb
* mit strchr kannst du die Position des '=' suchen lassen.
  Alles davor ist dann Variablenname, alles dahinter ist Argument
* auch strtok ist brauchbar.
  mit strtok den '=' suchen lassen (falls es überhaupt einen gibt).
  Wenn es einen gibt, setzt strtok da gleich ein \0 an dieser Stelle
  ein, so dass der String auch hier gleich mal in 2 Teile (Teilstrings)
  unterteilt wird.

Hast du die Teile, dann kann man zb den Variablennamen in einer Tabelle 
suchen und je nachdem wie komplex das ganz ist, in dieser Tabelle zb 
einen Pointer auf die zu verändernde Variable haben. In der Tabelle 
könnte aber auch zb ein Funktionspointer mit dem Namen verknüpft werden. 
Oder .... Da gibt es jetzt viele Möglichkeiten.

Hi!

Na da liegst Du doch schon recht dicht dran. Ich hätte jetzt noch zwei 
Dinge gemacht:
1) Trennen was nicht zusammen gehört
2) Übersicht in den Empfänger

1)
Die Entschlüsselung des empfangenen Strings ist nicht Aufgabe des 
Empfängers, sondern des Kommando-Interpreters
Daher würde ich das Suchen und von Dingen zwischen STX und ETX einer 
Funktion überlassen, die nach Beendigung des Empfangs eines Telegramms 
aufgerufen wird.

2)
Warum sschreibst Du nicht eine kleine Statemachine?
Der erste State sucht nach einem STX, der zweite empfängt dann Daten bis 
ETX oder Puffer voll. Der Dritte zieht bei ETX die Prüfsumme und setzt 
das Flag zuer Weiterverarbeitung. Der Vierte wartet daruf, dass der 
String verarbeitet wurde und verwirft so lange weitere Daten. Der Fünfte 
behandelt die Fehler aus den anderen States...

Zudem machst Du viel mit Puffern, die alle irgendwie begrenzt und damit 
vor Überlauf gefährdet sind. Empfange doch erst einmal alles in einen 
Puffer, der mit einfachen Maßnahmen gegen Überläufe gesichert ist:
a) Du zählst mit und blockierst bei Puffer-Ende
b) Du benutzt Pointer und rpüfst diese auf Schreiben > Puffer-Ende
c) Du baust einen Ringbuffer und schreibst mit Zählern oder Pointern
Wenn der gaanze String dann im Puffer ist, dann suchst Du nur mit 
Pointern nach den Punkten, die Du verarbeiten willst, kopierst aber nie 
was um.
D.h. Du kannst mit *rx_start den String in deinem Puffer finden, der ist 
dann gleich identisch mit UartVariable. Dann setzt du einen weiteren 
Pointer *rx_var auf das Zeichen hinter = und hast UartWert. Das = 
ersetzt Du durch \0 und nun kannst Du per !strncmp( rx_start, 
Variable[i], strlen(Variable[i])) die Variable finden und dann per 
atoi(rx_var) den Wert umwandeln und verarbeiten.

Wenn es super schnell gehen muss, dann machst Du eben zwei Puffer, der 
eine wird, wie zuvor beschrieben, dekodiert, der andere steht zum 
Empfang bereit. Mit zwei Flags schaltest Du hin und her, bzw. blockierst 
einen noch nicht verarbeiteten Puffer.

Gruß uns frohes Fest
Ulrich