Serielle Kommunikation / Protokoll mit Hochsprache

[Schlank und Schlau (Gast)]

Hallo,

wie lässt sich eine serielle Kommunikation elegant in einer Hochsprache 
umsetzen?

Problem:

> PC sendet einen Befehl
< Gerät antwortet dem Befehl entsprechend

Sowohl der Befehl als auch die Antwort unterscheiden sich in ihrem 
Format, teilweise ist die Antwort paketweise und muss vom PC bestätigt 
werden.

Drumherum braucht man natürlich Funktionen zum Ansprechen der 
Schnittstelle, Fehlerbehandlung, Herstellen/Prüfen der Verbindung zum 
Gerät, etc. die dann ggf. auch von höheren Funktionen benutzt werden.

Wie baut man so ein Programm auf? Einen Haufen Prozeduren/Funktionen 
bekommt man bei einem bottom-up Ansatz, hat dann aber am Ende teilweise 
ziemlich spezialisierten Code (jeder Gerätebefehl bekommt eine eigene 
Funktion, die dann aber teilweise redundaten Code enthält).

Sollte man eine allgemeine Funktion Befehl() bauen, wo aus einer Liste 
ein Handler für den Befehl ausgewählt wird?

Bringt ein objektorientierter Ansatz evtl. etwas?
Und wozu gehört dann die serielle Schnittstelle vom PC (gehört das 
Öffnen der Schnittstelle zum Geräte-Objekt, oder habe ich ein Objekt der 
lokalen seriellen Schnittstelle - und wie verbindet man sowas?)?

Aber selbst wenn das als Objekt gekapselt wird, vielleicht so in der 
Art:

Geraet = Device.new()
Geraet.supported_baudrates = (9600,56700)
..
antwort = Geraet.befehl("CMD param")

muss die Antwort unterschiedlich behandelt werden.
Wie geht so was allgemein?

[Markus Volz (Gast)]

Schau mal hier: http://de.wikipedia.org/wiki/OSI-Modell
Das OSI-Modell beschreibt verschieden Ebenen der Abstraktion (Layers) 
mit deren Hilfe Du dich bei der Implementierung eines Protokolls nicht 
so leicht verhedderst.

[aha (Gast)]

Nein, Objekte bringen nichs. Betrachte die Schnittstelle als Resource, 
und der Zugriff darauf muss gemanagt werden. Dh nur einer aufs Mal. 
Allenfalls muss ein Command-Antwort Paar als ansatz genommen werden, 
sodass ein Thread das auch so durchfuehrt. Ev Retries.

[Blackbird (Gast)]

Erst mal sollten die Begriffe eindeutig sein. In Anlehnung an das 
OSI-Modell (ja das kann man bei einer seriellen Kommunikation zugrunde 
legen) sind Nachrichten zwischen den Kommunikationspartnern "Messages" 
und Nachrichten zwischen den einzelnen Instanzen bei einem 
Kommunikationspartner "Primitives".
D.h., ein Timeraufruf ist ein Primitiv, die Antwort des Timers auch, 
auch so der einer untergeordneten Schicht (Layer).

Die Messages sind "paarweise" so aufgeteilt:

Von einem Master oder dem Initiator einer "Session" wird ein REQUEST 
gesendet und mit einer CONFIRMATION vom Slave beantwortet. Der Slave 
kann seinerseits mit einer INDICATION sich melden und bekommt vom Master 
als Antwort ein RESPONSE.

So läuft das zwischen den Kommunikationspartnern. Die Verarbeitung der 
Messages bei jedem erfolgt in mehreren Schichten (siehe OSI-Modell). Die 
niederste (die Transportschicht), kümmert sich nur um die 
übertragungstechnische Gestaltung; in der Regel also das Hinzufügen von 
Start- und Stoppbits oder die richtige Kodierung.
Die darüberliegende Schicht übernimmt die Sicherungsfunktion z.B. in 
Form von CRC, HEC oder dergleichen.
Und die (nur hier vereinfacht dargestellte) Application Layer 
beschäftigt sich mit dem Inhalt der Messages.

Was jede Message noch haben sollte: eine eineindeutige Nummer, auf die 
die Antwort Bezug nimmt (und auf die der Sender auch wartet).

Es lohnt sich, das Ganze grafisch darzulegen, damit man den Überblick 
bekommt (und auch behält).

Blackbird

[Eugen W. (ewiebe1)]

Es müsste sowas wie folgender Protokollaufbau sein: (jedes 1-2 byte 
groß)
MSG_ID | SenderAddr | RecAddr | DataLen | DATA ... DATA | CRC(XOR or 16)

Kennt jemand eine Implementierung davon in C ?
Wo?

Danke.

[... (Gast)]

Deswegen einen 3 Jahre alten Thread neu oeffnen ? Haemmer das Zeug doch 
einfach rein. Ist doch nicht so schwierig.