myvtm/DevAdapter/cw/watchdog.1.1/watchdogimpl.cpp

#include "watchdogimpl.h"
#include "cmb.h"
#include <sys/reboot.h>

WatchDogClassImpl::WatchDogClassImpl()
{
    m_hThreadID = 0;
    m_iStartTime = 0;
    m_bIsOpen = false;
    m_iRebootTime = 0;
}

WatchDogClassImpl::~WatchDogClassImpl()
{
    if (m_hThreadID)     pthread_cancel(m_hThreadID);
}

int getFileVer(char* sFile, short& ch1, short& ch2)
{
    ch1 = 0;
    ch2 = 0;
    char* pFind = strstr(sFile, ".so");
    char* pTemp = pFind;
    while (pTemp)
    {
        pFind = pTemp;
        pTemp = strstr(pFind + 3, ".so");
    }
    if (pFind == NULL) return 0;

    pTemp = pFind - 1;
    while(isdigit(*pTemp) && pTemp > sFile) pTemp--;
    if (*pTemp == '.')
        ch2 = atoi(pTemp+1);
    pTemp--;
    while(isdigit(*pTemp) && pTemp > sFile) pTemp--;
    if (*pTemp == '.')
        ch1 = atoi(pTemp+1);
    return 1;
}

ErrorCodeEnum WatchDogClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(-1, "GetDevCategory");
    ErrorCodeEnum err = Error_Succeed;
    char szType[] = {"PVER=cashway#MID=softdog"};
    char szModel[] = "FWID=00000000";
    strcpy(devCategory.szType, szType);
    strcpy(devCategory.szModel, szModel);
    strcpy(devCategory.szVendor, "cw");

    char sPath[256], sFile[128] = {0};
    GetCurLibsPath(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;
    char szRet[512] = {0};
    sprintf(szRet, "szType:%s,szModel:%s,szVendor:%s,version.wMajor:%d,version.wMinor:%d,version.wBuild:%d,version.wRevision:%d,eState:%d(0:故障1:正常)",
            devCategory.szType,devCategory.szModel,devCategory.szVendor,devCategory.version.wMajor,devCategory.version.wMinor,devCategory.version.wBuild,devCategory.version.wRevision,devCategory.eState);
    LOG4VTM(INFO, szRet);
    return err;
}

ErrorCodeEnum WatchDogClassImpl::Reset()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(-1, "Reset");
    m_iStartTime = 0;
    return GetErrorInfo(0, "Reset");
}


ErrorCodeEnum WatchDogClassImpl::DevClose()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(-1, "Reset");
    m_iStartTime = 0;
    m_bIsOpen = false;
    ErrorCodeEnum err = Error_Succeed;
    return err;
}

ErrorCodeEnum WatchDogClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    memcpy(&devErrInfo, &m_DevErrInfo, sizeof(DevErrorInfo));
    return Error_Succeed;
}

//
//	Device initialization.
//	Configure port input/output direction.
//
ErrorCodeEnum WatchDogClassImpl::DevOpen()
{
    LOG4VTM_FUNCTION();
    if (m_hThreadID)     pthread_cancel(m_hThreadID);
    m_hThreadID = 0;
    StartThread();
    m_bIsOpen = true;
    return GetErrorInfo(0, "DevOpen");
}

//  DEC_SUCCESS DEC_HARDWARE DEC_TIMEOUT DEC_INVALID_PARAMETER DEC_INVALID_MASTER_KEY
const static CmbErrorDef GpioErrorDat[] = {
    {0,    "成功", Error_Succeed, DEC_SUCCESS},
    {-1,   "设备没有打开", Error_Hardware, DEC_DEV_NOT_OPENED},
    {-2,   "设备硬件故障", Error_Hardware, DEC_HARDWARE},
    {-3,   "设备响应超时", Error_DevCommFailed, DEC_TIMEOUT},
    {-4,   "传入参数错误", Error_Param, DEC_INVALID_PARAMETER},
};

ErrorCodeEnum WatchDogClassImpl::GetErrorInfo(int iCode, char* sErr, ...)
{
    size_t iLenOne = sizeof(CmbErrorDef);
    size_t iLenAll = sizeof(GpioErrorDat);
    int iCount = iLenAll / iLenOne;
    char sErrInfo[256]="";
    DWORD dSta = 0;
    int iErr = -1;
    for (int ia = 0; ia < iCount; ia++)
    {
        if (GpioErrorDat[ia].iCode == iCode)
        {
            dSta = GpioErrorDat[ia].iInf;
            strcpy(sErrInfo, GpioErrorDat[ia].sInf);
            iErr = GpioErrorDat[ia].iRet;
            break;
        }
    }

    char sErrAll[300];
    va_list arglist;
    va_start(arglist, sErr);
    _vsnprintf(sErrAll, 128, sErr, arglist);
    va_end(arglist);

    if (sErrInfo[0])
    {
        strcat(sErrAll, " ");
        strcat(sErrAll, sErrInfo);
    }
    sErrAll[200] = 0;
    iLenOne = strlen(sErrAll);
    sprintf(m_DevErrInfo.szErrMsg, "{\"ErrCode\":\"%04x\"，\"Description\":\"%s\"}", iErr, sErrAll);
//    strcpy(m_DevErrInfo.szErrMsg, sErrAll);
    m_DevErrInfo.dwErrMsgLen = ((dSta << 16) & 0xffff0000) + iLenOne;
    if (iErr != Error_Succeed)
        LOG4VTM(WARN, m_DevErrInfo.szErrMsg);
    else
        LOG4VTM(INFO, m_DevErrInfo.szErrMsg);
    return (ErrorCodeEnum)iErr;
}

void WatchDogClassImpl::StartThread()
{
    pthread_attr_t	attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
    pthread_create(&m_hThreadID, &attr, ThreadProc, (void*) this);
    pthread_attr_destroy(&attr);

}

void* WatchDogClassImpl::ThreadProc(void* inPara)
{
    WatchDogClassImpl*	pCtrl = (WatchDogClassImpl*)inPara;
    return pCtrl->ThreadRun();
}

void*	WatchDogClassImpl::ThreadRun()
{
    time_t tNow=0;
    while (1)
    {
        Sleep(500);
        time(&tNow);
        if (!m_bIsOpen || m_iStartTime < 1 || tNow < m_iStartTime)   continue;   //监控未开始
        if (m_iRebootTime && tNow <= m_iRebootTime)   continue;   //监控未开始
        char sTemp[256];
        sprintf(sTemp, "WatchDogClassImpl timeout");
        LOG4VTM(INFO, sTemp);
        sync(); // 同步磁盘数据,将缓存数据回写到硬盘,以防数据丢失[luther.gliethttp]
        system("reboot");
    }
    return 0;
}

ErrorCodeEnum WatchDogClassImpl::StartWatch(DWORD dwDelay, DWORD dwTimeout)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(-1, "StartWatch");
    time_t tNow=0;
    time(&tNow);
    m_iStartTime = tNow + dwDelay;
    m_iTimeout = dwTimeout + 1;
    m_iRebootTime = m_iStartTime + m_iTimeout;
    return Error_Succeed;
}

ErrorCodeEnum WatchDogClassImpl::StopWatch()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(-1, "StopWatch");
    m_iStartTime = 0;
    m_iRebootTime = 0;
    return Error_Succeed;
}

//	Feed watchdog.
ErrorCodeEnum WatchDogClassImpl::RefreshDog()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(-1, "RefreshDog");
    time_t tNow=0;
    time(&tNow);
    m_iRebootTime = tNow + m_iTimeout;
    return Error_Succeed;
}