myvtm/DevAdapter/keba/CardIssuer.keba.1.1/ACT-Sankyo_DevCtrl.cpp

#include "stdafx.h"
#include "ACT-Sankyo_DevCtrl.h"
#include "CkLog.h"

LOG_EXTERN()

/*
typedef struct	tag_COMInfo
{
    DWORD dwCOM;
    char strCOM[64];
}COMInfo, *LPCOMInfo;
*/
//此处需要根据实际的设备上COM 口信息进行修改配置
Dev_COMInfo CACT_Sankyo_DevCtrl::m_arrCOMInfo[]=
{
    //设备类型1 COM口
    {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" }

    /*
      //设备类型2 COM口
        {21, "/dev/ttyXRUSB0" },
        {22, "/dev/ttyXRUSB1" },
        {23, "/dev/ttyXRUSB2" },
        {24, "/dev/ttyXRUSB3" },
        {25, "/dev/ttyXRUSB4" },
        {26, "/dev/ttyXRUSB5" }
    */
};

CACT_Sankyo_DevCtrl::CACT_Sankyo_DevCtrl(void)
{
	m_pDevCtrlImpl = new CACT_SDK_DevCtrlImpl();
}


CACT_Sankyo_DevCtrl::~CACT_Sankyo_DevCtrl(void)
{
	if (m_pDevCtrlImpl != NULL)
	{
		delete m_pDevCtrlImpl;
	}
}

WORD CACT_Sankyo_DevCtrl::Open(DWORD dwPort, DWORD dwBaudRate)
{
    LogM("CACT_Sankyo_DevCtrl:: entry->CACT_Sankyo_DevCtrl::Open(DWORD dwPort=%ld, DWORD dwBaudRate=%ld",dwPort,dwBaudRate);
	char szPort[16] = {0x00};
	WORD wResult = CRT_SUCCESS;
    char* lpPort = GetCOMPortString(dwPort);
    if(nullptr == lpPort) return CRT_OFFLINE;

    BOOL bRet = m_pDevCtrlImpl->OpenDevice(lpPort, dwBaudRate);
    LogM("CACT_Sankyo_DevCtrl::m_pDevCtrlImpl->OpenDevice(lpPort=%s, dwBaudRate=%ld",lpPort,dwBaudRate);
   // BOOL bRet = m_pDevCtrlImpl->OpenDevice("/dev/ttyUSB0", 38400);
	if (bRet == FALSE)
	{
        LogM("CACT_Sankyo_DevCtrl::entry->CACT_Sankyo_DevCtrl::Open->m_pDevCtrlImpl->OpenDevice failed");
		wResult = CRT_OFFLINE;
	}
	return wResult;
}

WORD CACT_Sankyo_DevCtrl::Close()
{
	WORD wResult = CRT_SUCCESS;
	
	m_pDevCtrlImpl->CloseDevice();

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::GetDevStatus(LPDevStatus lpDevStatus)
{
    LOG_FUNCTION();
	CRTCHUSensorInfo chuSnsInfo = {0};
	CRTHoppersInfo hoppersInfo = {0};
	BYTE bySt0 = '0';
	REPLY errReply;
	WORD wRes = CRT_RES_NO_CARD_IN_CHU;
	WORD wResult = CRT_SUCCESS;

	wResult = GetCHUStatus(&chuSnsInfo, &bySt0);
	if (wResult != CRT_SUCCESS)
	{
		return wResult;
	}

	lpDevStatus->cardStatus.wCardPos = CARD_READER_CARD_POS_NOCARD;
	lpDevStatus->cardStatus.wChip = CARD_READER_CARD_CHIP_UNKNOWN;
	lpDevStatus->cardStatus.wRetainBin = CARD_READER_RETAINBIN_UNKNOWN;
	lpDevStatus->cardStatus.wRetainCnt = 15;
	lpDevStatus->cardStatus.wShutter = CARD_READER_SHUTTER_UNKNOWN;
	lpDevStatus->hopperStatus[0].wHopperID = CARD_ISSUER_HOPPER_1;
	lpDevStatus->hopperStatus[1].wHopperID = CARD_ISSUER_HOPPER_2;
	for (int i = 0; i < MAX_HOPPER_COUNT; i++)
	{
		lpDevStatus->hopperStatus[i].wHopper = CARD_ISSUER_HOPPER_NOT_POS;
		lpDevStatus->hopperStatus[i].wIssuerCnt = 100;
	}

	if (bySt0 == '0')
	{
		lpDevStatus->cardStatus.wCardPos = CARD_READER_CARD_POS_NOCARD;
	}
	if ((chuSnsInfo.bSW1 == TRUE) && (chuSnsInfo.bSW2 == TRUE) && (bySt0 == '1'))
	{
		lpDevStatus->cardStatus.wCardPos |= CARD_READER_CARD_POS_GATE;
	}
	if (bySt0 == '2')
	{
		if ((chuSnsInfo.bPD1 == TRUE) || (chuSnsInfo.bPD2 == TRUE))
		{
			lpDevStatus->cardStatus.wCardPos |= CARD_READER_CARD_POS_MID;
		}
		if (chuSnsInfo.bPD3 == TRUE)
		{
			lpDevStatus->cardStatus.wCardPos |= CARD_READER_CARD_POS_REAR;
		}
	}

	wResult = GetDevErrCode(&errReply);
    LogM("wResult = GetDevErrCode(&errReply)=%d; line=%d" ,wResult,__LINE__);
	if (wResult != CRT_SUCCESS)
	{
        wRes = m_pDevCtrlImpl->GetResErrorType(wResult);
        LogM("wRes = m_pDevCtrlImpl->GetResErrorType(wResult)=%d; line=%d" ,wRes,__LINE__);
        if (wRes == CRT_RES_TYPE_SHUTTER_FAIL)
        {
            lpDevStatus->cardStatus.wShutter = CARD_READER_SHUTTER_FAIL;
        }
        if (wRes == CRT_RES_TYPE_MEC_ERROR_JAM)
        {
            lpDevStatus->cardStatus.wCardPos = CARD_READER_CARD_POS_JAM;
        }

        return wResult;

	}
	else
	{
		if (chuSnsInfo.bSW2 == TRUE)
		{
			lpDevStatus->cardStatus.wShutter = CARD_READER_SHUTTER_OPEN;
		}
		else
		{
			lpDevStatus->cardStatus.wShutter = CARD_READER_SHUTTER_CLOSE;
		}

		wRes = m_pDevCtrlImpl->GetNomalResValue(errReply.message.positiveReply);
        LogM("wRes = m_pDevCtrlImpl->GetNomalResValue(errReply.message.positiveReply)=%d; line=%d" ,wRes,__LINE__);
		if (wRes == EXWORDHL(CRT_RES_NO_CARD_IN_CHU))
		{
			lpDevStatus->cardStatus.wCardPos = CARD_READER_CARD_POS_NOCARD;
		}
		else
		{
			if (chuSnsInfo.bICD == TRUE)
			{
				lpDevStatus->cardStatus.wChip = CARD_READER_CARD_CHIP_PRESS;
				if (chuSnsInfo.bICCActive == TRUE)
				{
					lpDevStatus->cardStatus.wChip = CARD_READER_CARD_CHIP_ACTIVATION;
				}
				else
				{
					lpDevStatus->cardStatus.wChip = CARD_READER_CARD_CHIP_NO;
				}
			}
		}
	}
    usleep(50*1000);
	wResult = GetHopperStatus(&hoppersInfo);
    LogM("wResult = GetHopperStatus(&hoppersInfo)=%d; line=%d" ,wRes,__LINE__);
	if (wResult == CRT_SUCCESS)
	{
		//HOPPER_1
		if (hoppersInfo.bHopper1Exist == FALSE)
		{
			lpDevStatus->hopperStatus[0].wHopper = CARD_ISSUER_HOPPER_NOT_POS;
		}
		else
		{
			if (hoppersInfo.bHopper1Empty == TRUE)
			{
				lpDevStatus->hopperStatus[0].wHopper = CARD_ISSUER_HOPPER_EMPTY;
			}
			else if (hoppersInfo.bHopper1Full == TRUE)
			{
				lpDevStatus->hopperStatus[0].wHopper = CARD_ISSUER_HOPPER_FULL;
			}
			else if (hoppersInfo.bHopper1Low == TRUE)
			{
				lpDevStatus->hopperStatus[0].wHopper = CARD_ISSUER_HOPPER_LOW;
			}
		}
		//HOPPER_2
		if (hoppersInfo.bHopper2Exist == FALSE)
		{
			lpDevStatus->hopperStatus[1].wHopper = CARD_ISSUER_HOPPER_NOT_POS;
		}
		else
		{
			if (hoppersInfo.bHopper2Empty == TRUE)
			{
				lpDevStatus->hopperStatus[1].wHopper = CARD_ISSUER_HOPPER_EMPTY;
			}
			else if (hoppersInfo.bHopper2Full == TRUE)
			{
				lpDevStatus->hopperStatus[1].wHopper = CARD_ISSUER_HOPPER_FULL;
			}
			else if (hoppersInfo.bHopper2Low == TRUE)
			{
				lpDevStatus->hopperStatus[1].wHopper = CARD_ISSUER_HOPPER_LOW;
			}
		}
		//RETAINBIN
		if (hoppersInfo.bRetainBinExist == FALSE)
		{
			lpDevStatus->cardStatus.wRetainBin = CARD_READER_RETAINBIN_NOT_POS;
		}
		else
		{
			if (hoppersInfo.bRetainBinFull == TRUE)
			{
				lpDevStatus->cardStatus.wRetainBin = CARD_READER_RETAINBIN_FULL;
			}
			else /*if (hoppersInfo.bRetainBinLow == TRUE)*/
			{
				lpDevStatus->cardStatus.wRetainBin = CARD_READER_RETAINBIN_OK;
			}
		}
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::GetDevSN(LPSTR lpDevSN)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0xFF;
	command.bParameterCode = 0xB0;
	command.Data.dwSize = 0;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ);
	if (bRet == FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}
	else
	{
		if ((reply.message.positiveReply.Data.bBody != NULL) &&
			((reply.message.positiveReply.Data.dwSize > 0 &&
			reply.message.positiveReply.Data.dwSize < 16) == TRUE))
		{
			memcpy(lpDevSN, reply.message.positiveReply.Data.bBody, reply.message.positiveReply.Data.dwSize);
		}
		else
		{
			wResult = /*CRT_INVALID_DATA*/ACT_RES_INVALID_DATA;
		}
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::Reset(WORD wAction)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x30;
	command.bParameterCode = 0x32;

	switch(wAction)
	{
	case CARD_READER_DEV_ACT_EJECT:
		command.bParameterCode = 0x30;
		break;
	case CARD_READER_DEV_ACT_RETAIN:
		command.bParameterCode = 0x31;
		break;
	case CARD_READER_DEV_ACT_HOLD:
		command.bParameterCode = 0x32;
		break;
	case CARD_READER_DEV_ACT_NOACTION:
		command.bParameterCode = 0x33;
		break;
	default:
		break;
	}

	BYTE fm = 0x30;
	BYTE Pd = 0x32;
	BYTE Wv = 0x30;
	BYTE Sh = 0x31;
	BYTE Ds = 0x30;
	BYTE Ty = 0x30;
	BYTE Cp = 0x30;
	BYTE byData[] = {0x33, 0x32, 0x34, 0x30, fm, Pd, Wv, Sh, Ds, Ty, Cp};
	command.Data.dwSize = sizeof(byData) / sizeof(BYTE);
	command.Data.lpbBody = byData;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_ACT);
	if (bRet == FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::PermitInsertion(WORD wCardType)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x3A;
	command.Data.dwSize = 0;

	switch(wCardType)
	{
	case CARD_READER_CARD_TYPE_ANY:
		command.bParameterCode = 0x30;
		break;
	case CARD_READER_CARD_TYPE_TRACK:
		command.bCommandCode = 0x32;
		break;
	case CARD_READER_CARD_TYPE_CHIP:
		command.bCommandCode = 0x33;
		break;
	case CARD_READER_CARD_TYPE_TRACK_AND_CHIP:
		command.bCommandCode = 0x34;
		break;
	case CARD_READER_CARD_TYPE_TRACK_OR_CHIP:
		command.bCommandCode = 0x35;
		break;
	default:
		break;
	}

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ);
	if (bRet = FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::DenyInsertion()
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x3A;
	command.bParameterCode = 0x31;
	command.Data.dwSize = 0;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ);
	if (bRet = FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::ReadTrackData(LPMediaData lpMediaData, int nMediaCnt)
{
	BOOL bRet = TRUE;
	WORD wCmd = 0;
	int nReadIndexList[3] = {-1, -1, -1};
	int nIdxCnt = 0;
	int nIdx = 0;
	WORD wTrack = 0;
	BOOL bRead = FALSE;
	LPMediaData lpMedia = NULL;
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x56;
	command.Data.dwSize = 0;

	if (lpMediaData == NULL)
	{
		return CRT_PARAM_ERR;
	}

	for (nIdx = 0; nIdx < nMediaCnt; nIdx++)
	{
		lpMediaData[nIdx].dwDataLen = 0;
		memset(lpMediaData[nIdx].byDataBuf, 0x00, sizeof(lpMediaData[nIdx].byDataBuf));

		if (lpMediaData[nIdx].wMediaID == CARD_READER_MEDIA_TRACK1 || 
			lpMediaData[nIdx].wMediaID == CARD_READER_MEDIA_TRACK2 ||
			lpMediaData[nIdx].wMediaID == CARD_READER_MEDIA_TRACK3)
		{
			nReadIndexList[nIdxCnt++] = nIdx;
			wTrack |= lpMediaData[nIdx].wMediaID;
		}
	}

	if (nIdxCnt == 0)
	{
		return CRT_PARAM_ERR;
	}
	else
	{
		switch (wTrack)
		{
		case CARD_READER_MEDIA_TRACK1:
			command.bParameterCode = 0x31;
			break;
		case CARD_READER_MEDIA_TRACK2:
			command.bParameterCode = 0x32;
			break;
		case CARD_READER_MEDIA_TRACK3:
			command.bParameterCode = 0x33;
			break;
		case CARD_READER_MEDIA_TRACK1_TRACK2:
			command.bParameterCode = 0x34;
			break;
		case CARD_READER_MEDIA_TRACK1_TRACK3:
			command.bParameterCode = 0x35;
			break;
		case CARD_READER_MEDIA_TRACK2_TRACK3:
			command.bParameterCode = 0x36;
			break;
		case CARD_READER_MEDIA_TRACK1_TRACK2_TRACK3:
			command.bParameterCode = 0x37;
			break;
		default:
			break;
		}
	}

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_ACT);
	if (bRet == FALSE)
	{
		return CRT_OFFLINE;
	}

	if (nIdxCnt == 1)
	{
		lpMedia = &lpMediaData[nReadIndexList[0]];
		if (reply.replyType == PositiveReply)
		{
			lpMedia->wStatus = CARD_READER_MEDIA_DATAOK;
			lpMedia->dwDataLen = reply.message.positiveReply.Data.dwSize - 1;
			memcpy(lpMedia->byDataBuf, &reply.message.positiveReply.Data.bBody[1], lpMedia->dwDataLen);
		}
		else
		{
			lpMedia->wStatus = CARD_READER_MEDIA_DATAMISSING;
			lpMedia->dwDataLen = 0;
		}
	}
	else
	{
		m_pDevCtrlImpl->GetMultiTrackData(reply, lpMediaData, nMediaCnt);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::WriteTrackData(LPMediaData lpMediaData, int nMediaCnt, WORD wMode)
{
	WORD wResult = CRT_SUCCESS;
	int nIdx = 0;

	wResult = SetWriteMode(wMode);
	if (wResult != CRT_SUCCESS)
	{
		return wResult;
	}

	for (nIdx = 0; nIdx < nMediaCnt; nIdx++)
	{
		wResult = WriteDataToTrack(lpMediaData[nIdx]);
		if (wResult != CRT_SUCCESS)
		{
			break;
		}
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::EjectCard()
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x33;
	command.bParameterCode = 0x30;
	command.Data.dwSize = 0;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_ACT);
	if (bRet = FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::RetainCard()
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x33;
	command.bParameterCode = 0x31;
	command.Data.dwSize = 0;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_ACT);
	if (bRet = FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::ReIntakeCard()
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x34;
	command.bParameterCode = 0x30;
	command.Data.dwSize = 0;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_ACT);
	if (bRet = FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::DispenseCard(WORD wHopperNum)
{
	COMMAND command;
	BYTE bCmp;

	switch(wHopperNum)
	{
	case 1:
		bCmp = '1';
		break;
	case 2:
		bCmp = '2';
		break;
	default:
		bCmp = '0';
		break;
	}

	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x76;
	command.bParameterCode = 0x43;
	command.Data.lpbBody = &bCmp;
	command.Data.dwSize = 1;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_ACT);
	if (bRet = FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::ChipPower(WORD wChipPower)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	BYTE bCmp;
    DWORD dwTimeOut = CMD_TIMEOUT_ACT;

	switch(wChipPower)
	{
	case CARD_READER_ICC_ACTIVE:
		command.bCommandCode = 0x49;
		command.bParameterCode = 0x30;
		bCmp = '6';
		command.Data.lpbBody = &bCmp;
		command.Data.dwSize = 1;
		break;
	case CARD_READER_ICC_CONTACT:
		command.bCommandCode = 0x40;
		command.bParameterCode = 0x30;
		command.Data.dwSize = 0;
		break;
	case CARD_READER_ICC_RELEASE:
		command.bCommandCode = 0x40;
		command.bParameterCode = 0x32;
		command.Data.dwSize = 0;
        dwTimeOut = CMD_TIMEOUT_INQ;
		break;
	case CARD_READER_ICC_WARM:
		command.bCommandCode = 0x49;
		command.bParameterCode = 0x38;
		command.Data.dwSize = 0;
		break;
	default:
		return CRT_PARAM_ERR;
		break;
	}

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, dwTimeOut);
	if (bRet = FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::ChipIO(LPChipIOData lpChipData)
{
	WORD wResult = CRT_SUCCESS;
	REPLY reply;

	wResult = m_pDevCtrlImpl->SendAPDU(lpChipData->sendData, &reply);
	if (wResult == CRT_SUCCESS)
	{
		m_pDevCtrlImpl->GetChipResponse(reply.message.positiveReply, lpChipData);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::ReturnOffRetractCounter()
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x43;
	command.bParameterCode = 0x58;
	BYTE bCmp = {0x30};
	command.Data.dwSize = 1;
	command.Data.lpbBody = &bCmp;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ);
	if (bRet = FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::CheckReleaseIC()
{
	WORD wResult = CRT_SUCCESS;
	DevStatus getStatus = {0};

	wResult = GetDevStatus(&getStatus);
	if (wResult == CRT_SUCCESS)
	{
		if (IS_CARD_INNER(getStatus.cardStatus.wCardPos, getStatus.cardStatus.wShutter) == TRUE)
		{
			if (getStatus.cardStatus.wChip == CARD_READER_CARD_CHIP_ACTIVATION ||
				getStatus.cardStatus.wChip == CARD_READER_CARD_CHIP_NO)
			{
				wResult = ChipPower(CARD_READER_ICC_RELEASE);
			}
		}
		else if (IS_CARD_GATE(getStatus.cardStatus.wCardPos, getStatus.cardStatus.wShutter) == TRUE)
		{
			wResult = CRT_SUCCESS;
		}
		else
		{
			return CRT_NO_MEDIA;
		}
	}

	return wResult;
}




/*
WORD CACT_Sankyo_DevCtrl::GetErrorDetail(LPDevErrDetail lpErrDetail)
{
	WORD wResult = CRT_SUCCESS;
	WORD wErrCode = 0;
	WORD wOffSet = 0;
	CHAR szDetail[] = "HWERROR: ";
	wOffSet = strlen(szDetail);
	memset(lpErrDetail->szErrDetail, 0x00, sizeof(lpErrDetail->szErrDetail));
	memcpy(lpErrDetail->szErrDetail, szDetail, wOffSet);
	REPLY reply;

	wResult = GetDevErrCode(&reply);
	if (wResult == CRT_OFFLINE)
	{
		memcpy(lpErrDetail->szErrCode, "FF", strlen("FF"));
		memcpy(lpErrDetail->szErrDetail, "Device OffLine!", strlen("Device OffLine!"));
		return wResult;
	}

	if (reply.replyType == PositiveReply)
	{
		memcpy(lpErrDetail->szErrCode, "00", strlen("00"));
		memcpy(lpErrDetail->szErrDetail, "success!", strlen("success!"));
		return CRT_SUCCESS;
	}

	wErrCode = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);

	switch(wErrCode)
	{
	case EXWORDHL(CRT_RES_CARD_JAM):
		memcpy(lpErrDetail->szErrCode, "10", strlen("10"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CARD_JAM", strlen("CRT_RES_CARD_JAM"));
		break;
	case EXWORDHL(CRT_RES_SHUTTER_ABNORMAL):
		memcpy(lpErrDetail->szErrCode, "11", strlen("11"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_SHUTTER_ABNORMAL", strlen("CRT_RES_SHUTTER_ABNORMAL"));
		break;
	case EXWORDHL(CRT_RES_SENSOR_ERROR):
		memcpy(lpErrDetail->szErrCode, "12", strlen("12"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_SENSOR_ERROR", strlen("CRT_RES_SENSOR_ERROR"));
		break;
	case EXWORDHL(CRT_RES_CARD_TOO_LONG):
		memcpy(lpErrDetail->szErrCode, "13", strlen("13"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CARD_TOO_LONG", strlen("CRT_RES_CARD_TOO_LONG"));
		break;
	case EXWORDHL(CRT_RES_CARD_TOO_SHORT):
		memcpy(lpErrDetail->szErrCode, "14", strlen("14"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CARD_TOO_SHORT", strlen("CRT_RES_CARD_TOO_SHORT"));
		break;
	case EXWORDHL(CRT_RES_FRAM_ERROR):
		memcpy(lpErrDetail->szErrCode, "15", strlen("15"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_FRAM_ERROR", strlen("CRT_RES_FRAM_ERROR"));
		break;
	case EXWORDHL(CRT_RES_CARD_POS_MOVE):
		memcpy(lpErrDetail->szErrCode, "16", strlen("16"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CARD_POS_MOVE", strlen("CRT_RES_CARD_POS_MOVE"));
		break;
	case EXWORDHL(CRT_RES_CARD_JAM_ON_REINTAKE):
		memcpy(lpErrDetail->szErrCode, "17", strlen("17"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CARD_JAM_ON_REINTAKE", strlen("CRT_RES_CARD_JAM_ON_REINTAKE"));
		break;
	case EXWORDHL(CRT_RES_SW1_SW2_ERROR):
		memcpy(lpErrDetail->szErrCode, "18", strlen("18"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_SW1_SW2_ERROR", strlen("CRT_RES_SW1_SW2_ERROR"));
		break;
	case EXWORDHL(CRT_RES_CARD_NOT_INTAKE_FROM_REAR):
		memcpy(lpErrDetail->szErrCode, "19", strlen("19"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CARD_NOT_INTAKE_FROM_REAR", strlen("CRT_RES_CARD_NOT_INTAKE_FROM_REAR"));
		break;
	case EXWORDHL(CRT_RES_POWER_OFF):
		memcpy(lpErrDetail->szErrCode, "30", strlen("30"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_POWER_OFF", strlen("CRT_RES_POWER_OFF"));
		break;
	case EXWORDHL(CRT_RES_DSR_OFF):
		memcpy(lpErrDetail->szErrCode, "31", strlen("31"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_DSR_OFF", strlen("CRT_RES_DSR_OFF"));
		break;
	case EXWORDHL(CRT_RES_CARD_TAKEN_WHEN_RETAIN):
		memcpy(lpErrDetail->szErrCode, "40", strlen("40"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CARD_TAKEN_WHEN_RETAIN", strlen("CRT_RES_CARD_TAKEN_WHEN_RETAIN"));
		break;
	case EXWORDHL(CRT_RES_IC_CONTACTOR_SENSOR_ERROR):
		memcpy(lpErrDetail->szErrCode, "41", strlen("41"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_CONTACTOR_SENSOR_ERROR", strlen("CRT_RES_IC_CONTACTOR_SENSOR_ERROR"));
		break;
	case EXWORDHL(CRT_RES_NOT_REMOVE_TO_IC_POS):
		memcpy(lpErrDetail->szErrCode, "43", strlen("43"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_NOT_REMOVE_TO_IC_POS", strlen("CRT_RES_NOT_REMOVE_TO_IC_POS"));
		break;
	case EXWORDHL(CRT_RES_FORCE_EJECT):
		memcpy(lpErrDetail->szErrCode, "45", strlen("45"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_FORCE_EJECT", strlen("CRT_RES_FORCE_EJECT"));
		break;
	case EXWORDHL(CRT_RES_FRONT_CARD_TAKEN_TIMEOUT):
		memcpy(lpErrDetail->szErrCode, "46", strlen("46"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_FRONT_CARD_TAKEN_TIMEOUT", strlen("CRT_RES_FRONT_CARD_TAKEN_TIMEOUT"));
		break;
	case EXWORDHL(CRT_RES_RETAIN_COUNT_OVERFLOW):
		memcpy(lpErrDetail->szErrCode, "50", strlen("50"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_RETAIN_COUNT_OVERFLOW", strlen("CRT_RES_RETAIN_COUNT_OVERFLOW"));
		break;
	case EXWORDHL(CRT_RES_MOTOR_ERROR):
		memcpy(lpErrDetail->szErrCode, "51", strlen("51"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MOTOR_ERROR", strlen("CRT_RES_MOTOR_ERROR"));
		break;
	case EXWORDHL(CRT_RES_READ_DIGIT_DECODE_ERROR):
		memcpy(lpErrDetail->szErrCode, "53", strlen("53"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_READ_DIGIT_DECODE_ERROR", strlen("CRT_RES_READ_DIGIT_DECODE_ERROR"));
		break;
	case EXWORDHL(CRT_RES_HOOK_REMOVE_ERROR):
		memcpy(lpErrDetail->szErrCode, "54", strlen("54"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_HOOK_REMOVE_ERROR", strlen("CRT_RES_HOOK_REMOVE_ERROR"));
		break;
	case EXWORDHL(CRT_RES_HOOK_SET_ALREADY):
		memcpy(lpErrDetail->szErrCode, "55", strlen("55"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_HOOK_SET_ALREADY", strlen("CRT_RES_HOOK_SET_ALREADY"));
		break;
	case EXWORDHL(CRT_RES_CHIP_DETECT_SENSOR_ERROR):
		memcpy(lpErrDetail->szErrCode, "56", strlen("56"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CHIP_DETECT_SENSOR_ERROR", strlen("CRT_RES_CHIP_DETECT_SENSOR_ERROR"));
		break;
	case EXWORDHL(CRT_RES_HOOK_MOVING):
		memcpy(lpErrDetail->szErrCode, "58", strlen("58"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_HOOK_MOVING", strlen("CRT_RES_HOOK_MOVING"));
		break;
	case EXWORDHL(CRT_RES_ESU_CHU_COMM_ERROR):
		memcpy(lpErrDetail->szErrCode, "76", strlen("76"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_ESU_CHU_COMM_ERROR", strlen("CRT_RES_ESU_CHU_COMM_ERROR"));
		break;
	case EXWORDHL(CRT_RES_ESU_ERROR_OR_NO_CONNECT):
		memcpy(lpErrDetail->szErrCode, "95", strlen("95"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_ESU_ERROR_OR_NO_CONNECT", strlen("CRT_RES_ESU_ERROR_OR_NO_CONNECT"));
		break;
	case EXWORDHL(CRT_RES_ESU_OVERCURRENT):
		memcpy(lpErrDetail->szErrCode, "99", strlen("99"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_ESU_OVERCURRENT", strlen("CRT_RES_ESU_OVERCURRENT"));
		break;
	case EXWORDHL(CRT_RES_NOT_RECEIVE_INITIAL_CMD):
		memcpy(lpErrDetail->szErrCode, "B0", strlen("B0"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_NOT_RECEIVE_INITIAL_CMD", strlen("CRT_RES_NOT_RECEIVE_INITIAL_CMD"));
		break;
    case EXWORDHL(ACT_RES_CARDREADER_COMM_ERROR):
        memcpy(lpErrDetail->szErrCode, "A2", strlen("A2"));
        memcpy(&lpErrDetail->szErrDetail[wOffSet], "ACT_RES_CARDREADER_COMM_ERROR", strlen("ACT_RES_CARDREADER_COMM_ERROR"));
        break;
	case EXWORDHL(ACT_RES_JAM_OR_SENSOR_ERROR):
		memcpy(lpErrDetail->szErrCode, "A5", strlen("A5"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "ACT_RES_JAM_OR_SENSOR_ERROR", strlen("ACT_RES_JAM_OR_SENSOR_ERROR"));
		break;
	case EXWORDHL(ACT_RES_HOOK_NOT_AT_POS):
		memcpy(lpErrDetail->szErrCode, "A6", strlen("A6"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "ACT_RES_HOOK_NOT_AT_POS", strlen("ACT_RES_HOOK_NOT_AT_POS"));
		break;
	case EXWORDHL(ACT_RES_MOTOR_JAM_OR_OVERLOAD):
		memcpy(lpErrDetail->szErrCode, "A7", strlen("A7"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "ACT_RES_MOTOR_JAM_OR_OVERLOAD", strlen("ACT_RES_MOTOR_JAM_OR_OVERLOAD"));
		break;
	default:
		break;
	}

	return CRT_SUCCESS;
}

WORD CACT_Sankyo_DevCtrl::GetWarningDetail(LPDevErrDetail lpErrDetail, WORD wRes)
{
	WORD wResult = CRT_SUCCESS;
	WORD wErrCode = 0;
	WORD wOffSet = 0;
	CHAR szDetail[] = "Warning: ";
	wOffSet = strlen(szDetail);
	memset(lpErrDetail->szErrDetail, 0x00, sizeof(lpErrDetail->szErrDetail));
	memcpy(lpErrDetail->szErrDetail, szDetail, wOffSet);

	switch(wRes)
	{
	case EXWORDHL(CRT_RES_CMD_UNDEFINED):
        memcpy(lpErrDetail->szErrCode, "00", strlen("00"));
        memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_UNDEFINED", strlen("CRT_RES_CMD_UNDEFINED"));
		break;
	case EXWORDHL(CRT_RES_CMD_PARAM_ERROR):
        memcpy(lpErrDetail->szErrCode, "01", strlen("01"));
        memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_PARAM_ERROR", strlen("CRT_RES_CMD_PARAM_ERROR"));
		break;
	case EXWORDHL(CRT_RES_CMD_UNABLE_EXECUTE):
		memcpy(lpErrDetail->szErrCode, "02", strlen("02"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_UNABLE_EXECUTE", strlen("CRT_RES_CMD_UNABLE_EXECUTE"));
		break;
	case EXWORDHL(CRT_RES_CMD_NOT_SUPPORT):
		memcpy(lpErrDetail->szErrCode, "03", strlen("03"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_NOT_SUPPORT", strlen("CRT_RES_CMD_NOT_SUPPORT"));
		break;
	case EXWORDHL(CRT_RES_CMD_RES_ERROR):
		memcpy(lpErrDetail->szErrCode, "04", strlen("04"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_RES_ERROR", strlen("CRT_RES_CMD_RES_ERROR"));
		break;
	case EXWORDHL(CRT_RES_CMD_IC_NOT_RELEASE):
		memcpy(lpErrDetail->szErrCode, "05", strlen("05"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_IC_NOT_RELEASE", strlen("CRT_RES_CMD_IC_NOT_RELEASE"));
		break;
	case EXWORDHL(CRT_RES_CMD_KEY_NOT_FOUND):
		memcpy(lpErrDetail->szErrCode, "06", strlen("06"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_KEY_NOT_FOUND", strlen("CRT_RES_CMD_KEY_NOT_FOUND"));
		break;
	case EXWORDHL(CRT_RES_MAG_READ_PARITY_ERROR):
		memcpy(lpErrDetail->szErrCode, "20", strlen("20"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_READ_PARITY_ERROR", strlen("CRT_RES_MAG_READ_PARITY_ERROR"));
		break;
	case EXWORDHL(CRT_RES_MAG_READ_ERROR):
		memcpy(lpErrDetail->szErrCode, "21", strlen("21"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_READ_ERROR", strlen("CRT_RES_MAG_READ_ERROR"));
		break;
	case EXWORDHL(CRT_RES_MAG_WRITE_ERROR):
		memcpy(lpErrDetail->szErrCode, "22", strlen("22"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_WRITE_ERROR", strlen("CRT_RES_MAG_WRITE_ERROR"));
		break;
	case EXWORDHL(CRT_RES_MAG_READ_NO_DATA):
		memcpy(lpErrDetail->szErrCode, "23", strlen("23"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_READ_NO_DATA", strlen("CRT_RES_MAG_READ_NO_DATA"));
		break;
	case EXWORDHL(CRT_RES_MAG_READ_NO_TRACKS_OR_BLANK):
		memcpy(lpErrDetail->szErrCode, "24", strlen("24"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_READ_NO_TRACKS_OR_BLANK", strlen("CRT_RES_MAG_READ_NO_TRACKS_OR_BLANK"));
		break;
	case EXWORDHL(CRT_RES_MAG_WRITE_QUALITY_ERROR):
		memcpy(lpErrDetail->szErrCode, "25", strlen("25"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_WRITE_QUALITY_ERROR", strlen("CRT_RES_MAG_WRITE_QUALITY_ERROR"));
		break;
	case EXWORDHL(CRT_RES_MAG_READ_SS_ERROR):
		memcpy(lpErrDetail->szErrCode, "26", strlen("26"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_READ_SS_ERROR", strlen("CRT_RES_MAG_READ_SS_ERROR"));
		break;
	case EXWORDHL(CRT_RES_MAG_READ_ES_ERROR):
		memcpy(lpErrDetail->szErrCode, "27", strlen("27"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_READ_ES_ERROR", strlen("CRT_RES_MAG_READ_ES_ERROR"));
		break;
	case EXWORDHL(CRT_RES_MAG_READ_LRC_ERROR):
		memcpy(lpErrDetail->szErrCode, "28", strlen("28"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_READ_LRC_ERROR", strlen("CRT_RES_MAG_READ_LRC_ERROR"));
		break;
	case EXWORDHL(CRT_RES_MAG_WRITE_CHECK_ERROR):
		memcpy(lpErrDetail->szErrCode, "29", strlen("29"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_MAG_WRITE_CHECK_ERROR", strlen("CRT_RES_MAG_WRITE_CHECK_ERROR"));
		break;
	case EXWORDHL(CRT_RES_IC_OR_SAM_VCC_ERROR):
		memcpy(lpErrDetail->szErrCode, "60", strlen("60"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_OR_SAM_VCC_ERROR", strlen("CRT_RES_IC_OR_SAM_VCC_ERROR"));
		break;
	case EXWORDHL(CRT_RES_IC_OR_SAM_ATR_COMM_ERROR):
		memcpy(lpErrDetail->szErrCode, "61", strlen("61"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_OR_SAM_ATR_COMM_ERROR", strlen("CRT_RES_IC_OR_SAM_ATR_COMM_ERROR"));
		break;
	case EXWORDHL(CRT_RES_IC_OR_SAM_ATR_INVALID):
		memcpy(lpErrDetail->szErrCode, "62", strlen("62"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_OR_SAM_ATR_INVALID", strlen("CRT_RES_IC_OR_SAM_ATR_INVALID"));
		break;
	case EXWORDHL(CRT_RES_IC_OR_SAM_COMM_NO_RESPONSE):
		memcpy(lpErrDetail->szErrCode, "63", strlen("63"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_OR_SAM_COMM_NO_RESPONSE", strlen("CRT_RES_IC_OR_SAM_COMM_NO_RESPONSE"));
		break;
	case EXWORDHL(CRT_RES_IC_OR_SAM_COMM_ERROR):
		memcpy(lpErrDetail->szErrCode, "64", strlen("64"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_OR_SAM_COMM_ERROR", strlen("CRT_RES_IC_OR_SAM_COMM_ERROR"));
		break;
	case EXWORDHL(CRT_RES_IC_OR_SAM_NO_ACTIVATE):
		memcpy(lpErrDetail->szErrCode, "65", strlen("65"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_OR_SAM_NO_ACTIVATE", strlen("CRT_RES_IC_OR_SAM_NO_ACTIVATE"));
		break;
	case EXWORDHL(CRT_RES_IC_OR_SAM_NOT_SUPP_NO_EMV):
		memcpy(lpErrDetail->szErrCode, "66", strlen("66"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_OR_SAM_NOT_SUPP_NO_EMV", strlen("CRT_RES_IC_OR_SAM_NOT_SUPP_NO_EMV"));
		break;
	case EXWORDHL(CRT_RES_IC_OR_SAM_NOT_SUPP_ONLY_EMV):
		memcpy(lpErrDetail->szErrCode, "69", strlen("69"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_IC_OR_SAM_NOT_SUPP_ONLY_EMV", strlen("CRT_RES_IC_OR_SAM_NOT_SUPP_ONLY_EMV"));
		break;
	case EXWORDHL(ACT_RES_CARD_BOX_EMPTY):
		memcpy(lpErrDetail->szErrCode, "A0", strlen("A0"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "ACT_RES_CARD_BOX_EMPTY", strlen("ACT_RES_CARD_BOX_EMPTY"));
		break;
	case EXWORDHL(ACT_RES_RETAIN_BIN_FULL):
		memcpy(lpErrDetail->szErrCode, "AC", strlen("AC"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "ACT_RES_RETAIN_BIN_FULL", strlen("ACT_RES_RETAIN_BIN_FULL"));
		break;
	case EXWORDHL(ACT_RES_INVALID_DATA):
		memcpy(lpErrDetail->szErrCode, "C0", strlen("C0"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "ACT_RES_INVALID_DATA", strlen("ACT_RES_INVALID_DATA"));
		break;
	case EXWORDHL(ACT_RES_NO_MEDIA):
		memcpy(lpErrDetail->szErrCode, "C1", strlen("C1"));
		memcpy(&lpErrDetail->szErrDetail[wOffSet], "ACT_RES_NO_MEDIA", strlen("ACT_RES_NO_MEDIA"));
		break;
	default:
		break;
	}

	return CRT_SUCCESS;
}
*/


WORD CACT_Sankyo_DevCtrl::GetErrorDetail(LPDevErrDetail lpErrDetail)
{
    WORD wResult = CRT_SUCCESS;
    WORD wErrCode = 0;
    WORD wOffSet = 0;
    CHAR szDetail[] = "HWERROR: ";
    wOffSet = strlen(szDetail);
    memset(lpErrDetail->szErrDetail, 0x00, sizeof(lpErrDetail->szErrDetail));
    memcpy(lpErrDetail->szErrDetail, szDetail, wOffSet);
    REPLY reply;

    wResult = GetDevErrCode(&reply);
    if (wResult == CRT_OFFLINE)
    {
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_OFFLINE;
        strcpy(lpErrDetail->szErrCode, "FF");
        strcpy(lpErrDetail->szErrDetail, "发卡模块离线!");
        return wResult;
    }

    if (reply.replyType == PositiveReply)
    {
        lpErrDetail->iErrCode = DEP_SUCCESS;
        strcpy(lpErrDetail->szErrCode, "00");
        strcpy(lpErrDetail->szErrDetail, "成功!");
        return CRT_SUCCESS;
    }

    wErrCode = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);

    switch(wErrCode)
    {
    case EXWORDHL(CRT_RES_CARD_JAM):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_JAM;
        strcpy(lpErrDetail->szErrCode, "10");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡介质堵塞，CRT_RES_CARD_JAM");
        break;
    case EXWORDHL(CRT_RES_SHUTTER_ABNORMAL):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_SHUTTER_FAIL;
        strcpy(lpErrDetail->szErrCode, "11");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "闸门错误，CRT_RES_SHUTTER_ABNORMAL");
        break;
    case EXWORDHL(CRT_RES_SENSOR_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "12");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "传感器错误，CRT_RES_SENSOR_ERROR");
        break;
    case EXWORDHL(CRT_RES_CARD_TOO_LONG):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEDIA_ERROR;
        strcpy(lpErrDetail->szErrCode, "13");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡太长，CRT_RES_CARD_TOO_LONG");
        break;
    case EXWORDHL(CRT_RES_CARD_TOO_SHORT):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEDIA_ERROR;
        strcpy(lpErrDetail->szErrCode, "14");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡太短，CRT_RES_CARD_TOO_SHORT");
        break;
    case EXWORDHL(CRT_RES_FRAM_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_DEV_UNKNOWN;
        strcpy(lpErrDetail->szErrCode, "15");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "未知错误，CRT_RES_FRAM_ERROR");
        break;
    case EXWORDHL(CRT_RES_CARD_POS_MOVE):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
        strcpy(lpErrDetail->szErrCode, "16");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡被强行移动，CRT_RES_CARD_POS_MOVE");
        break;
    case EXWORDHL(CRT_RES_CARD_JAM_ON_REINTAKE):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_DEV_UNKNOWN;
        strcpy(lpErrDetail->szErrCode, "17");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "再次吸卡时堵塞，CRT_RES_CARD_JAM_ON_REINTAKE");
        break;
    case EXWORDHL(CRT_RES_SW1_SW2_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_INVALID_DATA;
        strcpy(lpErrDetail->szErrCode, "18");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "SW1SW2数据错误，CRT_RES_SW1_SW2_ERROR");
        break;
    case EXWORDHL(CRT_RES_CARD_NOT_INTAKE_FROM_REAR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "19");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡未从后部吸入，CRT_RES_CARD_NOT_INTAKE_FROM_REAR");
        break;
    case EXWORDHL(CRT_RES_POWER_OFF):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_DEV_UNKNOWN;
        strcpy(lpErrDetail->szErrCode, "30");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "已掉电，CRT_RES_POWER_OFF");
        break;
    case EXWORDHL(CRT_RES_DSR_OFF):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_DEV_UNKNOWN;
        strcpy(lpErrDetail->szErrCode, "31");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "未知错误，CRT_RES_DSR_OFF");
        break;
    case EXWORDHL(CRT_RES_CARD_TAKEN_WHEN_RETAIN):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
        strcpy(lpErrDetail->szErrCode, "40");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "吞卡时卡被拿走，CRT_RES_CARD_TAKEN_WHEN_RETAIN");
        break;
    case EXWORDHL(CRT_RES_IC_CONTACTOR_SENSOR_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "41");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC接触器传感器错误，CRT_RES_IC_CONTACTOR_SENSOR_ERROR");
        break;
    case EXWORDHL(CRT_RES_NOT_REMOVE_TO_IC_POS):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "43");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡片未移动到正确位置，CRT_RES_NOT_REMOVE_TO_IC_POS");
        break;
    case EXWORDHL(CRT_RES_FORCE_EJECT):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
        strcpy(lpErrDetail->szErrCode, "45");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡片被强制拔出，CRT_RES_FORCE_EJECT");
        break;
    case EXWORDHL(CRT_RES_FRONT_CARD_TAKEN_TIMEOUT):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
        strcpy(lpErrDetail->szErrCode, "46");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "前出卡口取卡超时，CRT_RES_FRONT_CARD_TAKEN_TIMEOUT");
        break;
    case EXWORDHL(CRT_RES_RETAIN_COUNT_OVERFLOW):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
        strcpy(lpErrDetail->szErrCode, "50");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "回收张数超限，CRT_RES_RETAIN_COUNT_OVERFLOW");
        break;
    case EXWORDHL(CRT_RES_MOTOR_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "51");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "电机故障，CRT_RES_MOTOR_ERROR");
        break;
    case EXWORDHL(CRT_RES_READ_DIGIT_DECODE_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_INVALID_DATA;
        strcpy(lpErrDetail->szErrCode, "53");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "读取时数据解码失败，CRT_RES_READ_DIGIT_DECODE_ERROR");
        break;
    case EXWORDHL(CRT_RES_HOOK_REMOVE_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "54");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "钩子移除故障，CRT_RES_HOOK_REMOVE_ERROR");
        break;
    case EXWORDHL(CRT_RES_HOOK_SET_ALREADY):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "55");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "钩子已经落下，CRT_RES_HOOK_SET_ALREADY");
        break;
    case EXWORDHL(CRT_RES_CHIP_DETECT_SENSOR_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "56");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "芯片侦测传感器故障，CRT_RES_CHIP_DETECT_SENSOR_ERROR");
        break;
    case EXWORDHL(CRT_RES_HOOK_MOVING):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "58");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "钩子移动中，CRT_RES_HOOK_MOVING");
        break;
    case EXWORDHL(CRT_RES_ESU_CHU_COMM_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "76");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "ESU、CHU通讯错误，CRT_RES_ESU_CHU_COMM_ERROR");
        break;
    case EXWORDHL(CRT_RES_ESU_ERROR_OR_NO_CONNECT):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "95");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "ESU故障或未连接，CRT_RES_ESU_ERROR_OR_NO_CONNECT");
        break;
    case EXWORDHL(CRT_RES_ESU_OVERCURRENT):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "99");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "ESU电流过载，CRT_RES_ESU_OVERCURRENT");
        break;
    case EXWORDHL(CRT_RES_NOT_RECEIVE_INITIAL_CMD):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "B0");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "未收到初始化命令，CRT_RES_NOT_RECEIVE_INITIAL_CMD");
        break;
    case EXWORDHL(ACT_RES_CARDREADER_COMM_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "A2");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "读卡器通讯错误，ACT_RES_CARDREADER_COMM_ERROR");
        break;
    case EXWORDHL(ACT_RES_JAM_OR_SENSOR_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "A5");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "阻塞或传感器故障，ACT_RES_JAM_OR_SENSOR_ERROR");
        break;
    case EXWORDHL(ACT_RES_HOOK_NOT_AT_POS):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "A6");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "钩子未归位，ACT_RES_HOOK_NOT_AT_POS");
        break;
    case EXWORDHL(ACT_RES_MOTOR_JAM_OR_OVERLOAD):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
        strcpy(lpErrDetail->szErrCode, "A7");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "电机阻塞或过载，ACT_RES_MOTOR_JAM_OR_OVERLOAD");
        break;
    default:
        break;
    }

    return CRT_SUCCESS;
}

WORD CACT_Sankyo_DevCtrl::GetWarningDetail(LPDevErrDetail lpErrDetail, WORD wRes)
{
    WORD wResult = CRT_SUCCESS;
    WORD wErrCode = 0;
    WORD wOffSet = 0;
    CHAR szDetail[] = "Warning: ";
    wOffSet = strlen(szDetail);
    memset(lpErrDetail->szErrDetail, 0x00, sizeof(lpErrDetail->szErrDetail));
    memcpy(lpErrDetail->szErrDetail, szDetail, wOffSet);

    switch(wRes)
    {
    case EXWORDHL(CRT_RES_CMD_UNDEFINED):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
        strcpy(lpErrDetail->szErrCode, "00");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令未定义，CRT_RES_CMD_UNDEFINED");
        break;
    case EXWORDHL(CRT_RES_CMD_PARAM_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
        strcpy(lpErrDetail->szErrCode, "01");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令参数错误，CRT_RES_CMD_PARAM_ERROR");
        break;
    case EXWORDHL(CRT_RES_CMD_UNABLE_EXECUTE):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
        strcpy(lpErrDetail->szErrCode, "02");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令无法执行，CRT_RES_CMD_UNABLE_EXECUTE");
        break;
    case EXWORDHL(CRT_RES_CMD_NOT_SUPPORT):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
        strcpy(lpErrDetail->szErrCode, "03");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令不支持，CRT_RES_CMD_NOT_SUPPORT");
        break;
    case EXWORDHL(CRT_RES_CMD_RES_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
        strcpy(lpErrDetail->szErrCode, "04");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令返回错误，CRT_RES_CMD_RES_ERROR");
        break;
    case EXWORDHL(CRT_RES_CMD_IC_NOT_RELEASE):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
        strcpy(lpErrDetail->szErrCode, "05");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令执行时IC卡未释放，CRT_RES_CMD_IC_NOT_RELEASE");
        break;
    case EXWORDHL(CRT_RES_CMD_KEY_NOT_FOUND):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
        strcpy(lpErrDetail->szErrCode, "06");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令Key未找到，CRT_RES_CMD_KEY_NOT_FOUND");
        break;
    case EXWORDHL(CRT_RES_MAG_READ_PARITY_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "20");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_PARITY_ERROR");
        break;
    case EXWORDHL(CRT_RES_MAG_READ_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "21");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡读取失败，CRT_RES_MAG_READ_ERROR");
        break;
    case EXWORDHL(CRT_RES_MAG_WRITE_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "22");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡写入失败，CRT_RES_MAG_WRITE_ERROR");
        break;
    case EXWORDHL(CRT_RES_MAG_READ_NO_DATA):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "23");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_NO_DATA");
        break;
    case EXWORDHL(CRT_RES_MAG_READ_NO_TRACKS_OR_BLANK):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "24");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_NO_TRACKS_OR_BLANK");
        break;
    case EXWORDHL(CRT_RES_MAG_WRITE_QUALITY_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "25");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_WRITE_QUALITY_ERROR");
        break;
    case EXWORDHL(CRT_RES_MAG_READ_SS_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "26");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_SS_ERROR");
        break;
    case EXWORDHL(CRT_RES_MAG_READ_ES_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "27");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_ES_ERROR");
        break;
    case EXWORDHL(CRT_RES_MAG_READ_LRC_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "28");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_LRC_ERROR");
        break;
    case EXWORDHL(CRT_RES_MAG_WRITE_CHECK_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
        strcpy(lpErrDetail->szErrCode, "29");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_WRITE_CHECK_ERROR");
        break;
    case EXWORDHL(CRT_RES_IC_OR_SAM_VCC_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
        strcpy(lpErrDetail->szErrCode, "60");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_VCC_ERROR");
        break;
    case EXWORDHL(CRT_RES_IC_OR_SAM_ATR_COMM_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
        strcpy(lpErrDetail->szErrCode, "61");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_ATR_COMM_ERROR");
        break;
    case EXWORDHL(CRT_RES_IC_OR_SAM_ATR_INVALID):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
        strcpy(lpErrDetail->szErrCode, "62");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_ATR_INVALID");
        break;
    case EXWORDHL(CRT_RES_IC_OR_SAM_COMM_NO_RESPONSE):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
        strcpy(lpErrDetail->szErrCode, "63");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_COMM_NO_RESPONSE");
        break;
    case EXWORDHL(CRT_RES_IC_OR_SAM_COMM_ERROR):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
        strcpy(lpErrDetail->szErrCode, "64");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_COMM_ERROR");
        break;
    case EXWORDHL(CRT_RES_IC_OR_SAM_NO_ACTIVATE):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
        strcpy(lpErrDetail->szErrCode, "65");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_NO_ACTIVATE");
        break;
    case EXWORDHL(CRT_RES_IC_OR_SAM_NOT_SUPP_NO_EMV):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
        strcpy(lpErrDetail->szErrCode, "66");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_NOT_SUPP_NO_EMV");
        break;
    case EXWORDHL(CRT_RES_IC_OR_SAM_NOT_SUPP_ONLY_EMV):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
        strcpy(lpErrDetail->szErrCode, "69");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_NOT_SUPP_ONLY_EMV");
        break;
    case EXWORDHL(ACT_RES_CARD_BOX_EMPTY):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
        strcpy(lpErrDetail->szErrCode, "A0");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "发卡箱为空，ACT_RES_CARD_BOX_EMPTY");
        break;
    case EXWORDHL(ACT_RES_RETAIN_BIN_FULL):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
        strcpy(lpErrDetail->szErrCode, "AC");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "回收盒已满，ACT_RES_RETAIN_BIN_FULL");
        break;
    case EXWORDHL(ACT_RES_INVALID_DATA):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_INVALID_DATA;
        strcpy(lpErrDetail->szErrCode, "C0");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "无效数据，ACT_RES_INVALID_DATA");
        break;
    case EXWORDHL(ACT_RES_NO_MEDIA):
        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_NO_MEDIA;
        strcpy(lpErrDetail->szErrCode, "C1");
        strcpy(&lpErrDetail->szErrDetail[wOffSet], "没有介质，ACT_RES_NO_MEDIA");
        break;
    default:
        break;
    }

    return CRT_SUCCESS;
}


WORD CACT_Sankyo_DevCtrl::GetCRTErrCode(WORD wValue)
{
	return m_pDevCtrlImpl->GetNGCRTResult(wValue);
}

WORD CACT_Sankyo_DevCtrl::GetDevErrCode(LPREPLY lpErrReply)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x31;
	command.bParameterCode = 0x30;
	command.Data.dwSize = 0;

	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, lpErrReply, CMD_TIMEOUT_INQ);
	if (bRet == FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (lpErrReply->replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(lpErrReply->message.negativeReply);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::GetCHUStatus(LPCRTCHUSensorInfo lpCHUInfo, LPBYTE lpbyStMark)
{
    LOG_FUNCTION();
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x31;
	command.bParameterCode = 0x33;
	command.Data.dwSize = 0;

	if (lpCHUInfo == NULL || lpbyStMark == NULL)
	{
		return CRT_PARAM_ERR;
	}

	REPLY reply;
	WORD wResult = CRT_SUCCESS;
	//BYTE byICCst = 0;
	CRTResSensor resSensor = {0};
    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ);
	if (bRet == FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
		return wResult;
	}
	else
	{
		*lpbyStMark = reply.message.positiveReply.StatusCode.bSt0;
		memcpy(&resSensor, reply.message.positiveReply.Data.bBody, sizeof(resSensor));
		m_pDevCtrlImpl->GetCHUSensorInfo(lpCHUInfo, resSensor/*, byICCst*/);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::GetHopperStatus(LPCRTHoppersInfo lpHoppersInfo)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x76;
	command.bParameterCode = 0x31;
	command.Data.dwSize = 0;

	if (lpHoppersInfo == NULL)
	{
		return CRT_PARAM_ERR;
	}

	REPLY reply;
	WORD wResult = CRT_SUCCESS;
	BYTE szSnsInfo[8] = {0x00};
    LogM("BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ=%d) line=%d",CMD_TIMEOUT_INQ,__LINE__);
    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ);
    LogM("BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ=%d) line=%d",CMD_TIMEOUT_INQ,__LINE__);
	if (bRet == FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
		return wResult;
	}
	else
	{
		memcpy(szSnsInfo, reply.message.positiveReply.Data.bBody, sizeof(szSnsInfo) - 1);
		m_pDevCtrlImpl->GetHopperSensorInfo(lpHoppersInfo, szSnsInfo);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::GetIccStatus(LPBYTE lpbyIccStatus)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x49;
	command.bParameterCode = 0x32;
	command.Data.dwSize = 0;

	if (lpbyIccStatus == NULL)
	{
		return CRT_PARAM_ERR;
	}

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ);
	if (bRet == FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
		return wResult;
	}
	else
	{
		memcpy(lpbyIccStatus, reply.message.positiveReply.Data.bBody, 1);
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::SetWriteMode(WORD wMode)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x37;
	command.bParameterCode = 0x30;
	BYTE bCmp[2] = {'0', '0'};

	switch(wMode)
	{
	case CARD_READER_WRITE_MODE_LOW:
		bCmp[0] = '0';
		break;
	case CARD_READER_WRITE_MODE_HIGH:
		bCmp[0] = '1';
		break;
	case CARD_READER_WRITE_MODE_AUTO:
		bCmp[0] = '2';
		break;
	default:
		return CRT_PARAM_ERR;
	}

	command.Data.lpbBody = bCmp;
	command.Data.dwSize = 2;

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_INQ);
	if (bRet == FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
		return wResult;
	}

	return wResult;
}

WORD CACT_Sankyo_DevCtrl::WriteDataToTrack(const MediaData writeData)
{
	COMMAND command;
	command.bCommandTag = CMD_TAG;
	command.bCommandCode = 0x37;
	BYTE bData[MAX_TRACK_BUFF_SIZE] = {0x00};

	switch(writeData.wMediaID)
	{
	case CARD_READER_MEDIA_TRACK1:
		command.bParameterCode = 0x31;
		break;
	case CARD_READER_MEDIA_TRACK2:
		command.bParameterCode = 0x32;
		break;
	case CARD_READER_MEDIA_TRACK3:
		command.bParameterCode = 0x33;
		break;
	default:
		return CRT_PARAM_ERR;
	}

	if (writeData.dwDataLen == 0 || writeData.byDataBuf == NULL)
	{
		return CRT_PARAM_ERR;
	}
	else
	{
		memset(&command.Data, 0x00, sizeof(command.Data));
		memcpy(bData, writeData.byDataBuf, writeData.dwDataLen);
		command.Data.dwSize = writeData.dwDataLen;
		command.Data.lpbBody = bData;
	}

	REPLY reply;
	WORD wResult = CRT_SUCCESS;

    BOOL bRet = m_pDevCtrlImpl->ExecuteCommand(command, &reply, CMD_TIMEOUT_ACT);
	if (bRet == FALSE)
	{
		wResult = CRT_OFFLINE;
		return wResult;
	}

	if (reply.replyType == NegativeReply)
	{
		wResult = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
		return wResult;
	}

	return wResult;
}


char* CACT_Sankyo_DevCtrl::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;
}