/*******************************************************************************
Function Name : sunNIReplayThreadFunc
Input(s) : pParam - Parameter to the thread
Output : -
Functionality : This is the Non Interactive thread function
Member of : CReplayProcess
Author(s) : Raja N
Date Created : 16.7.2005
Modifications :
*******************************************************************************/
UINT CReplayProcess::sunNIReplayThreadFunc( LPVOID pParam )
{
CReplayProcess* pReplayDetails = (CReplayProcess*)pParam;
if( pReplayDetails != nullptr )
{
// Reset the event
pReplayDetails->m_omThreadEvent.ResetEvent();
// Replay code here
// Time Calculation
CArray<UINT,UINT> omTimeDelay;
// Get the item count
int nCount = (int)pReplayDetails->m_omEntries.GetSize();
CString omStrCurr;
CString omStrNext;
// Init Message delay
UINT unMsgDelay = pReplayDetails->m_ouReplayFile.m_unMsgTimeDelay;
if( unMsgDelay == 0 )
{
unMsgDelay = 1;
}
int nIndex; //nIndex declared outside
for( nIndex = 0; nIndex < nCount - 1; nIndex++ )
{
if( pReplayDetails->m_ouReplayFile.m_nTimeMode ==
defREPLAY_RETAIN_DELAY )
{
// Get Next Entry
omStrNext = pReplayDetails->m_omEntries[ nIndex + 1 ];
// Get the current entry
omStrCurr = pReplayDetails->m_omEntries[ nIndex ];
UINT unTime = unTimeDiffBetweenMsg( omStrNext, omStrCurr,
pReplayDetails->m_wLogReplayTimeMode );
if( unTime == 0 )
{
unTime = 1;
}
omTimeDelay.Add( unTime );
}
else
{
omTimeDelay.Add( unMsgDelay );
}
}
// Add the cyclic delay at the end
unMsgDelay = pReplayDetails->m_ouReplayFile.m_unCycleTimeDelay;
if( unMsgDelay == 0 )
{
unMsgDelay = 1;
}
omTimeDelay.Add( unMsgDelay );
TIMECAPS time;
MMRESULT mmResult = TIMERR_NOERROR;
if (timeGetDevCaps(&time, sizeof(TIMECAPS)) == TIMERR_NOERROR)
{
mmResult = timeBeginPeriod(time.wPeriodMin);
}
// Create the event object to wait for
HANDLE hEventReplayWait = CreateEvent(nullptr, FALSE, FALSE, nullptr);
// main loop for message transmission.
nIndex = 0;
while( pReplayDetails->m_bStopReplayThread == FALSE )
{
// Set the event to wait
timeSetEvent( omTimeDelay[ nIndex ], time.wPeriodMin,
(LPTIMECALLBACK) hEventReplayWait, 0,
TIME_CALLBACK_EVENT_SET | TIME_ONESHOT);
// Send message in CAN bus if the message ID is valid
if ( pReplayDetails->m_omMsgList[ nIndex ].
m_uDataInfo.m_sCANMsg.m_unMsgID != -1 )
{
HRESULT hRet = 0;
SFRAMEINFO_BASIC_CAN sBasicCanInfo;
pReplayDetails->vFormatCANDataMsg(&pReplayDetails->m_omMsgList[ nIndex ], &sBasicCanInfo);
BOOL bTobeBlocked = FALSE;
if( pReplayDetails->m_ouReplayFile.m_sFilterApplied.m_bEnabled == TRUE)
{
EnterCriticalSection(&pReplayDetails->m_omCritSecFilter);
bTobeBlocked = pReplayDetails->m_ouReplayFile.m_sFilterApplied.bToBeBlocked(sBasicCanInfo);
LeaveCriticalSection(&pReplayDetails->m_omCritSecFilter);
}
if(bTobeBlocked == FALSE)
{
// Use HIL Function to send CAN message
hRet = s_pouDIL_CAN_Interface->DILC_SendMsg(s_dwClientID, pReplayDetails->m_omMsgList[ nIndex ].m_uDataInfo.m_sCANMsg);
}
if (hRet != 0)
{
//::PostMessage(GUI_hDisplayWindow, WM_ERROR,
// ERROR_DRIVER_API_FAIL, nZERO);
}
}
// Update the index
nIndex++;
// if last message is already sent,
// and it is a cyclic block then go to begining. Otherwise stop the
// thread
if( nIndex >= nCount )
{
if( pReplayDetails->m_ouReplayFile.m_nReplayMode ==
defREPLAY_MODE_CYCLIC )
{
nIndex %= nCount;
}
else
{
pReplayDetails->m_bStopReplayThread = TRUE;
}
}
// Wait for the event
if( pReplayDetails->m_bStopReplayThread == FALSE )
{
WaitForSingleObject(hEventReplayWait, INFINITE);
}
}
if (mmResult == TIMERR_NOERROR)
{
timeEndPeriod(time.wPeriodMin);
}
CloseHandle(hEventReplayWait);
pReplayDetails->m_omThreadEvent.SetEvent();
}
return 0;
}
/*******************************************************************************
Function Name : sunReplayCyclicThreadFunc
Input(s) : pParam - Parameter to the thread
Output : -
Functionality : This is the thread function for cyclic replay blocks
Member of : CReplayProcess
Author(s) : Raja N
Date Created : 16.7.2005
Modifications :
*******************************************************************************/
UINT CReplayProcess::sunReplayCyclicThreadFunc( LPVOID pParam )
{
CReplayProcess* pReplayDetails = (CReplayProcess*)pParam;
if( pReplayDetails != nullptr )
{
CMsgReplayWnd* pWnd = (CMsgReplayWnd*)pReplayDetails->m_pReplayWndPtr;
// Reset the event
pReplayDetails->m_omThreadEvent.ResetEvent();
// Disable List control
if( pWnd != nullptr )
{
pWnd->m_omMessageList.EnableWindow( FALSE );
}
// Replay code here
/// Get the number of messages to play
int nCount = pReplayDetails->m_nNoOfMessagesToPlay;
// Time Calculation
CArray<UINT,UINT> omTimeDelay;
CString omStrCurr;
CString omStrNext;
UINT unMsgDelay = pReplayDetails->m_ouReplayFile.m_unMsgTimeDelay;
if( unMsgDelay == 0 )
{
unMsgDelay = 1;
}
int nIndex; //nIndex declared outside
for( nIndex = 0; nIndex < nCount - 1; nIndex++ )
{
if( pReplayDetails->m_ouReplayFile.m_nTimeMode ==
defREPLAY_RETAIN_DELAY )
{
int nCurrentIndex = pReplayDetails->m_omSelectedIndex[ nIndex ];
int nNextIndex =
pReplayDetails->m_omSelectedIndex[ nIndex + 1 ];
// Get the current entry
omStrNext = pReplayDetails->m_omEntries[ nNextIndex ];
omStrCurr = pReplayDetails->m_omEntries[ nCurrentIndex ];
UINT unTime = unTimeDiffBetweenMsg( omStrNext, omStrCurr,
pReplayDetails->m_wLogReplayTimeMode );
if( unTime == 0 )
{
unTime = 1;
}
omTimeDelay.Add( unTime );
}
else
{
omTimeDelay.Add( unMsgDelay );
}
}
// Add the cyclic delay at the end
unMsgDelay = pReplayDetails->m_ouReplayFile.m_unCycleTimeDelay;
if( unMsgDelay == 0 )
{
unMsgDelay = 1;
}
omTimeDelay.Add( unMsgDelay );
TIMECAPS time;
MMRESULT mmResult = TIMERR_NOERROR;
if (timeGetDevCaps(&time, sizeof(TIMECAPS)) == TIMERR_NOERROR)
{
mmResult = timeBeginPeriod(time.wPeriodMin);
}
// Create the event object to wait for
HANDLE hEventReplayWait = CreateEvent(nullptr, FALSE, FALSE, nullptr);
// main loop for message transmission.
nIndex = 0;
while( pReplayDetails->m_bStopReplayThread == FALSE )
{
int nCurrentIndex = pReplayDetails->m_omSelectedIndex[ nIndex ];
// Set the event to wait
timeSetEvent( omTimeDelay[ nIndex ], time.wPeriodMin,
(LPTIMECALLBACK) hEventReplayWait, 0,
TIME_CALLBACK_EVENT_SET | TIME_ONESHOT);
// Send message in CAN bus if the message ID is valid
if ( pReplayDetails->m_omMsgList[ nCurrentIndex ].
m_uDataInfo.m_sCANMsg.m_unMsgID != -1 )
{
HRESULT hRet = 0;
SFRAMEINFO_BASIC_CAN sBasicCanInfo;
pReplayDetails->vFormatCANDataMsg(&pReplayDetails->m_omMsgList[ nIndex ], &sBasicCanInfo);
BOOL bTobeBlocked = FALSE;
EnterCriticalSection(&pReplayDetails->m_omCritSecFilter);
if( pReplayDetails->m_ouReplayFile.m_sFilterApplied.m_bEnabled == TRUE)
{
bTobeBlocked = pReplayDetails->m_ouReplayFile.m_sFilterApplied.bToBeBlocked(sBasicCanInfo);
}
LeaveCriticalSection(&pReplayDetails->m_omCritSecFilter);
if(bTobeBlocked == FALSE)
{
// Use HIL Function to send CAN message
HRESULT hRet = s_pouDIL_CAN_Interface->DILC_SendMsg(s_dwClientID,
pReplayDetails->m_omMsgList[ nCurrentIndex ].m_uDataInfo.m_sCANMsg );
}
}
// Update index and wrap up to modula of message list size
nIndex++;
nIndex %= nCount;
// Wait for the event
WaitForSingleObject(hEventReplayWait, INFINITE);
}
if (mmResult == TIMERR_NOERROR)
{
timeEndPeriod(time.wPeriodMin);
}
CloseHandle(hEventReplayWait);
if( pWnd != nullptr )
{
// Update the window
pWnd->m_omMessageList.EnableWindow( );
pWnd->m_eReplayState = REPLAY_TO_START;
}
pReplayDetails->m_omThreadEvent.SetEvent();
}
return 0;
}
UINT CReplayProcess::sunReplayMonoshotThreadFunc( LPVOID pParam )
{
CReplayProcess* pReplayDetails = (CReplayProcess*)pParam;
if( pReplayDetails != nullptr )
{
CMsgReplayWnd* pWnd = (CMsgReplayWnd*)pReplayDetails->m_pReplayWndPtr;
// Reset the event
pReplayDetails->m_omThreadEvent.ResetEvent();
// Disable List control
// To avoid flickering avoid disabling for a step action
if( pWnd != nullptr && pReplayDetails->m_nNoOfMessagesToPlay > 1)
{
pWnd->m_omMessageList.EnableWindow( FALSE );
}
// Replay code here
/// Get the number of messages to play
int nCount = pReplayDetails->m_nNoOfMessagesToPlay;
int nOffset = pReplayDetails->m_nUserSelectionIndex;
// Time Calculation
CArray<UINT,UINT> omTimeDelay;
if( pReplayDetails->m_ouReplayFile.m_nTimeMode == defREPLAY_RETAIN_DELAY
&& nCount > 1 )
{
CString omStrCurr;
CString omStrNext;
for( int nIndex = 0; nIndex < nCount - 1; nIndex++ )
{
// Get the current entry
omStrNext = pReplayDetails->m_omEntries[ nIndex + nOffset + 1];
omStrCurr = pReplayDetails->m_omEntries[ nIndex + nOffset ];
UINT unTime = unTimeDiffBetweenMsg( omStrNext, omStrCurr,
pReplayDetails->m_wLogReplayTimeMode );
if( unTime == 0 )
{
unTime = 1;
}
omTimeDelay.Add( unTime );
}
}
TIMECAPS time;
MMRESULT mmResult = TIMERR_NOERROR;
if (timeGetDevCaps(&time, sizeof(TIMECAPS)) == TIMERR_NOERROR)
{
mmResult = timeBeginPeriod(time.wPeriodMin);
}
// Create the event object to wait for
HANDLE hEventReplayWait = CreateEvent(nullptr, FALSE, FALSE, nullptr);
// Assign the message delay time
int nDelay = pReplayDetails->m_ouReplayFile.m_unMsgTimeDelay;
// main loop for message transmission.
for( int nIndex = 0;
pReplayDetails->m_bStopReplayThread == FALSE && nIndex < nCount;
nIndex++ )
{
int nCurrentIndex = nIndex + nOffset;
if( ( nIndex + 1 ) < nCount )
{
if( pReplayDetails->m_ouReplayFile.m_nTimeMode ==
defREPLAY_RETAIN_DELAY )
{
nDelay = omTimeDelay[ nIndex ];
}
timeSetEvent( nDelay, time.wPeriodMin,
(LPTIMECALLBACK) hEventReplayWait, 0,
TIME_CALLBACK_EVENT_SET | TIME_ONESHOT);
}
// Send message in CAN bus if the message ID is valid
if ( pReplayDetails->m_omMsgList[ nCurrentIndex].
m_uDataInfo.m_sCANMsg.m_unMsgID != -1 )
{
HRESULT hRet = 0;
SFRAMEINFO_BASIC_CAN sBasicCanInfo;
pReplayDetails->vFormatCANDataMsg(&pReplayDetails->m_omMsgList[ nIndex ], &sBasicCanInfo);
BOOL bTobeBlocked = FALSE;
if( pReplayDetails->m_ouReplayFile.m_sFilterApplied.m_bEnabled == TRUE)
{
EnterCriticalSection(&pReplayDetails->m_omCritSecFilter);
bTobeBlocked = pReplayDetails->m_ouReplayFile.m_sFilterApplied.bToBeBlocked(sBasicCanInfo);
LeaveCriticalSection(&pReplayDetails->m_omCritSecFilter);
}
if(bTobeBlocked == FALSE)
{
// Use HIL Function to send CAN message
HRESULT hRet = s_pouDIL_CAN_Interface->DILC_SendMsg(s_dwClientID,
pReplayDetails->m_omMsgList[ nCurrentIndex ].
m_uDataInfo.m_sCANMsg );
}
}
// Increment cur sel to set to next sel
pReplayDetails->m_nCurrentIndex = nCurrentIndex;
// last message is already sent
if( nIndex + 1 == nCount )
{
pReplayDetails->m_bStopReplayThread = TRUE;
}
else
{
// Wait for the event
WaitForSingleObject(hEventReplayWait, INFINITE);
}
}
if (mmResult == TIMERR_NOERROR)
{
timeEndPeriod(time.wPeriodMin);
}
CloseHandle(hEventReplayWait);
if( pWnd != nullptr )
{
pWnd->m_omMessageList.EnableWindow( );
pWnd->m_eReplayState = REPLAY_TO_START;
// Set the selection
pReplayDetails->m_nCurrentIndex++;
pReplayDetails->m_nCurrentIndex %=
pReplayDetails->m_omEntries.GetSize();
pWnd->m_omMessageList.SetItemState( pReplayDetails->m_nCurrentIndex,
LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED );
pWnd->m_omMessageList.EnsureVisible(
pReplayDetails->m_nCurrentIndex, FALSE );
}
pReplayDetails->m_omThreadEvent.SetEvent();
}
return 0;
}
/*******************************************************************************
Function Name : sunNIReplayThreadFunc
Input(s) : pParam - Parameter to the thread
Output : -
Functionality : This is the Non Interactive thread function
Member of : CReplayProcess
Author(s) : Raja N
Date Created : 16.7.2005
Modifications :
*******************************************************************************/
UINT CReplayProcess::sunNIReplayThreadFunc( LPVOID pParam )
{
CReplayProcess* pReplayDetails = (CReplayProcess*)pParam;
if( pReplayDetails != NULL )
{
pReplayDetails->bSetbIsProtocolMismatch(false);
pReplayDetails->bSetbIsInvalidMsg(false);
// Reset the event
pReplayDetails->m_omThreadEvent.ResetEvent();
// Replay code here
// Time Calculation
CArray<UINT,UINT> omTimeDelay;
// Get the item count
bool bSessionFlag = false;
bool bDetectSession = false;
bool bDetectEOF = false;
bool bEOFFlag = false;
CString omStrCurr = "";
CString omStrNext= "";
// Init Message delay
UINT unMsgDelay = pReplayDetails->m_ouReplayFile.m_unMsgTimeDelay;
if( unMsgDelay == 0 )
{
unMsgDelay = 1;
}
//int nIndex; //nIndex declared outside
// Add the cyclic delay at the end
UINT unCycleDelay = pReplayDetails->m_ouReplayFile.m_unCycleTimeDelay;
if( unCycleDelay == 0 )
{
unCycleDelay = 1;
}
UINT unSessionDelay=pReplayDetails->m_ouReplayFile.m_unSessionDelay;
if( unSessionDelay == 0 )
{
unSessionDelay = 1;
}
TIMECAPS time;
MMRESULT mmResult = TIMERR_NOERROR;
if (timeGetDevCaps(&time, sizeof(TIMECAPS)) == TIMERR_NOERROR)
{
mmResult = timeBeginPeriod(time.wPeriodMin);
}
// Create the event object to wait for
HANDLE hEventReplayWait = CreateEvent(NULL, FALSE, FALSE, NULL);
// main loop for message transmission.
UINT unTime;
pReplayDetails->omInReplayFile.clear(); // clear eof and fail bits
pReplayDetails->omInReplayFile.seekg(0, std::ios::beg);
std::string strLine;
while( pReplayDetails->m_bStopReplayThread == FALSE )
{
bool bIsProtocolMismatch = false;
unMsgDelay = pReplayDetails->m_ouReplayFile.m_unMsgTimeDelay;
if( unMsgDelay == 0 )
{
unMsgDelay = 1;
}
bSessionFlag = false;
bEOFFlag = false;
if(bDetectSession)
{
bSessionFlag = true;
bDetectSession = false;
}
if(bDetectEOF)
{
bEOFFlag = true;
bDetectEOF = false;
}
bool bIsComment = false;
while(getline(pReplayDetails->omInReplayFile , strLine))
{
CUtilFunctions::Trim(strLine,' ');
if(strLine.find(END_SESSION) != std::string::npos)
{
bDetectSession = true ;
}
if(strLine.find(START_COMMENT) != std::string::npos)
{
bIsComment = true;
}
if(strLine.find(END_COMMENT) != std::string::npos)
{
bIsComment = false;
}
if(strLine.empty() || bIsComment)
{
continue;
}
if(strLine.find("*") == std::string::npos)
{
omStrCurr = omStrNext;
omStrNext = strLine.c_str();
if(omStrCurr.Compare("") == 0)
{
continue;
}
else
{
break;
}
}
if(strLine.find("*") != std::string::npos)
{
if( strLine.find(defSTR_PROTOCOL_USED) != std::string::npos)
{
// If can related log file
if( strLine.find(defSTR_PROTOCOL_CAN) == std::string::npos)
{
pReplayDetails->m_omStrError = defSTR_LOG_PRTOCOL_MISMATCH;
bIsProtocolMismatch = true;
if(pReplayDetails->m_ouReplayFile.m_nReplayMode == defREPLAY_MODE_CYCLIC)
{
pReplayDetails->omInReplayFile.clear(); // clear eof and fail bits
pReplayDetails->omInReplayFile.seekg(0, std::ios::beg);
bDetectEOF = true;
}
else
{
pReplayDetails->m_bStopReplayThread = TRUE;
}
omStrCurr = omStrNext;
omStrNext = "";
break;
}
}
}
}
if(omStrCurr.IsEmpty() && omStrNext.IsEmpty())
{
CReplayManager::ouGetReplayManager().vSendToTrace(defSTR_REPLAY_FILE_EMPTY);
pReplayDetails->m_bStopReplayThread = TRUE;
continue;
}
if(pReplayDetails->omInReplayFile.eof())
{
omStrCurr = omStrNext;
omStrNext = "";
bDetectEOF = true;
}
STCANDATA sCanMsg,sNxtCanMsg;
bool bIsValidMessage = true;
pReplayDetails->sGetCanMsg(omStrCurr,sCanMsg);
if(omStrNext.IsEmpty() == FALSE)
{
bIsValidMessage = pReplayDetails->sGetCanMsg(omStrNext,sNxtCanMsg);
}
if(!bIsValidMessage)
{
pReplayDetails->m_omStrError = defSTR_LOG_INVALID_MESSAGE;
if(!pReplayDetails->bGetbIsInvalidMsg())
{
CReplayManager::ouGetReplayManager().vSendToTrace(defSTR_LOG_INVALID_MESSAGE);
pReplayDetails->bSetbIsInvalidMsg(true);
}
if(pReplayDetails->m_ouReplayFile.m_nReplayMode == defREPLAY_MODE_CYCLIC)
{
pReplayDetails->omInReplayFile.clear(); // clear eof and fail bits
pReplayDetails->omInReplayFile.seekg(0, std::ios::beg);
bDetectEOF = true;
omStrNext = "";
}
else
{
pReplayDetails->m_bStopReplayThread = TRUE;
}
}
if( (pReplayDetails->m_ouReplayFile.m_nTimeMode ==
defREPLAY_RETAIN_DELAY) && bIsValidMessage && !bIsProtocolMismatch)
{
unTime = unTimeDiffBetweenMsg( omStrNext, omStrCurr,
pReplayDetails->m_wLogReplayTimeMode );
if( unTime == 0 )
{
unTime = 1;
}
unMsgDelay = unTime;
}
if((pReplayDetails->m_ouReplayFile.m_nSessionMode == defREPLAY_SPECIFIC_SESSION_DELAY) && bDetectSession == true)
{
unMsgDelay = unSessionDelay;
}
if(bDetectEOF && pReplayDetails->m_ouReplayFile.m_nReplayMode == defREPLAY_MODE_CYCLIC)
{
unMsgDelay = unCycleDelay;
pReplayDetails->omInReplayFile.clear(); // clear eof and fail bits
pReplayDetails->omInReplayFile.seekg(0, std::ios::beg);
}
// Send message in CAN bus if the message ID is valid
timeSetEvent( unMsgDelay, time.wPeriodMin,
(LPTIMECALLBACK) hEventReplayWait, NULL,
TIME_CALLBACK_EVENT_SET | TIME_ONESHOT);
if (sCanMsg.m_uDataInfo.m_sCANMsg.m_unMsgID != -1 )
{
HRESULT hRet = 0;
SFRAMEINFO_BASIC_CAN sBasicCanInfo;
pReplayDetails->vFormatCANDataMsg(&sCanMsg, &sBasicCanInfo);
BOOL bTobeBlocked = FALSE;
if( pReplayDetails->m_ouReplayFile.m_sFilterApplied.m_bEnabled == TRUE)
{
EnterCriticalSection(&pReplayDetails->m_omCritSecFilter);
bTobeBlocked = pReplayDetails->m_ouReplayFile.m_sFilterApplied.bToBeBlocked(sBasicCanInfo);
LeaveCriticalSection(&pReplayDetails->m_omCritSecFilter);
}
if(bTobeBlocked == FALSE )
{
// Use HIL Function to send CAN message
hRet = s_pouDIL_CAN_Interface->DILC_SendMsg(s_dwClientID, sCanMsg.m_uDataInfo.m_sCANMsg);
}
if (hRet != 0)
{
//::PostMessage(GUI_hDisplayWindow, WM_ERROR,
// ERROR_DRIVER_API_FAIL, nZERO);
}
}
// Update the index
// if last message is already sent,
// and it is a cyclic block then go to begining. Otherwise stop the
// thread
if( pReplayDetails->omInReplayFile.eof() )
{
if( pReplayDetails->m_ouReplayFile.m_nReplayMode ==
defREPLAY_MODE_MONOSHOT )
{
pReplayDetails->m_bStopReplayThread = TRUE;
}
}
// Wait for the event
if( pReplayDetails->m_bStopReplayThread == FALSE)
{
WaitForSingleObject(hEventReplayWait, INFINITE);
}
if(bIsProtocolMismatch && bIsValidMessage)
{
if(!pReplayDetails->bGetbIsProtocolMismatch())
{
CReplayManager::ouGetReplayManager().vSendToTrace(defSTR_LOG_PRTOCOL_MISMATCH);
pReplayDetails->bSetbIsProtocolMismatch(true);
}
}
}
if (mmResult == TIMERR_NOERROR)
{
timeEndPeriod(time.wPeriodMin);
}
CloseHandle(hEventReplayWait);
pReplayDetails->m_omThreadEvent.SetEvent();
}
return 0;
}
UINT CReplayProcess::sunReplayMonoshotThreadFunc( LPVOID pParam )
{
CReplayProcess* pReplayDetails = (CReplayProcess*)pParam;
bool bNxtSessionFlag = false;
bool bNxtEOFflag = false;
bool bCurSessionFlag = false;
bool bCurEOFflag = false;
bool bCurProtocolMismatch = false;
bool bNxtProtocolMismatch = false;
bool bNxtInvalidMsg = false;
bool bCurInvalidMsg = false;
STCANDATA sNxtCanMsg;
STCANDATA sCurCanMsg;
ZeroMemory(&sCurCanMsg, sizeof(STCANDATA));
if( pReplayDetails != nullptr )
{
CMsgReplayWnd* pWnd = (CMsgReplayWnd*)pReplayDetails->m_pReplayWndPtr;
// Reset the event
pReplayDetails->m_omThreadEvent.ResetEvent();
// Disable List control
// To avoid flickering avoid disabling for a step action
if( pWnd != nullptr && pReplayDetails->m_nNoOfMessagesToPlay > 1)
{
pWnd->m_omMessageList.EnableWindow( FALSE );
}
// Replay code here
/// Get the number of messages to play
int nCount = pReplayDetails->m_nNoOfMessagesToPlay;
int nOffset = pReplayDetails->m_nUserSelectionIndex;
// Time Calculation
CArray<UINT,UINT> omTimeDelay;
TIMECAPS time;
MMRESULT mmResult = TIMERR_NOERROR;
if (timeGetDevCaps(&time, sizeof(TIMECAPS)) == TIMERR_NOERROR)
{
mmResult = timeBeginPeriod(time.wPeriodMin);
}
// Create the event object to wait for
HANDLE hEventReplayWait = CreateEvent(nullptr, FALSE, FALSE, nullptr);
// Assign the message delay time
UINT unDelay;
UINT unMsgDelay = pReplayDetails->m_ouReplayFile.m_unMsgTimeDelay;
if( unMsgDelay == 0 )
{
unMsgDelay = 1;
}
UINT unSessionDelay = pReplayDetails->m_ouReplayFile.m_unSessionDelay;
if( unSessionDelay == 0 )
{
unSessionDelay = 1;
}
// main loop for message transmission.
BOOL bBreakPointFlag = FALSE;
if(pReplayDetails->m_omBreakPoints[nOffset ] == TRUE)
{
bBreakPointFlag = TRUE;
}
for( int nIndex = 0;
pReplayDetails->m_bStopReplayThread == FALSE &&( (pReplayDetails->m_omBreakPoints[ nIndex + nOffset ] == FALSE)||(bBreakPointFlag == TRUE));
nIndex++ )
{
bBreakPointFlag = FALSE;
int nCurrentIndex = nIndex + nOffset;
if( ( nIndex + 1 ) <= nCount )
{
CString omStrCurr;
CString omStrNext;
omStrNext = pReplayDetails->omStrGetMsgFromLog(nIndex + nOffset + 1,sNxtCanMsg,bNxtSessionFlag, bNxtEOFflag,bNxtProtocolMismatch,bNxtInvalidMsg);
omStrCurr = pReplayDetails->omStrGetMsgFromLog(nIndex + nOffset,sCurCanMsg, bCurSessionFlag, bCurEOFflag,bCurProtocolMismatch,bCurInvalidMsg);
unDelay = unMsgDelay;
if( pReplayDetails->m_ouReplayFile.m_nTimeMode ==
defREPLAY_RETAIN_DELAY )
{
if(bCurEOFflag)
{
pReplayDetails->m_bStopReplayThread = TRUE;
}
UINT unTime = unTimeDiffBetweenMsg( omStrNext, omStrCurr,
pReplayDetails->m_wLogReplayTimeMode );
if( unTime == 0 )
{
unTime = 1;
}
unDelay = unTime;
}
if(bNxtSessionFlag && (pReplayDetails->m_ouReplayFile.m_nSessionMode == defREPLAY_SPECIFIC_SESSION_DELAY))
{
unDelay = unSessionDelay;
}
timeSetEvent( unDelay, time.wPeriodMin,
(LPTIMECALLBACK) hEventReplayWait, 0,
TIME_CALLBACK_EVENT_SET | TIME_ONESHOT);
}
// Send message in CAN bus if the message ID is valid
if ( sCurCanMsg.m_uDataInfo.m_sCANMsg.m_unMsgID != -1 )
{
HRESULT hRet = 0;
SFRAMEINFO_BASIC_CAN sBasicCanInfo;
pReplayDetails->vFormatCANDataMsg(&sCurCanMsg, &sBasicCanInfo);
BOOL bTobeBlocked = FALSE;
if( pReplayDetails->m_ouReplayFile.m_sFilterApplied.m_bEnabled == TRUE)
{
EnterCriticalSection(&pReplayDetails->m_omCritSecFilter);
bTobeBlocked = pReplayDetails->m_ouReplayFile.m_sFilterApplied.bToBeBlocked(sBasicCanInfo);
LeaveCriticalSection(&pReplayDetails->m_omCritSecFilter);
}
if(bTobeBlocked == FALSE)
{
// Use HIL Function to send CAN message
HRESULT hRet = s_pouDIL_CAN_Interface->DILC_SendMsg(s_dwClientID,
sCurCanMsg.
m_uDataInfo.m_sCANMsg );
}
}
// Increment cur sel to set to next sel
pReplayDetails->m_nCurrentIndex = nCurrentIndex;
// last message is already sent
if(bNxtEOFflag || nCount == 1)
{
pReplayDetails->m_bStopReplayThread = TRUE;
}
else
{
// Wait for the event
WaitForSingleObject(hEventReplayWait, INFINITE);
}
if(bNxtProtocolMismatch)
{
pReplayDetails->m_bStopReplayThread = TRUE;
if(!pReplayDetails->bGetbIsProtocolMismatch())
{
CReplayManager::ouGetReplayManager().vSendToTrace(defSTR_LOG_PRTOCOL_MISMATCH);
pReplayDetails->bSetbIsProtocolMismatch(true);
}
}
else if(bNxtInvalidMsg && !bNxtEOFflag)
{
pReplayDetails->m_bStopReplayThread = TRUE;
if(!pReplayDetails->bGetbIsInvalidMsg())
{
CReplayManager::ouGetReplayManager().vSendToTrace(defSTR_LOG_INVALID_MESSAGE);
pReplayDetails->bSetbIsProtocolMismatch(true);
}
}
}
if (mmResult == TIMERR_NOERROR)
{
timeEndPeriod(time.wPeriodMin);
}
CloseHandle(hEventReplayWait);
if( pWnd != nullptr )
{
pWnd->m_omMessageList.EnableWindow( );
pWnd->m_eReplayState = REPLAY_TO_START;
// Set the selection
pReplayDetails->m_nCurrentIndex++;
pReplayDetails->m_nCurrentIndex %= pReplayDetails->dwGetvecPegSize();
pWnd->m_omMessageList.SetItemState( pReplayDetails->m_nCurrentIndex,
LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED );
pWnd->m_omMessageList.EnsureVisible(
pReplayDetails->m_nCurrentIndex, FALSE );
}
pReplayDetails->m_omThreadEvent.SetEvent();
}
return 0;
}
/*******************************************************************************
Function Name : vStartNonInteractiveReplays
Input(s) : -
Output : -
Functionality : To create and start non interactive replay threads.
Member of : CReplayManager
Author(s) : Raja N
Date Created : 16.7.2005
Modifications :
*******************************************************************************/
void CReplayManager::vStartNonInteractiveReplays()
{
// Get the replay list size
int nSize = (int)m_omReplayFiles.GetSize();
//int nIndex; //nIndex declared outside loop
for( int nIndex = 0; nIndex < nSize; nIndex++ )
{
const CReplayFile& omFile = m_omReplayFiles.ElementAt( nIndex );
// If it is enabled non interactive replay
if( omFile.m_bEnabled == TRUE &&
omFile.m_bInteractive == FALSE )
{
// Create replay process
CReplayProcess* pNewProcess = new CReplayProcess( omFile );
if( pNewProcess != nullptr )
{
// Load the replay file
BOOL bResult = pNewProcess->bOpenReplayFile(FALSE);
// if loading is success
if( bResult == TRUE )
{
// check for empty replay file
/*if( pNewProcess->dwGetNoOfMsgsInLog()== 0 )
{
// Show the message in Trace Window
CString omStrErr;
omStrErr.Format( defSTR_REPLAY_ERROR,
pNewProcess->m_ouReplayFile.m_omStrFileName, // File
defSTR_REPLAY_FILE_EMPTY );
vSendToTrace(omStrErr.GetBuffer(MAX_PATH));
//gbSendStrToTrace( (char *)omStrErr.operator LPCTSTR());
bResult = FALSE;
}
else
{*/
// Add the replay process to the list
m_omReplayProcess.Add( pNewProcess );
//}
}
else
{
// Replay file parsing failed
// Show Error message
CString omStrErr;
omStrErr.Format(defSTR_REPLAY_ERROR,
omFile.m_omStrFileName, // File Name
pNewProcess->m_omStrError ); // Error Message
vSendToTrace(omStrErr.GetBuffer(MAX_PATH));
//gbSendStrToTrace( (char *)omStrErr.operator LPCTSTR() );
}
if( bResult == FALSE )
{
// Delete the memory
delete pNewProcess;
}
}
}
}
// Start all replay threads
nSize = (int)m_omReplayProcess.GetSize();
for(int i = 0; i < nSize; i++ )
{
EnterCriticalSection(&m_omReplayProcess[i]->m_omCritSecFilter);
m_omReplayProcess[i]->bStartNIReplay();
LeaveCriticalSection(&m_omReplayProcess[i]->m_omCritSecFilter);
}
}