short CCP4002Prot::Transmit(unsigned int cpStatus)
{
	short transRet = 0;	// Rückgabewert von Trans()
	short recvRet  = 0;	// Rückgabewert von Recv()

	m_cpStatus = cpStatus;
	switch (m_cpStatus)
	{
	case CP_A_SEND:	m_transChar = 'A';  m_bytesSollRecv = 0;     m_recvTimeoutSec = CP_NORMAL_TIMEOUT;								 break; // Reset CP4002
	case CP_J_SEND:	m_transChar = 'J';  m_bytesSollRecv = 16;    m_recvTimeoutSec = CP_NORMAL_TIMEOUT;								 break; // GC-Ident anfordern
	case CP_N_SEND:	m_transChar = 'N';  m_bytesSollRecv = 0;     m_recvTimeoutSec = CP_NORMAL_TIMEOUT;								 break; // FlushMode prüfen?
	case CP_C_SEND:	m_transChar = 'C';  m_bytesSollRecv = 14;    m_recvTimeoutSec = CP_NORMAL_TIMEOUT;								 break; // SBlockA
	case CP_H_SEND:	m_transChar = 'H';  m_bytesSollRecv = 14;    m_recvTimeoutSec = CP_NORMAL_TIMEOUT;								 break; // SBlockB
	case CP_SMB_SEND: m_transChar = '\0'; m_bytesSollRecv = 0;     m_recvTimeoutSec = CP_NORMAL_TIMEOUT;								 break; // a-m Parameter
	case CP_D_SEND:   m_transChar = 'D';  m_bytesSollRecv = 29;    m_recvTimeoutSec = CP_NORMAL_TIMEOUT;								 break; // Methode
	case CP_START:    m_transChar = 'B';  m_bytesSollRecv = 42000; m_recvTimeoutSec = ((SMethodBlock.sample_time*1000) + 5000); break; // Analysendaten		
	default:				ASSERT(false);                 																								    break; // Sollte nie vorkommen!		
	}

	memset(m_transBuf, 0x00, CP_TRANSMIT_MAX_LEN);

	m_myTimer->Set_MaxSecs(m_recvTimeoutSec/1000);

	switch (m_cpStatus)
	{
	case CP_A_SEND:
	case CP_J_SEND:
	case CP_N_SEND:
	case CP_C_SEND:
	case CP_H_SEND:
	case CP_D_SEND:
	case CP_START:	
		// Befehlszeichen senden
		m_transBuf[0] = m_transChar;
		m_transBuflen = 1;

		transRet = Trans();
		if (0 == transRet)	// Wenn das Senden erfolgreich war, wird empfangen
			recvRet = Recv();
		break;
		
	case CP_SMB_SEND:
		// Parameter a-m senden
		m_pSMethodBlock = (char *)&SMethodBlock;
		m_transBuflen = 2;

		for (int cSmb = 'a'; cSmb <= 'm'; cSmb++)
		{
			if (cSmb == 's')	/* 19tes Element aus SMB überspringen*/
				cSmb++; 
				             
			m_transBuf[0] = cSmb;
			m_transBuf[1] = *m_pSMethodBlock++;
			
			transRet = Trans();	
			if (0 == transRet)	// Wenn das Senden erfolgreich war, wird empfangen
				recvRet = Recv();
		}
		break;

	default:		// Sollte nie vorkommen!
		ASSERT(false);
		break;
	}

	return (transRet | recvRet);
}

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/1000);
		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) && m_ProtocollIsRunning) 
		{	// Wenn noch nicht alle Bytes empfangen wurden und es noch kein Timeout gab, wird auf weitere Daten gewartet
			// Prüfung von 'm_ProtocollIsRunning' ermöglicht sofortiges Beenden während Datenempfang von Messwerk
			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->ResetTimer();	// Timer zurücksetzen
				timeout = true;
				ret = -1;
			}
		}
		merkeBytesReceivedAll = m_bytesReceivedAll;	// Zur Sicherheit am Ende nochmals kopieren

		m_myTimer->StopTimer();

		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;

	return true;
}