seriel-byte-stream parsen

[Ray M. (ray_m)]

hi @all,

ich habe gerade einige probleme mit dem parsen von daten die ich
von der serielen schnittstelle auf einem mikrocontroller lese

irgendwie bekomme ich die daten nicht richtig auseinander, eventuell
kann mir hier ja jemand einen tip geben ;)

die datenstruktur schaut so aus

1byte | 1byte | 4byte | 110byte | 1byte
 117  |  105  |  idx  |  daten  |  chk

das problem ist, dass die daten im data-feld nicht
an byte sondern an bits ausgerichtet sind

die ersten    8bit = wert 1
die nächsten 15bit = wert 2
die nächsten  7bit = wert 3
usw...


also hab ich mir mal folgende structs gemacht

struct DataSetBinary {
    unsigned int dataset_length:8;
    unsigned int dataset_code:8;
    unsigned int dataset_index:32;
    unsigned int wert1:8;
    unsigned int wert2:15;
    unsigned int wert3:7;
    ...
    unsigned int checksumme:8;
}

struct DataSet {
    unsigned int dataset_length;
    unsigned int dataset_code;
    unsigned int dataset_index;
    signed int wert1;
    float wert2;
    signed int wert3;
    ...
    unsigned int checksumme;
}

parsen versuche ich aktuell so

unsigned int fillBuffer  = 0;
unsigned int bufCounter  = 0;
unsigned int arrayLength = 117;

int main() {
    unsigned char inBuffer[arrayLength];

    while( Serial3.available > 0 ) {
        unsigned char byte1 = Serial3.read();

           if(fillBuffer == 0 && byte1 == 117) {
               int byte2 = Serial3.read();
               if(byte2 == 105) {
                   fillBuffer = 1;
                   inBuffer[0] = byte1;
                   bufCounter = 1;
                   byte1 = byte2; // damit unten weiter richtig befüllt wird
               }
           }
           if(fillBuffer) {
               inBuffer[bufCounter++] = byte1;

               if(bufCounter == arrayLength) {
                   // checksum test
                   // summe über alle bytes (inkl. der Checksumme selbst) sollte 0 ergeben?!
                   unsigned char checksum = 0;
                   for(unsigned int i = 0; i < arrayLength; ++i) {
                       checksum += inBuffer[i];
                   }   
                   //checksumme passt nicht
                   if(checksum != 0) {
                       // weiter nach einem Anfang suchen
                       bool startfound = false;
                       for(unsigned int i = 2; i < arrayLength-2; ++i) {
                           // potentieller Anfang gefunden
                           if(inBuffer[i] == 117 && inBuffer[i+1] == 105) {
                               // inBuffer rest an den Anfang von inBuffer kopieren
                               // geht mglw. auch mit memcpy() oder ähnlichem
                               unsigned int k = 0;
                               for(; k < arrayLength-i; k++) {
                                   inBuffer[k] = inBuffer[i+k];
                               }   
                               bufCounter = k; // weiter von Serial3 lesen, bis Buffer wieder voll, dann wieder checksum, etc.
                               startfound = true;
                               break;
                           }
                       }
                       if(!startfound) {
                           bufCounter = 0;
                       }
                   } else {
                       struct DataSetBinary* data = (struct DataSetBinary*)inBuffer;

                       Serial.println("Index: %d\n", data->dataset_index);
                       Serial.println("\twert1: %d\n", data->wert1);
                       Serial.println("\twert2: %f\n", data->wert2*0.00413);

                       fillBuffer = false;
                       bufCounter = 0;
                   }
               }
           }
       }
}

leider sind die ausgegeben werte def. falsch ;(

[Rufus Τ. F. (rufus)]

Ray M. schrieb:
> leider sind die ausgegeben werte def. falsch ;(

Prüfe mal die Größe Deiner Struktur "DataSetBinary".

Entspricht die genau der Menge der enthaltenen Bits (aufgerundet auf 
Bytegrenzen)?

Wenn nicht, ist Deine Struktur nicht "gepackt", d.h. zur 
Geschwindigkeitsoptimierung werden Lücken eingefügt.

Je nach Compiler wird das mit einem #pragma pack o.ä. eingestellt.

[Ray M. (ray_m)]

nein, leider nicht

die struktur mit den daten wird nur hinten mit 0 aufgefüllt um auf 
110byte zu kommen, wenn werte nicht gesetzt sind werden die mit 0 
angegeben ...

[Rufus Τ. F. (rufus)]

Ray M. schrieb:
> die struktur mit den daten wird nur hinten mit 0 aufgefüllt um auf
> 110byte zu kommen

Ich glaube nicht, daß Du verstanden hast, was ich meine.

[Karl H. (kbuchegg)]

Mein Tip: es ist nicht verboten, sich während der Entwiclungsphase im 
Code mittels eingestreuten printf einen Überblick zu verschaffen, was da 
eigentlich passiert und mit welchen Werten gearbeitet wird.
Wenn dir nicht klar ist, wie ein bestimmtes Endergebnis zustande kommt, 
dann musst du dir eben dieses Wissen verschaffen. Zum Beispiel, indem 
man im Code zusätzliche printf einfügt, die einem dieses Wissen 
verschaffen.

Zum Beispiel ist interessant, welche Werte über die Serielle 
Schnittstelle reinkommen. Also geb ich mir die Bytes, so wie sie 
reinkommen aus.
Zum Beispiel möchte ich gerne wissen, ob die Synchronisierung auf den 
Anfang der Nachricht geklappt hat. Auch das gebe ich mir mittels printf 
aus. Wenn es einen Checksum Error gegeben hat (was eigentlich nicht 
vorkommen sollte), dann möchte ich das wissen und ich gebe mir auch hier 
eine entsprechende Meldung aus, zusammen mit der Information wo im 
Buffer die Startsequenz erneut angetroffen wurde. Zudem wird es eine 
gute Idee sein, wenn ich mir am Anfang der Auswertung mal alle 
empfangenen und gesammelten Bytes in einem Rutsch ausgebe, damit ich sie 
mir aus dem Protokoll nicht mühsam zusammensuchen muss um sie mal 
händisch den Bits zuzuordnen.


> leider sind die ausgegeben werte def. falsch ;(
lass dir mal die sizeof(DataSetBinary ) ausgeben. Die sollte eigentlich 
deiner Array-Length entsprechen. Je nachdem, ob dein Compiler Padding 
bytes eingefügt hat oder nicht, kann die aber auch unterschiedlich sein.

[Ray M. (ray_m)]

danke für eure gut gemeinten ratschläge, aber
das man printf reinschreiben kann und sich die größen der
daten anschauen kann, hab ich auch schon raus gefunden ;)

spaß bei seite, das problem ist eigentlich einfach, man(n)/frau muss
nur drauf kommen:

  padding ist das schlagwort ...

schreibt man(n)/frau

  #pragma pack(push,1)
  struct DataSetBinary {
    unsigned int dataset_length:8;
    unsigned int dataset_code:8;
    unsigned int dataset_index:32;
    unsigned int wert1:8;
    unsigned int wert2:15;
    unsigned int wert3:7;
    ...
    unsigned int checksumme:8;
  };
  #pragma pack(pop)

oder

  /* #pragma pack(1) */
  struct DataSetBinary {
    unsigned int dataset_length:8;
    unsigned int dataset_code:8;
    unsigned int dataset_index:32;
    unsigned int wert1:8;
    unsigned int wert2:15;
    unsigned int wert3:7;
    ...
    unsigned int checksumme:8;
  } _attribute_ ((packed));

macht der gcc auch genau das was man(n)/frau erwartet ...