C++ Serialport Datenverlust

[Andre (Gast)]

Hallo zusamen,

ich stehe total auf dem Schlauch, ich versuche mit Visual Studio 2012 
C++ einen, oder auch mehrere, Com Ports zu lesen. Ich habe mir dazu nach 
bestem Wissen aus dem Internet etwas zusammen gesucht. Nur leider habe 
ich ganz komische Effekte:
Manchmal scheint es so als ob Readfile() dem Eingang sagt wo er die 
nächsten Daten hin schreiben soll, wenn ich durchsteppe dann steht das 
nächste Byte sofort im Eingangsbuffer, manchmal aber eben auch erst nach 
dem nächsten Readfile(). Und manchmal gehen einfach Bytes verloren.

Ich blicke das echt nicht. Kann das daran liegen dass der 
Entwicklungsrechner eine VM ist? Mit Putty zu Putty funktioniert es 
problemlos.

Der folgende Code läuft als Thread.

Danke schonmal worweg.

int Serial::StartComm(void)
{

  OVERLAPPED oEv,ovRd;
  char inbuff[INPUTBUFFERSIZE];
  int buffptr = 0;
  BOOL stillread = TRUE;
  BOOL rc = 0;
  int CommTimeoutCnt = 0;

  DWORD Err;
  DWORD EventMask;

  int i;

  oEv.hEvent = CreateEvent(
    NULL,   // default security attributes 
    TRUE,   // manual-reset event 
    FALSE,  // not signaled 
    NULL    // no name
    );
    
  // Initialize the rest of the OVERLAPPED structure to zero.
  oEv.Internal = 0;
  oEv.InternalHigh = 0;
  oEv.Offset = 0;
  oEv.OffsetHigh = 0;

  assert(oEv.hEvent);

  ovRd.hEvent = CreateEvent(
    NULL,   // default security attributes 
    FALSE,   // not manual-reset event 
    FALSE,  // not signaled 
    NULL    // no name
    );

  // Initialize the rest of the OVERLAPPED structure to zero.
  ovRd.Internal = 0;
  ovRd.InternalHigh = 0;
  ovRd.Offset = 0;
  ovRd.OffsetHigh = 0;

  assert(ovRd.hEvent);

  //Verwende folgendes Event: warte auf irgendein Char
  SetCommMask(hPort, EV_RXCHAR);
    
  while(1)
  {

    rc = ::WaitCommEvent(hPort, &EventMask, &oEv); 
  
    if (!rc) Err = ::GetLastError(); 
  
    // Gucken ob "pending", wenn ja auf Beendigung warten: 
    if (Err == ERROR_IO_PENDING) 
    { 
  
      CommTimeoutCnt = 0;
      while (1) 
       { 
          
        // Max. 100 msec auf den Event warten: 
        DWORD wait_result = ::WaitForSingleObject(oEv.hEvent, 100); 

        if (wait_result == WAIT_TIMEOUT) 
        { 
          // Timeout
          
          if((CommTimeoutCnt++) > (COMMTIMEOUT_SEK*10))
          {
            CommTimeoutCnt = 0;
            MeldeCommTimeout();
          }
        } 
        else if (wait_result == WAIT_OBJECT_0) 
        { 
          // Zeichen da 
          CommTimeoutCnt = 0;
          break; 
        } 
        else 
        { 
          // schwerer Fehler
          while(1); 
        } 
      } 
   
      DWORD bytes_transferred = 0; 
      rc = GetOverlappedResult(hPort, &oEv, &bytes_transferred, FALSE); 
  
      if (rc) Err = 0; 
      else Err = ::GetLastError(); 
  
      if ((Err == ERROR_IO_PENDING) || (Err == ERROR_IO_INCOMPLETE)) 
      { 
        // Schwerer Fehler 
        while(1);
      } 
  
    } 
     
    if (rc) 
    { 
      // WaitCommEvent war erfolgreich
      stillread = TRUE;

      while( stillread )
      {
        if(buffptr && inbuff[buffptr-1] == 0x0D)
        {
          //Jetzt kam ein LF
          if(strlen(inbuff) == 8)
          {
            //Datenlänge stimmt

            //Status lesen
            status = inbuff[0];

            //LF ersetzen
            inbuff[7] = 0;

            //Zahl ermitteln
            wert = atof(&inbuff[1]);

            //Signalisieren dass neue Daten da sind
            MeldeNeueWerte();            
          }
          else
          {
            MeldeDataError();
          }
          //inbuff löschen
          for(i=0;i<sizeof(inbuff);i++)
          {
            inbuff[i] = 0;
          }
          //Pointer zurück setzen
          buffptr = 0;
        }
        else if (buffptr > 8)
        {
          //inbuff löschen
          for(i=0;i<sizeof(inbuff);i++)
          {
            inbuff[i] = 0;
          }
          //Pointer zurück setzen
          buffptr = 0;
          MeldeDataError();
        }
        if(ReadFile(hPort,&inbuff[buffptr], 1, NULL, &ovRd))
        {
          //Schön, neue Daten wurden gelesen
          buffptr++;
        }
        else
        {
          //Kein Byte gelesen
          Err = GetLastError();
          stillread = FALSE;
        }
      }
    } 
    else 
    { 
      // WaitCommEvent war nicht erfolgreich, der Grund steht in "error"
      Err = GetLastError();
    }
  }
  return 1;
}

[Rufus Τ. F. (rufus)]

    rc = ::WaitCommEvent(hPort, &EventMask, &oEv); 
  
    if (!rc) Err = ::GetLastError(); 
  
    // Gucken ob "pending", wenn ja auf Beendigung warten: 
    if (Err == ERROR_IO_PENDING) 
    { 
  
      CommTimeoutCnt = 0;

Was geschieht hier, wenn rc gültig ist?

Genau: Deine komplette Fehlerbehandlungsroutine wird durchlaufen, wenn 
Err /zufälligerweise/ vom letzten Aufruf her noch den Wert 
ERROR_IO_PENDING enthält -- obwohl rc doch gültig war.

Da Du weiter unten auch den Fall auswertest, daß rc gültig ist, 
solltest Du dem if-Statement hier ein paar geschweifte Klammern 
spendieren, so daß die Bestimmung und Auswertung von Err nur erfolgt, 
wenn rc ungültig ist.

Danach kommt ein else anstelle der zweiten Auswertung von rc, und 
Dein Programm bekommt die Chance, sich anders zu verhalten.

Das abschließende else und der letzte Aufruf von GetLastError dürfte 
dann auch klar als Unfug erkennbar sein.

[Andre (Gast)]

Danke, ist natürlich klar.

Aber das Grundproblem liegt vermutlich woanders: ich hab jetzt erst 
verstanden was overlapped bedeutet.

Also habe ich das jetzt umgebaut. Muss man denn eigentlich auf einen 
neuen Char warten? Denn wenn ich ReadFile() aufrufe kann ich mit 
WaitForSingleObject ja auch darauf warten, oder spricht da was gegen?
Der folgende Code funzt jedenfalls:

//Overlapped 
int Serial::StartComm(void)
{

  OVERLAPPED ovRd;
  char inbuff[INPUTBUFFERSIZE];
  int buffptr = 0;
  int CommTimeoutCnt = 0;
  DWORD bytes_transferred = 0;
  DWORD wait_result = 0;

  DWORD Err;
  DWORD EventMask;

  int i = 0;

  ovRd.hEvent = CreateEvent(
    NULL,   // default security attributes 
    FALSE,   // not manual-reset event 
    FALSE,  // not signaled 
    NULL    // no name
    );

  // Initialize the rest of the OVERLAPPED structure to zero.
  ovRd.Internal = 0;
  ovRd.InternalHigh = 0;
  ovRd.Offset = 0;
  ovRd.OffsetHigh = 0;

  assert(ovRd.hEvent);

  //Verwende folgendes Event: warte auf irgendein Char
  SetCommMask(hPort, EV_RXCHAR);
    
  while(1)
  {

    while(ReadFile(hPort,&inbuff[buffptr++], 1, NULL, &ovRd))
    {
      //Schön, neue Daten wurden gelesen
      CheckBuffer(inbuff,&buffptr,sizeof(inbuff));
      //gleich nochmal
    }
    
    //Kein Byte gelesen
    Err = GetLastError();

    if (Err == ERROR_IO_PENDING)
    {
      //Warte auf ein Zeichen, denn der Port wird ja OVERLAPPED benutzt
      CommTimeoutCnt = 0;
      while (1) 
      {       
        // Max. 100 msec auf den Event warten: 
        wait_result = ::WaitForSingleObject(ovRd.hEvent, 100); 

        if (wait_result == WAIT_TIMEOUT) 
        { 
          // Timeout, noch kein Zeichen da      
          if((CommTimeoutCnt++) > (COMMTIMEOUT_SEK*10))
          {
            CommTimeoutCnt = 0;
            MeldeCommTimeout();
          }
        } 
        else if (wait_result == WAIT_OBJECT_0) 
        { 
          // Zeichen da     
          CommTimeoutCnt = 0;
          break; 
        } 
        else 
        { 
          // schwerer Fehler
          Err = GetLastError();
          while(1); 
        } 
      }

      //Jetzt kam vermutlich ein Zeichen
      //bytes_transferred ist undefined
      if(!(GetOverlappedResult(hPort, &ovRd, &bytes_transferred, FALSE)))
      {
        Err = ::GetLastError(); 
        if ((Err == ERROR_IO_PENDING) || (Err == ERROR_IO_INCOMPLETE)) 
        { 
          // Es kam wohl doch kein Zeichen, schwerer Fehler, da ein Zeichen da sein muss,
          // denn sonst wäre WaitForSingleObject ja nicht beendet worden
          while(1);
        }
      }
      else
      {
        //Juhu, das Zeichen kam wirklich
        CheckBuffer(inbuff,&buffptr,sizeof(inbuff));
        //Und wieder von vorn
      }
    }
    else
    {
      //ReadFile wurde nicht mit ERROR_IO_PENDING abgebrochen
      //Was soll das? Schwerer Fehler?
      while(1);
    }
  }
  return 1;
}