myvtm/Module/mod_gpio/mod_gpio.h

#ifndef __MOD_GPIO_H
#define __MOD_GPIO_H

#include "modVer.h"
#include "SpBase.h"
#include "GpioClass.h"
#include "Gpio_server_g.h"
#include "EventCode.h"
#include "GetDevInfoHelper.h"
#include "DevFSMCommBase.hpp"
#include "CommEntityUtil.hpp"

using namespace Gpio;
const int GPIO_INIT_COUNT = 3;
typedef ErrorCodeEnum (*lpCreateDevCom)(DeviceBaseClass *&baseObj);
typedef ErrorCodeEnum (*lpReleaseDevCom)(DeviceBaseClass *&pBaseObj);
enum OutputMode{
	OM_POSITIVE_LEVEL,
	OM_NEGATIVE_LEVEL,
	OM_POSITIVE_FLICKER,
	OM_NEGATIVE_FLICKER
};
enum StopMode{
	SM_CALLTRIGGER,
	SM_TIMEOUT,
	SM_CYCLE
};
enum InputMode{
	IM_POSITIVE_PULSE_UP,
	IM_NEGATIVE_PULSE_DOWN,
	IM_POSITIVE_PULSE_BOTH,
	IM_NEGATIVE_PULSE_BOTH,
	IM_POSITIVE_LEVEL,
	IM_NEGATIVE_LEVEL
};
enum PinPort{
	VIBRATIONSENSOR,
	OPENSENSOR,
	PICKUPSENSOR,
	MOVESENSOR,
	CARDGATESENSOR,
};
struct OutDrivingInfo 
{
	ULONG Port;
	int OutputMode;
	int StopMode;
	int SetTime;
	int ResetTime;
	int TimeOut;
};
struct ReceivingInfo 
{
	ULONG Port;
	int InputMode;
	int ContinuousTriggerTime;
};

enum PrintSealType{
	PRINTERSEAL_UNKNOWN = 0,
	PRINTER_LIGHT_GREEN,
	PRINTER_LIGHT_RED,
	PRINTER_LIGHT_OFF,
	PAPER_LIGHT_GREEN,
	PAPER_LIGHT_RED,
	PAPER_LIGHT_OFF
};


enum DevicePinSeq
{
	PIN_CARD_READER_LIGHT,
	PIN_USB_CONTROL_SWITCH,
	PIN_IDCERTIFICATE_LIGHT,
	PIN_PINPAD_LIGHT,
	PIN_HEAD_LIGHT,
	PIN_TROUBLE_LIGHT,
	PIN_CARD_ISSUE_MAINTAIN_LIGHT,
	PIN_USB_CONTROL_LIGHT,
	PIN_CONTACELESS_LIGHT,
	PIN_QR_LIGHT,
	PIN_FINGERPRINT_LIGHT,
	PIN_THERMPRINT_LIGHT,
	PIN_HSPSCANNER_PREVIEW_LIGHT,
	PIN_PRINTERSEAL_GREEN_LIGHT,
	PIN_PAPER_SLOT_GREEN_LIGHT,
	PIN_PAPER_SHORTAGE_RED_LIGHT,
	PIN_PRINTERSEAL_RED_LIGHT = 24,
	PIN_HSPSCANNER_LIGHT
};

class CGpioEntity;

class CGpioServiceSession : public GpioService_ServerSessionBase
{
public:
	CGpioServiceSession(CGpioEntity* pEntity):m_pEntity(pEntity){};
	virtual void Handle_Set(SpOnewayCallContext<GpioService_Set_Info>::Pointer ctx);
	virtual void Handle_GetStatus(SpReqAnsContext<GpioService_GetStatus_Req, GpioService_GetStatus_Ans>::Pointer ctx);
	virtual void Handle_QueryCurrSet(SpReqAnsContext<GpioService_QueryCurrSet_Req, GpioService_QueryCurrSet_Ans>::Pointer ctx);
private:
	CGpioEntity* m_pEntity;
};
struct DevOutputInfo
{
	ULONG dir;
	ULONG output;
};
struct SetContextInfo
{
	SpOnewayCallContext<GpioService_Set_Info>::Pointer ctx;
	ULONG timerID;
	BYTE index;
	ULONG pinSeq;
	int setTime;
	int resetTime;
	int timeout;
};
struct GetContextInfo
{
	int Port;
	SpReqAnsContext<GpioService_GetStatus_Req, GpioService_GetStatus_Ans>::Pointer ctx;
	ULONG timerID;
	ULONG index;
	int CttPhone,CttMove,CttShake,CttSwitch,CttCard;
	int InitCTT;//ContinuousTriggerTime get from configure file
};
class CGpioEntity : public CDevAdptEntityBase, public ILogListener
{
public:
	//0000 0000 0000 0010 0110 1111 1100 0000
	CGpioEntity():m_devEnableStatus(0x1f),m_bPickUpRound(false),m_bVibrationRound(false)
		,m_bOpenRound(false),m_bMoveRound(false),m_bCardGateRound(false),m_bPickUpFlag(false)
		,m_bVibrationFlag(false),m_bOpenFlag(false),m_bMoveFlag(false),m_bCardGateFlag(false)
		, m_pLogListener(NULL), m_bHeadLightFlag(false), m_headlightDevPort(0), m_moveHoldTimes(0)
		, m_moveDisappearTimes(0),m_eMachineType(SP::Module::Comm::RVC_UNKNOWN)
		, m_bNewVersion(FALSE)
	{
		m_timerID = 1;
		currDevStatus.dir = 0x3eFC0;
		//   11 1110 1111 1100 0000
		//currDevStatus.dir = 0x7ffb0;
		memset(m_btOutputStatus,0,MAX_PORT_NUM);
		currDevStatus.output = 0x0;
//		currDir = 0x2007ffff;
		//m_pPIUT = new PositivePulseUpTimer();
	}

#ifdef RVC_OS_LINUX
	unsigned long GetTickCount()
	{
		struct timespec ts;
		clock_gettime(CLOCK_MONOTONIC, &ts);
		return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
	}
#endif

	virtual ~CGpioEntity()
	{
		LOG_FUNCTION();
	}

	virtual const char* GetEntityName()const {return "Gpio";}
	const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		LOG_FUNCTION();
		InitializeVendorLogSwitch();

		ErrorCodeEnum err = Initial();
		if (err == Error_Succeed)
		{
			LOG_TRACE("Gpio open succeeded.");
			GetStatus(PHONEPICKUP,NULL);
			Dbg("subscribelog...");
			GetFunction()->SubscribeLog(m_uuidHealth,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"HealthManager");
			GetFunction()->SubscribeLog(m_uuidPtr,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"Printer");
			GetFunction()->SubscribeLog(m_uuidIDC,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"IDCertificate");
			GetFunction()->SubscribeLog(m_uuidFP, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "FingerPrint");
			GetFunction()->SubscribeLog(m_uuidKB,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"PinPad");
			GetFunction()->SubscribeLog(m_uuidCR,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"CardIssuer");
			GetFunction()->SubscribeLog(m_uuidCA,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"CustomerAware");
			GetFunction()->SubscribeLog(m_uuidCC,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"ContactlessCard");
			GetFunction()->SubscribeLog(m_uuidDD,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"DeviceControl");
			GetFunction()->SubscribeLog(m_uuidCS, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "CardSwiper");
			GetFunction()->SubscribeLog(m_uuidIE, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "IEBrowser");
			GetFunction()->SubscribeLog(m_uuidHSPscanner, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "HSPScanner");
			GetFunction()->SubscribeLog(m_uuidPrinter, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "ThermalPrint");
			GetFunction()->SubscribeLog(m_uuidPrintSeal, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "PrintSeal");
			Dbg("subscribelog ok...");
			pTransactionContext->SendAnswer(Error_Succeed);
		}
		else
		{
			Dbg("gpio open failed(%s).",SpStrError(err));
			pTransactionContext->SendAnswer(Error_Unexpect);
		}
	}

	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		LogEvent(Severity_Middle, LOG_EVT_PICKUP, "pick up");
		Dbg("logevent pick up");

		CSimpleStringA initDriver = "";
		int driverPort;
		ErrorCodeEnum Error;
		CSmartPointer<IEntityFunction> spEntityFunction = GetFunction();
		CSmartPointer<IConfigInfo> spConfig;
		Error = spEntityFunction->OpenConfig(Config_Software, spConfig);
		spConfig->ReadConfigValue("InitDriver","CardReader",initDriver);
		spConfig->ReadConfigValueInt("DriverPort","CardReader",driverPort);
		OutDrivingInfo odi;
		GetOutDrivingModInfo(initDriver,odi);
		bool bSetFlag = true;
		Dbg("read port[%u]",(ULONG)driverPort);
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		LOG_FUNCTION();
		m_hDevHelper.TearDown();
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual CServerSessionBase *OnNewSession(const char* /*pszRemoteEntityName*/, const char * pszClass)
	{
		return new CGpioServiceSession(this);
	}

	bool SetOutDriving(GpioService_Set_Info req,OutDrivingInfo od, ULONG iIndex,ULONG devSeq);

	bool GetReceiving(int deviceSeq,ReceivingInfo ri, ULONG iIndex, SpReqAnsContext<GpioService_GetStatus_Req, GpioService_GetStatus_Ans>::Pointer ctx);

	DevOutputInfo GetCurrDevStatus()const {return currDevStatus;}

	void SaveCurrDevStatus(DevOutputInfo devOutputInfo) {currDevStatus = devOutputInfo;}

	ULONG GetDevEnableStatus(){return m_devEnableStatus;}

	void SetDevEnableStatus(ULONG devEnableStatus){m_devEnableStatus = devEnableStatus;}

	ULONG GetNewTimerID(){return m_timerID++;}

	BYTE GetOutputStatus(int sn=0);

	virtual bool IsService()const{return true;}
	virtual bool IsMultiThread()const{return false;}
	ErrorCodeEnum Initial();
	void OnOutputPositiveLevelTimerout(void *pData);
	void OnPositiveFlickerSetTimerout(void *pData);
	void OnPositiveFlickerResetTimerout(void *pData);
	void OnPositivePulseUpTimerout(void* pData);
	void OnNegativePulseUpTimerout(void* pData);
	void OnPositiveLevelTimerOut(void* pData);
	void OnNegativeLevelTimerOut(void* pData);
	void GetOutDrivingModInfo(CSimpleStringA modName, OutDrivingInfo& odi);
	void GetReceivingModInfo(CSimpleStringA modName, ReceivingInfo& ri);
	void GetStatus(int deviceSeq,SpReqAnsContext<GpioService_GetStatus_Req, GpioService_GetStatus_Ans>::Pointer ctx);
	void Set(GpioService_Set_Info info);
	void WritePin(DWORD dwPinSeq,bool bHighLevel);

	virtual void OnLog(const CAutoArray<CUUID> &SubIDs, const CUUID nLogID,const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
		const DWORD dwSysError,const DWORD dwUserCode,const DWORD dwEntityInstanceID, const WORD wEntityDevelID, 
		const CAutoArray<DWORD> &Param, const char *pszEntityName, const char *pszModuleName,const char *pszMessage);

private:

	HMODULE m_hVerdorDll;
	lpCreateDevCom CreateDevComponent;
	lpReleaseDevCom ReleaseDevComponent;

	DevAdptLibHelper<GpioClass> m_hDevHelper;
	SP::Module::Comm::What m_eMachineType;

	BYTE m_btOutputStatus[MAX_PORT_NUM];
	DWORD m_dwPortNum,m_dwInOutDir;
	BOOL m_bNewVersion;
	CUUID m_uuidHealth,m_uuidPtr,m_uuidCR,m_uuidIDC,m_uuidFP,m_uuidKB,m_uuidCA,m_uuidCC,m_uuidDD,m_uuidCS,m_uuidIE,m_uuidPrinter;
	CUUID m_uuidHSPscanner;
	CUUID m_uuidPrintSeal;
	DevOutputInfo currDevStatus;
	ULONG m_devEnableStatus;
	ULONG m_timerID;
	bool m_bPickUpRound,m_bVibrationRound,m_bOpenRound,m_bMoveRound,m_bCardGateRound;
	bool m_bPickUpFlag,m_bVibrationFlag,m_bOpenFlag,m_bMoveFlag,m_bCardGateFlag;
	bool m_bHeadLightFlag;
	int m_headlightDevPort, m_moveHoldTimes, m_moveDisappearTimes;
	ILogListener *m_pLogListener;
	CSimpleStringA m_csMachineType;

};

template<class T>
class TimerOutHelper : public ITimerListener
{
public:
	typedef void (T::*FuncTimer)(void *pUserdata);

	TimerOutHelper(T *p, FuncTimer pTimerFunc, void *pUserData, bool bDeleteSelf = false) 
		: m_pObject(p), m_pUserData(pUserData), m_pTimer(pTimerFunc), m_bDeleteSelf(bDeleteSelf) {}

	virtual void OnTimeout(DWORD dwTimerID)
	{
		(m_pObject->*m_pTimer)(m_pUserData);
		if (m_bDeleteSelf)
			delete this;
	}
private:
	void *m_pUserData;
	T *m_pObject;
	FuncTimer m_pTimer;
	bool m_bDeleteSelf;
};
#endif //__MOD_GPIO_H