short CCP4002Prot::Trans(void)
{
	short ret    = 0;
	DWORD retErr = 0;

	SetCpStatusString(TRANSMIT);

	if (false == WriteCanQueue(m_comnum, m_transBuf, m_transBuflen))
	{	
		DTLOG(m_logid, DT_CP4002PROT_CAN_WRITE_FAILED);
		retErr = GetLastError();
		m_errCounterTrans++;
		ret = -1; 
	}
	else
	{
		m_myTimer->Set_MaxSecs(m_recvTimeoutSec);
		m_myTimer->StartTimer(true);
		retErr = 0;
		m_errCounterTrans = 0;
		ret = 0; 
	}

	return ret;
}

short CCP4002Prot::Recv(void)
{	// Wartet auf ReceiveEvents und überwacht Timeouts
	static int merkeBytesReceivedAll = 0;
	DWORD waitResult = 0;
	short ret        = 0;	
	bool timeout     = false;
	
	SetCpStatusString(RECEIVE);

	m_bytesReceived  = 0;
	m_recvTimeout    = false;

	memset(m_recvBuf, 0x00, CP_RECEIVE_MAX_LEN);					
	
	if (m_bytesSollRecv > 0)
	{	// Wenn gesendeter Befehl eine Antwort erwartet, wird auf ReceiveEvent gewartet
		if (CP_START == m_cpStatus)
		{
			m_CountSampleTime = true;
			m_startSampleTime = time(NULL);
		}

		//merkeBytesReceivedAll = 0;
		while ((m_bytesReceived < m_bytesSollRecv) && (!timeout))
		{	// Wenn noch nicht alle Bytes empfangen wurden und es noch kein Timeout gab, wird auf weitere Daten gewartet
			if (merkeBytesReceivedAll != m_bytesReceivedAll)
			{	// Es wurden neuen Daten empfangen
				m_myTimer->Set_MaxSecs(CP_ANADATA_TIMEOUT_2/1000);
				m_myTimer->ResetTimer();	// Timer zurücksetzen		

				if (CP_START == m_cpStatus && false == m_CountRunTime)
				{	// Nach dem Spülen, wenn das erste Byte empfangen wurde, wird die RunTime gezählt und die Ventile geschaltet
					m_CountRunTime = true;
					m_startRunTime = time(NULL);

					m_flushingFinished = true;	
				}

				merkeBytesReceivedAll = m_bytesReceivedAll;
			}

			if (m_myTimer->Get_NumberOfExpiry() > 0)
			{	// Wenn Timer abgelaufen war -> Timeout!
				m_myTimer->StopTimer();		// Timer anhalten
				m_myTimer->ResetTimer();	// Timer zurücksetzen
				timeout = true;
			}
		}
		merkeBytesReceivedAll = m_bytesReceivedAll;	// Zur Sicherheit am Ende nochmals kopieren

		if (m_bytesReceived == m_bytesSollRecv && (!timeout))
		{	// Wenn alles empfangen und kein Timeout
			ret = ProcessRecvData();
			xValue(CP4002ReqWithAnsw)++;
			//SaveXVars();
		}
		else
		{
			DTLOG(m_logid, DT_CP4002PROT_RECEIVE_FAILED, m_bytesSollRecv, m_bytesReceived);
			TRACE(_T("NOT all Bytes received or timeout! %i\n"), m_bytesReceived);	
			xValue(CP4002ReqWithoutAnsw)++;
			//SaveXVars();
		}
	}

	if (CP_START == m_cpStatus)
	{
		m_CountSampleTime = false;
		m_CountRunTime    = false;
	}

	return ret;
}

bool CCP4002Prot::RecvFomCAN(CANMSG *cm)
{	// Hier kommt Empfangenes von CAN an
	CANMSG *cmTemp = cm;
	
	memcpy((m_recvBuf+m_bytesReceived), cmTemp->byContent, cmTemp->byDatalength);

	if (0 == m_bytesReceived)	
		m_bytesReceivedAll = 0;
	m_bytesReceivedAll += cmTemp->byDatalength;

	if (CP_START == m_cpStatus)
		SetCpStatusString(RECEIVE);

	m_bytesReceived += cmTemp->byDatalength;

	//if (cmTemp->byDatalength > 0)
	//{
	//	SetEvent(m_recvEvent);	// Dem Protokoll melden, dass neue Daten eingegangen sind
	//}

	return true;
}