예제 #1
0
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;
}
예제 #2
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;
}
예제 #3
0
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;
}
예제 #4
0
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;
}
예제 #5
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;
}