www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Befehle aus mehreren ASCII- Zeichen generieren?


Autor: Nop M. (gtf)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo sehr geehrte Community.
Ich stehe momentan vor einem Problem für das ich keine optimale Lösung 
habe,
die Suchanfrage hat auch nichts Sinnvolles rausgespuckt :-)
Und zwar habe ich einen Mega 16 so programmiert, dass er ASCII- Zeichen 
über RS232 empfängt und diese in einen 256 Byte Buffer ablegt. Übrigens 
alles in ASM.
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Gewünschte Funktion:
Drei auf einander folgende Zeichen sollten als Befehl interpretiert 
werden. Das ist auch schon das hauptsächliche Problem.
Als Beispiel bestehen diese Befehle nur aus Zahlen und somit währen 999 
Befehle möglich. Für meine Anwendung reichen auch 100 Befehle.
Zu jeden dieser Befehle möchte ich eine Anwendung aufrufen und etwas 
ausführen.
Nur wie soll das gehen?

Bitte um Hilfe !!

Autor: Matthias (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn das nicht zwingend ASCII sein muss, dann bastel Dir eine "Wrapper 
Struktur" drum herum.

Beispiel:
Befehl:    L (z.B: LED)
Parameter: 01 oder 00 (für An und Aus)

Jetzt verpacken wir das mit Synczeichen und Endezeichen:
Sync: 0x16
Ende: 0x04

Jetzt braucht man nur noch einen Zustandsautomaten, der sich auf das 
Sync-Zeichen synchronisiert und nach dem Endezeichen den String an einen
Auswerter übergibt.

Alternativ kann man sich allerdings auch das Ganze etwas anders 
aufbauen, wenn keine "Maschine" die Kommandos sendet. So dass alles 
ASCII ist und
immer bei CR am Ende der Uaswerter angeworfen wird.

Autor: Matthias (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hoppla:

Das mit dem Verpacken ist noch nicht vollständig:

"SYN L 0 1 END" oder HEX: "0x16 0x4C 0x30 0x30 0x04"

Autor: Wegstaben Verbuchsler (wegstabenverbuchsler)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
wie weit bist du denn schon in deinen Überlegungen gekommen?

nach meinem Verständniss hast du folgende Teilthemen:

1. aus dem ankommenden Datenstrom "die richtigen" 3 Zeichen 
rauszufischen

2. bei ankommenden Steuerbefehlen eine bestimmte Subroutine aufrufen 
(ggf. Errorhandler)


Zu 1.
Das kannst nur du alleine wissen was du hast oder brauchst. 
Möglicherweise hast du Einfluss auf beide Seiten (Sender und Empfänger), 
dann wäre es möglich ein gewisses Minimal-Protokoll zu implementieren. 
Vielleicht ist ja aber auch das Sendeprotokoll  vorgegeben (das macht 
die Sache eventuell leichter)

:: woran erkennst du, welche 3 Zeichen zusammen gehören? Wenn z.B. im 
Datenstrom ankommt: "123 4 56"

- ist es dann 123 (weil dazwischen eine Pause ist zum nächsten Zeichen)
- oder 23 4 (weil deine Steuerkommandos immer mit 2xx anfangen)
- oder 3 4 5 (weil zwischen den einzelnen Ziffern deinen Steuerkommandos 
immer eine gewisse Pause sein muß)
- oder .... oder

(Zweckmäßigerweise könntest du Steuerbefehle mit einem bestimmten 
"Zauberwort" einleiten, so wie die Modems z.B. auf "AT" reagieren

:: was machst du mit den restlichen Zeichen (eventuell Müll) der da 
eingetroffen ist?

:: Was machst du wenn der Eingangspuffer deiner Befehlssequenzen voll 
ist (weil deine Subroutinen etwas länger brauchen)? Verwirfst du alle 
ankommenden weiteren Steuerzeichen bis wieder "Luft" ist, oder 
verwendest du eine Art Handshake, um den Sender zu signalisieren, daß er 
erst mal aufhören soll?

zu 2:
Da die Anzahl deiner Steuerzeichen gering ist, kannst du das über 
Sprungtabelle realisieren. Nachdem du erkannt hast daß PQ3 ein gültiger 
Steuerbefehl ist, wird dieser "übersetzt" zu "nutze Sprungvektor 9". Und 
von da aus hüpfst du los.

> für das ich keine optimale Lösung habe

Die Optimum-Kriterien solltes du vorher festlegen (Geschwindigkeit, 
Platzbedarf, Eleganz des Codes, ...)

Autor: Ralf (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Drei auf einander folgende Zeichen sollten als Befehl interpretiert
> werden. Das ist auch schon das hauptsächliche Problem.
> Als Beispiel bestehen diese Befehle nur aus Zahlen und somit währen 999
> Befehle möglich. Für meine Anwendung reichen auch 100 Befehle.
> Zu jeden dieser Befehle möchte ich eine Anwendung aufrufen und etwas
> ausführen.
Wenn du 000 mitzählst, sind es 1000 Befehle. Du legst eine 2-Byte 
Variable an. Der Befehl wird ermittelt, indem du aus der ASCII-Zahl den 
numerischen Wert bildest, also erstmal 0x30 davon abziehst, und 
entsprechend der Stelle mit 100, 10 oder 1 multplizierst. Das ergibt 
dann den kompletten numerischen Wert des Befehls, welcher in der 2-Byte 
Variablen abgelegt wird. Zum Schluss über einen Vergleich herausfinden, 
um welchen Befehl es sich handelt, und entsprechend reagieren.

Ralf

Autor: Route_66 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo erstmal!
Ich kann auch nicht genau erkennen, womit deine Frage jetzt "auf den 
Punkt" zu beantworten wäre...
Wichtig ist: (was auch von den Vorrednern ausgeführt wurde) es muß eine 
eindeutige Trennung von Befehl und Parameter geben. Dies ist gerade auch 
im Hinblick auf Störungen im Übertragungskanal wichtig.
Oft wird dafür ein Startzeichen oder eine -sequenz benutzt, die sonst im 
Datenstrom nicht vorkommt. Intel-Hex nutzt dafür den Doppelpunkt [:]

Wenn also das Startzeichen / die Startsequenz erkannt wurde liest man 
entweder eine vorgegebene feste Anzahl an Zeichen (hier evtl. 3) oder 
bis zu einem erwarteten Trennzeichen (z.B. 'Space',20h).

Wenn dann der Befehl isoliert ist, könnte man ihn für Befehlsnummern von 
1...255 in HEX wandeln. dann kann man aus einer Tabelle die Zieladresse 
für die weitere Verarbeitung ablesen.


Das Byte 00 bietet sich als Endemarke füer die Tabelle an.
 z.B. so:

BEFTAB:
   .DEFB 1     ;Befehl "001"
   .DEFW prog1 ;wird hier ausgeführt
   .DEFB 3     ;Befehl "003"
   .DEFW prog7 ;hier
   .DEFB 11    ; usw.
   .DEFW prog23
   .DEFB 55
   .DEFW prog4
   .DEFB 178
   .DEFW prog37
   .DEFB 0     ;hier ist Schluss, wenn Befehl jetzt noch nicht gefunden,
dann Fehlerroutine.

Für allgemeine Methoden der Befehlsentschlüsselung mit variabler 
Befehlslänge und/oder -struktur (Buchstaben  Zeichen  Ziffern / 
Unterscheidung Groß-Kleinschreibung usw.) heißt das Zauberwort "Parser" 
oder auch Befehlsdekoder. So nennt sich das bei allen 
Programmiersprachen, Compilern, Assemblern oder wo sowas eingesetz wird.

Autor: rene (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert

Autor: Nop M. (gtf)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Guten Tag die Herren.

@Wegstaben Verbuchsler
sorry ich hätte die ganze Angelegenheit etwas Präziser umschreiben 
sollen,
und zwar ist es so das, dass Protokoll mein eigenes Hirngespenst ist :-)
 Das ganze sieht dann mal so aus:

Startkondition
Befehl bestehend aus 3 ASCII Zeichen
Daten variabler Länge
CRC (noch nicht implementiert)
Stoppkondition

Gegen überlauf ist das Ganze auch geschützt.


@Route_66
Eine eindeutige Trennung von Befehl und Parameter ist vorhanden(siehe 
Protokollaufbau oben).
Insofern ich deine Idee verstanden habe, empfiehlst du mir
die Empfangenen ASCII- Zeichen  in eine HEX- zu Wandeln. Das sollte kein 
Problem sein, da ich die Daten ständig für Docklight(Terminalprogramm) 
und andersrum aufbereiten muss.
Doch das mit der Tabelle ist mir nicht ganz klar. Ich kenne nur die 
Mehrfachverzweigung aus’m AVR- Tutorial oder die simpelste Art. Cpi, 
Breq : -)
Könntest du mir bitte deine Version anhand von einem Beispiel etwas 
genauer schildern. Währe echt super.
Das Zauberwort like Parser ist mir in der Tat nicht bekannt, doch mit 
Befehlsdecoder hab ich’s bereits probiert , ohne Erfolg weil 
Befehlsdecoder oft mit CPU- Befehlen in Verbindung gebraucht werden.

@Rene
THX für den Link

Autor: spess53 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi

>Als Beispiel bestehen diese Befehle nur aus Zahlen und somit währen 999
>Befehle möglich.

Wenn du deine 'Adresse' Hexadezimal auslegst hättest du sogar 4096 
mögliche Befehle. Für deine 100 würden zwei Stellen genügen. Die 
Auswertung würde sich dadurch auch vereinfachen. Du müsstest nur die 
ASCII-Ziffer in einen Hexwert umwandeln. Dann legst du dir eine Tabelle 
mit Sprüngen zu den entsprechenden Routinen an. Z mit dem Anfang der 
Tabelle laden und zu Z den doppelten Hexwert addieren. Mit 'icall' wird 
deine Routine aufgerufen. Geht ganz ohne Parsen.

MfG Spess

Autor: Olaf (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> die Suchanfrage hat auch nichts Sinnvolles rausgespuckt :-)

Sowas heisst Parser oder lexical analyzer.

Weil so ein Problem sehr haeufig vorkommt gibt es tools (z.B flex) die 
soetwas automatisch machen. Du beschreibst dort also deine Sprache und 
das Tools erzeugt dir einen C-Source.
Unter Linux sollte dir 'man flex' weiterhelfen.

Olaf

Autor: Christian Berger (casandro) Flattr this
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Du bräuchtest einen Parser. Am einfachsten schreibst Du den erst einmal 
in Prolog und überlegst Dir dann, wie Du den in Assembler 
implementierst. Das Buch "Programming in Prolog" hat da eine schönes 
Kapitel zum Thema parsen, welches auch für Programmierer anderer 
Sprachen interessant ist.

Autor: gtf (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@spess53
ne hexadezimal passt nicht! so müsste ich ASCII und HEX mischen und das 
kann nicht gut gehen ich bleibe lieber bei ASCII, weil auch schon alle 
Routinen mit PAP und Doku belegt sind.
Es ist mir schon klar, dass durch ASCII ein Mehraufwand betrieben wird, 
aber so kann ich mit Zeichen  „STX“, „EOT“ Handshakes ersetzten, da das 
ganze über RS232 läuft.


Schlussendlich werden jetzt 3 ASCII Zeichen, deren Gesamtwert nicht 255 
überschreiten darf
nach HEX gewandelt. Somit steht mir eine 8-Bit Zahl im Bereich von 0-255 
zur Verfügung,
dieser Wert wird in die Mehrfachverzweigung 
http://www.mikrocontroller.net/articles/AVR-Tutori... 
geladen und anschließend durch die Tabelle zu Routinen umgeleitet.

Vielen dank für die zahlreichen guten Tipps. Ihr habt mir dazu verholfen 
mein Projekt einen Schritt weiter zu bringen.

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//XX  Ich wünsch euch allen noch ein Frohes Weihnachtsfest    XX
//XX         und einen guten rutsch ins neue Jahr!              XX
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.