Es werden zwar Daten ausgelesen, aber irgendwie ist alles um 15 Bytes verschoben.
Also Normlerweise sehen die Daten so aus:

Counter,Data0,...,DataN, 0x0D0A
Counter,Data0,...,DataN, 0x0D0A
Counter,Data0,...,DataN, 0x0D0A
usw.
Alles ist 16bit Integer, Big Endian.

Was ich allerdings auslesen, sieht so aus:
15 Bytes irgendwas, 0x0D0A, Counter, 3 Bytes irgendwas

Wieso ist das alles irgendwie verschoben, hat vielleicht jemand einen Tipp?

Ich habe hier eine Software die die Daten aus dem seriellen Port auslesen und anzeigen kann. Da ist alles zu 100% richtig. Allerdings ist es nicht meine Software und sie ist in Delphi geschrieben (RealTerm: Serial Capture Program).

Ich bin mir sicher das der Counter und der Marker "0x0D0A" richtig ausgelesen werden. Aber bei den anderen Werten bin ich mir nicht sicher.

Edit: Es waren unsigned Werte, und ich bin mir jetzt fast sicher das es die richtigen sind. Aber wieso sind die Daten um 15 Bytes verschoben?

Code ist nichts besonders:

//...
{
    // framesize = Frame Number + Daten + \nl\cr
    const size_t framesize = (1 + 8 + 1) * 2;
    const size_t buffsize = framesize * count;
    char* buffer = calloc(buffsize, 1);
    read(portdata, buffer, buffsize, &read);

    int move = 0;
    short d;
    for ( i = 0; i < count; i++ )
    {
      size_t offset = move+framesize*i;
      memcpy(&d, buffer+offset, 2);
      datas[i].frame = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      datas[i].sensordatas[0] = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      datas[i].sensordatas[1] = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      datas[i].sensordatas[2] = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      datas[i].sensordatas[3] = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      datas[i].sensordatas[4] = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      datas[i].sensordatas[5] = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      datas[i].sensordatas[6] = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      datas[i].sensordatas[7] = htons(d);

      offset += 2;
      memcpy(&d, buffer+offset, 2);
      short marker = htons(d);
      printf("marker: %d\n", marker);

}

bool read(Portdata* portdata, void* data, size_t length, size_t* read)
{
    DWORD r;
    ReadFile(pdata->portHandle, data, length, &r, NULL);
    *read = r;

    return true;
}

Ich setzte folgende Werte:

fOutxCtsFlow = 0;                    // Disable CTS monitoring
        fOutxDsrFlow = 0;                    // Disable DSR monitoring
        fDtrControl = DTR_CONTROL_DISABLE;        // Disable DTR monitoring
        fOutX = 0;                            // Disable XON/XOFF for transmission
        fInX = 0;                            // Disable XON/XOFF for receiving
        fRtsControl = RTS_CONTROL_DISABLE;        // Disable RTS (Ready To Send)
    baudRate = 921600;
    parityon = FALSE;
    parity = NOPARITY;
    stopBits = ONESTOPBIT;
    byteSize = 8;

Ich hab das ganze unter Linux nochmal programmiert und dort werden die Werte alle richtig ausgelesen, da ist nichts verschoben oder so. Es wird immer zuerst der Counter, dann die Daten und dann 0x0D0A ausgelesen.

Die serielle Schnittstelle ist *nicht* trivial, deswegen verwende am besten eine fertige Klasse:
http://www.codeproject.com/system/serial.asp

Danke, werde mir anschauen. Es hat sich aber erledigt, weil die Daten doch alle richtig sind. Die 15 Bytes waren eine Art "echo" vom Geraet, also die Steuerzeichen die ich zuvor gesendet hatte wurden mir als Bestaetigung zurueckgesendet.