myvtm/DevAdapter/keba/WatchDog.keba.1.1/WatchDogClassImpl.cpp

#include "WatchDogClassImpl.h"
//#include "CkLog.h"


LOG_EXTERN()
//extern CTraceManager g_Trace;
static DWORD dwWDTTime = 0;
static DWORD dwDelayTime = 0;

WatchDogClassImpl::WatchDogClassImpl():
     m_bDevOpen(false)
    ,m_bDelayTimer(false)
    ,m_bWDTTimer(false)
    ,m_dwTimeOut(0)
    ,m_dwRealTimeOut(0)
    ,m_dwWDTDelayTime(0)
    ,m_dwDelay(0)
    ,m_dwDelayTime(0)
    ,m_dwDelayRemain(0)
{
    LOG_FUNCTION();
    m_TimerCtrl=new CTimerCtrl;
    m_wfd=NULL;
}

WatchDogClassImpl::~WatchDogClassImpl()
{
    LOG_FUNCTION();
    m_bDevOpen = false;
    if(m_TimerCtrl!=nullptr)
    {
        delete m_TimerCtrl;
    }
    if(m_wfd!=NULL)
    {
        ioctl(m_wfd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD) ;
        char stopmagic='v';
        write(m_wfd, &stopmagic, sizeof(stopmagic));
        close(m_wfd);
    }


}

ErrorCodeEnum WatchDogClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG_FUNCTION();

    memset(&devCategory, 0, sizeof(devCategory));

    strcpy(devCategory.szModel, "FWID=MB330");
    strcpy(devCategory.szVendor, "keba");
    sprintf(devCategory.szType, "keba.WatchDog.MB330-1.0.0.5");

    char sPath[256], sFile[128] = {0};
    GetCurModulePath(sPath, sFile);
    short v1,v2;
    getFileVer(sFile, v1, v2);

    devCategory.version.wMajor = v1;
    devCategory.version.wMinor = v2;

    devCategory.version.wRevision = 0xffff;
    devCategory.version.wBuild = FILE_VERSION;

    if(m_bDevOpen)
        devCategory.eState = DEVICE_STATUS_NORMAL;
    else
        devCategory.eState = DEVICE_STATUS_NOT_READY;

    return Error_Succeed;
}

ErrorCodeEnum WatchDogClassImpl::Reset()
{
    LOG_FUNCTION();
    if (!m_bDevOpen)
    {
        SaveErrorInfo("Reset m_bDevOpen is null!", Error_DevNotAvailable);
        LogE("WatchDogClassImpl::Reset()->Reset m_bDevOpen is nullline=%d",__LINE__);
        return Error_DevNotAvailable;
    }

    if(m_wfd == NULL)
    {
        SaveErrorInfo("Reset m_pMB330CRM is null!", Error_DevNotAvailable);
        LogE("WatchDogClassImpl::Reset()->Reset m_wfd is null! line=%d",__LINE__);
        return Error_DevNotAvailable;
    }
    ioctl(m_wfd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD);
    LogM("WatchDogClassImpl::Reset()->Reset is Execute success! line=%d",__LINE__);
    return Error_Succeed;
}

ErrorCodeEnum WatchDogClassImpl::DevClose()
{
    LOG_FUNCTION();
    m_bDevOpen = false;
    if(m_wfd == NULL)
    {
        SaveErrorInfo("DevClose m_pMB330CRM is null!", Error_DevNotAvailable);     
        LogE(" WatchDogClassImpl::DevClose()-> DevClose m_wfd is null! line=%d",__LINE__);
        return Error_DevNotAvailable;
    }
    ioctl(m_wfd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD) ;
    char stopmagic='v';
    write(m_wfd, &stopmagic, sizeof(stopmagic));
    close(m_wfd);
    LogE("WatchDogClassImpl::DevClose()-> DevClose DevClose is Execute success! line=%d",__LINE__);
    return Error_Succeed;
}

ErrorCodeEnum WatchDogClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    LOG_FUNCTION();
    devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
    memset(devErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    memcpy(devErrInfo.szErrMsg, m_szErrMsg, std::min((uint32_t)devErrInfo.dwErrMsgLen,(uint32_t) MAX_DEV_ERROR_MSG_LEN));
    return Error_Succeed;
}

ErrorCodeEnum WatchDogClassImpl::DevOpen()
{
    LOG_FUNCTION();
    int preset_timeout{0};
    if(m_bDevOpen)
    {
        SaveErrorInfo("DevOpen DevAlreadyConnected!");
        LogW("DevOpen DevAlreadyConnected! line=%d",__LINE__);
        return  Error_DevAlreadyConnected;
    }
    ErrorCodeEnum eErr = Error_DevNotAvailable;
    if(m_wfd==NULL)
    {
        m_wfd = open(WATCHDOG0, O_RDWR);
        if (m_wfd == -1)
        {
            eErr = Error_Failed;
            LogE("WatchDogClassImpl::DevOpen Error_DevCommFailed=%d line=%d",eErr,__LINE__);
            return Error_Failed;
        }
       ioctl(m_wfd, WDIOC_GETTIMEOUT, &preset_timeout);
       LogW("ioctl(m_wfd, WDIOC_GETTIMEOUT, &preset_timeout=%d) line=%d",preset_timeout,__LINE__);
       int config_timeout=178;
       ioctl(m_wfd, WDIOC_SETTIMEOUT, &config_timeout);
       int flag=WDIOS_DISABLECARD;
       if(-1== ioctl(m_wfd, WDIOC_SETOPTIONS, &flag))
       {
            LogW("-1==ioctl(m_wfd, WDIOC_SETOPTIONS, &flag=WDIOS_DISABLECARD); line=%d",__LINE__);
       }
       else
       {
           LogW("ioctl(m_wfd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD) sucessfull line=%d",__LINE__);
       }
    }
    if(m_wfd)
    {
        eErr = Error_Succeed;
        m_bDevOpen=true;
        /*测试能否获取看门狗打开后，默认的时间*/
        if(-1==ioctl(m_wfd, WDIOC_GETTIMEOUT, &preset_timeout))
        {
            LogW("-1==ioctl(m_wfd, WDIOC_GETTIMEOUT, &preset_timeout=%d) line=%d",preset_timeout,__LINE__);
            char stopmagic = 'V';
            if (write(m_wfd, &stopmagic, sizeof(stopmagic)) != sizeof(stopmagic))
            {
                LogW("Watchdog magic stop write error  line=%d",__LINE__);
            }
            close(m_wfd);
            LogW("Watchdog gettimeout ioctl error %s line=%d", strerror(errno),__LINE__);
            return  Error_Failed;
        }
        else
        {
             LogW("Watchdog preset timeout is %d line=%d",preset_timeout,__LINE__);
        }
    }
    else
    {
        eErr = Error_DevCommFailed;
        LogE("WatchDogClassImpl::DevOpen Error_DevCommFailed=%d line=%d",eErr,__LINE__);
    }
    return eErr;
}

ErrorCodeEnum WatchDogClassImpl::StartWatch(DWORD dwDelay, DWORD dwTimeout)
{
    LOG_FUNCTION();
    LogE("StartWatch dwDelay=%d,dwTimeout=%d,line=%d",dwDelay,dwTimeout,__LINE__);
    if (!m_bDevOpen)
    {
        SaveErrorInfo("StartWatch m_bDevOpen is null!");
        LogE("StartWatch m_bDevOpen is null! line=%d",__LINE__);
        return Error_DevNotAvailable;
    }
    if(m_wfd == NULL)
    {
        SaveErrorInfo("StartWatch m_pMB330CRM is null!");
        LogE("StartWatch m_pMB330CRM is null! Error_DevNotAvailable=%d line=%d",Error_DevNotAvailable,__LINE__);
        return Error_DevNotAvailable;
    }
    //初始化全局静态变量
    dwWDTTime = 0 ;
    dwDelayTime = 0;
    if (dwTimeout > 178)
    {
        m_dwTimeOut = dwTimeout % 178;//设置看门狗的超时时间
        m_dwWDTDelayTime = (dwTimeout - m_dwTimeOut) / 178;//超过178秒后确定要延迟几次
        LogW("m_dwTimeOut=%d,m_dwWDTDelayTime=%d line=%d,",m_dwTimeOut,m_dwWDTDelayTime,__LINE__);
    }
    else if (dwTimeout > 0 && dwTimeout < 178)
    {
        m_dwTimeOut = dwTimeout;
    }
    m_dwRealTimeOut = dwTimeout;
    LogE("m_dwRealTimeOut=%d line=%d" ,m_dwRealTimeOut , __LINE__);
    //Start DelayTimer
    if ( dwDelay != 0 )
    {
        LogW("dwDelay != 0! line=%d",__LINE__);
        if (m_bDelayTimer)
        {
            m_TimerCtrl->EndTimer_ptr(m_mmDelayTimerID);
            LogW("StartWatch(dwDelay=%d, dwTimeout=%d) StartWatch Delay timeKillEvent m_mmDelayTimerID = %d line=%d ",dwDelay, dwTimeout,m_mmDelayTimerID, __LINE__);
        }
        m_dwDelayTime = dwDelay;
        LogW("m_dwDelayTime = %d line=%d !", m_dwDelayTime,__LINE__);
        m_TimerCtrl->SetTimerFunction(DelayTimer);
        m_TimerCtrl->StartTimer_ptr(m_mmDelayTimerID,this,dwDelay*1000,FALSE);
        LogW("WatchDogClassImpl::StartWatch->StartWatch Delay timeSetEvent m_mmDelayTimerID = %d line=%d !", m_mmDelayTimerID,__LINE__);
        m_bDelayTimer = true;
        m_dwDelay = dwDelay;
    }
    //处理延时为0的情况，dwTimeout >178的时候定时器调用WDTTimer函数
    else if(dwDelay==0)
    {
        LogW("dwDelay==0! line=%d",__LINE__);
        if ( dwTimeout == 0)
        {
            //SaveErrorInfo("StartWatch Check Param fail!");
            LogW("StartWatch Check two Param are 0! line=%d",__LINE__);
            int flag=WDIOS_ENABLECARD;
            if(-1== ioctl(m_wfd, WDIOC_SETOPTIONS, &flag))
            {
                LogW("-1==ioctl(m_wfd, WDIOC_SETOPTIONS, &flag=WDIOS_ENABLECARD); line=%d",__LINE__);
            }
            dwTimeout=1;
            LogW("dwTimeout=%d, line=%d",dwTimeout,__LINE__);
            ioctl(m_wfd,WDIOC_SETTIMEOUT,&dwTimeout);
            return Error_Succeed;
        }
        else if (dwTimeout > 0 && dwTimeout < 178)
        {
            LogW("StartWatch Check dwDelay == 0 && dwTimeout =%d 0! line=%d",dwTimeout,__LINE__);
            int flag=WDIOS_ENABLECARD;
            if(-1== ioctl(m_wfd, WDIOC_SETOPTIONS, &flag))
            {
                LogW("-1==ioctl(m_wfd, WDIOC_SETOPTIONS, &flag=WDIOS_ENABLECARD); line=%d",__LINE__);
            }
            LogW("dwTimeout=%d, line=%d",dwTimeout,__LINE__);
            ioctl(m_wfd,WDIOC_SETTIMEOUT,&dwTimeout);
            return Error_Succeed;
        }
        else if (dwTimeout > 178)
        {
            //Start WDTTimer
            if (m_bWDTTimer)
            {
                m_TimerCtrl->EndTimer_ptr(m_mmWDTTimerID);
                LogW("WatchDogClassImpl::StartWatch->StartWatch no Delay Timeout timeKillEvent m_mmWDTTimerID = %d ! line=%d", m_mmDelayTimerID ,__LINE__);
            }
            //m_mmWDTTimerID = timeSetEvent( _TIMER_DELAY, 1, &WDTTimer, (DWORD)this, TIME_PERIODIC );
            m_TimerCtrl->SetTimerFunction(WDTTimer);
            m_TimerCtrl->StartTimer_ptr(m_mmWDTTimerID,this,_TIMER_DELAY,TRUE);//TRUE表示循环定时器
            LogW(" m_TimerCtrl->StartTimer_ptr(m_mmWDTTimerID,this,dwDelay*1000=%d,TRUE) ! line=%d", dwDelay*1000,__LINE__);
            m_bWDTTimer = true;
        }
    }
    LogW(" WatchDogClassImpl::StartWatch->StartWatch is Execute success!,line=%d",__LINE__);

    return Error_Succeed;
}

ErrorCodeEnum WatchDogClassImpl::StopWatch()
{
    LOG_FUNCTION();
    if (!m_bDevOpen)
    {
        SaveErrorInfo("StopWatch m_bDevOpen is null!");
        LogE(" WatchDogClassImpl::StopWatch()->StopWatch m_bDevOpen is null !");
        return Error_DevNotAvailable;
    }
    if ( m_bDelayTimer )
    {
        dwDelayTime = 0;
        //timeKillEvent(m_mmDelayTimerID);
        m_TimerCtrl->EndTimer_ptr(m_mmDelayTimerID);
        LogW(" WatchDogClassImpl::StopWatch()->Delay timeKillEvent m_mmDelayTimerID = %d !", m_mmDelayTimerID );
        m_bDelayTimer = false;
    }

    if (m_bWDTTimer)
    {
        dwWDTTime = 0;
        //timeKillEvent(m_mmWDTTimerID);
        m_TimerCtrl->EndTimer_ptr(m_mmWDTTimerID);
        LogW(" WatchDogClassImpl::StopWatch()->WDTTimer timeKillEvent m_mmWDTTimerID = %d !", m_mmWDTTimerID);
        m_bWDTTimer = false;
    }

    if (!m_bDelayTimer && !m_bWDTTimer)
    {
        //m_pMB330CRM->StopWDT();
        int flag = WDIOS_DISABLECARD;
        ioctl(m_wfd, WDIOC_SETOPTIONS, &flag);
        char stopmagic = 'V';
        write(m_wfd, &stopmagic, sizeof(stopmagic));
    }
    LogW("WatchDogClassImpl::StopWatch()->StopWatch is Execute success! !");
    return Error_Succeed;

}

ErrorCodeEnum WatchDogClassImpl::RefreshDog()
{
    LOG_FUNCTION();
    if (!m_bDevOpen)
    {
        SaveErrorInfo("RefreshDog m_bDevOpen is null!");
        LogW("WatchDogClassImpl::RefreshDog()->RefreshDog m_bDevOpen is false! line=%d",__LINE__);
        return Error_DevNotAvailable;
    }

    if(m_wfd == NULL)
    {
        SaveErrorInfo("RefreshDog m_pMB330CRM is null!");
        LogE(" WatchDogClassImpl::RefreshDog()->RefreshDog m_wfd is null! line=%d",__LINE__);
        return Error_DevNotAvailable;
    }
    if ( m_bDelayTimer)
    {
        m_TimerCtrl->EndTimer_ptr(m_mmDelayTimerID);
        LogW("WatchDogClassImpl::RefreshDog()->RefreshDog m_bDelayTimer timeKillEvent m_mmDelayTimerID = %d !", m_mmDelayTimerID);          
        m_TimerCtrl->SetTimerFunction(DelayTimer);
        m_TimerCtrl->StartTimer_ptr(m_mmDelayTimerID,this, m_dwDelay*1000,TRUE);
        LogW("WatchDogClassImpl::RefreshDog()->RefreshDog Delay < 178 timeSetEvent m_mmDelayTimerID = %d !", m_mmDelayTimerID );

        m_bDelayTimer = true;
        dwDelayTime = 0;
        return Error_Succeed;
    }
    //TimeOut > 178
    if (m_dwRealTimeOut > 178)
    {
        //m_pMB330CRM->StopWDT();
        if (m_bWDTTimer)
        {
            //timeKillEvent(m_mmWDTTimerID);
            m_TimerCtrl->EndTimer_ptr(m_mmWDTTimerID);
            LogW("WatchDogClassImpl::RefreshDog()->RefreshDog  Kill m_mmWDTTimerID = %d !", m_mmWDTTimerID );
        }
        ioctl(m_wfd, WDIOC_KEEPALIVE, 0);
        m_TimerCtrl->SetTimerFunction(WDTTimer);
        m_TimerCtrl->StartTimer_ptr(m_mmDelayTimerID,this, _TIMER_DELAY,TRUE);
        LogW("WatchDogClassImpl::RefreshDog()->RefreshDog  timeSetEvent m_mmWDTTimerID = %d !", m_mmWDTTimerID );
        m_bWDTTimer  = true;
        dwWDTTime = 0;
    }
    else
    {
        //m_pMB330CRM->TimeOutFresh();
        ioctl(m_wfd, WDIOC_KEEPALIVE, 0);
        LogW("WatchDogClassImpl::RefreshDog()->RefreshDog  TimeOutFresh ok!");
    }
    LogW("WatchDogClassImpl::RefreshDog()->RefreshDog is Execute success!");
    return Error_Succeed;
}

void WatchDogClassImpl::SaveErrorInfo(CHAR *errMsg, int errCode)
{
    LOG_FUNCTION();
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    sprintf(m_szErrMsg, "%s[%d]", errMsg, errCode);
    LogE("SaveErrorInfo(errMsg=%s, errCode=%d)",errMsg,errCode);
}

void WatchDogClassImpl::DelayTimer(sigval_t ptr)
{
    LOG_FUNCTION();
    WatchDogClassImpl *pThis = (WatchDogClassImpl *)ptr.sival_ptr;

    static bool bTimeSet = false;

//    if (pThis->m_dwDelayTime > 0 && !bTimeSet)
//    {
//        dwDelayTime++ ;
//        if (dwDelayTime < pThis->m_dwDelayTime)
//        {
//            return;
//        }
//        //timeKillEvent(pThis->m_mmDelayTimerID);
//        pThis->m_TimerCtrl->EndTimer_ptr(pThis->m_mmDelayTimerID);

//        if (pThis->m_dwDelayRemain > 0 && !bTimeSet)
//        {
//            //pThis->m_mmDelayTimerID = timeSetEvent( pThis->m_dwDelayRemain*1000, 1, &DelayTimer, (DWORD)pThis, TIME_ONESHOT );
//            pThis->m_TimerCtrl->SetTimerFunction(DelayTimer);
//            pThis->m_TimerCtrl->StartTimer_ptr(pThis->m_mmDelayTimerID,pThis,pThis->m_dwDelayRemain*1000,FALSE);
//            LogW("WatchDogClassImpl::DelayTimer->DelayTimer TimeOut timeSetEvent  m_mmWDTTimerID = %d !  TIME_ONESHOT line=%d ", pThis->m_mmWDTTimerID ,__LINE__);
//            pThis->m_bDelayTimer = true;
//            bTimeSet = true;
//            if (bTimeSet)
//            {
//                return;
//            }
//        }
//    }

    //Start WDTTimer
    if(0==pThis->m_dwRealTimeOut)
    {
        LogW("pThis->m_dwRealTimeOut==0 line=%d",__LINE__);
        int flag=WDIOS_ENABLECARD;
        if(-1== ioctl(pThis->m_wfd, WDIOC_SETOPTIONS, &flag))
        {
            LogW("-1==ioctl(m_wfd, WDIOC_SETOPTIONS, &flag=WDIOS_ENABLECARD); line=%d",__LINE__);
        }
        pThis->m_dwRealTimeOut=1;
        LogW("pThis->m_dwRealTimeOut=%d, line=%d",pThis->m_dwRealTimeOut,__LINE__);
        ioctl(pThis->m_wfd,WDIOC_SETTIMEOUT,&pThis->m_dwRealTimeOut);
        //pThis->m_bWDTTimer = true;
    }
    else if (pThis->m_dwRealTimeOut >0 && pThis->m_dwRealTimeOut <178)
    {
        LogW("pThis->m_dwRealTimeOut==0 line=%d",__LINE__);
        int flag = WDIOS_ENABLECARD;
        ioctl(pThis->m_wfd,WDIOC_SETOPTIONS,&flag);
        LogW(" ioctl(pThis->m_wfd,WDIOC_SETOPTIONS,&flag=WDIOS_ENABLECARD) line=%d", __LINE__ );
        ioctl(pThis->m_wfd,WDIOC_SETTIMEOUT,&pThis->m_dwTimeOut);
        LogW("ioctl(pThis->m_wfd,WDIOC_SETTIMEOUT,&pThis->m_dwTimeOut= %d line=%d!) ",pThis->m_dwTimeOut ,__LINE__);

    }
    else if (pThis->m_dwRealTimeOut > 178)
    {
        LogW("pThis->m_dwRealTimeOut==0 line=%d",__LINE__);
        pThis->m_TimerCtrl->SetTimerFunction(WDTTimer);
        pThis->m_TimerCtrl->StartTimer_ptr(pThis->m_mmWDTTimerID,pThis,_TIMER_DELAY,TRUE);
        LogW("WatchDogClassImpl::DelayTimer->DelayTimer TimeOut timeSetEvent  m_mmWDTTimerID = %d !  TIME_PERIODIC line=%d ", pThis->m_mmWDTTimerID ,__LINE__);
        pThis->m_bWDTTimer = true;
    }
    pThis->m_TimerCtrl->EndTimer_ptr(pThis->m_mmDelayTimerID);
    LogW(" WatchDogClassImpl::DelayTimer->DelayTimer  Kill m_mmDelayTimerID = %d line=%d!", pThis->m_mmDelayTimerID ,__LINE__);
    pThis->m_bDelayTimer = false;
    bTimeSet = false;
    dwDelayTime = 0;
    return;
}

void WatchDogClassImpl::WDTTimer(sigval_t ptr)
{
    LOG_FUNCTION();
    WatchDogClassImpl *pThis = (WatchDogClassImpl *)ptr.sival_ptr;

    dwWDTTime++ ;
    if (dwWDTTime < pThis->m_dwWDTDelayTime)
    {
        return;
    }
    //Set WDT
    //pThis->m_pMB330CRM->SetWDT(true, (BYTE)(pThis->m_dwTimeOut));
    int flag = WDIOS_ENABLECARD;
    ioctl(pThis->m_wfd,WDIOC_SETOPTIONS,&flag);
    LogW(" ioctl(pThis->m_wfd,WDIOC_SETOPTIONS,&flag=WDIOS_ENABLECARD) line=%d", __LINE__ );
    ioctl(pThis->m_wfd,WDIOC_SETTIMEOUT,&(pThis->m_dwRealTimeOut));
    LogW(" ioctl(pThis->m_wfd,WDIOC_SETTIMEOUT,pThis->m_dwTimeOut=%d) line=%d", pThis->m_mmDelayTimerID,__LINE__ );
    //timeKillEvent(pThis->m_mmWDTTimerID);
    pThis->m_TimerCtrl->EndTimer_ptr(pThis->m_mmWDTTimerID);
    LogW("pThis->m_TimerCtrl->EndTimer_ptr(pThis->m_mmWDTTimerID); line=%d",__LINE__ );
    pThis->m_bWDTTimer = false;
    dwWDTTime = 0;
}