myvtm/Module/mod_gpio/GpioFSM.cpp

#include "GpioFSM.h"
#include "publicFunExport.h"
#include "EventCode.h"
#include <bitset>

const int MAX_GPIO_INIT_TRIES = 3;
const int INPUT_PORT_2 = 2;
const int MAX_MOVE_HOLD_TIMES = 5000;
const int ON_EVENT_DETECT_TIMOUE_MILLSECS = 500;
const int REPEAT_FIRE_TIMEOUT_VALUE = 10000; //10s

#define SETBIT(x,y) x|=(1<<(y))
#define CLEARBIT(x,y) x&=((1<<(y))^0xffffff)

using namespace SP::Module::Comm;

static const char* GetDriverPortStringZhCN(int pin)
{
	switch (pin) {
	case 1: return "【驱动】读卡发卡器提示灯";
	case 2: return "【驱动】前端USB通断控制";
	case 3: return "【驱动】身份证阅读器提示灯";
	case 4: return "【驱动】密码键盘提示灯";
	case 5: return "【驱动】脸部照明灯";
	case 6: return "【驱动】故障灯";
	case 7: return "【驱动】读卡发卡器维护提示灯";
	case 8: return "【驱动】前端USB口提示灯";
	case 9: return "【驱动】非接IC读卡器提示灯";
	case 10: return "";
	case 11: return "【驱动】指纹仪提示灯";
	case 12: return "【驱动】凭条打印提示灯";
	case 13: return "【驱动】高拍仪提示灯";
	case 14: return "";
	case 15: return "";
	case 16: return "";
	case 17: return "【接收】震动探测器";
	case 18: return "【接收】机具门感应开关";
	case 19: return "【接收】话机提机感应开关";
	case 20: return "【接收】人体探测感应器";
	case 21: return "【接收】发卡器卡嘴覆盖探测器";
		//case 22: return "";
		//case 23: return "";
		//case 24: return "";
		//case 25: return "";
	case 26: return "【驱动】高拍仪提示灯";
		//case 27: return "";
		//case 28: return "";
		//case 29: return "";
		//case 30: return "";
		//case 31: return "";
		//case 32: return "";
		//case 33: return "";
		//case 34: return "";
		//case 35: return "";
		//case 36: return "";
		//case 37: return "";
		//case 38: return "";
		//case 39: return "";
		//case 40: return "";
		//case 41: return "";
		//case 42: return "";
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unkown pin sequence: %d", pin);
		return "";
		break;
	}
}

static const char* pinStatusName[8][2] =
{
	{"无震动", "**有震动**"},
	{"关门", "**开门**"},
	{"挂机", "**摘机**"},
	{"无移动", "**移动**"},
	{"卡嘴正常", "**卡嘴不正常**"},
	{"Pin 22 Normal", "**Pin 22 High**"},
	{"Pin 23 Normal", "**Pin 23 High**"},
	{"Pin 24 Normal", "**Pin 24 High**"}
};

static const char* GetDriverPortString(int pin)
{
	switch (pin) {
	case 1: return "[Driver] CarIssuer Tip Light";
	case 2: return "[Driver] USB Switch";
	case 3: return "[Driver] IDCer Tip Light";
	case 4: return "[Driver] PinPad Tip Light";
	case 5: return "[Driver] Face Light";
	case 6: return "[Driver] Maintain Light";
	case 7: return "[Driver] CardIssuser Mouse Maintain Light";
	case 8: return "[Driver] USB Tip Light";
	case 9: return "[Driver] RF Tip Light";
	case 10: return "";
	case 11: return "[Driver] FingerPrint Tip Light";
	case 12: return "[Driver] Printer Tip Light";
	case 13: return "[Driver] HSPSCanner Read Light";
	case 14: return "";
	case 15: return "";
	case 16: return "";
	case 17: return "[Receiver] Shake Detecter";
	case 18: return "[Receiver] Door Detecter";
	case 19: return "[Receiver] Phone Detecter";
	case 20: return "[Receiver] Body Detecter";
	case 21: return "[Receiver] CardIssuer Mouse Detecter";
		//case 22: return "";
		//case 23: return "";
		//case 24: return "";
		//case 25: return "";
	case 26: return "[Driver] HSPSCanner Tip Light";
		//case 27: return "";
		//case 28: return "";
		//case 29: return "";
		//case 30: return "";
		//case 31: return "";
		//case 32: return "";
		//case 33: return "";
		//case 34: return "";
		//case 35: return "";
		//case 36: return "";
		//case 37: return "";
		//case 38: return "";
		//case 39: return "";
		//case 40: return "";
		//case 41: return "";
		//case 42: return "";
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unkown pin sequence: %d", pin);
		return "";
		break;
	}
}

#define LIGHT_STRING_CONVERT(str)   case str : return #str; break;

static const char* GetLightSeqString(int seq)
{
	switch (seq) {
		LIGHT_STRING_CONVERT(UNKNOWN_DEVICE)
			LIGHT_STRING_CONVERT(CARDREADER)
			LIGHT_STRING_CONVERT(CARDREADER_RED)
			LIGHT_STRING_CONVERT(IDCERTIFICATE)
			LIGHT_STRING_CONVERT(PINPAD)
			LIGHT_STRING_CONVERT(SHAKEDETECT)
			LIGHT_STRING_CONVERT(SWITCHINDUCTOR)
			LIGHT_STRING_CONVERT(PHONEPICKUP)
			LIGHT_STRING_CONVERT(MOVEDETECT)
			LIGHT_STRING_CONVERT(CARDGATEDETECT)
			LIGHT_STRING_CONVERT(HEADLIGHT)
			LIGHT_STRING_CONVERT(HEADLIGHT_RED)
			LIGHT_STRING_CONVERT(CONTACTLESSCARD)
			LIGHT_STRING_CONVERT(HEADLIGHT_ASSIST)
			LIGHT_STRING_CONVERT(HSPSCANNER)
			LIGHT_STRING_CONVERT(FINGERPRINT)
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unkonwn LightSeq: %d", seq);
		return "UnConver One";
		break;
	}
}
#undef LIGHT_STRING_CONVERT


/** Just for Debug  [Gifur@2024911]*/
void LogPinStatus(ULONG val)
{
	char byteString[9] = { 0 };
	_itoa((int)val, byteString, 2);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ReadPort returned btInput[%s]", byteString);

	std::bitset<8> pinSet((int)val);
	if (pinSet[0])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[0][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[0][0]);
	}

	if (pinSet[1])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[1][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[1][0]);
	}
	if (pinSet[2])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[2][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[2][0]);
	}
	if (pinSet[3])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[3][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[3][0]);
	}
	if (pinSet[4])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[4][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[4][0]);
	}
	if (pinSet[5])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[5][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[5][0]);
	}
	if (pinSet[6])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[6][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[6][0]);
	}
	if (pinSet[7])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[7][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[7][0]);
	}
	return;
}

CSimpleStringA CombineJsonContext(const char* szMessage)
{
	CSimpleStringA result(true);
	if (szMessage == NULL || strlen(szMessage) == 0) {
		return result;
	}
	result = CSimpleStringA::Format("{\"addition\": \"%s\"}", szMessage);
	return  result;
}

CGPIOFSM::CGPIOFSM(void) :m_bVibrationFlag(false), m_bOpenFlag(false), m_bMoveFlag(false), m_bCardGateFlag(false)
	, m_bHeadLightFlag(false), m_headlightDevPort(4), m_moveHoldTimes(0)
	, m_moveDisappearTimes(0)
	, m_bNewVersion(FALSE), m_bFuncVer2(FALSE), m_btLastRevcInput(-1)
{
	memset(m_btOutputStatus, 0, MAX_PORT_NUM * sizeof(BYTE));
}

ErrorCodeEnum CGPIOFSM::OnInit()
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Succeed, eErrDev = Error_Succeed;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Source Code complied at: %s %s", __DATE__, __TIME__);
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->InitializeVendorLogSwitch();
	SetDevInitingFlag(true);
	SetDevInitFlag(false);
	CSimpleStringA strNoUse(true);
	erroCode = pEntity->ExtractVendorLibFullPath(strNoUse);
	if (erroCode != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("load vendor dll or so(%s) failed, ec=%s", strNoUse.GetData(), SpStrError(erroCode));
		SetDevInitingFlag(false);
		return Error_DevLoadFileFailed;
	}

	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
	LogWarn(Severity_Low, Error_Unexpect, GPIO_UserErrorCode_RootInfo, (LPCTSTR)m_adapterInfo.adapterFilePath);
	erroCode = LoadUpAdapterLibrary();
	if (erroCode != Error_Succeed) {
		SetDevInitingFlag(false);
		return erroCode;
	}

	GpioInitParam initParam;
	initParam.dwPort = m_adapterInfo.GetPortInt();
	initParam.dwBaudRate = m_adapterInfo.GetBaudrateInt();
	initParam.dir[0] = true;
	initParam.dir[1] = true;
	initParam.dir[2] = false;
	initParam.dir[3] = false;
	initParam.dwPortNum = 3;
	if (m_adapterInfo.GetPortNumInt() == 4) {
		m_bNewVersion = TRUE;
		initParam.dwPortNum = 4;
		initParam.dir[3] = true;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("New available 4 port num");
	}

	int initTries = 0;
	ErrorCodeEnum err;
	do {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to open device...port(%d), baudrate(%d).", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		err = m_hDevHelper->DevOpen(initParam);
		ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (err == Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpen").setCostTime(ullEnd - ullStart)("open device succ");
			ToLogRootINIInfo();
			DevCategoryInfo devCatInfo;
			ZeroMemory(devCatInfo.szModel, sizeof(devCatInfo.szModel));
			ZeroMemory(devCatInfo.szType, sizeof(devCatInfo.szType));
			ZeroMemory(devCatInfo.szVendor, sizeof(devCatInfo.szVendor));
			ullStart = SP::Module::Comm::RVCGetTickCount();
			err = m_hDevHelper->GetDevCategory(devCatInfo);
			ullEnd = SP::Module::Comm::RVCGetTickCount();
			if (err == Error_Succeed) {
				m_adapterInfo.FulfillCategoryInfo(devCatInfo);
				ToLogWarnInfoAboutTerm();
#if defined(RVC_OS_LINUX)
				CSimpleStringA strType(devCatInfo.szType);
				if (strType.IndexOf("FUNCVER=2.0") != -1) {
					m_bFuncVer2 = TRUE;
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Detect new interface version: %s", strType.GetData());
				}
#endif //RVC_OS_LINUX
			}
			else {
				SetErrorAndLog(err, GPIO_UserErrorCode_GetDevCategory_Failed, "DevAdapter::GetDevCategory", "FulfillAdapterDevCategory", false, ullEnd - ullStart);
			}
			SetDevInitFlag(true);
			break;
		}
		else {
			SetErrorAndLog(err, GPIO_UserErrorCode_DevOpen_Failed, "DevAdapter::DevOpen", __FUNCTION__, false, ullEnd - ullStart);
			Sleep(300);
			initTries++;
			continue;
		}
	} while (initTries < MAX_GPIO_INIT_TRIES);

	if (!GetDevInitFlag()) {
		err = Error_DevConnFailed;
	}
	else {
		if (!m_bFuncVer2) {
			ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
			eErrDev = m_hDevHelper->WritePort(0, 0x00);
			ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
			if (eErrDev != Error_Succeed)
				SetErrorAndLog(eErrDev, GPIO_UserErrorCode_WritePort_Failed, "DevAdapter::WritePort", __FUNCTION__, false, ullEnd - ullStart, "", CombineJsonContext("WritePort(0) after DevOpen"));
			ullStart = SP::Module::Comm::RVCGetTickCount();
			eErrDev = m_hDevHelper->WritePort(1, 0x00);
			ullEnd = SP::Module::Comm::RVCGetTickCount();
			if (eErrDev != Error_Succeed)
				SetErrorAndLog(eErrDev, GPIO_UserErrorCode_WritePort_Failed, "DevAdapter::WritePort", __FUNCTION__, false, ullEnd - ullStart, "", CombineJsonContext("WritePort(1) after DevOpen"));
			if (m_bNewVersion) {
				ullStart = SP::Module::Comm::RVCGetTickCount();
				eErrDev = m_hDevHelper->WritePort(3, 0x00);
				ullEnd = SP::Module::Comm::RVCGetTickCount();
				if (eErrDev != Error_Succeed)
					SetErrorAndLog(eErrDev, GPIO_UserErrorCode_WritePort_Failed, "DevAdapter::WritePort", __FUNCTION__, false, ullEnd - ullStart, "", CombineJsonContext("WritePort(3) after DevOpen"));
			}
		}
		else {
#if defined(RVC_OS_LINUX)
			ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
			eErrDev = m_hDevHelper->SetStatus(GPIO_DEV_SN_LIGHT_SENSOR_ALL, GPIO_DEV_LIGHT_MODE_RESET);
			ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
			if (eErrDev != Error_Succeed)
				SetErrorAndLog(eErrDev, GPIO_UserErrorCode_SetStatus_Failed, "DevAdapter::SetStatus", __FUNCTION__, false, ullEnd - ullStart, "", CombineJsonContext("SetStatus after DevOpen"));
#endif //RVC_OS_LINUX
		}
		SetDevState(DEVICE_STATUS_NORMAL);
	}
	SetDevInitingFlag(false);
	m_moveHoldTimes = MAX_MOVE_HOLD_TIMES;//oiltmp about 5000*300ms = 25 minutes
	m_moveDisappearTimes = m_moveHoldTimes;
	return err;

}

void CGPIOFSM::AfterInit()
{
	StartDetectWorkThread();
}

void CGPIOFSM::SelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
{
	OnHardwareShakeHand(pTransactionContext);
}

void CGPIOFSM::GetDevInfo(SpReqAnsContext<GpioService_GetDevInfo_Req, GpioService_GetDevInfo_Ans>::Pointer ctx)
{
	if (m_bOpening) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(GpioService_LogCode_GetDevInfo).setAPI(__FUNCTION__)("device is opening");
		ctx->Answer(Error_NotInit);
		return;
	}
	if (!m_bOpened) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(GpioService_LogCode_GetDevInfo).setResultCode("RTA2901").setAPI(__FUNCTION__)("GPIO未打开");
		ctx->Answer(Error_DevNotAvailable, GPIO_UserErrorCode_DevOpen_Failed);
	}
	else {
		DevCategoryInfo info = { 0 };
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		ErrorCodeEnum erroCode = m_hDevHelper->GetDevCategory(info);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		ctx->Ans.state = (int)erroCode;
		if (erroCode == Error_Succeed) {
			ctx->Ans.model = info.szModel;
			ctx->Ans.type = info.szType;
			ctx->Ans.version = CSimpleStringA::Format("%d.%d.%d.%d",
				info.version.wMajor, info.version.wMinor, info.version.wRevision, info.version.wBuild);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_GetDevInfo)
				.setAPI("DevAdapter::GetDevCategory").setCostTime(ullEnd - ullStart)("model: %s, state:%d, type:%s, version:%s"
					, ctx->Ans.model.GetData(), ctx->Ans.state, ctx->Ans.type.GetData(), ctx->Ans.version.GetData());
		}
		else {
			SetErrorAndLog(erroCode, GPIO_UserErrorCode_GetDevCategory_Failed, "DevAdapter::GetDevCategory", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, GpioService_LogCode_GetDevInfo);
		}
		ctx->Answer(Error_Succeed);
	}
}

void CGPIOFSM::Exit(SpOnewayCallContext<GpioService_Exit_Info>::Pointer ctx)
{

}

bool CGPIOFSM::DetectBit(ULONG data, int pos)
{
	if (!m_bFuncVer2) {
		ULONG tmp = 0;
		SETBIT(tmp, pos);
		return (data & tmp);
	}
#if defined(RVC_OS_LINUX)
	else {
		DWORD dwReq = (GPIO_DEV_SN_SENSOR_SHAKE << pos);
		return (data & dwReq);
	}
#endif //RVC_OS_LINUX
	return 0;
}

void CGPIOFSM::OnLogEvent(DWORD dwUserCode)
{

	GpioSet_Info Req;
	if (!m_bOpened) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("usercode [%x], but device is not open", dwUserCode);
		return;
	}
	else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("receive usercode [%x]", dwUserCode);
	}
	Req.close = 0;
	switch (dwUserCode) {
	case LOG_EVT_CARDISSUER_GREEN_ON:
	case LOG_EVT_CARDISSUER_STORE_GREEN_ON:
		Req.devseq = CARDREADER;
		Req.mode = 1;
		break;
	case LOG_EVT_CARDISSUER_RED_ON:
		Req.devseq = CARDREADER_RED;
		Req.mode = 1;
		break;
	case LOG_EVT_IDCERTIFICATE_GREEN_ON:
		Req.devseq = IDCERTIFICATE;
		Req.mode = 1;
		break;
	case LOG_EVT_FINGERPRINT_GREEN_ON:
		Req.devseq = FINGERPRINT;
		Req.mode = 1;
		break;
	case LOG_EVT_PINPAD_GREEN_ON:
		Req.devseq = PINPAD;
		Req.mode = 1;
		break;
	case LOG_EVT_HEADLIGHT_GREEN_ON:
		m_bHeadLightFlag = true;
		Req.devseq = HEADLIGHT;
		Req.mode = 0;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machine light on");
		break;
	case LOG_EVT_HEADLIGHT_RED_ON:
		Req.devseq = HEADLIGHT_RED;
		Req.mode = 1;
		break;
	case LOG_EVT_CONTACTLESS_CARD_GREEN_ON:
		Req.devseq = CONTACTLESSCARD;
		Req.mode = 1;
		break;
	case LOG_EVT_IEBROWSER_LIGHT_ASSISTANT_ON:
		Req.devseq = HEADLIGHT_ASSIST;
		Req.mode = 1;
		break;
	case LOG_EVT_CARDISSUER_GREEN_OFF:
	case LOG_EVT_CARDISSUER_STORE_GREEN_OFF:
		Req.devseq = CARDREADER;
		Req.mode = 1;
		Req.close = 1;
		break;
	case LOG_EVT_CARDISSUER_RED_OFF:
		Req.devseq = CARDREADER_RED;
		Req.mode = 1;
		Req.close = 1;
		break;
	case LOG_EVT_IDCERTIFICATE_GREEN_OFF:
		Req.devseq = IDCERTIFICATE;
		Req.mode = 1;
		Req.close = 1;
		break;
	case LOG_EVT_FINGERPRINT_GREEN_OFF:
		Req.devseq = FINGERPRINT;
		Req.mode = 1;
		Req.close = 1;
		break;
	case LOG_EVT_PINPAD_GREEN_OFF:
		Req.devseq = PINPAD;
		Req.mode = 1;
		Req.close = 1;
		break;
	case LOG_EVT_HEADLIGHT_GREEN_OFF:
		m_bHeadLightFlag = false;
		Req.devseq = HEADLIGHT;
		Req.mode = 1;
		Req.close = 1;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machine light off");
		break;
	case LOG_EVT_HEADLIGHT_RED_OFF:
		Req.devseq = HEADLIGHT_RED;
		Req.mode = 1;
		Req.close = 1;
		break;
	case LOG_EVT_CONTACTLESS_CARD_GREEN_OFF:
		Req.devseq = CONTACTLESSCARD;
		Req.mode = 1;
		Req.close = 1;
		break;
	case LOG_EVT_IEBROWSER_LIGHT_ASSISTANT_OFF:
		Req.devseq = HEADLIGHT_ASSIST;
		Req.mode = 1;
		Req.close = 1;
		break;
	case LOG_EVT_HSPS_LIGHT_ON:
		Req.devseq = HSPSCANNER;
		Req.mode = 1;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hspscanner light on");
		break;
	case LOG_EVT_HSPS_LIGHT_OFF:
		Req.devseq = HSPSCANNER;
		Req.mode = 1;
		Req.close = 1;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hspscanner light off");
		break;
	default:
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("unkown event: 0x%X", dwUserCode);
		return;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("devseq[%d],mode[%d]close[%d]", Req.devseq, Req.mode, Req.close);
	m_bFuncVer2 ? SetEx(Req) : Set(Req);
}

//老接口，用于控制灯
bool CGPIOFSM::SetOutDriving(GpioSet_Info req, OutDrivingInfo od, ULONG iIndex, ULONG pinSeq)
{
	if (req.close == 1) {
		GetEntityBase()->GetFunction()->KillTimer(req.devseq);

		//oilyang add 20161222
		//如果关闭照明灯，以感知为准
		if (pinSeq == m_headlightDevPort)
			WritePin(pinSeq, m_bHeadLightFlag);
		else {
			if (pinSeq == PIN_HSPSCANNER_PREVIEW_LIGHT) {
				//额外多关闭高拍仪提示灯
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("off light hspsanner.");
				WritePin(PIN_HSPSCANNER_LIGHT, false);
			}
			WritePin(pinSeq, false);
		}
		return true;
	}

	switch (od.OutputMode) {
	case OM_POSITIVE_LEVEL:
	{
		if (od.StopMode == SM_CALLTRIGGER) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("0.0 mode: pinSeq=%u", pinSeq);
			//if it is hspsanner
			if (pinSeq == PIN_HSPSCANNER_PREVIEW_LIGHT) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("light hspsanner.");
				WritePin(PIN_HSPSCANNER_LIGHT, true);
			}
			WritePin(pinSeq, true);
		}
	}
	break;
	case OM_POSITIVE_FLICKER:
		if (od.StopMode == SM_CYCLE) {
			SetContextInfo* pSci = new SetContextInfo();
			pSci->pinSeq = pinSeq;
			pSci->timerID = req.devseq;
			pSci->setTime = od.SetTime;
			pSci->resetTime = od.ResetTime;
			pSci->timeout = od.TimeOut;

			WritePin(pinSeq, true);

			ITimerListener* pListener = new TimerOutHelper<CGPIOFSM>(this, &CGPIOFSM::OnPositiveFlickerSetTimerout, pSci, true);
			GetEntityBase()->GetFunction()->SetTimer(pSci->timerID, pListener, pSci->setTime);
		}
		break;
	default:
		break;
	}
	return true;
}


void CGPIOFSM::WritePin(DWORD dwPinSeq, bool bHighLevel)
{
	ErrorCodeEnum result(Error_Succeed);
	int idx = -1;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Write Pin %s with %s", GetDriverPortString(dwPinSeq + 1), bHighLevel ? "[Active]" : "[InActive]");
	if (dwPinSeq > 16) {/** 目前只有一个高拍仪的提示灯会超过该值  [Gifur@202495]*/
		if (!m_bNewVersion || dwPinSeq < 24) {
			return;
		}
		idx = 3;
	}
	else if (dwPinSeq < 8) {
		idx = 0;
	}
	else {
		idx = 1;
	}

	if (bHighLevel)
		SETBIT(m_btOutputStatus[idx], dwPinSeq - 8 * idx);
	else
		CLEARBIT(m_btOutputStatus[idx], dwPinSeq - 8 * idx);

	const auto iBegin = SP::Module::Comm::RVCGetTickCount();
	result = m_hDevHelper->WritePort(idx, m_btOutputStatus[idx]);
	const auto iEnd = SP::Module::Comm::RVCGetTickCount();
	if (result != Error_Succeed) {
		SetErrorAndLog(result, GPIO_UserErrorCode_WritePort_Failed, "DevAdapter::WritePort", __FUNCTION__, false, iEnd - iBegin, "", CombineJsonContext(CSimpleStringA::Format("write port[%d] with %d", idx, m_btOutputStatus[idx])));
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::WritePort").setAPI(__FUNCTION__).setCostTime(iEnd - iBegin)("write port[%d] with %d succ", idx, m_btOutputStatus[idx]);
	}
	return;
}

void CGPIOFSM::SetEx(GpioSet_Info req)
{
#if defined(RVC_OS_LINUX)

	int devicePort;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("SetEx request %s arrived!", GetLightSeqString(req.devseq));
	switch (req.devseq) {
	case CARDREADER:
	{
		devicePort = GPIO_DEV_SN_LIGHT_CARDISSUER;
		break;
	}
	case CARDREADER_RED:
	{
		devicePort = GPIO_DEV_SN_LIGHT_CARDISSUER_MAINTAIN;
		break;
	}
	case IDCERTIFICATE:
	{
		devicePort = GPIO_DEV_SN_LIGHT_IDCERTIFICATE;
		break;
	}
	case FINGERPRINT:
	{
		devicePort = GPIO_DEV_SN_LIGHT_FINGERPRINT;
		break;
	}
	case PINPAD:
	{
		devicePort = GPIO_DEV_SN_LIGHT_PINPAD;
		break;
	}
	case HEADLIGHT:
	{
		devicePort = GPIO_DEV_SN_LIGHT_FACE;
		break;
	}
	case HEADLIGHT_RED:
	{
		devicePort = 6/*GPIO_DEV_SN_LIGHT_MACHINE_FAULT*/;
		break;
	}
	case CONTACTLESSCARD:
	{
		devicePort = GPIO_DEV_SN_LIGHT_CONTACTLESSCARD;
		break;
	}
	case HEADLIGHT_ASSIST:
	{
		devicePort = GPIO_DEV_SN_LIGHT_FACE;
		break;
	}
	break;
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(__FUNCTION__)("unsupport device seq: %d", req.devseq);
		return;
	}

	if (m_hDevHelper != nullptr) {
		DWORD dwReq = devicePort;
		DWORD dwMode = 0;
		if (!req.close) {
			dwMode |= GPIO_DEV_LIGHT_MODE_COLOR_NORMAL;
			if (!!req.mode) {
				dwMode |= GPIO_DEV_LIGHT_MODE_LIGHT_FLICKER;
			}
			else {
				dwMode |= GPIO_DEV_LIGHT_MODE_LIGHT_SUSTAIN;
			}
		}
		const auto iBegin = SP::Module::Comm::RVCGetTickCount();
		const ErrorCodeEnum ec = m_hDevHelper->SetStatus(dwReq, dwMode);
		const auto iEnd = SP::Module::Comm::RVCGetTickCount();
		if (ec != Error_Succeed) {
			SetErrorAndLog(ec, GPIO_UserErrorCode_SetStatus_Failed, "DevAdapter::SetStatus", __FUNCTION__, false, iEnd - iBegin, "", CombineJsonContext(CSimpleStringA::Format("SetStatus with 0x%X,0x%X", dwReq, dwMode)));
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetStatus").setAPI(__FUNCTION__).setCostTime(iEnd - iBegin)("SetStatus with 0x%X,0x%X", dwReq, dwMode);
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("dev helper object is invalid pointer!");
	}
#endif //RVC_OS_LINUX
}

void CGPIOFSM::Set(GpioSet_Info req)
{
	CSimpleStringA activeModeSecName = "";
	int devicePort;
	OutDrivingInfo odi;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Set request %s arrived!", GetLightSeqString(req.devseq));
	switch (req.devseq) {
	case CARDREADER:
	case PINPAD:
	case CONTACTLESSCARD:
	{
		devicePort = req.devseq == CARDREADER ? 0 : (req.devseq == PINPAD ? 3 : 8);
		odi.OutputMode = OM_POSITIVE_FLICKER;
		odi.StopMode = SM_CYCLE;
		odi.SetTime = 200;
		odi.ResetTime = 200;
		odi.TimeOut = 5000;
		break;
	}
	case CARDREADER_RED:
	case HEADLIGHT_RED:
	{
		devicePort = req.devseq == CARDREADER_RED ? 6 : 5;
		odi.OutputMode = OM_POSITIVE_LEVEL;
		odi.StopMode = SM_CALLTRIGGER;
		odi.SetTime = 200;
		odi.ResetTime = 200;
		odi.TimeOut = 3000;
		break;
	}
	case IDCERTIFICATE:
	case FINGERPRINT:
	{
		devicePort = req.devseq == IDCERTIFICATE ? 2 : 10;
		odi.OutputMode = OM_POSITIVE_FLICKER;
		odi.StopMode = SM_CYCLE;
		odi.SetTime = 150;
		odi.ResetTime = 150;
		odi.TimeOut = 5000;
		break;
	}
	case HEADLIGHT:
	case HSPSCANNER:
	{
		devicePort = req.devseq == HEADLIGHT ? 4 : 12;
		odi.OutputMode = OM_POSITIVE_LEVEL;
		odi.StopMode = SM_CALLTRIGGER;
		odi.SetTime = 1000;
		odi.ResetTime = 1000;
		odi.TimeOut = 5000;
		break;
	}
	case HEADLIGHT_ASSIST:
	{
		devicePort = 4;
		odi.OutputMode = OM_POSITIVE_FLICKER;
		odi.StopMode = SM_CYCLE;
		odi.SetTime = 1000;
		odi.ResetTime = 500;
		odi.TimeOut = 5000;
		break;
	}
	default:
		odi.OutputMode = OM_POSITIVE_LEVEL;
		odi.StopMode = SM_CALLTRIGGER;
		odi.SetTime = 200;
		odi.ResetTime = 200;
		odi.TimeOut = 5000;
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("unsupport device seq: %d", req.devseq);
		return;
	}
	SetOutDriving(req, odi, 0, devicePort);
}

void CGPIOFSM::StartDetectWorkThread()
{
	ReceivingInfo ri;
	ri.ContinuousTriggerTime = 2;

	GetContextInfo* pGci = new GetContextInfo();
	/** 注意设备序号是实体内定义的逻辑，不是设备端口号，最后用作于计时器的ID去了*/
	pGci->timerID = PHONEPICKUP;
	m_PickUpTimeStamp = m_PutDownTimeStamp = SP::Module::Comm::RVCGetTickCount();
	m_DoorOpenTimeStamp = m_DoorCloseTimeStamp = SP::Module::Comm::RVCGetTickCount();
	ITimerListener* pListener = new TimerOutHelper<CGPIOFSM>(this, &CGPIOFSM::OnEventDetect, pGci);
	GetEntityBase()->GetFunction()->SetTimer(pGci->timerID, pListener, 100);
}

void CGPIOFSM::OnPositiveFlickerSetTimerout(void* pData)
{
	SetContextInfo* pSCI = (SetContextInfo*)pData;
	GetEntityBase()->GetFunction()->KillTimer(pSCI->timerID);
	WritePin(pSCI->pinSeq, false); //实际操作
	pSCI->timerID = pSCI->timerID;
	ITimerListener* pListener = new TimerOutHelper<CGPIOFSM>(this, &CGPIOFSM::OnPositiveFlickerResetTimerout, pSCI, true);
	GetEntityBase()->GetFunction()->SetTimer(pSCI->timerID, pListener, pSCI->resetTime);
}

void CGPIOFSM::OnPositiveFlickerResetTimerout(void* pData)
{
	SetContextInfo* pSCI = (SetContextInfo*)pData;
	GetEntityBase()->GetFunction()->KillTimer(pSCI->timerID);
	WritePin(pSCI->pinSeq, true); //实际操作
	ITimerListener* pListener = new TimerOutHelper<CGPIOFSM>(this, &CGPIOFSM::OnPositiveFlickerSetTimerout, pSCI, true);
	GetEntityBase()->GetFunction()->SetTimer(pSCI->timerID, pListener, pSCI->setTime);
}

void CGPIOFSM::OnEventDetect(void* pData)
{
	GetContextInfo* pGci = (GetContextInfo*)pData;

	ULONG input = 0;
	BYTE btInput;
	ErrorCodeEnum err(Error_Succeed);
	if (!m_bFuncVer2) {
		const auto iBegin = SP::Module::Comm::RVCGetTickCount();
		err = m_hDevHelper->ReadPort(INPUT_PORT_2, btInput);
		const auto iEnd = SP::Module::Comm::RVCGetTickCount();
		if (err != Error_Succeed) {
			SetErrorAndLog(err, GPIO_UserErrorCode_ReadPort_Failed, "DevAdapter::ReadPort", __FUNCTION__, false, iEnd - iBegin, "",
				CombineJsonContext(CSimpleStringA::Format("read port[%d] with %d", INPUT_PORT_2, btInput)));
		}
		else if (btInput != m_btLastRevcInput) {
			m_btLastRevcInput = btInput;
			LogPinStatus(btInput);
		}
	}
	else {
#if defined(RVC_OS_LINUX)
		DWORD dwReq(GPIO_DEV_SN_LIGHT_SENSOR_ALL);
		DWORD dwMode = 0;
		const auto iBegin = SP::Module::Comm::RVCGetTickCount();
		err = m_hDevHelper->DetectStatus(dwReq, dwMode);
		const auto iEnd = SP::Module::Comm::RVCGetTickCount();
		btInput = dwMode;
		if (err != Error_Succeed) {
			SetErrorAndLog(err, GPIO_UserErrorCode_DetectStatus_Failed, "DevAdapter::DetectStatus", __FUNCTION__, false, iEnd - iBegin, "",
				CombineJsonContext(CSimpleStringA::Format("detect status[%d] with %d", dwReq, dwMode)));
		}
		else if (btInput != m_btLastRevcInput) {
			m_btLastRevcInput = btInput;
			LogPinStatus(btInput);
		}
#else
		err = Error_NotSupport;
#endif //RVC_OS_LINUX
	}
	if (err != Error_Succeed) {
		m_btLastRevcInput = (BYTE)(-1);
		GetEntityBase()->GetFunction()->ResetTimer(pGci->timerID, ON_EVENT_DETECT_TIMOUE_MILLSECS);
		return;
	}
	/** 震动感应 */
	if (DetectBit(btInput, VIBRATIONSENSOR) && !m_bVibrationFlag) {
		m_bVibrationFlag = true;
		LogEvent(Severity_Middle, LOG_EVT_VIBRATIONSENSOR, CSimpleStringA::Format("%s [Active] line: %d", GetDriverPortString(17), __LINE__));
	}
	else if (!DetectBit(btInput, VIBRATIONSENSOR) && m_bVibrationFlag) {
		LogEvent(Severity_Middle, LOG_EVT_VIBRATIONSENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(17), __LINE__));
		m_bVibrationFlag = false;
	}

	/** 机箱门开关检测*/
	if (DetectBit(btInput, OPENSENSOR) && !m_bOpenFlag) {
		m_bOpenFlag = true;
		m_DoorOpenTimeStamp = SP::Module::Comm::RVCGetTickCount();
		LogEvent(Severity_Middle, LOG_EVT_OPENSENSOR_ON, CSimpleStringA::Format("%s [Active] line: %d", GetDriverPortString(18), __LINE__));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_DoorOpen)("[GPIO] The chassis door is open");
	}
	else if (!DetectBit(btInput, OPENSENSOR) && m_bOpenFlag) {
		m_bOpenFlag = false;
		m_DoorCloseTimeStamp = SP::Module::Comm::RVCGetTickCount();
		LogEvent(Severity_Middle, LOG_EVT_OPENSENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(18), __LINE__));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_DoorClose).setCostTime(m_DoorCloseTimeStamp - m_DoorOpenTimeStamp)("[GPIO] The chassis door is close");
	}

	/**话机检测*/
	if (DetectBit(btInput, PICKUPSENSOR)) {
		if (m_ePickUpFlag == InActive) {
			m_ePickUpFlag = Actived;
			m_PickUpTimeStamp = SP::Module::Comm::RVCGetTickCount();
			LogEvent(Severity_Middle, LOG_EVT_PICKUP, "Life the Phone up");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_PhonePickup)("[GPIO] 话机提起");
			LogWarn(Severity_Low, Error_Debug, GPIO_UserErrorCode_Phone_HandUp, "话机提起");
		}
		else if (m_ePickUpFlag == UnknownStatus) {
			m_ePickUpFlag = Actived;
			m_PickUpTimeStamp = SP::Module::Comm::RVCGetTickCount();
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_PhonePickup)("[GPIO] 话机提起（启动时）");
			LogWarn(Severity_Low, Error_Debug, GPIO_UserErrorCode_Phone_HandUp_AtBegin, "话机提起（启动时）");
		}
	}
	else if (!DetectBit(btInput, PICKUPSENSOR)) {
		if (m_ePickUpFlag == Actived) {
			m_ePickUpFlag = InActive;
			m_PutDownTimeStamp = SP::Module::Comm::RVCGetTickCount();
			LogEvent(Severity_Middle, LOG_EVT_ONHOOK, "Put the Phone down");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_PhonePutDown).setCostTime(m_PutDownTimeStamp - m_PickUpTimeStamp)("[GPIO] 话机放下");
			LogWarn(Severity_Low, Error_Debug, GPIO_UserErrorCode_Phone_PutDown, "话机放下");
		}
		else if (m_ePickUpFlag == UnknownStatus) {
			m_ePickUpFlag = InActive;
			m_PutDownTimeStamp = SP::Module::Comm::RVCGetTickCount();
		}
	}
	/*物体靠近感知检测*/
	if (DetectBit(btInput, MOVESENSOR)) {
		if (!m_bMoveFlag) {
			m_bMoveFlag = true;
			m_moveDisappearTimes = 0;
			LogEvent(Severity_Middle, LOG_EVT_MOVESENSOR_ON, CSimpleStringA::Format("%s [Active] line: %d, times: %lu", GetDriverPortString(20), __LINE__, m_moveHoldTimes));
		}
		/** 只是发一次时间时，发现感知实体没有收到或者不处理第一次发出的时间，所以需要沿用原有的发送频率，再继续发送消失的事件，下同  [Gifur@202496]*/
		else if (m_moveHoldTimes != 0 && (m_moveHoldTimes % (REPEAT_FIRE_TIMEOUT_VALUE / ON_EVENT_DETECT_TIMOUE_MILLSECS)) == 0) {
			LogEvent(Severity_Middle, LOG_EVT_MOVESENSOR_ON, CSimpleStringA::Format("%s [Active] line: %d, times: %lu", GetDriverPortString(20), __LINE__, m_moveHoldTimes));
		}
		const bool toCheck = !!(m_moveHoldTimes != 0 && (m_moveHoldTimes % (8/*mins*/ * 60 * 1000 / ON_EVENT_DETECT_TIMOUE_MILLSECS) == 0));
		if (toCheck) {
			SYSTEMTIME localTime;
			GetLocalTime(&localTime);
			if (localTime.wHour < (WORD)8 || (localTime.wHour == 8 && localTime.wMinute <= (WORD)30) || localTime.wHour >= (WORD)18)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2903")("Move detect is abnormal(off work).");
				LogWarn(Severity_High, Error_Unexpect, LOG_EVT_MOVEDETECT_ABNORMAL_OFFWORK, "Move detect is abnormal(off work).");
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2902")("Move detect is abnormal(Work time).");
				LogWarn(Severity_High, Error_Unexpect, LOG_EVT_MOVEDETECT_ABNORMAL_WORKTIME, "Move detect is abnormal(Work time).");
			}
		}
		m_moveHoldTimes++;
	}
	else if (!DetectBit(btInput, MOVESENSOR)) {
		if (m_bMoveFlag) {
			m_bMoveFlag = false;
			m_moveHoldTimes = 0;
			LogEvent(Severity_Middle, LOG_EVT_MOVESENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(20), __LINE__));
		}
		else if (m_moveDisappearTimes != 0 && (m_moveDisappearTimes % (REPEAT_FIRE_TIMEOUT_VALUE / ON_EVENT_DETECT_TIMOUE_MILLSECS)) == 0) {
			LogEvent(Severity_Middle, LOG_EVT_MOVESENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(20), __LINE__));
		}
		m_moveDisappearTimes++;
	}
	/*卡嘴异物检测*/
	if (DetectBit(btInput, CARDGATESENSOR) && !m_bCardGateFlag) {
		m_bCardGateFlag = true;
		LogEvent(Severity_Middle, LOG_EVT_CARDGATESENSOR, CSimpleStringA::Format("%s [Active] line: %d", GetDriverPortString(21), __LINE__));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_CardMouseJam)("[GPIO] The card mouse is jam");
	}
	else if (!DetectBit(btInput, CARDGATESENSOR) && m_bCardGateFlag) {
		LogEvent(Severity_Middle, LOG_EVT_CARDGATESENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(21), __LINE__));
		m_bCardGateFlag = false;
	}

	GetEntityBase()->GetFunction()->ResetTimer(pGci->timerID, ON_EVENT_DETECT_TIMOUE_MILLSECS);
}