Derzeit versuche ich eine Art Datenlogger für ein Messgerät zu schreiben, welcher über eine RS422 die Daten aufzeichnen und in eine CSV Datei schreiben soll. Dazu habe ich mit Hilfe der Windows API eine Klasse für die Schnittstellenkommunikation geschrieben. Diese funktioniert problemlos bis zu einer Übertragungsrate von 115.200 kBits. Wenn ich aber die Übertragungsrate höher schraube, verliere ich aus irgendeinem Grund einzelne Bytes.

Zu erwähnen wäre vielleicht noch, dass das Messgerät mit einer Frequenz von 4kHz und 8 Byte pro Wert Daten für jeweils 300ms sendet (was ca. 2400 Bytes pro Übertragung sind). Ich habe schon mehrere andere Varianten probiert, aber es scheint einfach ein Problem bei hohen Übertragungsraten bei den von mir getesteten Varianten zu geben.

Ich ergänze mal eben die Routine der Klasse welche den Datenblock auffangen soll.

DWORD SER_COM::ser_com_read_timeout(char *cRead, DWORD iBytes, DWORD Time)
{
	DWORD dwCount = 0, dwCountAll = 0;
	DWORD dwEventMask = 0;
	bool timeOut = false;
	if(ComOpen)
	{
		do{
			WaitCommEvent(hComm, &dwEventMask, &ovReader);		//Auf Comm Event warten
			if(WaitForSingleObject(ovReader.hEvent, Time) == WAIT_OBJECT_0)
			{
				if((dwEventMask & EV_RXFLAG) || (dwEventMask & EV_RXCHAR))
				{
					do{
						ReadFile(hComm, &cRead[dwCountAll], 1, &dwCount, &ovReader);	//Rückgabewert holen
						dwCountAll += dwCount;
					}while(dwCount > 0);
					ResetEvent(ovReader.hEvent);
				}else{
					timeOut = true;
				}
			}else{
				timeOut = true;
			}
		}while(!timeOut);
	}
	return dwCountAll;
}

versuch doch erstmal praktisch zu ermitteln, ob dein PC und das Gerät höhere Datenraten überhaupt fehlerfrei unterstützten.
Für serielle Schnittstellen ist bei 115KBit eigentlich offiziel schluss.
es gibt aber geräte welche mit multiplikatoren arbeiten.
evtl. ist das ja ein hardwareproblem.

Ich habe noch ein wenig mit dem RS422 Adapter herum gespielt und konnte in der Zwischenzeit bis auf 921600 kBit die Geschwindigkeit erhöhen. Bei einer Abtastrate des Messgerätes von 2kHz kommt alles noch sauber an, jedoch bei 4kHz verschwinden schon wieder einzelne Bytes. Komischer weise, verliert er diese immer wieder nach einem bestimmte Muster (jedes 63, 65 oder 67 Datenpacket das 7. oder 8. Byte)

Um ein wenig herum zu experimentieren habe ich in das selbe Programm einen Simulator eingebaut, bei dem ich das selbe Phänomen feststellen kann, wie mit dem Messgerät. Jetzt stellt sich mir die Frage, ob auf der Sende oder Empfangsseite die Daten verloren gehen.

wenn Dir dabei ein Zeitfenster von 55ms über den Weg läuft... Dies ist ein Intervall von Windows für alles mögliche. Besonders bei Timern. "Normale" Timer haben dieses Intervall als maximal mögliche Auflösung. Es soll aber bei DirectX hochpräzise Timer geben...

Ich bin damals beim programmieren eines empfängers für Infrarot beiname wahnsinnig geworden. ist aber lang her.

Stefan

Es kann eigentlich nur noch sein, dass entweder der Adapter oder Windows die Bytes verschluckt. Obwohl ich nicht glaube, dass Windows daran schuld ist.

Die Idee mit dem Timer Tick unter Windows habe ich mal durchgerechnet, jedoch passt das Intervall nicht (ca. 16ms bis ein Byte fehlt). Den eingzigen Timer, den ich nutze, ist der Timer für den Simulator und dieser läuft ausreichend präzise.

Wenn bei der Datenübetragung, die Messwerte (jeweils 8 Byte) in einem Abstand von über 0,3 ms gesendet werden, ist alles bestens. Darunter gehen nach 63 Datenpaketen immer wieder Bytes verschütt. Wenn ich jedoch die Daten in einem Stück sende, gehen keine Bytes verloren. Woher dieses Verhalten kommt kann ich nicht nachvollziehen, obwohl die Vermutung nahe liegt, dass es die RS422 Schnittstelle/Converter ist.

Ich habe zusätzlich die Empfangsroutine umgeschrieben, obwohl ich nicht glaube, dass dieses irgendwelche Auswirkungen hat.

DWORD SER_COM::ser_com_read(char *cRead, DWORD iBytes, DWORD Time)
{
	DWORD dwCount = 0, dwCountAll = 0;
	DWORD dwEventMask = 0, dwError;
	COMSTAT comstat;
	BOOL bReadStatus;
	if(ComOpen)
	{
		do{
			ClearCommError( hComm , &dwError , &comstat );
			if(comstat.cbInQue != 0)//hole hängende Bytes ab
			{	
				bReadStatus = ReadFile( hComm, &cRead[dwCountAll], iBytes, &dwCount, &ovReader );
				dwCountAll += dwCount;
				if( !bReadStatus )
				{
					if( GetLastError() == ERROR_IO_PENDING )
					{
						WaitForSingleObject( ovReader.hEvent, Time );
					}
				}
			}else{					//Warte auf die nächsten Bytes
	            WaitCommEvent(hComm, &dwEventMask, &ovReader);
	            if(WaitForSingleObject(ovReader.hEvent, Time) == WAIT_OBJECT_0)
		        {
			        if((dwEventMask & EV_RXFLAG) || (dwEventMask & EV_RXCHAR))
				    {
					    do{
					        ReadFile(hComm, &cRead[dwCountAll], 1, &dwCount, &ovReader);
					        dwCountAll += dwCount;
					    }while(dwCount > 0);
					}
				}
			}

		}while(dwCountAll < iBytes);
	}
	return dwCountAll;
}

ich hatte mal eine Ansteuerung für Beta-Cam-Videorekorder für RS232 programmiert. Den gleichen Befehl konnte ich ohne Pause immer wieder schicken (z.B. die Abfrage des Zählerstandes). Sobald ich aber zwei Unterschiedliche Befehle im Wechsel gesendet habe, mußte ich immer 200ms warten. Sonst gabs Übertragungsfehler...

Stefan