Logga seriell kommunikation med filter?

// Serial.h

#ifndef __SERIAL_H__
#define __SERIAL_H__

#define FC_DTRDSR       0x01
#define FC_RTSCTS       0x02
#define FC_XONXOFF      0x04
#define ASCII_BEL       0x07
#define ASCII_BS        0x08
#define ASCII_LF        0x0A
#define ASCII_CR        0x0D
#define ASCII_XON       0x11
#define ASCII_XOFF      0x13

class CSerial
{

public:
	CSerial(int nPort = 2, int nBaud = 9600);
	~CSerial();



	BOOL Open(CTestMethod *Testshell);
	BOOL Close();

	int ReadData( void *, int );
	int SendData( const char *, int );
	int ReadDataWaiting( void );

	char* WaitUntil(char *SearchString,int Timeout = 60,BOOL PrintLines = TRUE);
	BOOL IsOpened( void ){ return( m_bOpened ); }

protected:

	CTestMethod *TestShell;
	int Port,Baud;
	CString CompString;

	BOOL WriteCommByte( unsigned char );

	HANDLE m_hIDComDev;
	OVERLAPPED m_OverlappedRead, m_OverlappedWrite;
	BOOL m_bOpened;

};

#endif

// Serial.cpp

#include "..\stdafx.h"
#include "Serial.h"

CSerial::CSerial(int nPort, int nBaud)
{
	//Save port setting
	Port = nPort;
	Baud = nBaud;

	memset( &m_OverlappedRead, 0, sizeof( OVERLAPPED ) );
 	memset( &m_OverlappedWrite, 0, sizeof( OVERLAPPED ) );
	m_hIDComDev = NULL;
	m_bOpened = FALSE;

}

CSerial::~CSerial()
{

	Close();

}

BOOL CSerial::Open( CTestMethod *Testshell)
{
	//Save test shell pointer
	TestShell = Testshell;

	if( m_bOpened ) return( TRUE );

	char szPort[15];
	char szComParams[50];
	DCB dcb;

	wsprintf( szPort, "COM%d", Port );
	m_hIDComDev = CreateFile( szPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL );
	if( m_hIDComDev == NULL ) return( FALSE );

	memset( &m_OverlappedRead, 0, sizeof( OVERLAPPED ) );
 	memset( &m_OverlappedWrite, 0, sizeof( OVERLAPPED ) );

	COMMTIMEOUTS CommTimeOuts;
	CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF;
	CommTimeOuts.ReadTotalTimeoutMultiplier = 0;
	CommTimeOuts.ReadTotalTimeoutConstant = 0;
	CommTimeOuts.WriteTotalTimeoutMultiplier = 0;
	CommTimeOuts.WriteTotalTimeoutConstant = 5000;
	SetCommTimeouts( m_hIDComDev, &CommTimeOuts );

	wsprintf( szComParams, "COM%d:%d,n,8,1", Port, Baud );

	m_OverlappedRead.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
	m_OverlappedWrite.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );

	GetCommState( m_hIDComDev, &dcb );

	dcb.BaudRate			= Baud;
	dcb.Parity				= 0;
	dcb.ByteSize			= 8;
	dcb.fAbortOnError		= 1;
	dcb.fRtsControl			= 2;
	dcb.fTXContinueOnXoff	= 1;
	dcb.fOutxCtsFlow		= 1;

	unsigned char ucSet;
	ucSet = (unsigned char) ( ( FC_RTSCTS & FC_DTRDSR ) != 0 );
	ucSet = (unsigned char) ( ( FC_RTSCTS & FC_RTSCTS ) != 0 );
	ucSet = (unsigned char) ( ( FC_RTSCTS & FC_XONXOFF ) != 0 );
	if( !SetCommState( m_hIDComDev, &dcb ) ||!SetupComm( m_hIDComDev, 10000, 10000 ) ||	m_OverlappedRead.hEvent == NULL ||m_OverlappedWrite.hEvent == NULL )
	{
		DWORD dwError = GetLastError();
		if( m_OverlappedRead.hEvent != NULL ) CloseHandle( m_OverlappedRead.hEvent );
		if( m_OverlappedWrite.hEvent != NULL ) CloseHandle( m_OverlappedWrite.hEvent );
		CloseHandle( m_hIDComDev );
		return( FALSE );
	}

	m_bOpened = TRUE;

	return( m_bOpened );

}

BOOL CSerial::Close()
{

	if( !m_bOpened || m_hIDComDev == NULL ) return( TRUE );

	if( m_OverlappedRead.hEvent != NULL ) CloseHandle( m_OverlappedRead.hEvent );
	if( m_OverlappedWrite.hEvent != NULL ) CloseHandle( m_OverlappedWrite.hEvent );
	CloseHandle( m_hIDComDev );
	m_bOpened = FALSE;
	m_hIDComDev = NULL;

	return( TRUE );

}

BOOL CSerial::WriteCommByte( unsigned char ucByte )
{
	BOOL bWriteStat;
	DWORD dwBytesWritten;

	bWriteStat = WriteFile( m_hIDComDev, (LPSTR) &ucByte, 1, &dwBytesWritten, &m_OverlappedWrite );
	if( !bWriteStat && ( GetLastError() == ERROR_IO_PENDING ) ){
		if( WaitForSingleObject( m_OverlappedWrite.hEvent, 1000 ) ) dwBytesWritten = 0;
		else{
			GetOverlappedResult( m_hIDComDev, &m_OverlappedWrite, &dwBytesWritten, FALSE );
			m_OverlappedWrite.Offset += dwBytesWritten;
			}
		}

	return( TRUE );

}

int CSerial::SendData( const char *buffer, int size )
{

	if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );

	DWORD dwBytesWritten = 0;
	int i;
	for( i=0; i<size; i++ ){
		WriteCommByte( buffer[i] );
		dwBytesWritten++;
		}

	return( (int) dwBytesWritten );

}

int CSerial::ReadDataWaiting( void )
{

	if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );

	DWORD dwErrorFlags;
	COMSTAT ComStat;

	ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );

	return( (int) ComStat.cbInQue );

}

int CSerial::ReadData( void *buffer, int limit )
{

	if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );

	BOOL bReadStatus;
	DWORD dwBytesRead, dwErrorFlags;
	COMSTAT ComStat;

	ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );
	if( !ComStat.cbInQue ) return( 0 );

	dwBytesRead = (DWORD) ComStat.cbInQue;
	if( limit < (int) dwBytesRead ) dwBytesRead = (DWORD) limit;

	bReadStatus = ReadFile( m_hIDComDev, buffer, dwBytesRead, &dwBytesRead, &m_OverlappedRead );
	if( !bReadStatus ){
		if( GetLastError() == ERROR_IO_PENDING ){
			WaitForSingleObject( m_OverlappedRead.hEvent, 2000 );
			return( (int) dwBytesRead );
			}
		return( 0 );
		}

	return( (int) dwBytesRead );

}


//Waits until the search string is found or the time out is reached
//Return a pointer to char string containing the recived answer
//from RS232.
char * CSerial::WaitUntil(char *SearchString,int Timeout,BOOL PrintLines)
{
	CompString="";
	int Length,Time=0,PrintLinePos=0,ReciveStringPos;
	char ReciveString[10000];
	char PrintLine[1024];

	Sleep(100);

	while(CompString.Find(SearchString)==-1)
	{
		//Check stop flag
		if(TestShell->GetStopFlag())	return NULL;

		Time=0;
		while(!ReadDataWaiting())
		{
			if(Time==Timeout*20)
			{
				TestShell->TextOut("Time Out!!\\\nSearch string \"%s\"  not found!",SearchString);				
				return NULL;
			}

			if(TestShell->GetStopFlag())	return NULL;

			Sleep(50);
			Time++;
		}

		Length=ReadData(ReciveString,sizeof(ReciveString));
		ReciveString[Length]='\0';
		CompString=CompString+ReciveString;

		ReciveStringPos=0;
		while(ReciveString[ReciveStringPos]!='\0')
		{
			//Check stop flag
			if(TestShell->GetStopFlag())	return NULL;

			PrintLine[PrintLinePos]=ReciveString[ReciveStringPos];
			PrintLinePos++;
			ReciveStringPos++;
			if(PrintLine[PrintLinePos-1]=='\n'||PrintLine[PrintLinePos-1]=='\r')
			{
				PrintLine[PrintLinePos]='\0';
				if(PrintLines == TRUE)	TestShell->TextOut("\\f1%s",PrintLine);
				PrintLinePos=0;
			}
		}

	}
	PrintLine[PrintLinePos]='\0';
	if(PrintLines == TRUE)	TestShell->TextOut("\\f1%s",PrintLine);
	
	return CompString.GetBuffer(1);
}

//******************************************************************************
int CCommunicationCheck::Measure(void)
{
	const char * IPaddress,* Password;
	int ComPort,BaudRate;
	CString CompString;

// do some stuff
//	GetData("IPaddress",&IPaddress);
//	GetData("Password",&Password);	
//	GetData("ComPort",&ComPort);
//	GetData("BaudRate",&BaudRate);	

//********************************************************
//   Check RS232 Communication
//********************************************************

	CSerial RNC_RS232(ComPort,BaudRate);

	if(RNC_RS232.Open(this))
		TextOut("Serial connection established!");
	else
	{
		TextOutError("Serial connection faild!");
		BoxError("Serial connection faild!"," Communication test");
		return TS_METHOD_ERROR;
	}

	//Connect
	RNC_RS232.SendData("\r\n",strlen("\r\n"));
	CompString = RNC_RS232.WaitUntil("$");

	if(CompString.Find("$")==-1)
	{
		TextOutError("No prompt found!");
		return TS_METHOD_ERROR;
	}
	else
	{
		TextOut("Prompt found!");
	}