myvtm/DevAdapter/keba/Ups.keba.1.1/UpsClassImpl_East.cpp

#include "UpsClassImpl_East.h"

LOG_EXTERN()

CSerialComm g_SerialComm;

Dev_COMInfo UpsClassImpl::m_arrCOMInfo[]=
{
    {1, "/dev/ttyUSB0" },
    {2, "/dev/ttyUSB1" },
    {3, "/dev/ttyUSB2" },
    {4, "/dev/ttyUSB3" },

    {5, "/dev/ttyUSB4" },
    {6, "/dev/ttyUSB5" },
    {7, "/dev/ttyUSB6" },
    {8, "/dev/ttyUSB7" },

    {9, "/dev/ttyAMA0" },
    {10, "/dev/ttyAMA1" },
    {11, "/dev/ttyAMA2" },
    {12, "/dev/ttyAMA3" },
    {13, "/dev/ttyXRUSB0"},
    {14, "/dev/ttyXRUSB1"},
    {15, "/dev/ttyXRUSB2"},
    {16, "/dev/ttyXRUSB3"},
    {17, "/dev/ttyXRUSB4"},
    {18, "/dev/ttyXRUSB5"}
};

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 == nullptr) 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;
}

UpsClassImpl::UpsClassImpl() :
    m_bDevOpen(FALSE)
{
    LOG_FUNCTION();
    m_hComLib = NULL;								//Default value
    memset( m_cDeviceID, 0x00, sizeof (m_cDeviceID));
    memset( m_cDevType, 0x00, sizeof(m_cDevType) );
    memset( m_cFWMain, 0x00, sizeof(m_cFWMain) );
    memset( &m_stDevStatus, 0x00, sizeof (m_stDevStatus));
    SaveErrorInfo("OK", Error_Succeed);
}

UpsClassImpl::~UpsClassImpl()
{
    LOG_FUNCTION();
    g_SerialComm.Disconnect(m_hDevHnd);
    return;
}
ErrorCodeEnum UpsClassImpl::GetDevStatus(UpsStatusEnum &eStatus)
{
    LOG_FUNCTION();
    BYTE sCommand[] ={'Q', '1', 0x0D, 0x00};
    COMRESULT stComResult;
    memset(&stComResult, 0x00, sizeof (stComResult));
    int ret = 0;
    if (!m_bDevOpen)
    {
        if(DevOpen(m_nPort, m_nBaudRate) != Error_Succeed)
        {
            SaveErrorInfo("GetDevStatus() DevOpen() failed", Error_DevNotAvailable);
            g_SerialComm.Disconnect(m_hDevHnd);				//Get status failed
            m_hDevHnd = NULL;
            m_bDevOpen = false;
            eStatus = UPS_STATUS_ERROR_TO_GET_STATUS;
            return Error_DevNotAvailable;
        }
    }
    else
    {
        if(g_SerialComm.SendAndReceive(m_hDevHnd, sCommand, strlen((char*)sCommand), 10, &stComResult) != 0)
        {
            SaveErrorInfo("GetDevStatus() SendAndReceive failed", Error_DevNotAvailable);
            g_SerialComm.Disconnect(m_hDevHnd);				//Get status failed
            m_hDevHnd = NULL;
            m_bDevOpen = false;
            eStatus = UPS_STATUS_ERROR_TO_GET_STATUS;
            return Error_DevNotAvailable;
        }
    }
    LogXE( sCommand, strlen((char*)sCommand), "Snd");
    LogXE( stComResult.Buff, stComResult.Length , "Rcv");
    if(stComResult.Buff[38]=='0')
    {
        eStatus = UPS_STATUS_NORMAL;
        LogM("GetDevStatus() return eStatus:UPS_STATUS_NORMAL");
    }
    else
    {
        eStatus = UPS_STATUS_NO_ELECTOR;
        LogM("GetDevStatus() return eStatus:UPS_STATUS_NO_ELECTOR");
    }

    //todo: additional ups status-->m_stDevStatus
    return Error_Succeed;
}

ErrorCodeEnum UpsClassImpl::Shutdown(DWORD dwShutTime,DWORD dwRestartTime)
{
    LOG_FUNCTION();
    BYTE dataBuf[100]={0};
    int nRet = 0;
    int nLen = 3;
    if( !m_bDevOpen )
    {
        SaveErrorInfo("Shutdown()->Dev is not open",Error_DevNotAvailable );
        return Error_DevNotAvailable;
    }
    dataBuf[0]=0x53;
    dataBuf[1]=0x30;
    if(dwShutTime <= 5)
    {
        dataBuf[2]=0x30+dwShutTime;
    }
    else
    {
        dataBuf[2]=0x39;
    }
    if(dwRestartTime == 0)
    {
        dataBuf[3]=0x0D;
        nLen = 4;
    }
    else
    {
        dataBuf[3]=0x52;
        sprintf((char*)dataBuf+4,"%04d",dwRestartTime);
        dataBuf[8]=0x0D;
        nLen = 9;

    }
    nRet = g_SerialComm.SendData(m_hDevHnd, dataBuf, nLen );
    if(nRet < 0)
    {
        SaveErrorInfo("GetDevStatus() DevOpen() failed", Error_DevNotAvailable);
        g_SerialComm.Disconnect(m_hDevHnd);				//Get status failed
        m_hDevHnd = NULL;
        m_bDevOpen = false;
        return Error_DevNotAvailable;
    }
    return Error_Succeed;
}

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

    CHAR szHardwareSN[16] = {0};
    CHAR szTemp[128] = {0};
    memset(devCategory.szType, 0, MAX_DEV_TYPE_LEN);
    memset(devCategory.szModel, 0, MAX_DEV_MODEL_LEN);
    memset(devCategory.szVendor, 0, MAX_DEV_VENDOR_LEN);
    memset(&devCategory.version, 0, sizeof(devCategory.version));
    UpsStatusEnum eStatus;
    GetDevStatus(eStatus);
    if(m_bDevOpen)
    {
        devCategory.eState = DEVICE_STATUS_NORMAL;
    }
    else
    {
        devCategory.eState = DEVICE_STATUS_MAINTAINCE;
    }
    memcpy(devCategory.szType, "keba.UPS.EAST", strlen("keba.UPS.EAST"));
    memcpy(devCategory.szModel, "", strlen(""));
    memcpy(devCategory.szVendor, "keba", strlen("keba"));
    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;
    //devCategory.version.wRevision = 0xFFFF;
    //devCategory.version.wBuild = 1;
    //devCategory.version.wMajor = 0;
    //devCategory.version.wMinor = 0;
    return Error_Succeed;
}

ErrorCodeEnum UpsClassImpl::Reset()
{
    LOG_FUNCTION();
    m_bDevOpen = false;
    DevClose();
    return DevOpen(m_nPort, m_nBaudRate);
}

ErrorCodeEnum UpsClassImpl::DevClose()
{
    LOG_FUNCTION();
    if(!m_bDevOpen)
    {
        LogM("Device is not open yet!");
    }
    g_SerialComm.Disconnect(m_hDevHnd);
    LogM("DevClose() set com to close.")
    m_hDevHnd = NULL;
    m_bDevOpen = false;
    return Error_Succeed;
}

ErrorCodeEnum UpsClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    LOG_FUNCTION();
    devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
    memset(devErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    memcpy(devErrInfo.szErrMsg, m_szErrMsg, devErrInfo.dwErrMsgLen<MAX_DEV_ERROR_MSG_LEN? devErrInfo.dwErrMsgLen:MAX_DEV_ERROR_MSG_LEN);
    return Error_Succeed;
}

ErrorCodeEnum UpsClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    m_nPort = dwPort;
    m_nBaudRate = dwBaudRate;

    m_nPort = 14;
    char* lpPort = GetCOMPortString(m_nPort);
    if(nullptr == lpPort)
    {
        m_bDevOpen = false;
        sprintf(szErrorMsg, "Invalid COM name");
        SaveErrorInfo(szErrorMsg, Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }

    memcpy(m_cDeviceID, lpPort, strlen(lpPort));
    int ret = g_SerialComm.Connect(m_cDeviceID, 2400, 2, 1, &m_hDevHnd, 8);
    if( ret == 0) //返回0， 串口打开成功
    {
        sprintf(szErrorMsg, "Open %s OK:%d COM：%s", lpPort, ret, m_cDeviceID);
        SaveErrorInfo(szErrorMsg, Error_Succeed);
    }
    else
    {
        m_bDevOpen = false;
        sprintf(szErrorMsg, "Open %s OK:%d COM：%s", lpPort, ret, m_cDeviceID);
        SaveErrorInfo(szErrorMsg, Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }

    m_bDevOpen = true;
    UpsStatusEnum eStatus = UPS_STATUS_NORMAL;
    return GetDevStatus(eStatus);
}

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

char* UpsClassImpl::GetCOMPortString(DWORD dwCOM)
{
    int iCount = sizeof(m_arrCOMInfo)/sizeof(Dev_COMInfo);

    for(int i = 0; i < iCount; i++)
    {
        if(dwCOM == m_arrCOMInfo[i].dwCOM)
            return m_arrCOMInfo[i].strCOM;
    }

    return nullptr;
}