//----------------------------------------------------------------------------
BOOL 
ComProt::WriteProt (LPBYTE pDataBuffer, DWORD dwBytesToWrite, PDWORD pdwBytesWritten)
{
	int OldPriority;
	HANDLE hThread;
	BOOL ok = FALSE;
	COMSTAT ComStat;
	DWORD dwComError;

	if ((pDataBuffer == NULL) || (dwBytesToWrite ==  0 ))
	{
		TRACE("ComProt::WriteProt: ERROR_PARAMETER");
		return FALSE;
	}

	hThread = GetCurrentThread();
	OldPriority = GetThreadPriority(hThread);
	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);

	// Sender belegen
	//TRACE("SendModBus: Warten auf Senderfreigabe...\n");
	if (WaitForSingleObject(hSenden, nErrTimeout) != WAIT_OBJECT_0){
		SetThreadPriority(hThread, OldPriority);
		TRACE("ComProt::WriteProt: Com Mutex busy\n");
		//DbgTrace(TRACE_WARNING, "SendModBus: ..Sender NICHT verfьgbar!\n");
		//SetLastError (ERROR_MODBUS_WAIT_SENDER);
		return FALSE;
	}
	//DbgTrace(TRACE_INFO+5, "SendModBus: ..Sender verfьgbar..\n");
 

	// Empfangspuffer-Inhalt lцschen
	PurgeComm(hIdCom, PURGE_RXCLEAR);
	ClearCommError(hIdCom, &dwComError, &ComStat);
	if (dwComError !=  0 )
		TRACE("WriteModBus: ClearCommError returned 0x%08x\n", dwComError);

/*
	// Hack.... Win95 OSR2 loses last 2 byte of packet. Suxx.
	*pDst++ = 0x44;
	*pDst++ = 0x44;
*/

/*	ResetEvent(pCB->hCommRxdByte);*/
	
	// really start to write
//	OVERLAPPED	TxOverlapped;

	if( !EscapeCommFunction(hIdCom, SETRTS) )
	{
		TRACE("ComProt::WriteProt: set RTS failed\n");
	}

	if (bIsRadio)
	{
		Sleep(nTangenTime ); 
	}
/**
	ClearCommError(hIdCom, &dwComError, &ComStat);
	if (dwComError)
		TRACE("WriteComm: Comm-Error %08x\n", dwComError);

	if (ComStat.cbInQue > 1)
	{
		TRACE("WriteComm: %d Bytes in Rx-Queue\n", ComStat.cbInQue);
		//
		// HACK - HACK - HACK
		///
		// Falls (unter Windows95) zwei COM-Ports auf dem gleichen Interrupt arbeiten,
		// wird ein ReadFile-Aufruf nicht mehr beendet, nachdem ein Programm den anderen
		// COM-Port geцffnet hat.
		// Um wenigstens nach dessen SchlieЯen den ReadFile-Aufruf beendet zu bekommen,
		// wird bei jedem Sendeversuch mit PurgeComm die Rx-Queue gelцscht, falls darin 
		// mehr als 1 Zeichen ist:
		PurgeComm(hIdCom, PURGE_RXCLEAR);
	}
 */
	if (!WriteFile (hIdCom, pDataBuffer, dwBytesToWrite, pdwBytesWritten, NULL/*&TxOverlapped*/))
	{
		DWORD dwError = GetLastError();
		if (dwError != ERROR_IO_PENDING)
		{
			DWORD dwComError;
			//???pCB->dwLastError = dwError;
			ClearCommError(hIdCom, &dwComError, &ComStat);
			if (dwComError)
			{
				TRACE("ComProt::WriteProt: Comm-Error %08x\n", dwComError);
				//???pCB->LastError.dwErrorCOM = dwComError;
				//MessageBox (HWND_DESKTOP, "WriteFile Comm-Error!", "", MB_OK | MB_ICONHAND);
			}
		}
		else
		{
			TRACE("WriteComm: WriteFile returns ERROR_IO_PENDING");
		}
	}
	if (*pdwBytesWritten == dwBytesToWrite)
	{
		TRACE("ComProt::WriteProt: Success\n");
		ok = TRUE;
	}
	else
		TRACE("ComProt::WriteProt: ..No Success..\n");

	TRACE("Write > %5.3f\n", (float)clock() / CLOCKS_PER_SEC);

	// wait to end transfer  ??????
	//Sleep(10);
	if (bIsRadio)
	{
		Sleep(nTangenTime ); 
	}

	if( !EscapeCommFunction(hIdCom, CLRRTS) )
	{
		TRACE("WriteComm: reset RTS failed\n");
	}

//	if( !PurgeComm(hIdCom, PURGE_RXCLEAR | PURGE_RXABORT) )
//	{
//		TRACE("WriteComm: Purge input buffer failed\n");
//	}

#ifndef NDEBUG
	// dump data
	CString		msg = "ComProt::WriteProt sent:";

	if( dwBytesToWrite )
	{
		TRACE("ComProt::WriteProt sent:");
		for( int i =  0 ; i < (int)dwBytesToWrite; i++ )
		{
			char buf[ 30 ];
			TRACE("%x ", pDataBuffer[i]);
			msg += itoa(pDataBuffer[i], buf,  16 );
			msg += " ";
		}
		TRACE("\n");
	}
	WriteLog(msg);
#endif
	
	// Sender wieder freigeben
	ReleaseMutex(hSenden); 
	SetThreadPriority(hThread, OldPriority);

	return ok;	
}


//----------------------------------------------------------------------------
BOOL 
ComProt::ReadProt (LPVOID pDataBuffer, DWORD dwBufferSize, PDWORD pdwBytesRead)
{
	BOOL bOk = FALSE;
	DWORD dwEventMask =  0 ;
	DWORD nRead =  0 ;
	BYTE szReadBfr[ 256 ];
	DWORD dwBytesRead;
	DWORD dwComError =  0 ;
	COMSTAT ComStat;
//	OVERLAPPED	RxOverlapped;
	int OldPriority;
	HANDLE hThread;

	if (WaitForSingleObject(hSenden, nErrTimeout) != WAIT_OBJECT_0){
		TRACE("ComProt::ReadProt:  Com Mutex busy\n");
		//DbgTrace(TRACE_WARNING, "SendModBus: ..Sender NICHT verfьgbar!\n");
		//SetLastError (ERROR_MODBUS_WAIT_SENDER);
		return FALSE;
	}


	hThread = GetCurrentThread();
	OldPriority = GetThreadPriority(hThread);
	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);

	TRACE("Read > %5.3f\n", (float)clock() / CLOCKS_PER_SEC);

	if (!ReadFile(hIdCom, szReadBfr, sizeof szReadBfr, &dwBytesRead, NULL/*&RxOverlapped*/))
	{
		DWORD dwError = GetLastError();
		TRACE("ReadModBus: ReadFile FAILED %d\n ", dwError);
	}

	ClearCommError(hIdCom, &dwComError, &ComStat);
/**
	// this must work, but with Prot won't. Why???
	if (dwComError != 0){
//			SetLastError(ERROR_MODBUS_COMERROR);//???
		TRACE("ReadModBus: ClearCommError FAILED %d\n", dwComError);
		return FALSE;
	}
 */
/* 1st-order frame check
	// searching DLE, checking size
	LPBYTE	ptr = szReadBfr; 
	BYTE byFrameLen;
	BOOL found = FALSE;
	while (ptr <= szReadBfr + dwBytesRead - FRAME_SZ - 2)
	{
		if (ptr[0] == DLE && ptr[2] == Options.byPuNum) // 1st fast check
		{
			byFrameLen = ptr[1];	// expected position
			if (byFrameLen > FRAME_SZ &&
				ptr + byFrameLen < szReadBfr + dwBytesRead)
			{
				found = TRUE;
				break;
			}
		}
		ptr++;
	}

	if( found )// ein RTU-Telegramm besteht aus mindestens Zeichen, weniger bedeutet Fehler
	{						
		WORD crc16;
		int nByte;
		crc16 = 0;
		for (nByte = 1; nByte <= byFrameLen - 2; nByte++)
		{
			crc16 = crc_byte(ptr[nByte], crc16);
		}
		if (LOBYTE(crc16) == ptr[byFrameLen - 1] &&
			HIBYTE(crc16) == ptr[byFrameLen])
		{
			*pdwBytesRead = byFrameLen - 2;
			memcpy(pDataBuffer, ptr + 1, *pdwBytesRead);
			bOk = TRUE;
		}
		else
			TRACE("ReadModBus: faked CRC\n");
	}
	else
	{
	 	// kleines data oder schlechte blok empfangen !!
		TRACE("ReadModBus: Broken or short frame\n");
	}
*/
	// only translate data 
	LPBYTE	ptr = szReadBfr; 
	*pdwBytesRead = dwBytesRead;
	memcpy(pDataBuffer, ptr, *pdwBytesRead);
	bOk = TRUE;

#ifndef NDEBUG
	// dump data
	CString		msg = "ComProt::ReadProt read:";

	if( dwBytesRead )
	{
		TRACE("ComProt::ReadProt read:");
		for( int i =  0 ; i < (int)dwBytesRead; i++ )
		{
			char buf[ 30 ];
			TRACE("%x ", szReadBfr[i]);
			msg += itoa(szReadBfr[i], buf,  16 );
			msg += " ";
		}
		TRACE("\n");
	}
	WriteLog(msg);
#endif

	if (bIsRadio)
	{
		Sleep(nPilotTime);
	}
	
	SetThreadPriority(hThread, OldPriority);

	ReleaseMutex(hSenden); 

	return bOk;
}