ReadFile WriteFile an serielle Schnittstelle

[Zoran St. (Gast)]

Hallo!

Nach stundenlangen Tests mal hier die Anfrage bei euch:
Ich habe auf Basis der LUFA Library und einem USB-AVR eine Firmware mit 
zwei virtuellen Schnittstellen erstellt.
eine dient der Kommunikation zw. AVR und PC.

Jetzt habe ich das Problem, dass meine Applikation nicht funktioniert 
und ich weiß gerade nicht weiter:
Ich verwende die WinAPI um über die serielle mit dem Gerät zu 
kommunizieren.
Mittlerweile bin ich der Meinung, dass das Problem beim Windows eigenen 
USB-seriell Treiber oder im FileRead bzw. FileWrite liegt.

Zum Programmablauf:
Es werden mehrere Byte (zw. 2 und 20) an das Gerät geschickt und danach 
1 Byte zurückgelesen.

Hier ein "Code-Schnippel":
// create file not overlapped
        flasher_port = CreateFile(strcat(buf, jtag_port), GENERIC_READ 
|GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

        ....
        // write some bytes --> 2 .... 16 bytes
        if (!WriteFile(flasher_port, usb_cache, 2 + usb_cache_cnt + 3 / 
4, &written, NULL)) {
            fprintf(stderr, "Sending BLOCK_DATA error!\n");
            exit(1);
        }
        // read 1 byte
        if (!ReadFile(flasher_port, recbuf, sizeof (unsigned char), 
&read, NULL)) {
            fprintf(stderr, "Can't receive BLOCK_DATA response!\n");
            exit(1);
        }

Jetzt kann es passieren, dass ReadFile keinen Fehler zurückmeldet, aber 
statt 1 Byte (sizeof (unsigned char)) leider 0 in die read Variable 
schreibt. Das ganze natürlich obwohl das Gerät geantwortet hat, d.h. 
dieses Byte übertragen hat.
Dadurch stürzt mein Programm in weiterer Folge ab.
Ich habe nun eine Zeile eingefügt in der das Programm bevor es weiter 
macht überprüft, ob eh ein Byte gelesen wurde und falls nicht dann noch 
ein Mal liest.
So funktioniert dieser Teil des Programmes dann.

Leider aber gibt es da noch einen Fehler beim Schreiben, d.h. manchmal 
ist der Returnwert von WriteFile 0 und das Programm beendet wieder.

Dieses Problem habe ich nur mit einem Rechner wirklich extrem (i5 CPU). 
Bei einem anderen, langsameren Rechner (Core2Duo) passiert das nicht. 
Beide sind XP-SP3 rechner mit gleichem Softwarestand.
Jemand eine Idee?
Kann es an irgendwelchen Buffern liegen? Oder hat jemand einen debug 
Ansatz?

Danke im Vorhinein.

[Peter II (Gast)]

Ich habe zwar in der Doku auf die schnelle nichts gefunden, aber ich 
kann es sein das bei einem timeout dieses Verhalten auftritt?

[Rufus Τ. F. (rufus)]

Zoran St. schrieb:
> if (!WriteFile(flasher_port, usb_cache, 2 + usb_cache_cnt + 3 /
> 4, &written, NULL))

Das macht ziemlich sicher nicht das, was Du willst. Die Anzahl der zu 
schreibenden Bytes dürfte deutlich größer sein als das, was Du 
erwartest.

Sieh Dir den Ausdruck

  2 + usb_cache_cnt + 3 / 4

mal genau an.

Was wird durch 4 geteilt?

[Zoran St. (Gast)]

Hallo!
Danke f.d. schnellen Antworten.
Zuerst : ja, es sollte 2 + (usb_cache_cnt + 3) / 4 heißen und
Ja, es ist die Timeout Ausgabe von Readfile.
Sorry, das hatte ich mittlerweile vergessen. Wenn ich das Timeout 
deaktiviere, dann bleibt die SW stehen. Mit dem Timeout konnte ich 
wenigstens Readfile noch ein Mal ausführen.
Es scheint so als ob windows nicht mitkriegt, dass das Byte schon da 
ist.

Den Errorcode von Writefile muss ich noch ermitteln.

Danke,
Zoran

[W.S. (Gast)]

Zoran St. schrieb:
> Hier ein "Code-Schnippel":

Ja, sieht grausig aus.

Hier ein Schnippel von mir, bei dem weiß ich wenigstens, daß er 
funktioniert:

{ Write a string out the COM port, return true if all chars written }
function TComPort.Write (const sData: String): DWORD;
var
  dwCharsWritten: DWORD;
  i: longint;
begin
  dwCharsWritten := 0;
  Result := 0;
  if hPort <> INVALID_HANDLE_VALUE
  then
  begin
    WriteFile(hPort, PChar(sData)^, Length(sData), dwCharsWritten, nil);
    result:= dwCharsWritten;
  end;
end;

bemerke bitte, daß mich der Rückgabewert von WriteFile nicht 
interessiert, sondern die Sache über dwCharsWritten geregelt wird.

{ Return the number of bytes waiting in the queue }
function TComPort.GetInCount: LongInt;
var
  statPort: TCOMSTAT;
  dwErrorCode: DWord;
  i: LongInt;
begin
  i := 0;
  if hPort <> INVALID_HANDLE_VALUE
  then begin
         ClearCommError(hPort, dwErrorCode, @statPort);
         i:= statPort.cbInQue;
       end;
  if inPtr > outPtr
  then begin
         i:= i + inPtr - outPtr;
       end;
  Result:= i;
end;


function TComPort.Read: Char;
var
  Ch_Cnt,
  Ch_Read: DWord;
begin
  Result := #0;
  if inPtr > outPtr          { Puffer ist nicht leer, also daraus lesen 
}
  then begin
         Result:= RxBuff[outPtr];
   inc(outPtr);
         exit;
       end;
  { Puffer ist leer, also Windows bemühen... }
  if hPort = INVALID_HANDLE_VALUE then exit;
  Ch_Cnt:= GetInCount;
  if Ch_Cnt=0 then exit;    { wenn nix vorhanden, Ende }
  if Ch_Cnt > buffermax then Ch_Cnt:= buffermax;

  ReadFile(hPort, RxBuff, Ch_Cnt, Ch_Read, nil);
  inPtr:= Ch_read;
  outPtr:= 0;
  if inPtr > 0
  then begin
         Result:= RxBuff[0];
         outPtr:= 1;
       end;
end;

Und hier wird der Stream programmintern gepuffert und wieder über die 
Anzahl gelesener Zeichen die Sache geregelt.

W.S.

[Rufus Τ. F. (rufus)]

Ob unkommentierter Delphi-Code jemandem hilft, der in C programmieren 
möchte?

[Purzel H. (hacky)]

Das Comport ist bei Windows leider vermurkst. Die Ideen einem 
Characterdevice das Verhalten eines Block- oder Stream-devices 
ueberzustuelpen ist derart absurd von Beginn weg. Am Sinnvollsten nimmt 
man eine Library, die zur Sprache passt und das schoen versteckt.

[Programmierer (Gast)]

Rufus Τ. Firefly schrieb:
> Ob unkommentierter Delphi-Code jemandem hilft, der in C programmieren
> möchte?
Dann soll er "begin/end" durch "{}" ersetzen, den Code als symbolische 
Programmiersprache akzeptieren und das Ding zwischen den Ohren 
aktivieren.

[Peter II (Gast)]

Zweieinhalb Oschi schrieb:
> Das Comport ist bei Windows leider vermurkst. Die Ideen einem
> Characterdevice das Verhalten eines Block- oder Stream-devices
> ueberzustuelpen ist derart absurd von Beginn weg. Am Sinnvollsten nimmt
> man eine Library, die zur Sprache passt und das schoen versteckt.

versteht nicht wo dein Problem ist. Wo wird dann etwas von BLock und 
Characterdevice device gemixt? Es gibt eine Read und eine Write funktion 
und die arbeiten so wie man es erwartet. Wenn es ein Blockdevice ist 
könnte man ja mit Seek arbeiten was aber nicht geht.

[Zoran S. (zoran_s)]

Hallo Allerseids!

Danke für die Info, dass das delphi code ist. Damit hatte ich noch 
nichts zu tun. Leider verstehe ich deshalb auch nicht viel davon, aber 
versuchen wir es mal:
Eigentlich scheint sich dein Programm nur darin zu unterscheiden, dass
dich die Return Werte von Read- und Writefile nicht interessieren -> ich 
breche danach ab.
Wieso (bzw. wann) wird ClearCommError aufgeführt?
Mich würden auch die Einstellungen der COM Schnittstelle interessieren 
(Timeouts, DCB). Vielleicht ist dort der Hund drin.

Ich habe schon einiges versucht:
wenn BytesRead != BytesToRead dann wiederhole ich ReadFile bis zu 10 
Mal.
Meistens funktioniert es wenn ich einmalig wiederhole, dann liest das 
Programm den empfangenen Wert auch aus.
Hier die beiden Funktionen die mir die Sorgen bereiten:

void flush_serial_cache(void) {
  int i;
  if (serial_cache_cnt) {
    countit++;
    //Send the cache via SERIAL but update the cache header before
    serial_cache[0] = BLOCK_DATA | (serial_cache_cnt >> 8 & 0xf);
    serial_cache[1] = serial_cache_cnt;
    // the cached data is sent without '\n' a.k.a raw !!!
    DWORD readed, written;
    // send cache to the device
    if (!WriteFile(flasher_port, serial_cache, 2 + (serial_cache_cnt + 3) / 4, &written, NULL))
      fprintf(stderr, "Sending BLOCK_DATA error!\n"), exit(1);

    if (written != 2 + (serial_cache_cnt + 3) / 4) {
      fprintf(stderr, "Sending BLOCK_DATA error %d instead of %d\n", written, 2 + (serial_cache_cnt + 3) / 4); 
      exit(1);
    }

    // clear receivebuffer before reading new data to make sure to read new received data
    memset(recbuf, 0, sizeof (recbuf));

    // Read 1 byte of data 
    if (!ReadFile(flasher_port, recbuf, sizeof (unsigned char), &readed, NULL)) {
      fprintf(stderr, "Can't receive BLOCK_DATA response!\n");
      exit(1);
    }
    else {  // check readed bytes value, if not as expected retry ReadFile max. 10 times
      register unsigned char ntimes = 0;
      while (readed != sizeof (unsigned char) && ntimes++<MAX_READ_RETRIES)
        fprintf(stderr, "%hhd %s() read-retries: %d\n", ntimes, __FUNCTION__, readed),
        memset(recbuf, 0, sizeof (recbuf)),
        ReadFile(flasher_port, recbuf, sizeof (unsigned char), &readed, NULL);
    }

    if (*recbuf != BLOCK_DATA) {
      fprintf(stderr, "Incorrect BLOCK_DATA response at %d: %x (%x)\n", countit, *recbuf, BLOCK_DATA);
      exit(1);
    }

    serial_cache_cnt = 0;
  }
}

int single_data_with_read(register int tms_tdi) {
  int res;
  unsigned char single_with_read[] = {SINGLE_DATA_WITH_READ | (tms_tdi & 3), '\n'};
  
  if (!WriteFile(flasher_port, single_with_read, sizeof (single_with_read), (DWORD *) & res, NULL))
    fprintf(stderr, "Can't write!\n"), exit(1);
    
  if (res != sizeof (single_with_read)) {
    fprintf(stderr, "Send SINGLE_DATA_WITH_READ error %d instead of %d\n", res, sizeof (single_with_read));
    exit(1);
  }
  
  memset(recbuf, 0, sizeof (recbuf));
  
  if (!ReadFile(flasher_port, recbuf, sizeof (unsigned char), (DWORD *) & res, NULL))
    res = -1;

  if (res < 0) {
    fprintf(stderr, "Can't receive SINGLE_DATA_WITH_READ response!\n");
    exit(1);
  }

  register unsigned char ntimes = 0;
  while (res != sizeof (unsigned char) && ntimes++<MAX_READ_RETRIES) {
    fprintf(stderr, "%hhd %s() read-retries: %d\n", ntimes, __FUNCTION__, res);
    memset(recbuf, 0, sizeof (recbuf));
    // Read 1 byte of data 
    ReadFile(flasher_port, recbuf, sizeof (unsigned char), (DWORD *) & res, NULL);
    }

  if ((recbuf[0] & 0xfc) != SINGLE_DATA_WITH_READ) {
    fprintf(stderr, "Incorrect SINGLE_DATA_WITH_READ response! %x instead of %x\n", *recbuf, SINGLE_DATA_WITH_READ);
    exit(1);
  } else if (verbose) 
    fprintf(stdout, ">> \t%x\n", *recbuf & 3);

  return recbuf[0] & 1;
}

Ich poste noch die Ausgaben von der Konsole ...

Eine andere Frage/ Idee hätte ich noch:
Wenn ich eine dll daraus mache, dann könnte ich das Programm über die 
GUI laufen lassen. Es soll nämlich das Programm von einer JAVA GUI 
aufgerufen werden.
Ich habe die Serielle in JAVA so weit im Griff. wenn ich also statt über 
ReadFile und WriteFile einen anderen Weg hätte die Daten hin und her zu 
schaufeln,
dann könnte ich mal versuchen ob es dann funktioniert.
Hat jemand vielleicht einen Vorschlag, bzw. besser ein Beispiel dafür? 
Pipes, Queues, o.ä.?

Danke,

Zoran

[Peter II (Gast)]

Zoran S. schrieb:
> Ich habe schon einiges versucht:
> wenn BytesRead != BytesToRead dann wiederhole ich ReadFile bis zu 10

das ist unsinn, entweder geht es beim ersten mal oder die verwendest zu 
kurze timeouts. Arbeite doch erstmal ohne Timeouts (das sollte das 
default sein). Dann blockiert das Read bis etwas gelesen wird.

auserdem muss  BytesRead != BytesToRead nicht falsch sein, wenn man mehr 
als 1 byte erwarten, dann kann es auch sein das er die zeichen nicht auf 
einmal liefert.

[Blackbird (Gast)]

@Zoran St.:
Deinen Ansatz zum Senden und Empfangen halte ich für fehleranfällig. 
Richtig wäre das eventgetriggerte Empfangen von Bytes in einem eigenen 
Thread und Weiterleiten der Daten zu einem Haupt-Thread. Dort kann dann 
entschieden werden, wo die Daten (zeitlich) hingehören. Das Senden 
sollte auch eventgesteuert im Hintergrund in einem eigenen Thread 
ablaufen.
Damit ist Senden und Empfangen entkoppelt, Verzögerungen durch das OS 
und der seriellen Gegenstelle sind nicht mehr relevant.

Hier ein Beispiel, wie man auch ohne Threads einmal etwas senden kann 
und dann auf die Antwort wartet. Hier wird beim Senden im Hauptprogramm 
nicht auf den Abschluß der Aktion (das Ppysische Aussenden des letzten 
Bytes) gewartet, dafür wird die Zeit aber beim Empfangen durch eine 
Schleife wieder aufgebracht.

// Consolen-Programm zum Senden/Empfangen von Bytes über COM (9600-8N1)
// Es wird ein String als Start gesendet.
// Alle empfangenen Bytes werden zurückgesendet.
// OS: W95, W98, W98SE, WinME, WinNT, Win2000, WinXP (und höher)
// Note: Fast keine Fehlerbehandlung implementiert!
#include <windows.h>
#include <stdio.h>

#define COM_BUFFER_SIZE 256       // Read- und Write-Buffer-Size
#define BAUDRATE  CBR_9600 // 9600 Baud
#define BYTESIZE  8 
#define PARITY    NOPARITY
#define STOPBITS  ONESTOPBIT 
#define HELP_STRING TEXT("Aufruf mit: progname <COM-Port-Nummer>\r\n")
//char COMMAND1[] = {(0x02), (0x49), (0x05), (0x12), (0x03)};
char COMMAND1[] = HELP_STRING;


// Hauptprogramm: Aufruf mit: progname <COM-Port-Nummer>
int main (int argc, char **argv)
{
  DCB           dcb;    
  DWORD         iBytesWritten;
  BOOL          bRet      = true;
  DWORD         dwRead    = 0;
  DWORD         dwSetMask = EV_RXCHAR | EV_ERR; 
  DWORD         dwEvtMask; 
  OVERLAPPED    o;
  COMMTIMEOUTS  ct;
  unsigned char InString[COM_BUFFER_SIZE + 1];
  TCHAR         szCOM[6];


  if (argc == 2 &&                              // progname + COM-Port-Nummer ?
      atoi (argv[1]) > 0 && atoi (argv[1]) < 5) // COM1 ... COM4?
    wsprintf (szCOM, TEXT("COM%s"), argv[1]);   // String "basteln" ...
  else
  { 
    printf (TEXT("\r\nERROR:\t %s"), HELP_STRING);
    return (1); // und tschüß ...
  }

  memset (&o, 0, sizeof (OVERLAPPED)); // Struktur mit 0en füllen
  o.hEvent = CreateEvent (NULL, FALSE, FALSE, NULL); // einen Event setzten

  HANDLE hCom = CreateFile (szCOM, GENERIC_WRITE | GENERIC_READ, 0, NULL, 
                            OPEN_EXISTING, 0, NULL);                     

  if (hCom == INVALID_HANDLE_VALUE)
  { // Fehlerausgabe:
    LPVOID lpMsgBuf;
    FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | 
                    FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
    MessageBox (NULL, (LPCTSTR)lpMsgBuf, "Error: CreateFile", MB_OK | MB_ICONINFORMATION);
    LocalFree (lpMsgBuf);
    return (1); // und tschüß ...
  }
  
  dcb.DCBlength = sizeof(DCB);  // Laenge des Blockes MUSS gesetzt sein!
  GetCommState (hCom, &dcb);    // COM-Einstellungen holen und aendern
  dcb.BaudRate  = BAUDRATE;     // Baudrate
  dcb.ByteSize  = BYTESIZE;     // Datenbits
  dcb.Parity    = PARITY;       // Parität
  dcb.StopBits  = STOPBITS;     // Stopbits
  SetCommState (hCom, &dcb);    // COM-Einstellungen speichern
  
  GetCommTimeouts (hCom, &ct);
  // Warte-Zeit [ms] vom Beginn eines Bytes bis zum Beginn des nächsten Bytes 
  ct.ReadIntervalTimeout         = 1000 / BAUDRATE * (dcb.ByteSize + 
                                                     (dcb.Parity == NOPARITY ? 0 : 1) + 
                                                     (dcb.StopBits == ONESTOPBIT ? 1 : 2)) * RECVBYTES;
  ct.ReadTotalTimeoutMultiplier  = 0;  // [ms] wird mit Read-Buffer-Size multipliziert
  ct.ReadTotalTimeoutConstant    = 50; // wird an ReadTotalTimeoutMultiplier angehängt
  ct.WriteTotalTimeoutMultiplier = 0;
  ct.WriteTotalTimeoutConstant   = 0;
  SetCommTimeouts (hCom, &ct);

  // Zwischenspeicher des serial-Drivers einstellen (für read und write):
  SetupComm (hCom, COM_BUFFER_SIZE, COM_BUFFER_SIZE);
  SetCommMask (hCom, dwSetMask); // Empfangssignale definieren

  // Byte(s) senden:
  if (!WriteFile (hCom, &COMMAND1, strlen (COMMAND1), &iBytesWritten, NULL)) // Senden der Bytes
  { // Fehlerausgabe:
    LPVOID lpMsgBuf;
    FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | 
                    FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
    MessageBox (NULL, (LPCTSTR)lpMsgBuf, "Error: WriteFile", MB_OK | MB_ICONINFORMATION);
    LocalFree (lpMsgBuf);
  }
  else
    printf ("%d Byte(s) sent.", iBytesWritten);

  do  // in Endlos-Schleife auf Empfangssignale warten:
  {
    WaitCommEvent (hCom, &dwEvtMask, &o); // Event mit Empfangssignalen verknüpfen

    if (WAIT_OBJECT_0 == WaitForSingleObject (o.hEvent, INFINITE)) // warten bis Event
    {
      if (dwEvtMask & EV_RXCHAR) // Zeichen an RxD empfangen:
      {
        bRet = ReadFile (hCom, &InString, sizeof (InString), &dwRead, NULL);

        if (!bRet)
        { // Fehlerausgabe:
          LPVOID lpMsgBuf;
          FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | 
                          FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(),
                          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                          (LPTSTR) &lpMsgBuf, 0, NULL);
          MessageBox (NULL, (LPCTSTR)lpMsgBuf, "Error: ReadFile", 
                      MB_OK | MB_ICONINFORMATION);
          LocalFree (lpMsgBuf);
        }
        else
        { // Ausgabe (oder Verarbeitung) der empfangenen Bytes:
          InString[dwRead] = '\0'; // in "zero-ended"-String verwandeln
          printf (TEXT("\r\n\tRxD (%d Byte(s)): %s"), dwRead, InString);
          WriteFile (hCom, &InString, dwRead, &iBytesWritten, NULL); // Senden der Bytes
        }
      }

      if (dwEvtMask & EV_ERR) 
      {
        MessageBox (NULL, "Error empfangen", "Error: ReadFile", MB_OK);
        break; // Schleifen-Abbruch
      }
    }
  }
  while (1);

  CloseHandle (hCom);     // COM schließen
  CloseHandle (o.hEvent); // Event-Handle zurückgeben

  return (0);
}

Blackbird

[Peter II (Gast)]

Blackbird schrieb:
> Richtig wäre das eventgetriggerte Empfangen von Bytes in einem eigenen
> Thread und Weiterleiten der Daten zu einem Haupt-Thread. Dort kann dann
> entschieden werden, wo die Daten (zeitlich) hingehören. Das Senden
> sollte auch eventgesteuert im Hintergrund in einem eigenen Thread
> ablaufen.

ich halte von den event gesteuerten ansatz wenig. Dann die meisten 
anwendungen warten ja auf eine Antwort.

Sende('Frage');
Antwort = Empfange();

wenn man jetzt mit events arbeitet, dann verkompilziert das die sache 
unnötig und bringt auch kein Vorteil.

SendeAsyn('Frage');
WarteAufEntwort();
Anwwort = AsynAntwort;

Das Programm blockiert in beiden Fälle an der Stelle, hier bringen 
events keine Vorteil. Klar könnte man jetzt das ganze noch als 
Statemaschine abbilden aber das finde ich viel schwerer zu warten.

Lieber alles Synchron machen, wenn die Hauptprogramm nicht blockieren 
soll dann alles in einen Worker-Thread auslagern dieser arbeitet dann 
intern ohne events.

[Zoran S. (zoran_s)]

Peter II schrieb:
> das ist unsinn, entweder geht es beim ersten mal oder die verwendest zu
> kurze timeouts. Arbeite doch erstmal ohne Timeouts (das sollte das
> default sein). Dann blockiert das Read bis etwas gelesen wird.
>
Das habe ich schon probiert. Wenn die Timeouts auf 0 gesetzt sind, dann 
bleibt das Programm hängen. Darum habe ich das Timeout gesetzt und falls 
nichts gelesen wurde wird wiederholt. Meistens funktioniert es dann auch 
beim zweiten Mal lesen.
Da die Kommunikation eigentlich über USB geht (virtuelles COM) und dann 
ca. 1 MHz zwei Bytes geschickt werden, ist die Antwort auch schon 
innerhalb 2ms wieder da.
Zur Info: Es wird der Windows eigene Treiber usbser.sys verwendet.

> auserdem muss  BytesRead != BytesToRead nicht falsch sein, wenn man mehr
> als 1 byte erwarten, dann kann es auch sein das er die zeichen nicht auf
> einmal liefert.

ReadFile sollte eigentlich erst beenden wenn die gewünschte Anzahl an 
Bytes empfangen wurde, oder nicht?

[Peter II (Gast)]

Zoran S. schrieb:
> ReadFile sollte eigentlich erst beenden wenn die gewünschte Anzahl an
> Bytes empfangen wurde, oder nicht?

da bin ich mir ebend nicht sicher, beim Netwerk ist es auf jeden fall so 
das das nicht immer alles ankommt.

> Das habe ich schon probiert. Wenn die Timeouts auf 0 gesetzt sind, dann
> bleibt das Programm hängen. Darum habe ich das Timeout gesetzt und falls
> nichts gelesen wurde wird wiederholt. Meistens funktioniert es dann auch
> beim zweiten Mal lesen.
dann hast du ein anders Problem. Das muss auf jeden Fall gehen.

Schreibe estmal ein Programm was 1 Zeichen senden und diesen wieder 
empfängt. Dann eine Bücke zwischen PIN 2 und 3 machen.


while(1)
  WriteFile( .. 'A' .. )
  ReadFile( ... );
  // Prüfe ob ReadFile 1 zeichen gelsen hat was ein 'A' ist
  // print OK sonst ERRROR
)

Dass muss erstmal ohne timeouts fehlerfrei durchlaufen.

[Zoran S. (zoran_s)]

Hallo!

habe jetzt mal den code von Blackbird ausprobiert.

Leider bleibt das Programm dann irgendwann stehen.

Dann die Read-Write geschichte mit folgendem code:

/* 
 * File:   main.c
 * Author: zst
 *
 * Created on 02. November 2011, 11:33
 */

#include <stdio.h>
#include <windows.h>

HANDLE flasher_port;
char* com_port;

/*
 * 
 */
void comport_init(void) {
  int res;
  DCB dcb;
  unsigned char get_info[] = {'C', '5', '\n'};
  BYTE buf[30] = "\\\\.\\";
  COMMTIMEOUTS CommTimeouts;
  fprintf(stdout, "Opening %s\n", com_port);
  flasher_port = CreateFile(strcat(buf, com_port), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
    0, NULL);

  if (flasher_port == INVALID_HANDLE_VALUE) fprintf(stderr, "opening failed\n"), exit(1);


  //  Initialize the DCB structure.
  //  SecureZeroMemory(&dcb, sizeof(DCB));
  dcb.DCBlength = sizeof (DCB);

  if (GetCommState(flasher_port, &dcb)) {
    dcb.BaudRate = /*CBR_9600,*/CBR_115200;
      dcb.ByteSize = 8; //OCTET BYTE
      dcb.Parity = NOPARITY;
      dcb.StopBits = ONESTOPBIT;
      dcb.fInX = FALSE;
      dcb.fOutX = FALSE;
      dcb.fRtsControl = RTS_CONTROL_DISABLE;
  } else fprintf(stderr, "COM - mode set error\n"), exit(1);


  if (!SetCommState(flasher_port, &dcb)) fprintf(stderr, "COM - mode set error\n"), exit(1);

  if (GetCommTimeouts(flasher_port, &CommTimeouts)) {
    CommTimeouts.ReadIntervalTimeout = 0;
    CommTimeouts.ReadTotalTimeoutConstant = 0;
    CommTimeouts.ReadTotalTimeoutMultiplier = 300;
    CommTimeouts.WriteTotalTimeoutConstant = 0;
    CommTimeouts.WriteTotalTimeoutMultiplier = 300;
    if (!SetCommTimeouts(flasher_port, &CommTimeouts)) fprintf(stderr, "Timeout set error\n"), exit(1);
  }
}



int main(int argc, char** argv) {
  int arg = 0;

  for (arg = 1; arg < argc; arg++) {
    switch (toupper(argv[arg][1])) {
      case 'J':
        com_port = &argv[arg][2];
        break;
      default:
        break;
    }
  }

  comport_init();
  
  int countit = 0;
  unsigned char buffer = 'A';
  unsigned char recbuf;
  DWORD rxcnt = 0,txcnt = 0;
  int retValue = 0;
  while(1) {
    
    if (!WriteFile(flasher_port, &buffer, sizeof (unsigned char), &txcnt, NULL)) {
      fprintf(stderr, "Can't send Data!\n");
      retValue = 1;
      break;
    }
    else if (txcnt != sizeof (unsigned char)) {
      fprintf(stdout, "Sent %i instead of %i charachters!\n", txcnt, sizeof (unsigned char));
    }
    
    recbuf = 0;
    if (!ReadFile(flasher_port, &recbuf, sizeof (unsigned char), &rxcnt, NULL)) {
      retValue = 1;
      break;
    }
    else if (rxcnt != sizeof (unsigned char)) {
      fprintf(stdout, "Received %i instead of %i charachters!\n", rxcnt, sizeof (unsigned char));
    }
      
    if(recbuf != 'A')
      fprintf(stdout, "Loop %i error %c\n", countit, recbuf);
    
    if (countit%10000 == 0)
      fprintf(stdout, "%i Loops successfull!\n", countit);
    
    countit++;
  }
    
  fprintf(stdout, "Stopping at &i. Error %c\n", countit, recbuf);
  return retValue;
}

Hier die Ausgabe:
zst@zst-i5 /h/NetBeansProjects/LoopTest
$ LoopTest -jCOM4
Opening COM4
0 Loops successfull!
10000 Loops successfull!
20000 Loops successfull!
30000 Loops successfull!
40000 Loops successfull!
50000 Loops successfull!
60000 Loops successfull!
Received 0 instead of 1 charachters!
Loop 67742 error
70000 Loops successfull!
80000 Loops successfull!
Received 0 instead of 1 charachters!
Loop 87764 error
90000 Loops successfull!
100000 Loops successfull!
110000 Loops successfull!
120000 Loops successfull!
130000 Loops successfull!
140000 Loops successfull!
150000 Loops successfull!
160000 Loops successfull!
170000 Loops successfull!
Received 0 instead of 1 charachters!
Loop 173465 error
180000 Loops successfull!
Received 0 instead of 1 charachters!
Loop 182742 error
190000 Loops successfull!
200000 Loops successfull!
210000 Loops successfull!
220000 Loops successfull!
Received 0 instead of 1 charachters!
Loop 229614 error
230000 Loops successfull!
240000 Loops successfull!
250000 Loops successfull!
260000 Loops successfull!
270000 Loops successfull!
Received 0 instead of 1 charachters!
Loop 271759 error
280000 Loops successfull!
290000 Loops successfull!
300000 Loops successfull!
310000 Loops successfull!
320000 Loops successfull!
330000 Loops successfull!
340000 Loops successfull!
Received 0 instead of 1 charachters!
Loop 342993 error
...
usw.

Was kann das sein?

Ich könnte jetzt mal versuchen ein "retry" einzubauen. Vielleicht hilft 
das.
Andere Vorschläge?

Zoran

[Peter II (Gast)]

Opening (null)
0 Loops successfull!
10000 Loops successfull!
20000 Loops successfull!
30000 Loops successfull!
40000 Loops successfull!
50000 Loops successfull!
60000 Loops successfull!
70000 Loops successfull!
80000 Loops successfull!
90000 Loops successfull!
100000 Loops successfull!
110000 Loops successfull!
120000 Loops successfull!
130000 Loops successfull!
140000 Loops successfull!
150000 Loops successfull!
160000 Loops successfull!
170000 Loops successfull!
180000 Loops successfull!
190000 Loops successfull!
200000 Loops successfull!
210000 Loops successfull!
220000 Loops successfull!
230000 Loops successfull!
240000 Loops successfull!
250000 Loops successfull!
260000 Loops successfull!
270000 Loops successfull!
280000 Loops successfull!
290000 Loops successfull!
300000 Loops successfull!
310000 Loops successfull!
320000 Loops successfull!
330000 Loops successfull!
340000 Loops successfull!
350000 Loops successfull!



also an dem Programm liegt es nicht. Du hast also ein Problem mit deiner 
Hardware order den Treibern.

Was soll das hier in deinem code?

BYTE buf[30] = "\\\\.\\";

für strings nimmt man char

besser du machst es mit

char buf[30];
snprintf(buf, "\\\\.\\%s",sizeof(buf)-1, com_port);
CreateFile(buf,...)

[Zoran S. (zoran_s)]

Hallo!

Ich glaube, ich geb's auf.

bin gerade daheim und habe den LoopTest am Laptop getestet.
Nach 1.38 Mio. Loops kein einziger Fehler.

Ich habe noch zwei Rechner (1x XP und 1x Vista) an denen ich es morgen 
auch testen werde.
Falls dort auch keine Fehler auftreten dann liegt es an diesem PC.
Ob es das Chipset oder die CPU ist werde ich wohl nicht herauszufinden 
können.

Ansonsten kann ich nur noch den Treiber neu installieren und wenn es 
dann nicht klappt den ganzen Rechner neu aufsetzen.
Falls es dann immer noch nicht klappt wird Rechner getauscht.

Morgen gebe ich noch die Ergebnisse bekannt.

Danke euch allen für die Hilfe.

Zoran

[Rufus Τ. F. (rufus)]

Warum ist das hier auskommentiert?

  //  Initialize the DCB structure.
  //  SecureZeroMemory(&dcb, sizeof(DCB));
  dcb.DCBlength = sizeof (DCB);

Wenn aus irgendeinem Grund SecureZeroMemory nicht verwendet werden 
kann, sollte memset verwendet werden.

[Peter II (Gast)]

viel mir gerade auf:

if (!SetCommTimeouts(flasher_port, &CommTimeouts)) fprintf(stderr, "Timeout set error\n"), exit(1);

das ist auch ein Syntax der jenseits von gut und böse ist.

[Zoran S. (zoran_s)]

Peter II schrieb:
> viel mir gerade auf:
>
>

> if (!SetCommTimeouts(flasher_port, &CommTimeouts)) fprintf(stderr,
> "Timeout set error\n"), exit(1);
>

>
> das ist auch ein Syntax der jenseits von gut und böse ist.

Weil ...?

[Peter II (Gast)]

Zoran S. schrieb:
> Weil ...?

komma operator, für soetwas kann man schon eine extra zeile und {} 
verwenden.