/****************************************************************************** Function Name : TSDataReadThreadProc Input(s) : LPVOID pVoid - Thread Parameter Output : DWORD - S_OK if Success otherwise S_FALSE Functionality : Starts The Read Thread Member of : - Friend of : - Author(s) : Venkatanarayana Makam Date Created : 01/04/2011 Modifications : ******************************************************************************/ DWORD WINAPI TSDataReadThreadProc(LPVOID pVoid) { USES_CONVERSION; CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; if (pThreadParam == NULL) { return ((DWORD)-1); } CTSExecutionCAN* pTSXExecutionCAN = (CTSExecutionCAN*)pThreadParam->m_pBuffer; if (pTSXExecutionCAN == NULL) { return ((DWORD)-1); } bool bLoopON = true; pThreadParam->m_unActionCode = INVOKE_FUNCTION; while (bLoopON) { WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE); switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { ReadTSXDataBuffer(pTSXExecutionCAN); // Retrieve message from the driver } break; case EXIT_THREAD: { bLoopON = false; } break; case CREATE_TIME_MAP: { } break; case INACTION: { ReadVerifyTSXDataBuffer(pTSXExecutionCAN); // nothing right at this moment } break; default: { } break; } } SetEvent(pThreadParam->hGetExitNotifyEvent()); return 0; }
DWORD WINAPI FlexMsgReadThreadProc_Stub(LPVOID pVoid) { VALIDATE_POINTER_RETURN_VAL(sg_pIlog, (DWORD)-1); CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC *) pVoid; pThreadParam->m_unActionCode = CREATE_TIME_MAP; // Validate certain required pointers bool bLoopON = true; while (bLoopON) { static HANDLE ahClientReadHandle[MAX_CLIENT_ALLOWED] = {0}; for (UINT i = 0; i < sg_unClientCnt; i++) { ahClientReadHandle[i] = sg_asClientToBufMap[i].hClientHandle; } DWORD dwIndex = WaitForMultipleObjects(sg_unClientCnt, ahClientReadHandle, FALSE, INFINITE); if (dwIndex == WAIT_FAILED) { GetSystemErrorString(); } else { UINT Index = dwIndex - WAIT_OBJECT_0; switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { // Retrieve message from the pipe ProcessCanMsg(sg_asClientToBufMap[Index].hPipeFileHandle, Index); } break; case CREATE_TIME_MAP: { PerformAnOperation(GET_TIME_MAP); ProcessCanMsg(sg_asClientToBufMap[Index].hPipeFileHandle, Index); pThreadParam->m_unActionCode = INVOKE_FUNCTION; } break; case EXIT_THREAD: { bLoopON = false; } break; default: case INACTION: { // nothing right at this moment } break; } } } SetEvent(pThreadParam->hGetExitNotifyEvent()); return 0; }
HRESULT Worker_Disconnect(ISimENG* /*pISimENGLoc*/, Base_WrapperErrorLogger* pIlogLoc) { if (GetCurrState() == STATE_PRIMORDIAL) { sg_acErrStr = _("CAN_STUB_DeselectHwInterface called at STATE_PRIMORDIAL"); return S_FALSE; } else if (GetCurrState() == STATE_RESET) { pIlogLoc->vLogAMessage(__FILE__, __LINE__, (_("CAN_STUB_DeselectHwInterface called at improper state"))); return S_FALSE; } // Close the message reading thread if(sg_unClientCnt <= 0 ) { //Some Error Happened But Thread close is required. //sg_unClientCnt = 0 means there is no data flow and thread //force termination is safe. sg_sParmRThreadStub.bForceTerminateThread(); } else { sg_sParmRThreadStub.bTerminateThread(); } return S_OK; }
/** * \param[in] pVoid contains CBusStatisticCAN pointer * * Thread Function that is used to read the driver data and * updates the Bus Statistics. */ DWORD WINAPI BSDataReadThreadProc(LPVOID pVoid) { CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; if (pThreadParam == NULL) { return ((DWORD)-1); } CBusStatisticCAN* pBusStatistics = static_cast<CBusStatisticCAN*> (pThreadParam->m_pBuffer); if (pBusStatistics == NULL) { return ((DWORD)-1); } bool bLoopON = true; pThreadParam->m_unActionCode = INVOKE_FUNCTION; while (bLoopON) { WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE); switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { ReadBSDataBuffer(pBusStatistics); // Retrieve message from the driver } break; case EXIT_THREAD: { bLoopON = false; } break; case CREATE_TIME_MAP: { //Nothing at this moment } break; case INACTION: { // nothing right at this moment } break; default: { } break; } } SetEvent(pThreadParam->hGetExitNotifyEvent()); return 0; }
DWORD WINAPI DataCopyThreadProc(LPVOID pVoid) { CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; if (pThreadParam == NULL) { // TBD } CFrameProcessor_Common* pCurrObj = (CFrameProcessor_Common*) pThreadParam->m_pBuffer; if (pCurrObj == NULL) { // TBD } //pThreadParam->m_unActionCode = INACTION; bool bLoopON = true; while (bLoopON) { WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE); switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { // Retrieve message from the driver pCurrObj->vRetrieveDataFromBuffer(); ResetEvent(pThreadParam->m_hActionEvent); } break; case EXIT_THREAD: { bLoopON = false; } break; case CREATE_TIME_MAP: { pCurrObj->InitTimeParams(); pThreadParam->m_unActionCode = INVOKE_FUNCTION; SetEvent(pThreadParam->m_hActionEvent); } break; default: case INACTION: { // nothing right at this moment } break; } } SetEvent(pThreadParam->hGetExitNotifyEvent()); return 0; }
DWORD WINAPI ExecuteThread( LPVOID pParam ) { USES_CONVERSION; CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pParam; if (pThreadParam == NULL) { return ((DWORD)-1); } CTSExecutorChildFrame* pExecutionFrame = (CTSExecutorChildFrame*)pThreadParam->m_pBuffer; if (pExecutionFrame == NULL) { return ((DWORD)-1); } bool bLoopON = true; pThreadParam->m_unActionCode = INVOKE_FUNCTION; while (bLoopON) { WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE); switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { pExecutionFrame->m_ouTSExecutor.Execute(); pExecutionFrame->SendMessage(WM_EXECUSTIONOVER, 0, 0); } break; case EXIT_THREAD: { bLoopON = false; } break; default: { } break; } } SetEvent(pThreadParam->hGetExitNotifyEvent()); return S_OK; }
HRESULT CDIL_CAN_STUB::CAN_PerformInitOperations(void) { HRESULT hResult = S_FALSE; // Initialize the critical section InitializeCriticalSection(&sg_CSBroker); // Create the notification event sg_hNotifyFinish = CreateEvent(NULL, false, false, NULL); if (NULL != sg_hNotifyFinish) { // Then create the broker worker thread sg_sBrokerObjBusEmulation.m_hActionEvent = CreateEvent(NULL, false, false, NULL); ResetEvent(sg_sBrokerObjBusEmulation.m_hActionEvent); sg_sBrokerObjBusEmulation.m_unActionCode = INACTION; if (sg_sBrokerObjBusEmulation.bStartThread(BrokerThreadBusEmulation)) { hResult = S_OK; } else { CloseHandle(sg_hNotifyFinish); sg_hNotifyFinish = NULL; } } return hResult; }
HRESULT CDIL_CAN_STUB::CAN_PerformClosureOperations(void) { //First remove all the client for (UINT nCount = 0; nCount < sg_unClientCnt; nCount++) { CAN_RegisterClient(FALSE, sg_asClientToBufMap[nCount].dwClientID, ""); } // First disconnect from the simulation engine CAN_DeselectHwInterface(); // Then terminate the broker thread sg_sBrokerObjBusEmulation.bTerminateThread(); // Close the notification event if (NULL != sg_hNotifyFinish) { CloseHandle(sg_hNotifyFinish); sg_hNotifyFinish = NULL; } // Delete the critical section DeleteCriticalSection(&sg_CSBroker); sg_pIlog = NULL; // Log interface pointer SetCurrState(STATE_PRIMORDIAL); return S_OK; }
DWORD WINAPI CTxEthernetDataStore::EthernetTxWndTransmitThread(LPVOID pVoid) { CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; if (pThreadParam == NULL) { return (DWORD)-1; } CTxEthernetDataStore* pouData = (CTxEthernetDataStore*)pThreadParam->m_pBuffer; if (pouData == NULL) { return (DWORD)-1; } bool bLoopON = true; while (bLoopON) { WaitForSingleObject(pThreadParam->m_hActionEvent, 1); switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { pouData->nTransmitMessages(); } break; case SUSPEND: { WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE); } break; case EXIT_THREAD: { bLoopON = false; } break; default: break; } } SetEvent(pThreadParam->hGetExitNotifyEvent()); return 0; }
/* Function to stop msg read thread*/ BOOL bStopGraphReadThread() { BOOL bReturn = FALSE; bReturn = m_ouGraphReadThread.bTerminateThread(); m_ouGraphReadThread.m_hActionEvent = NULL; m_ouGraphReadThread.m_unActionCode = IDLE; return bReturn; }
DWORD WINAPI SigWatchDataReadThreadProc_C(LPVOID pVoid) { CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC *) pVoid; if (pThreadParam == NULL) { return (DWORD)-1; } CSignalWatch_CAN* pSWCan = (CSignalWatch_CAN*)pThreadParam->m_pBuffer; if (pSWCan == NULL) { return (DWORD)-1; } bool bLoopON = true; pThreadParam->m_unActionCode = INVOKE_FUNCTION; while (bLoopON) { WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE); switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { ReadCANDataBuffer(pSWCan); // Retrieve message from the driver } break; case EXIT_THREAD: { bLoopON = false; } break; case CREATE_TIME_MAP: { //Nothing at this moment } break; default: case INACTION: { // nothing right at this moment } break; } } SetEvent(pThreadParam->hGetExitNotifyEvent()); return 0; }
/* Function to start Msg read thread*/ BOOL bStartGraphReadThread() { BOOL bReturn = FALSE; //First stop the thread if running bStopGraphReadThread(); m_ouGraphReadThread.m_hActionEvent = NULL; m_ouGraphReadThread.m_unActionCode = IDLE; m_ouGraphReadThread.m_pBuffer = NULL; m_ouGraphReadThread.m_hActionEvent = m_ouMsgInterpretBuffer.hGetNotifyingEvent(); bReturn = m_ouGraphReadThread.bStartThread(SignalDataPlotterThread); return bReturn; }
HRESULT CSimENG::FinalConstruct() { // Initialise the random number generator srand((unsigned) time(NULL)); // To create the worker thread that relays messages to other nodes // First initialise the parameters sg_sThreadCtrlObj.m_hActionEvent = sg_MessageBuf.hGetNotifyingEvent(); sg_sThreadCtrlObj.m_pBuffer = &sg_MessageBuf; sg_sThreadCtrlObj.m_unActionCode = INVOKE_FUNCTION; // Now start the thread sg_sThreadCtrlObj.bStartThread(MsgDelegatingThread); //MessageBox(NULL, "in FinalConstruct()", "Member function", MB_OK); return S_OK; }
HRESULT Worker_Disconnect(ISimENG* /*pISimENGLoc*/, Base_WrapperErrorLogger* pIlogLoc) { if (GetCurrState() == STATE_PRIMORDIAL) { sg_acErrStr = "CAN_STUB_DeselectHwInterface called at STATE_PRIMORDIAL"; return S_FALSE; } else if (GetCurrState() == STATE_RESET) { pIlogLoc->vLogAMessage(__FILE__, __LINE__, ("CAN_STUB_DeselectHwInterface called at improper state")); return S_FALSE; } // Close the message reading thread sg_sParmRThreadStub.bTerminateThread(); return S_OK; }
HRESULT Worker_Connect(ISimENG* pISimENGLoc, Base_WrapperErrorLogger* pIlogLoc) { if (GetCurrState() == STATE_PRIMORDIAL) { sg_acErrStr = "CAN_STUB_Connect called at STATE_PRIMORDIAL"; return S_FALSE; } else if (GetCurrState() != STATE_INITIALISED) { sg_pIlog->vLogAMessage(__FILE__, __LINE__, ("CAN_STUB_Connect called at improper state")); return S_FALSE; } sg_sParmRThreadStub.m_unActionCode = INVOKE_FUNCTION; if (sg_sParmRThreadStub.bStartThread(FlexMsgReadThreadProc_Stub) == FALSE) { sg_sParmRThreadStub.m_hActionEvent = NULL; // Unregister from the simulation engine for (UINT i = 0; i < sg_unClientCnt; i++) { sg_ushTempClientID = (USHORT)sg_asClientToBufMap[i].dwClientID; sg_hTmpClientHandle = sg_asClientToBufMap[i].hClientHandle; sg_hTmpPipeHandle = sg_asClientToBufMap[i].hPipeFileHandle; Worker_UnregisterClient(pISimENGLoc, pIlogLoc); sg_asClientToBufMap[i].dwClientID = 0; sg_asClientToBufMap[i].hClientHandle = NULL; sg_asClientToBufMap[i].hPipeFileHandle = NULL; } sg_pIlog->vLogAMessage(__FILE__, __LINE__, ("Unable to start the reading thread")); return S_FALSE; } // Reaching upto this point means all the necessary activities are over SetCurrState(STATE_REGISTERED); return S_OK; }
void CSimENG::FinalRelease() { // Close the message relay worker thread sg_sThreadCtrlObj.bTerminateThread(); DeleteCriticalSection(&sg_CriticalSection); DeleteCriticalSection(&sg_CSMsgEntry); if (NULL != sg_pbEntry) { delete[] sg_pbEntry; sg_pbEntry = NULL; sg_nEntryLen = 0; } if (NULL != sg_pbEntry2) { delete[] sg_pbEntry2; sg_pbEntry2 = NULL; sg_nEntryLen2 = 0; } }
HRESULT CDIL_Ethernet_Interface:: Ethernet_StartHardware(void) { sg_bCurrState = STATE_HW_INTERFACE_SELECTED; //TODO: remove this line, added just to test VALIDATE_VALUE_RETURN_VAL(sg_bCurrState, STATE_HW_INTERFACE_SELECTED, ERR_IMPROPER_STATE); USES_CONVERSION; HRESULT hResult = S_OK; ResetEvent(g_hInformStopTx); //Connect to the network hResult = nConnect(TRUE); if (hResult == defERR_OK) { hResult = S_OK; sg_bCurrState = STATE_CONNECTED; // vCreateTimeModeMapping(g_hReadEventObject); } else { //log the error for open port failure vRetrieveAndLog(hResult, __FILE__, __LINE__); hResult = ERR_LOAD_HW_INTERFACE; } //If everything is ok start the read thread if (hResult == S_OK) { if (sg_sParmRThread.bStartThread(EthernetMsgReadThreadProc)) { hResult = S_OK; } else { sg_pIlog->vLogAMessage(A2T(__FILE__), __LINE__, _T(_("Could not start the read thread") )); } } return hResult; }
HRESULT CDIL_Ethernet_Interface:: Ethernet_StopHardware(void) { VALIDATE_VALUE_RETURN_VAL(sg_bCurrState, STATE_CONNECTED, ERR_IMPROPER_STATE); HRESULT hResult = S_OK; //Terminate the read thread sg_sParmRThread.bTerminateThread(); SetEvent(g_hInformStopTx); hResult = nConnect(FALSE); if (hResult == defERR_OK) { hResult = S_OK; sg_bCurrState = STATE_HW_INTERFACE_SELECTED; } else { //log the error for open port failure vRetrieveAndLog(hResult, __FILE__, __LINE__); hResult = ERR_LOAD_HW_INTERFACE; } return hResult; }
DWORD WINAPI BrokerThreadBusEmulation(LPVOID pVoid) { CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; // Validate certain required pointers //VALIDATE_POINTER_RETURN_VALUE_LOG(pThreadParam, -1); //VALIDATE_POINTER_RETURN_VALUE_LOG(pThreadParam->m_hActionEvent, -1); // Get hold of the bus simulation and error logger interfaces HRESULT hResult = CoInitialize(NULL); ISimENG* pISimENG = NULL; hResult = CoCreateInstance(CLSID_SimENG, NULL, CLSCTX_LOCAL_SERVER, IID_ISimENG, (LPVOID*) &pISimENG); if ((S_OK != hResult) || (NULL == pISimENG)) { return 0L; } bool bLoopON = true; while (bLoopON) { WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE); switch (pThreadParam->m_unActionCode) { case CONNECT: { sg_hResult = Worker_Connect(pISimENG, sg_pIlog); SetEvent(sg_hNotifyFinish); } break; case DISCONNECT: { sg_hResult = Worker_Disconnect(pISimENG, sg_pIlog); SetEvent(sg_hNotifyFinish); } break; case STOP_HARDWARE: { sg_hResult = Worker_StopHardware(pISimENG, sg_pIlog); SetEvent(sg_hNotifyFinish); } break; case START_HARDWARE: { sg_hResult = Worker_StartHardware(pISimENG, sg_pIlog); SetEvent(sg_hNotifyFinish); } break; case SEND_MESSAGE: { sg_hResult = Worker_SendCanMsg(pISimENG, sg_pIlog, sg_pouCanTxMsg); SetEvent(sg_hNotifyFinish); } break; case GET_TIME_MAP: { sg_hResult = Worker_GetTimeModeMapping(pISimENG, sg_pIlog); SetEvent(sg_hNotifyFinish); } break; case REGISTER: { sg_hResult = Worker_RegisterClient(pISimENG, sg_pIlog); SetEvent(sg_hNotifyFinish); } break; case UNREGISTER: { sg_hResult = Worker_UnregisterClient(pISimENG, sg_pIlog); SetEvent(sg_hNotifyFinish); } break; case EXIT_THREAD: { bLoopON = false; } break; default: case INACTION: { // nothing right at this moment } break; } } // Release the bus simulation & error logger out-of-proc server components //pISimENG->Release(); // Reset the interface pointers pISimENG = NULL; SetEvent(pThreadParam->hGetExitNotifyEvent()); 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 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 = NULL; return 0; }
DWORD WINAPI ReadDILCANMsg(LPVOID pVoid) { CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; if (pThreadParam != NULL) { CReadCanMsg* pCurrObj = (CReadCanMsg*) pThreadParam->m_pBuffer; if (pCurrObj != NULL) { pThreadParam->m_unActionCode = INVOKE_FUNCTION; // Set default action // Create the action event. In this case this will be used solely for // thread exit procedure. The first entry will be used. pThreadParam->m_hActionEvent = pCurrObj->m_ahActionEvent[0]; DWORD dwWaitRet; BYTE byHIndex; bool bLoopON = true; while (bLoopON) { dwWaitRet = WaitForMultipleObjects(pCurrObj->m_nEvents, pCurrObj->m_ahActionEvent, FALSE, INFINITE); ///// TEMP : BEGIN DWORD dwLLimit = WAIT_OBJECT_0; DWORD dwULimit = WAIT_OBJECT_0 + pCurrObj->m_nEvents - 1; DWORD dwLLError = WAIT_ABANDONED_0; DWORD dwULError = WAIT_ABANDONED_0 + pCurrObj->m_nEvents - 1; if ((dwWaitRet >= dwLLimit) && (dwWaitRet <= dwULimit)) { switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { //Get the handle's index and pass it byHIndex = (BYTE)(dwWaitRet - WAIT_OBJECT_0); HANDLE hHandleSet = pCurrObj->m_ahActionEvent[byHIndex]; BYTE byNodeIndex; if( pCurrObj->m_omHandleToNodeMgrMap.Lookup(hHandleSet, byNodeIndex)) { //vRetrieveDataFromBuffer to read from that buffer pCurrObj->vRetrieveDataFromBuffer(byNodeIndex); } //BOOL Result = ResetEvent(hHandleSet); ResetEvent(hHandleSet); } break; case EXIT_THREAD: { bLoopON = false; } break; case INACTION: { // Signal the owner SetEvent(pThreadParam->m_hThread2Owner); Sleep(0); // Wait until owner signals back. WaitForSingleObject(pThreadParam->m_hOwner2Thread, INFINITE); // Signal the owner SetEvent(pThreadParam->m_hThread2Owner); Sleep(0); } break; case CREATE_TIME_MAP: default: break; } } else if ((dwWaitRet >= dwLLError) && (dwWaitRet <= dwULError)) { TRACE(_T(_("Abandoned... %X %d\n")), dwWaitRet, g_unCount++); } else if ( dwWaitRet == WAIT_TIMEOUT) { TRACE(_T("ReadDILCANMsg->WAIT_TIMEOUT %d\n"), g_unCount++); } else if (dwWaitRet == WAIT_FAILED) { TRACE(_T("WAIT_FAILED... %X %d\n"), GetLastError(), g_unCount++); } ///// TEMP : END } SetEvent(pThreadParam->hGetExitNotifyEvent()); } } 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; }
/** * \brief Read thread procedure * \param[in] pVoid contains the CPARAM_THREADPROC class object * \return void * \authors Arunkumar Karri * \date 07.19.2013 Created */ DWORD WINAPI CDIL_LIN_VectorXL::LINMsgReadThreadProc_LIN_Vector_XL(LPVOID pVoid) { USES_CONVERSION; CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; XLstatus xlStatus = XL_SUCCESS; /* Assign thread action to CREATE_TIME_MAP */ pThreadParam->m_unActionCode = CREATE_TIME_MAP; /* Set the event to LIN_Vector_XL driver for wakeup and frame arrival notification */ //for (UINT i = 0; i < sg_unClientCnt; i++) { xlStatus = xlSetNotification (g_xlPortHandle[0], &g_hDataEvent[0], 1); } /* Set the thread action event to first notification event handle */ if (g_hDataEvent[0] != nullptr) { pThreadParam->m_hActionEvent = g_hDataEvent[0]; } /* Get the handle to the controller and validate it */ VALIDATE_POINTER_RETURN_VALUE_LOG(pThreadParam->m_hActionEvent, (DWORD)-1); DWORD dwResult = 0; unsigned int msgsrx; XLevent xlEvent; bool bLoopON = true; while (bLoopON) { WaitForSingleObject(g_hDataEvent[0], INFINITE); switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { bool bMoreDataExist; msgsrx = RECEIVE_EVENT_SIZE; xlStatus = xlReceive(g_xlPortHandle[0], &msgsrx, &xlEvent); while (xlStatus == XL_SUCCESS ) { switch (xlStatus) { case XL_SUCCESS: { if ( g_pouDIL_LIN_Vector_XL != nullptr ) { g_pouDIL_LIN_Vector_XL->ProcessLINMsg(xlEvent); bMoreDataExist = true; } } break; default: break; } xlStatus = xlReceive(g_xlPortHandle[0], &msgsrx, &xlEvent);; } } break; case EXIT_THREAD: { bLoopON = false; } break; case CREATE_TIME_MAP: { //vCreateTimeModeMapping(pThreadParam->m_hActionEvent); SetEvent(pThreadParam->m_hActionEvent); pThreadParam->m_unActionCode = INVOKE_FUNCTION; } break; default: case INACTION: { // nothing right at this moment } break; } } SetEvent(pThreadParam->hGetExitNotifyEvent()); { ResetEvent(g_hDataEvent[0]); g_hDataEvent[0] = nullptr; } pThreadParam->m_hActionEvent = nullptr; return 0; }
/* Thread function used for sending messages cyclically */ DWORD WINAPI Cyclic_Transmission_Thread(LPVOID pVoid) { CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; if (pThreadParam == NULL) { return (DWORD)-1; } CTxMsgWndJ1939* pTxMsgWndJ1939 = static_cast<CTxMsgWndJ1939*> (pThreadParam->m_pBuffer); if (pTxMsgWndJ1939 == NULL) { return (DWORD)-1; } bool bLoopON = true; DWORD dwMiliSecs = INFINITE; while (bLoopON) // Continue so long as the loop is ON. { WaitForSingleObject(pThreadParam->m_hActionEvent, dwMiliSecs); dwMiliSecs = pTxMsgWndJ1939->unGetTimerVal(); ESTATE_TRANS eTransState = pTxMsgWndJ1939->eGetTransState(); if ((eTransState == TRANS_TO_BE_STOPPED) || (eTransState == TRANS_STOPPED)) { if (NULL != pTxMsgWndJ1939 && IsWindow(pTxMsgWndJ1939->m_hWnd)) { pTxMsgWndJ1939->vProcessTransmission(FALSE); dwMiliSecs = INFINITE; ResetEvent(pThreadParam->m_hActionEvent); } } else if (eTransState == TRANS_STARTED) { switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { if (pTxMsgWndJ1939->SendSavedMessage() == S_OK) { if (pTxMsgWndJ1939->m_sMsgToBeSent.m_unDLC > 8) { WaitForSingleObject(sg_hMsgSent, INFINITE); } } } break; case EXIT_THREAD: { bLoopON = false; } break; case IDLE: break; default: break; } } } SetEvent(pThreadParam->hGetExitNotifyEvent()); // Signal the owner that the thread Sleep(0); // is going to terminate the infinite loop. return 0; }
/** * Read thread procedure */ DWORD WINAPI EthernetMsgReadThreadProc(LPVOID pVoid) { USES_CONVERSION; CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid; // Validate certain required pointers VALIDATE_POINTER_RETURN_VALUE_LOG(pThreadParam, (DWORD)-1); // Assign thread action to CREATE_TIME_MAP pThreadParam->m_unActionCode = INVOKE_FUNCTION; //Set event object for reading from the socket //SOCKET ClientSocket = sg_Connector.GetClientSocket(); //int rc = WSAEventSelect(ClientSocket, g_hReadEventObject, FD_READ); int rc = 0; if(rc == SOCKET_ERROR) { //unable to add event for reading return 1; } HANDLE hDataEvent = sg_Connector.GetEvent(); HANDLE hEvents[] = {sg_hDataReceivedEvent, g_hInformStopTx}; bool bLoopON = true; sg_Connector.SetReceiveCallBackFn(); PPKTHDR *pHeader = new PPKTHDR; u_char *pkt_data = new u_char[1540]; while (bLoopON) { //g_hReadEventObject is the event triggered on reception of the Data in ethernet port //Event should listen to the client socket in CConnector class WaitForMultipleObjects(2, hEvents, FALSE, INFINITE); //WaitForSingleObject(sg_hDataReceivedEvent, INFINITE); if(sg_bIsConnected == false) { pThreadParam->m_unActionCode = EXIT_THREAD; break; } switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { int nResult = 0; do { string strError; nResult = sg_Connector.ReceivePackets(&pHeader,&pkt_data); if(nResult == S_FALSE) { sg_pIlog->vLogAMessage(A2T(__FILE__), __LINE__, strError); break; } ProcessMsg(pHeader,pkt_data ); ResetEvent(sg_hDataReceivedEvent); //delete(pHeader); //delete(pkt_data); } while (nResult > 0); } 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; } } /*delete(pHeader); delete(pkt_data);*/ SetEvent(pThreadParam->hGetExitNotifyEvent()); ResetEvent(sg_hDataReceivedEvent); //g_hReadEventObject = NULL; /* for (UINT i = 0; i < sg_unClientCnt; i++) { ResetEvent(hReadEventObject); g_hDataEvent[i] = NULL; }*/ pThreadParam->m_hActionEvent = NULL; return 0; }
DWORD WINAPI MsgDelegatingThread(LPVOID pParam) { CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pParam; WORD wSenderID = 0; INT Type = -1; UINT64 TimeStamp = 0x0; bool bLoopON = true; while (bLoopON) { WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE); switch (pThreadParam->m_unActionCode) { case INVOKE_FUNCTION: { // Retrieve message from the circular buffer while (sg_MessageBuf.GetMsgCount() > 0) { EnterCriticalSection(&sg_CriticalSection); BYTE* pbCurrEntry = sg_pbEntry2; INT CurrLength = sg_nEntryLen2; sg_MessageBuf.ReadFromBuffer(Type, pbCurrEntry, CurrLength); // Save the sender id for reference memcpy(&TimeStamp, pbCurrEntry + 1, SIZE_TIMESTAMP); wSenderID = (WORD) TimeStamp; // Calculate the current time stamp assigning the same to // the message LARGE_INTEGER CurrCounter; QueryPerformanceCounter(&CurrCounter); // Convert it to time stamp with the granularity of hundreds of us if (CurrCounter.QuadPart * 10000 > CurrCounter.QuadPart) { TimeStamp = (CurrCounter.QuadPart * 10000) / sg_lnFrequency.QuadPart; } else { TimeStamp = (CurrCounter.QuadPart / sg_lnFrequency.QuadPart) * 10000; } // Now save the time stamp calculated memcpy(pbCurrEntry + 1, &TimeStamp, SIZE_TIMESTAMP); CLIENT_MAP::iterator itr = sg_ClientMap.begin(); while (itr != sg_ClientMap.end()) { BOOL Result = TRUE; // If the current client is meant for the same bus, // then continue with the same. if (itr->second.m_nBus == Type) { Result = itr->second.m_bActive; } if (Result) { if (itr->first == wSenderID) { // Make the self reception bit up //CurrMsgDat.stcDataMsg.dwHeaderInfoFlags |= 0x800; *pbCurrEntry = 0x1; } DWORD Count = 0; Result = WriteFile(itr->second.m_hWrite, pbCurrEntry, itr->second.m_dwDataSize, &Count, NULL); //&CurrMsgDat, SIZE_ENTRY, &Count, NULL); SetEvent(itr->second.m_hEvent); FlushFileBuffers(itr->second.m_hWrite); if (itr->first == wSenderID) { // Make the self reception bit down //CurrMsgDat.stcDataMsg.dwHeaderInfoFlags &= ~0x800; *pbCurrEntry = 0x0; } } itr++; } LeaveCriticalSection(&sg_CriticalSection); } ResetEvent(pThreadParam->m_hActionEvent); } break; case EXIT_THREAD: { bLoopON = false; } break; default: case INACTION: { // nothing right at this moment } break; } } SetEvent(pThreadParam->hGetExitNotifyEvent()); return 0; }