Steuerzeichen und 24-Bit Daten

[MadTulip (Gast)]

Moin.

Ich habe derzeit einen Stream von 24-Bit Daten(pro Quelle) von 4 Quellen 
über UART zu verschicken. Die Daten sind momentan derart aufgebaut:

<Quelle1><Quelle2><Quelle3><Quelle4><Quelle1>...      Bedeutung
XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX ...      Hexwert

Die Hexwerte (XX) können alle Werte von 00 bis FF annehmen.

Das Muster wiederhohlt sich n mal. Ich übertrage also z.b. 1000 
Messdaten hintereinander.

Das ganze will ich jetzt Fenstern in etwa so:

<STX><CMD><ID><Länge><Daten><ETX>

wobei die Messwerte in den Daten untergebracht werden sollen. Die Daten 
sollen die variable Anzahl von n Messwerten pro Quelle enthalten (wobei 
n dann aus <länge> hervorgeht.

Da es keinen Zustand eines einzelnen Bytes gibt welcher nie in den Daten 
vorkommt gibt es keine eindeutigen Steuerzeichen für STX und ETX. Ich 
möchte die Datenmenge möglichst gering, also den Overhead möglichst 
klein halten. Ich möchte auch möglichst keine aufwendige Operation auf 
den Daten ausführen bevor ich sie in das Datenpaket schreibe.

Was für eine von Veränderung der Daten bietet sich hier an, um Platz für 
eindeutige Steuerzeichen zu schaffen ?

[Pause (Gast)]

Wenn zwischen den Daten eine definierte Mindestzeit (z.B. 200ms) liegt, 
dann kannst du anhand der Pause doch den Anfang des neuen Paketes genau 
identifizieren. Somit kannst du auch den nachfolgenden Header mit Länge 
etc. auswerten.

[DirkB (Gast)]

aus 24-Bit 32-Bit machen.
Z.B: uuencode
Hinweise bei wikipedia.

[Karl H. (kbuchegg)]

MadTulip schrieb:

> Da es keinen Zustand eines einzelnen Bytes gibt welcher nie in den Daten
> vorkommt gibt es keine eindeutigen Steuerzeichen für STX und ETX.

Dann musst du dir 2 Bytewerte dafür freischaufeln. D.h. du musst dafür 
sorgen, dass diese nie in den tatsächlich übertragenen Daten vorkommen 
können.


> Was für eine von Veränderung der Daten bietet sich hier an, um Platz für
> eindeutige Steuerzeichen zu schaffen ?

Du suchst dir in den Daten 3 Bytewerte, die selten vorkommen.
Und diese beiden Werte 'escapest' du dann. Du stellst also dem Wert 
einen anderen Wert vorann, so dass der Empfänger erkennen kann, dass 
dieser Bytewert jetzt nicht so wie empfangen zu verwenden ist, sondern 
eine Sonderbedeutung hat.

C macht das zb so

gibst du 'n' aus, so wird auch 'n' aufs Ausgabegerät geschrieben. 
Escapest du aber das n, '\n' so bedeutet das n nicht mehr 'n' ausgeben, 
sondern Zeilenvorschub. Natürlich muss man dafür sorgen dass man \ immer 
noch ausgeben kann, dann muss man eben '\\' benutzen, welches für ein 
einzelnes \ steht.


Du könntest zb bei dir definieren:
Wenn das Byte 0xFF übertragen wird, dann ist das das Esacpe Byte, 
welches die Bedeutung des nächsten Bytes modifiziert. Das 0xFF alleine 
sagt also noch nichts über den Wert selber aus

  0xFF 0xFF       bedeutet für den Empfänger: ein einzelnes 0xFF wurde
                  übertragen
  0xFF 0xFE       bedeutet für den Empfänger: Das ist der Bytewert 0x03
  0xFF 0xFD       bedeutet für den Empfänger: Das ist der Bytewert 0x04


dmit hast du dir die Bytewerte 0x03 und 0x04 freigespielt. Sie können in 
den Daten selber nicht mehr vorkommen, bzw. wenn sie in den Daten 
vorkommen, werden sie nicht als 0x03 bzw 0x04 übertragen, sondern durch 
Ersatzsequenzen.
Und damit hast du dann 2 Bytewerte, nämlich 0x03 und 0x04, die du als 
STX bzw ETX benutzen kannst und die auch nur in dieser Bedeutung auf der 
Übertragungsstrecke vorkommen können.
Die entsprechenden Substituierungen kann man in der Verarbeitungskette 
sehr tief unten ansetzen, sodass sich darüber liegende Softwareschichten 
nicht darum kümmern müssen, für sie ist diese Datenübertragung 
transparent bzw nicht vorhanden: Die tiefe Schicht erkennt zuverlässig 
STX bzw ETX und meldet das auch und ansonsten muss sich die höhere 
Schicht um die Bytewerte selbst nicht kümmern. Sie übergibt ihre Daten 
einfach an die Sendefunktion und die kümmert sich um die Substitution so 
dass an der Gegenstelle aus der Empfangsfunktion wieder dieselben Daten 
rauskommen.