myvtm/DevAdapter/cw/cardissuer.1.1/cardissuerimpl.cpp

#include "cardissuerimpl.h"
#include <cstring>
#include <cstdio>
#include "sini.h"
#include "public.h"

CardIssuerClassImpl::CardIssuerClassImpl()
        :m_mode(0)
{
    m_pDriver = new IDCSankyoImpl ();
    m_T = 0;
    m_bIsOpen = false;
    m_bCardRead = false;
}

CardIssuerClassImpl::~CardIssuerClassImpl()
{
    if(NULL != m_pDriver)
    {
        delete m_pDriver;
        m_pDriver = NULL;
    }
}

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 CardIssuerClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "GetDevCategory");
    char version[256];
    char sFwid[32];
    int iRt = m_pDriver->getFirmversion((unsigned char*)version);
    ErrorCodeEnum eRt = HandleDevError(iRt, "GetDevCategory");
    if(Error_Succeed == eRt)
    {
        strcpy(sFwid, version+18);
    }
    else
        strcpy(sFwid, "G422-72");

    char szType[] = {"PVER=ACT#MID=F5-5540"};
    char szModel[] = "CM=V2.0#FWID=%s#CID=00000000";
    memset(&devCategory, 0, sizeof(devCategory));
    strcpy(devCategory.szType ,szType);
    sprintf(devCategory.szModel , szModel, sFwid);
    strcpy(devCategory.szVendor , "cw");
    devCategory.version.wMajor = 1;
    devCategory.version.wMinor = 1;
    devCategory.version.wRevision = 0xffff;
    devCategory.version.wBuild = FILE_VERSION;
//没有获取设备状态
    iRt = m_pDriver->getStatus();
    switch(iRt)
    {
    case CWINFO_IDC_S_EMPTY:
    case CWINFO_IDC_S_GATE:
    case CWINFO_IDC_S_INSIDE:
        devCategory.eState = DEVICE_STATUS_NORMAL;
        break;
    case 0x10:
    default:
        devCategory.eState = DEVICE_STATUS_NOT_READY;
        break;
    }

    return Error_Succeed;
}

ErrorCodeEnum CardIssuerClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
    LOG4VTM_FUNCTION();
    char sTemp[128] = { 0 };
    sprintf(sTemp, "DevOpen dwPort %d, dwBaudRate %d", dwPort, dwBaudRate);
    LOG4VTM(INFO, sTemp);
    ErrorCodeEnum eRt = Error_Succeed;
    m_bIsOpen = false;
    int iRt = 0;
    do
    {
        char sPort[16],sGet[32];
        sprintf(sPort, "COM%d", dwPort);
        SIni ini;
        if (ini.GetValueFromIniFile("/cashway/setting/cashway.ini", "Serial", sPort, sGet, 30))
            strcpy(sPort, sGet);

        iRt = m_pDriver->openPort(sPort, dwBaudRate, true);
        eRt = HandleDevError(iRt, "openPort");
        if(Error_Succeed != eRt)    break;
        unsigned char version[64] = { 0 };
        iRt = m_pDriver->getFirmversion(version);
        eRt = HandleDevError(iRt, "getFirmversion");
        if(Error_Succeed != eRt)    break;
        sprintf(sTemp, "Firmversion: %s", version);
        LOG4VTM(INFO, sTemp);
        m_bIsOpen = true;
    }while(0);

    sprintf(sTemp, "DevOpen openPort %d", iRt);
    LOG4VTM(INFO, sTemp);
    return eRt;
}

ErrorCodeEnum CardIssuerClassImpl::DevOpenEx(DWORD dwPort, DWORD dwBaudRate, BYTE btOpenType, const char* pDevSN, BYTE& btType)
{
    LOG4VTM_FUNCTION();
    m_bIsOpen = false;
    char sTemp[128] = { 0 };
    sprintf(sTemp, "DevOpen dwPort %d, dwBaudRate %d", dwPort, dwBaudRate);
    LOG4VTM(INFO, sTemp);
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
    do
    {
        char sPort[16],sGet[32];
        sprintf(sPort, "COM%d", dwPort);
        SIni ini;
        if (ini.GetValueFromIniFile("/cashway/setting/cashway.ini", "Serial", sPort, sGet, 30))
            strcpy(sPort, sGet);

        iRt = m_pDriver->openPort(sPort, dwBaudRate, true);
        eRt = HandleDevError(iRt, "DevOpenEx openPort");
        if(Error_Succeed != eRt)    break;
        iRt = m_pDriver->reset(RESET_TO_HOLD, PWR_OFF_TO_INSIDE);
        eRt = HandleDevError(iRt, "DevOpenEx reset");
        if(Error_Succeed != eRt)    break;
//        unsigned char version[64] = { 0 };
//        iRt = m_pDriver->getFirmversion(version);
//        eRt = HandleDevError(iRt, "DevOpenEx getFirmversion");
//        if(Error_Succeed != eRt)    break;
//        version[15]=0;
//        memcpy((char*)pDevSN, version, strlen((const char*)version));
        m_pDriver->resetCount();
        m_bIsOpen = true;
    }while(0);

    sprintf(sTemp, "DevOpen openPort %d", iRt);
    btType = 2;
    LOG4VTM(INFO, sTemp);
    return eRt;
}

ErrorCodeEnum CardIssuerClassImpl::Reset()
{
    LOG4VTM_FUNCTION();
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = m_pDriver->reset(RESET_TO_HOLD, PWR_OFF_TO_INSIDE);
    eRt = HandleDevError(iRt, __FUNCTION__);
    return eRt;
}

ErrorCodeEnum CardIssuerClassImpl::DevClose()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "DevClose");
    m_pDriver->closePort();
    m_bIsOpen = false;
    return Error_Succeed;
}

ErrorCodeEnum CardIssuerClassImpl::GetDevStatus(CardIssuerStatus& devStatus)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "GetDevStatus");
    ErrorCodeEnum eRt = Error_Succeed;
    memset(&devStatus, 0, sizeof(devStatus));
    int iRt = 0;
    do
    {
        //get card reader status
        iRt = m_pDriver->getStatus();
        if(CWINFO_IDC_S_EMPTY == iRt)
        {
            devStatus.eMedia = CI_MEDIA_NOTPRESENT;
        }
        else if(CWINFO_IDC_S_GATE == iRt)
        {
            devStatus.eMedia = CI_MEDIA_ENTERING;
        }
        else if(CWINFO_IDC_S_INSIDE == iRt)
        {
            devStatus.eMedia = CI_MEDIA_PRESENT;
        }
        else if(0x10 == iRt)
        {
            devStatus.eMedia = CI_MEDIA_JAMMED;
        }
        else {
            eRt = HandleDevError(iRt, "GetDevStatus getStatus");
            break;
        }
//*
        //get box status
        CUStatus cuStatus;
        RetainBinStatus rtStatus;
        iRt = m_pDriver->GetBoxStatus(cuStatus, rtStatus);
        eRt = HandleDevError(iRt, "GetDevStatus GetBoxStatus");
        if(Error_Succeed != eRt)
        {
            break;
        }
        if(rtStatus.BoxCount >= 1)
        {
            devStatus.dwRetainCount = 60;
            switch (rtStatus.status[0])
            {
            case O_Box_Ok:
            case O_Box_Empty:
                devStatus.eRetainBin = CI_RETAINBIN_OK;
                break;
            case O_Box_High:
            case O_Box_Full:
                devStatus.eRetainBin = CI_RETAINBIN_FULL;
                break;
            case O_Box_Miss:
                devStatus.eRetainBin = CI_RETAIN_NOTSUPP;
                break;
            default:
                devStatus.eRetainBin = CI_RETAIN_NOTSUPP;
                break;
            }
        }

        for (int i = 0; i < 3; i++)
        {
            if(i < cuStatus.BoxCount)
            {
                devStatus.dwIssuerCount[i] = 200;
                switch (cuStatus.status[i])
                {
                case O_Box_Ok:
                    devStatus.eIssuerBin[i] = CI_ISSUEHOPPER_OK;
                    break;
                case O_Box_Empty:
                    devStatus.eIssuerBin[i] = CI_ISSUEHOPPER_EMPTY;
                    break;
                case O_Box_Low:
                    devStatus.eIssuerBin[i] = CI_ISSUEHOPPER_LOW;
                    break;
                case O_Box_Miss:
                    devStatus.eIssuerBin[i] = CI_ISSUEHOPPER_NOTSUPP;
                    break;
                case O_Box_High:
                case O_Box_Full:
                    devStatus.eIssuerBin[i] = CI_ISSUEHOPPER_OK;
                    break;
                default:
                    devStatus.eIssuerBin[i] = CI_ISSUEHOPPER_NOTSUPP;
                    break;
                }
            }
            else
            {
                devStatus.dwIssuerCount[i] = 0;
                devStatus.eIssuerBin[i] = CI_ISSUEHOPPER_NOTSUPP;
            }
        }
//*/
    }while(0);

    char outputParam[512] = { 0 };
    sprintf(outputParam, "GetDevStatus cardstatus(%s) retainBinStatus(%s) hopper1Status(%s) hopper2Status(%s) hopper3Status(%s)",
            FormatCardStatus(devStatus.eMedia), FormatRetainBinStatus(devStatus.eRetainBin), FormatCuBoxStatus(devStatus.eIssuerBin[0]),
            FormatCuBoxStatus(devStatus.eIssuerBin[1]), FormatCuBoxStatus(devStatus.eIssuerBin[2]));
    LOG4VTM(INFO, outputParam);
    return eRt;
}

ErrorCodeEnum CardIssuerClassImpl::GetDeviceSN(char*& pDevSN)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "GetDeviceSN");
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
    do
    {
        unsigned char version[64] = { 0 };
        iRt = m_pDriver->getFirmversion(version);
        eRt = HandleDevError(iRt, "GetDeviceSN getFirmversion");
        if(Error_Succeed != eRt)
        {
            break;
        }
        memcpy((char*)pDevSN, version, strlen((const char*)version));
    }while(0);
    char outputParam[128] = { 0 };
    sprintf(outputParam, "GetDeviceSN pDevSN(%s)", pDevSN);
    LOG4VTM(INFO, outputParam);
    return eRt;
}

ErrorCodeEnum CardIssuerClassImpl::MoveCard(CardPosEnum eCardPos, int hopperNo)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "MoveCard");
    char inputParam[128] = { 0 };
    sprintf(inputParam, "InputParam>> eCardPos(%s) hopperNo(%d)", FormatCardPosStatus(eCardPos), hopperNo);
    LOG4VTM(INFO, inputParam);
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
    m_bCardRead = false;
    eRt = ReleaseIC();
    if(CI_MOVECARD_FRONT_GATE == eCardPos)
    {
        iRt = m_pDriver->ejectCard();
        eRt = HandleDevError(iRt, "MoveCard ejectCard");
        return eRt;
    }

    if(CI_MOVECARD_RF_POSITION == eCardPos || CI_MOVECARD_IC_POSITION == eCardPos || CI_MOVECARD_MAG_POSITION == eCardPos)
    {
//       iRt = m_pDriver->moveCardToICRW();
        iRt = m_pDriver->reIntakeCard();
        eRt = HandleDevError(iRt, "MoveCard ToICRW");
        return eRt;
    }
    if(CI_MOVECARD_BACK_NOT_HOLD == eCardPos)
    {
        bool bOK = false;

        CUStatus cuStatus;
        RetainBinStatus rtStatus;
        iRt = m_pDriver->GetBoxStatus(cuStatus, rtStatus);
        eRt = HandleDevError(iRt, "GetBoxStatus");
        if(Error_Succeed != eRt)
            return eRt;
        switch (rtStatus.status[0])
        {
        case O_Box_Ok:
        case O_Box_Empty:
        case O_Box_Low:
        case O_Box_High:
            bOK = true;
            break;
        default:
            break;
        }
        if (!bOK)
        {
            eRt = HandleDevError(RETAIN_BIN_ERROR, "MoveCard retainCard");
            return eRt;
        }
        //需要先检测卡片位置，如果在入口需要先进入
        //没有获取设备状态
        iRt = m_pDriver->getStatus();
        switch(iRt)
        {
        case CWINFO_IDC_S_EMPTY:
            return HandleDevError(DEVICE_NO_MEDIA, "MoveCard retainCard");
        case CWINFO_IDC_S_GATE:
            m_pDriver->reIntakeCard();
        case CWINFO_IDC_S_INSIDE:
            iRt = m_pDriver->retainCard();
            return HandleDevError(iRt, "MoveCard DispensCard");
        default:
            return HandleDevError(DEVICE_NO_MEDIA, "MoveCard retainCard");
        }
    }
    if(CI_MOVECARD_FROM_HOPPER == eCardPos)
    {
        iRt = m_pDriver->DispensCard(hopperNo);
        return HandleDevError(iRt, "MoveCard DispensCard");
    }

    return HandleDevError(DEVICE_NOT_SUPP, "MoveCard DispensCard");
}

//	Set card entry
ErrorCodeEnum CardIssuerClassImpl::SetCardInType(CardInEnum eCardIn)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "SetCardInType");
    m_bCardRead = false;
    char sTemp[128] = { 0 };
    sprintf(sTemp, "SetCardInType eCardIn(%s)", FormatCardIn(eCardIn));
    LOG4VTM(INFO, sTemp);
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
    do
    {
        bool fluxInactive = false;
        if(CI_CARD_IN_TYPE_FORBIDDEN == eCardIn)
        {
            iRt = m_pDriver->denyCardIn();
            eRt = HandleDevError(iRt, "SetCardInType denyCardIn");
            if(Error_Succeed != eRt)
            {
                break;
            }
        }
        else if(CI_CARD_IN_TYPE_MAG == eCardIn || CI_CARD_IN_TYPE_ALL == eCardIn)
        {
            if(CI_CARD_IN_TYPE_ALL == eCardIn)
            {
                fluxInactive = true;
            }
            iRt = m_pDriver->waitCardIn(fluxInactive);
            eRt = HandleDevError(iRt, "SetCardInType waitCardIn");
            if(Error_Succeed != eRt)
            {
                break;
            }
        }

    }while(0);
    return eRt;
}

bool SetCardData(TrackInfo& track, char* sData, TrackSrcEnum eTrack)
{
    track.eSource = eTrack;
    int iLen = strlen(sData);
    if(iLen)
    {
        track.eStatus = CI_DATA_OK;
        strcpy((char*)track.data, sData);
        track.dwSize = iLen;
        return true;
    }
    else
    {
        track.eStatus = CI_DATA_INVALID;
        track.data[0] = 0;
        track.dwSize = 0;
        return false;
    }
}

void CardIssuerClassImpl::ReadMagData()
{
    memset(m_saMagData, 0, sizeof(m_saMagData));
    if (m_pDriver->getStatus() != CWINFO_IDC_S_INSIDE)
    {
        m_iReadReturn = DEVICE_NO_MEDIA;
        m_bCardRead = false;
        return;
    }
//    m_iReadCode = m_pDriver->readRawData(m_rawDataArr, 3);
    m_pDriver->readTrack(1, m_saMagData[0]);
    m_pDriver->readTrack(2, m_saMagData[1]);
    m_pDriver->readTrack(3, m_saMagData[2]);
    if (strlen(m_saMagData[0]) || strlen(m_saMagData[1]) || strlen(m_saMagData[2]))
        m_iReadReturn = 0;
    else
        m_iReadReturn = DEVICE_NO_DATA;
    m_bCardRead = true;
}

//	Read data from magnetic track.
ErrorCodeEnum CardIssuerClassImpl::MagRead(MagTracks& magTracks)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "MagRead");
    char sTemp[128] = { 0 };
    sprintf(sTemp, "MagRead eRange(%s)", FormatTrackRange(magTracks.eRange));
    LOG4VTM(INFO, sTemp);
    ErrorCodeEnum eRt = Error_Succeed;
    if (!m_bCardRead)
        ReadMagData();
    bool    bReadSucc = false;
    //上层要求必须有数据长度，只有错误码会报错
    if (SetCardData(magTracks.track[0], m_saMagData[0], CI_TRACK_SOURCE_1))
        bReadSucc=true;
    if (SetCardData(magTracks.track[1], m_saMagData[1], CI_TRACK_SOURCE_2))
        bReadSucc=true;
    if (SetCardData(magTracks.track[2], m_saMagData[2], CI_TRACK_SOURCE_3))
        bReadSucc=true;
    eRt = HandleDevError(m_iReadReturn, "MagRead");
    sprintf(sTemp, "MagRead track%dlen(%d) track%dlen(%d) track%dlen(%d)",
            magTracks.track[0].eSource, magTracks.track[0].dwSize,
            magTracks.track[1].eSource, magTracks.track[1].dwSize,
            magTracks.track[2].eSource, magTracks.track[2].dwSize);
    LOG4VTM(INFO, sTemp);
    return bReadSucc ? Error_Succeed : eRt;
}

//	Write data to magnetic track.
ErrorCodeEnum CardIssuerClassImpl::MagWrite(MagTracks magTracks, MagWriteModeEnum eWriteMode)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "MagWrite");
    char sTemp[512] = { 0 };
    sprintf(sTemp, "MagWrite eRange(%s) track1[%d], track2[%d], track3[%d]", FormatTrackRange(magTracks.eRange),
            magTracks.track[0].dwSize, magTracks.track[1].dwSize, magTracks.track[2].dwSize);
    LOG4VTM(INFO, sTemp);
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
    do
    {
        bool btrack1 = false, btrack2 = false, btrack3 = false;
        if(CI_TRACK_RANGE_1 == magTracks.eRange || CI_TRACK_RANGE_1_2 == magTracks.eRange || CI_TRACK_RANGE_1_3 == magTracks.eRange || CI_TRACK_RANGE_1_2_3 == magTracks.eRange)
        {
           btrack1 = true;
        }
        if(CI_TRACK_RANGE_2 == magTracks.eRange || CI_TRACK_RANGE_1_2 == magTracks.eRange || CI_TRACK_RANGE_2_3 == magTracks.eRange || CI_TRACK_RANGE_1_2_3 == magTracks.eRange)
        {
           btrack2 = true;
        }
        if(CI_TRACK_RANGE_3 == magTracks.eRange || CI_TRACK_RANGE_2_3 == magTracks.eRange || CI_TRACK_RANGE_1_3 == magTracks.eRange || CI_TRACK_RANGE_1_2_3 == magTracks.eRange)
        {
           btrack3 = true;
        }
        IDCRawData rawDataArr[3];
        unsigned short itemsCount = 0;
        memset(rawDataArr, 0, sizeof(rawDataArr));
        for (int i = 0; i < MAX_MAG_TRACK_NUM; i++)
        {
            if(btrack1)
            {
                if(CI_TRACK_SOURCE_1 == magTracks.track[i].eSource)
                {
                    rawDataArr[itemsCount].source = O_Source_Track1;
                    rawDataArr[itemsCount].len = magTracks.track[i].dwSize;
                    memcmp(rawDataArr[itemsCount].rawData, magTracks.track[i].data, magTracks.track[i].dwSize);
                    itemsCount++;

                    iRt = m_pDriver->setTrackData(magTracks.track[i].data, 1);
                    eRt = HandleDevError(iRt, "MagWrite setTrackData 1");
                    if(Error_Succeed != eRt)
                    {
                        break;
                    }
                }
            }
            if(btrack2)
            {
                if(CI_TRACK_SOURCE_2 == magTracks.track[i].eSource)
                {
                    rawDataArr[itemsCount].source = O_Source_Track2;
                    rawDataArr[itemsCount].len = magTracks.track[i].dwSize;
                    memcmp(rawDataArr[itemsCount].rawData, magTracks.track[i].data, magTracks.track[i].dwSize);
                    itemsCount++;

                    iRt = m_pDriver->setTrackData(magTracks.track[i].data, 2);
                    eRt = HandleDevError(iRt, "MagWrite setTrackData 2");
                    if(Error_Succeed != eRt)
                    {
                        break;
                    }
                }
            }
            if(btrack3)
            {
                if(CI_TRACK_SOURCE_3 == magTracks.track[i].eSource)
                {
                    rawDataArr[itemsCount].source = O_Source_Track3;
                    rawDataArr[itemsCount].len = magTracks.track[i].dwSize;
                    memcmp(rawDataArr[itemsCount].rawData, magTracks.track[i].data, magTracks.track[i].dwSize);
                    itemsCount++;

                    iRt = m_pDriver->setTrackData(magTracks.track[i].data, 3);
                    eRt = HandleDevError(iRt, "MagWrite setTrackData 3");
                    if(Error_Succeed != eRt)
                    {
                        break;
                    }
                }
            }
        }
        iRt = m_pDriver->writeRawData(rawDataArr, itemsCount);
        eRt = HandleDevError(iRt, "MagWrite writeRawData");
    }while(0);

    return eRt;
}

//	Active contact IC card
ErrorCodeEnum CardIssuerClassImpl::ActiveICCard()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "ActiveICCard");
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
    do
    {
        IDCRawData chipATR;
        memset(&chipATR, 0, sizeof(chipATR));
        iRt = m_pDriver->icActive(&chipATR);
        eRt = HandleDevError(iRt, "ActiveICCard");
        if(Error_Succeed != eRt)
        {
            break;
        }
        unsigned char p = (chipATR.rawData[0] & 0xF0);
        char sTemp[256];
        sprintf(sTemp, "ActiveICCard Card type %02x", chipATR.rawData[0]);
        LOG4VTM(WARN, sTemp);
        if(p == 0xe0)
            m_T = 1;
        else if (p == 0x60)
            m_T = 0;
        else
            m_T = 0;
    }while(0);

    return eRt;
}

//	Move IC card to contact position
ErrorCodeEnum CardIssuerClassImpl::ContactIC()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "ContactIC");
    if (!m_bCardRead)
        ReadMagData();
    int iRt = m_pDriver->icPress();
    return HandleDevError(iRt, "ContactIC");
//    return Error_Succeed;
}

ErrorCodeEnum CardIssuerClassImpl::ReleaseIC()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "ReleaseIC");
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
//    iRt = m_pDriver->icDeactiveAndRelease();
    eRt = HandleDevError(iRt, "ReleaseIC");
    return eRt;
}

//	Warm reset card(IC)
ErrorCodeEnum CardIssuerClassImpl::WarmReset()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "WarmReset");
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
    do
    {
        IDCRawData chipATR;
        memset(&chipATR, 0, sizeof(chipATR));
        iRt = m_pDriver->icWarmReset(&chipATR);
        eRt = HandleDevError(iRt, "WarmReset");
    }while(0);

    return eRt;
}

ErrorCodeEnum CardIssuerClassImpl::ICCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return HandleDevError(DEVICE_NOT_OPEN, "ICCommand");
    char sTemp[512] = { 0 };
    sprintf(sTemp, "ICCommand sendlen (%d)", sendBuf.dwSize);
    LOG4VTM(INFO, sTemp);
    ErrorCodeEnum eRt = Error_Succeed;
    int iRt = 0;
    do
    {
        IDCRawData chipInput;
        memset(&chipInput, 0, sizeof(chipInput));
        IDCRawData chipOutput;
        memset(&chipOutput, 0, sizeof(chipOutput));

        chipInput.len = sendBuf.dwSize;
        memcpy(chipInput.rawData, sendBuf.data, sendBuf.dwSize);
        ChipProtocolType type = O_Chip_T0;
        if(1 == m_T)
            type = O_Chip_T1;
        iRt = m_pDriver->icPPSExchange(type);
        eRt = HandleDevError(iRt, "ICCommand");
        if(Error_Succeed != eRt)    break;
        iRt = m_pDriver->icCommunicate(&chipInput, &chipOutput);
        if(Error_Succeed != eRt)    break;
        memcpy(recvBuf.data, chipOutput.rawData, chipOutput.len);
        recvBuf.dwSize = chipOutput.len;
        recvBuf.data[recvBuf.dwSize] = 0;
    }while(0);

    sprintf(sTemp, "ICCommand recvlen(%d)", recvBuf.dwSize);
    LOG4VTM(INFO, sTemp);
    return eRt;
}

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

char* CardIssuerClassImpl::FormatRetainBinStatus(RtBinStatusEnum status)
{
    memset(m_pformatStatus, 0, 64);
    switch(status)
    {
    case CI_RETAINBIN_OK:
        sprintf(m_pformatStatus, "CI_RETAINBIN_OK");
        break;
    case CI_RETAIN_NOTSUPP:
        sprintf(m_pformatStatus, "CI_RETAIN_NOTSUPP");
        break;
    case CI_RETAINBIN_FULL:
        sprintf(m_pformatStatus, "CI_RETAINBIN_FULL");
        break;
    case CI_RETAINBIN_HIGH:
        sprintf(m_pformatStatus, "CI_RETAINBIN_HIGH");
        break;
    }
    return m_pformatStatus;
}

char* CardIssuerClassImpl::FormatCuBoxStatus(IssHopperStatusEnum status)
{
    memset(m_pformatStatus, 0, 64);
    switch(status)
    {
    case CI_ISSUEHOPPER_OK:
        sprintf(m_pformatStatus, "CI_ISSUEHOPPER_OK");
        break;
    case CI_ISSUEHOPPER_NOTSUPP:
        sprintf(m_pformatStatus, "CI_ISSUEHOPPER_NOTSUPP");
        break;
    case CI_ISSUEHOPPER_EMPTY:
        sprintf(m_pformatStatus, "CI_ISSUEHOPPER_EMPTY");
        break;
    case CI_ISSUEHOPPER_LOW:
        sprintf(m_pformatStatus, "CI_ISSUEHOPPER_LOW");
        break;
    }
    return m_pformatStatus;
}

char* CardIssuerClassImpl::FormatCardPosStatus(CardPosEnum status)
{
    memset(m_pformatStatus, 0, 64);
    switch(status)
    {
    case CI_MOVECARD_FRONT_GATE:
        sprintf(m_pformatStatus, "CI_MOVECARD_FRONT_GATE");
        break;
    case CI_MOVECARD_RF_POSITION:
        sprintf(m_pformatStatus, "CI_MOVECARD_RF_POSITION");
        break;
    case CI_MOVECARD_IC_POSITION:
        sprintf(m_pformatStatus, "CI_MOVECARD_IC_POSITION");
        break;
    case CI_MOVECARD_MAG_POSITION:
        sprintf(m_pformatStatus, "CI_MOVECARD_MAG_POSITION");
        break;
    case CI_MOVECARD_BACK_NOT_HOLD:
        sprintf(m_pformatStatus, "CI_MOVECARD_BACK_NOT_HOLD");
        break;
    case CI_MOVECARD_FROM_HOPPER:
        sprintf(m_pformatStatus, "CI_MOVECARD_FROM_HOPPER");
        break;
    case CI_MOVECARD_RETRIEVE:
        sprintf(m_pformatStatus, "CI_MOVECARD_RETRIEVE");
        break;
    }
    return m_pformatStatus;
}

char* CardIssuerClassImpl::FormatCardStatus(CardStatusEnum status)
{
    memset(m_pformatStatus, 0, 64);
    switch(status)
    {
    case CI_MEDIA_NOTPRESENT:
        sprintf(m_pformatStatus, "CI_MEDIA_NOTPRESENT");
        break;
    case CI_MEDIA_PRESENT:
        sprintf(m_pformatStatus, "CI_MEDIA_PRESENT");
        break;
    case CI_MEDIA_JAMMED:
        sprintf(m_pformatStatus, "CI_MEDIA_JAMMED");
        break;
    default:
        sprintf(m_pformatStatus, "Unknown %d", status);
        break;
    }
    return m_pformatStatus;
}

char* CardIssuerClassImpl::FormatCardIn(CardInEnum status)
{
    memset(m_pformatStatus, 0, 64);
    switch(status)
    {
    case CI_CARD_IN_TYPE_FORBIDDEN:
        sprintf(m_pformatStatus, "CI_CARD_IN_TYPE_FORBIDDEN");
        break;
    case CI_CARD_IN_TYPE_MAG:
        sprintf(m_pformatStatus, "CI_CARD_IN_TYPE_MAG");
        break;
    case CI_CARD_IN_TYPE_ALL:
        sprintf(m_pformatStatus, "CI_CARD_IN_TYPE_ALL");
        break;
    }
    return m_pformatStatus;
}

char* CardIssuerClassImpl::FormatTrackRange(TrackRange status)
{
    memset(m_pformatStatus, 0, 64);
    switch(status)
    {
    case CI_TRACK_RANGE_1:
        sprintf(m_pformatStatus, "CI_TRACK_RANGE_1");
        break;
    case CI_TRACK_RANGE_2:
        sprintf(m_pformatStatus, "CI_TRACK_RANGE_2");
        break;
    case CI_TRACK_RANGE_3:
        sprintf(m_pformatStatus, "CI_TRACK_RANGE_3");
        break;
    case CI_TRACK_RANGE_1_2:
        sprintf(m_pformatStatus, "CI_TRACK_RANGE_1_2");
        break;
    case CI_TRACK_RANGE_2_3:
        sprintf(m_pformatStatus, "CI_TRACK_RANGE_2_3");
        break;
    case CI_TRACK_RANGE_1_3:
        sprintf(m_pformatStatus, "CI_TRACK_RANGE_1_3");
        break;
    case CI_TRACK_RANGE_1_2_3:
        sprintf(m_pformatStatus, "CI_TRACK_RANGE_1_2_3");
        break;
    default:
        sprintf(m_pformatStatus, "CI_TRACK_RANGE_Unk");
        break;
    }
    return m_pformatStatus;
}

ErrorCodeEnum CardIssuerClassImpl::HandleDevError(int nRt, LPCTSTR lpszFormat, ...)
{
    ErrorCodeEnum eRt = Error_Succeed;
    char strErrInfo[80] = { 0 };
    switch (nRt)
    {
    case DEVICE_NOT_SUPP:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "not support the command");
        break;
    case DEVICE_NO_MEDIA:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "no media error");
        break;
    case RETAIN_BIN_ERROR:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "RetainBin error");
        break;
    case  DEVICE_NOT_OPEN:
        eRt = Error_Hardware;
        sprintf(strErrInfo, "device not opened");
        break;
    case  DEVICE_NO_DATA:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "read track no data");
        break;
    //成功
    case  0:
        eRt = Error_Succeed;
        sprintf(strErrInfo, "success");
        break;

    //正常情况
    case CWINFO_IDC_S_EMPTY:
        eRt = Error_Succeed;
        sprintf(strErrInfo, "no card.");
        break;
    case CWINFO_IDC_S_GATE:
        eRt = Error_Succeed;
        sprintf(strErrInfo, "card in the gate.");
        break;
    case CWINFO_IDC_S_INSIDE:
        eRt = Error_Succeed;
        sprintf(strErrInfo, "card inside.");
        break;
    case 0x01:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Parameter is not correct.");
        break;
    case 0x02:
        eRt = Error_Hardware;
        sprintf(strErrInfo, "Command execution is impossible.");
        break;
    case 0x03:
        eRt = Error_Hardware;
        sprintf(strErrInfo, "Hardware is not present.");
        break;
    case 0x04:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Command data error.");
        break;
    case 0x05:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Tried to card feed commands before the IC contact release command.");
        break;
    case 0x06:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "ICRW does not have that decipher the data.");
        break;
    case 0x10:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "Card jam.");
        break;
    case 0x11:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Shutter failure.");
        break;
    case 0x12:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Sensor failure of PD1, PD2, PD3, PDI/Card remains inside.");
        break;
    case 0x13:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Irregular card length(LONG).");
        break;
    case 0x14:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Irregular card length(SHORT).");
        break;
    case 0x15:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "F-ROM error.");
        break;
    case 0x16:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "The card was moved forcibly.");
        break;
    case 0x17:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "Jam error at retrieve.");
        break;
    case 0x18:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "SW1 or SW2 error.");
        break;
    case 0x19:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Card was not inserted from the rear.");
        break;
    case 0x20:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Read Error(Parity error).");
        break;
    case 0x21:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Read error.");
        break;
    case 0x22:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Write Error.");
        break;
    case 0x23:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Read Error(Only SS-ES-LRC).");
        break;
    case 0x24:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Read Error(no encode and/or no magnetic stripe).");
        break;
    case 0x25:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Write Verify Error(Quality error).");
        break;
    case 0x26:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Read Error(No SS).");
        break;
    case 0x27:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Read Error(No ES).");
        break;
    case 0x28:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Read Error(LRC error).");
        break;
    case 0x29:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Write Verify Error(Data discordance).");
        break;
    case 0x30:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Power Down.");
        break;
    case 0x40:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Card wos pulled out during capture.");
        break;
    case 0x41:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Failure IC contact solenoid or sensor ICD.");
        break;
    case 0x43:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Card could not be set to IC contact position.");
        break;
    case 0x45:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "ICRW ejected the card forcibly.");
        break;
    case 0x46:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "The ejected card has not been withdrawn until the specified time.");
        break;
    case 0x50:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Retract counter overflow.");
        break;
    case 0x51:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Motor error.");
        break;
    case 0x53:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Digital decode read error.");
        break;
    case 0x54:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Ant-fishing pin does not move correctly.");
        break;
    case 0x55:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "command can not be executed since the pin is down.");
        break;
    case 0x58:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Anti-fishing pin is during the movement.");
        break;
    case 0x60:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Abnormal condition was found on the power-lin(Vcc) of IC card.");
        break;
    case 0x61:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Receiving error of ATR.");
        break;
    case 0x62:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Thespecified protocol does not agreee with that of IC card.");
        break;
    case 0x63:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "IC card communication error(IC card does not respond).");
        break;
    case 0x64:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "IC card communication error(Ohter than '63').");
        break;
    case 0x65:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "HOST sends command for IC card communication before receiving ATR.");
        break;
    case 0x66:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Tried to communicate with IC card not supported in ICRW.");
        break;
    case 0x67:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Collision error of Contactless IC card(multiple cards detected)");
        break;
    case 0x69:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Tried to communicate with IC card not supported in Protocol EMV.");
        break;
    case 0xA0:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "The card does not exist at the hopper.");
        break;
    case 0xA1:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "There is a card at the lead line.");
        break;
    case 0xA2:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "Transmission error between MST and ICRW(time over).");
        break;
    case 0xA3:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Transmission error between MST and ICRW(retry error).");
        break;
    case 0xA4:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Transmission error between MST and ICT(retry error).");
        break;
    case 0xA5:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "The card jam at the hopper.");
        break;
    case 0xA6:
        eRt = Error_Hardware;
        sprintf(strErrInfo, "The hopping kicker could not return to the home position.");
        break;
    case 0xA7:
        eRt = Error_Hardware;
        sprintf(strErrInfo, "Motor error of MST.");
        break;
    case 0xA8:
        eRt = Error_Hardware;
        sprintf(strErrInfo, "SS sensor error of MST.");
        break;
    case 0xA9:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "The card does not exist at the slider.");
        break;
    case 0xAB:
        eRt = Error_DevMedia;
        sprintf(strErrInfo, "The reject-stacker does not exist./The reject-stacker was filled.");
        break;
    case 0xB0:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "Not received initialize command.");
        break;
    case 0xFF:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "A given command code is unidentified.");
        break;
    case CWERR_IDC_S_SOFT_UNK:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "communation error.");
        break;
    default:
        eRt = Error_Stoped;
        sprintf(strErrInfo, "unknow errcode(%d).", nRt);
        break;
    }
    char strInfo[300] = { 0 };
    va_list arglist;
    va_start(arglist, lpszFormat);
    _vsnprintf(strInfo, 128, lpszFormat, arglist);
    va_end(arglist);

    sprintf(strInfo + strlen(strInfo), " %s", strErrInfo);
    strInfo[200] = 0;
    //对dwErrMsgLen字段进行拆分
    // 高两字节存储硬件设备错误码 (dwErrMsgLen & 0xFFFF0000)
    // 低两字节保留以前的作用即：存储错误信息字符串szErrMsg的实际有效长度

    m_DevErrInfo.dwErrMsgLen = (eRt<<16)&0xFFFF0000;
    m_DevErrInfo.dwErrMsgLen += strlen(m_DevErrInfo.szErrMsg)&0x0000FFFF;
    sprintf(m_DevErrInfo.szErrMsg, "{\"ErrCode\":\"%04x\"，\"Description\":\"%s\"}", eRt, strInfo);
//    memset(m_DevErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
//    memcpy(m_DevErrInfo.szErrMsg, strErrInfo, strlen(strErrInfo));

    if (eRt != Error_Succeed)
        LOG4VTM(WARN, m_DevErrInfo.szErrMsg);
    else
        LOG4VTM(INFO, m_DevErrInfo.szErrMsg);
    return eRt;
 }