/**
* \brief Processing of the received packets from bus
* \param[in] XLevent& xlEvent message polled from the bus in XLevent format
* \param[in] unClientIndex is the client index
* \return void
* \authors Arunkumar Karri
* \date 07.10.2011 Created
*/
void CDIL_LIN_VectorXL::ProcessLINMsg(XLevent& xlEvent)
{
if ( S_OK == bClassifyMsgType(xlEvent, sg_asLINMsg) )
{
vWriteIntoClientsBuffer(sg_asLINMsg);
}
}
// RxD Event-Funktion
static void CALLBACK_TYPE CanRxEvent(uint32_t index, struct TCanMsg* msg, int32_t count)
{
(void)index;
static STCANDATA can_data;
can_data.m_uDataInfo.m_sCANMsg.m_bCANFD = false;
for (; count; count--)
{
EnterCriticalSection(&sg_DIL_CriticalSection);
can_data.m_uDataInfo.m_sCANMsg.m_ucChannel = 1;
can_data.m_uDataInfo.m_sCANMsg.m_unMsgID = msg->Id;
can_data.m_uDataInfo.m_sCANMsg.m_ucDataLen = msg->MsgLen;
can_data.m_uDataInfo.m_sCANMsg.m_ucEXTENDED = msg->MsgEFF;
can_data.m_uDataInfo.m_sCANMsg.m_ucRTR = msg->MsgRTR;
if (msg->MsgTxD)
{
can_data.m_ucDataType = TX_FLAG;
}
else
{
can_data.m_ucDataType = RX_FLAG;
}
//can_data.m_lTickCount.QuadPart = (LONGLONG)(msg->TimeStamp);
memcpy(can_data.m_uDataInfo.m_sCANMsg.m_ucData, msg->MsgData, 8);
//Write the msg into registered client's buffer
vWriteIntoClientsBuffer(can_data);
LeaveCriticalSection(&sg_DIL_CriticalSection);
msg++;
}
}
/** * \brief Processing of the received packets from bus * \param[in] LinMessageInfo msgInf message polled from the bus in LinMessageInfo format * \param[in] unClientIndex is the client index * \return void * \authors [email protected] * \date 05.29.2015 Created */ void CDIL_LIN_Kvaser::ProcessLINMsg(LinMessageInfo msgInf,unsigned char* msg,unsigned int flags,unsigned int len,unsigned int id,int chnindex) { if ( S_OK == bClassifyMsgType(&msgInf, sg_asLINMsg,msg,flags,len,id, chnindex) ) { vWriteIntoClientsBuffer(sg_asLINMsg); } }
/**
* @brief Sends STCAN_MSG structure from the client dwClientID.
* @param[in] dwClientID is the client ID
* @param[in] sMessage is the application specific CAN message structure
* @return S_OK for success, S_FALSE for failure
*/
HRESULT CDIL_CAN_VSCOM::sendMessage(DWORD dwClientID, const STCAN_MSG& sMessage)
{
VSCAN_MSG msg;
DWORD dwTemp;
static SACK_MAP sAckMap;
HRESULT hResult;
VALIDATE_VALUE_RETURN_VAL(sg_bCurrState, STATE_CONNECTED, ERR_IMPROPER_STATE);
hResult = S_FALSE;
if (bClientIdExist(dwClientID))
{
if (sMessage.m_ucChannel <= sg_nNoOfChannels)
{
memset(&msg, 0, sizeof(msg));
if (sMessage.m_ucEXTENDED == 1)
{
msg.Flags |= VSCAN_FLAGS_EXTENDED;
}
if (sMessage.m_ucRTR == 1)
{
msg.Flags |= VSCAN_FLAGS_REMOTE;
}
msg.Id = sMessage.m_unMsgID;
msg.Size = sMessage.m_ucDataLen;
memcpy(msg.Data, &sMessage.m_ucData, msg.Size);
sAckMap.m_ClientID = dwClientID;
sAckMap.m_Channel = sMessage.m_ucChannel;
sAckMap.m_MsgID = msg.Id;
vMarkEntryIntoMap(sAckMap);
if (VSCAN_Write(sg_VSCanCfg.hCan, &msg, 1, &dwTemp) == VSCAN_ERR_OK && dwTemp == 1)
{
static STCANDATA can_data;
CopyMsg2CanData(&can_data, &msg, TX_FLAG);
EnterCriticalSection(&sg_DIL_CriticalSection);
//Write the msg into registered client's buffer
vWriteIntoClientsBuffer(can_data);
LeaveCriticalSection(&sg_DIL_CriticalSection);
hResult = S_OK;
}
else
{
hResult = S_FALSE;
sg_pIlog->logMessage(A2T(__FILE__), __LINE__, _("could not write can data into bus"));
}
}
else
{
hResult = ERR_INVALID_CHANNEL;
}
}
else
{
hResult = ERR_NO_CLIENT_EXIST;
}
return(hResult);
}
// RxD Event-Funktion
static DWORD WINAPI CanRxEvent(LPVOID /*lpParam*/)
{
static STCANDATA can_data;
can_data.m_uDataInfo.m_sCANMsg.m_bCANFD = false;
DWORD dwTemp;
VSCAN_MSG msg;
for (;;)
{
if (WaitForSingleObject(sg_hEventRecv, INFINITE) == WAIT_OBJECT_0)
{
for (;;)
{
if (VSCAN_Read(sg_VSCanCfg.hCan, &msg, 1, &dwTemp) != VSCAN_ERR_OK)
{
sg_pIlog->logMessage(A2T(__FILE__), __LINE__, _("VSCAN_Read failed"));
Sleep(100);
continue;
}
if (dwTemp == 1)
{
CopyMsg2CanData(&can_data, &msg, RX_FLAG);
//Write the msg into registered client's buffer
EnterCriticalSection(&sg_DIL_CriticalSection);
vWriteIntoClientsBuffer(can_data);
LeaveCriticalSection(&sg_DIL_CriticalSection);
}
else
{
break;
}
}
}
else
{
sg_pIlog->logMessage(A2T(__FILE__), __LINE__, _("WaitForSingleObject failed"));
Sleep(100);
}
}
}
/**
* \brief Read thread procedure
* \param[in] pVoid contains the CPARAM_THREADPROC class object
* \return void
* \authors Prince Varghese
* \date 09.04.2013 Created
*/
DWORD WINAPI CanMsgReadThreadProc_CAN_ISolar_Eve(LPVOID pVoid)
{
USES_CONVERSION;
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
/* Assign thread action to CREATE_TIME_MAP */
pThreadParam->m_unActionCode = CREATE_TIME_MAP;
bool bLoopON = true;
while (bLoopON)
{
Sleep (10); // To avoid continuous loop as there is no event mechanism
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
int functionType = 0;
unsigned int dataSize = 0;
if (ReceiveCommandFromClient(&functionType, &dataSize) >= 0)
{
switch (functionType)
{
case SEND_MESSAGE:
{
STCAN_MSG RxMsg;
int receiveResult = ReceiveCANMessageFromClient(&RxMsg);
if (receiveResult > 0)
{
sg_EVE_CANMsg.m_uDataInfo.m_sCANMsg.m_bCANFD = false;
sg_EVE_CANMsg.m_ucDataType = receiveResult;
sg_EVE_CANMsg.m_uDataInfo.m_sCANMsg = RxMsg;
RxMsg.m_ucChannel = 1;
vWriteIntoClientsBuffer(sg_EVE_CANMsg);
}
}
break;
default:
break;
}
}
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case CREATE_TIME_MAP:
{
SetEvent(pThreadParam->m_hActionEvent);
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
pThreadParam->m_hActionEvent = nullptr;
return 0;
}
/**
* \brief Read thread procedure
* \param[in] pVoid contains the CPARAM_THREADPROC class object
* \return void
* \authors Prince Varghese
* \date 09.04.2013 Created
*/
DWORD WINAPI LinMsgReadThreadProc_LIN_ISolar_Eve(LPVOID pVoid)
{
USES_CONVERSION;
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
/* Assign thread action to CREATE_TIME_MAP */
pThreadParam->m_unActionCode = CREATE_TIME_MAP;
/* Dummy action event */
pThreadParam->m_hActionEvent = CreateEvent(nullptr, false, false, nullptr);
bool bLoopON = true;
while (bLoopON)
{
Sleep (10);
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
static STLIN_FRAME RxFrame;
static STLIN_MSG RxMsg;
static int iRxLength;
int iChecksum = 0;
RxMsg.m_ucDataLen = 0;
unsigned int uiDataType = ReceiveLINMessageFromClient(&RxFrame, &iRxLength);
if (iRxLength == LIN_PID_LENGTH)
{
RxMsg.m_ucMsgID = RxFrame.m_ucMsgID;
RxMsg.m_ucChksum = 0;
vValidateReceivedLinPID(RxMsg);
/*sg_EVE_LINMsg.m_ucDataType = TX_FLAG;*/
sg_EVE_LINMsg.m_uDataInfo.m_sLINMsg = RxMsg;
RxMsg.m_ucChannel = LIN_CHANNEL_1;
//vWriteIntoClientsBuffer(sg_EVE_LINMsg);
}
else if (iRxLength > LIN_PID_LENGTH)
{
RxMsg.m_ucMsgID = RxFrame.m_ucMsgID;
RxMsg.m_ucChksum = RxFrame.m_ucChksum;
RxMsg.m_ucDataLen = iRxLength - (LIN_PID_LENGTH + LIN_CHECKSUM_LENGTH); // 2 (1 byte checksum and 1byte pid)
for(int i=0; i<8; i++)
{
RxMsg.m_ucData[i] = RxFrame.m_ucData[i];
iChecksum = iChecksum + RxFrame.m_ucData[i];
if (iChecksum > 255)
{
iChecksum = iChecksum - 255;
}
}
RxMsg.m_ucChksum = 255 - iChecksum;
if((RxMsg.m_ucChksum != RxFrame.m_ucChksum))
{
RxMsg.m_ucMsgTyp = LIN_CHECKSUM_ERROR;
RxMsg.m_ucChksum = RxFrame.m_ucChksum;
}
else
{
vValidateReceivedLinMsg(RxMsg);
}
if(uiDataType == TX_LOOPBACK_UDP_DATA)
{
sg_EVE_LINMsg.m_ucDataType = TX_FLAG;
}
else if((uiDataType == RX_UDP_PID)||(uiDataType == RX_UDP_DATA))
{
sg_EVE_LINMsg.m_ucDataType = RX_FLAG;
}
RxMsg.m_ucChannel = LIN_CHANNEL_1;
sg_EVE_LINMsg.m_uDataInfo.m_sLINMsg = RxMsg;
RxMsg.m_ucChannel = 1;
vWriteIntoClientsBuffer(sg_EVE_LINMsg);
}
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case CREATE_TIME_MAP:
{
SetEvent(pThreadParam->m_hActionEvent);
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
pThreadParam->m_hActionEvent = nullptr;
return 0;
}
