myvtm/Module/mod_sensors/SensorsFSM.h

#ifndef __SENSORS_FSM_H
#define __SENSORS_FSM_H
#pragma once
#include <map>
using namespace std;

#include "SpFSM.h"
#include <InitGuid.h>
#include <SensorsApi.h>
#include <Sensors.h>
#include "Sensors_server_g.h"
#include "GnssClass.h"
using namespace Sensors;

enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_INIT,
	USER_EVT_INIT_FINISHED,
	USER_EVT_WORK_FINISHED,
	USER_EVT_EXIT,
	USER_EVT_GET_DEVINFO,
	USER_EVT_ERROR,
};
enum SensorType
{
	AMBIENT_LIGHT = 0x1,
	GYROMETER_3D = 0x2,
	COMPASS_3D = 0x4,
	INCLINOMETER_3D = 0x8,
	ACCELEROMETER_3D = 0x10,
// 	ORIENTATION,
// 	SIMPLE_DEVICE_ORIENTATION,
// 	CUSTOM,
};

struct SensorValue
{
	double dwData;
	double dwX;
	double dwY;
	double dwZ;
};
typedef ErrorCodeEnum(*lpCreateDevCom)(DeviceBaseClass*& baseObj);
typedef ErrorCodeEnum(*lpReleaseDevCom)(DeviceBaseClass*& pBaseObj);
class MyEvents;
class CSensorsFSM : public FSMImpl<CSensorsFSM>
{
public:
	enum {s0,s1,s2};

	BEGIN_FSM_STATE(CSensorsFSM)
		FSM_STATE_ENTRY(s0,"Init",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"Normal",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"Fail",s2_on_entry,s2_on_exit,s2_on_event)
		END_FSM_STATE()

		BEGIN_FSM_RULE(CSensorsFSM, s0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_INIT_FINISHED, 0)
		FSM_RULE_ENTRY(s0, s2, USER_EVT_INIT_FINISHED, 1)
		END_FSM_RULE()

		CSensorsFSM():m_dwSensorsHave(0),m_testResult(Error_Succeed),m_pLightSensor(NULL)
	,m_lightVar(10),m_gyroVar(10),m_inclineVar(10),m_compassVar(10),m_acceleroVar(10), m_csFWBVendor("")
	, m_pGnssClass(NULL){};
	virtual ~CSensorsFSM() {};

	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	virtual void s0_on_entry();
	virtual void s0_on_exit();
	virtual unsigned int s0_on_event(FSMEvent* e);

	virtual void s1_on_entry();
	virtual void s1_on_exit();
	virtual unsigned int s1_on_event(FSMEvent* e);

	virtual void s2_on_entry();
	virtual void s2_on_exit();
	virtual unsigned int s2_on_event(FSMEvent* e);

	int DoInit();
	int DoWork();
	void OnCheckTimeTimeout();
	//to get
	void GetAmbientLightData();
	void GetGyroMeter3DData();
	void GetCompass3DData();
	void GetInclinoMeter3DData();
	void GetAcceleroMeter3DData();
	void FindSensorDataChange(SensorType eType,double dwValue1,double dwX,double dwY,double dwZ);
	bool Is3DDataChanged(SensorType eType,double dwX,double dwY,double dwZ);

	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);
	HRESULT SetCurrentReportInterval(ISensor* pSensor, ULONG ulNewInterval);
	void DoGetGnss();
private:
	DWORD m_dwSensorsHave;
	int m_lightVar,m_gyroVar,m_inclineVar,m_compassVar,m_acceleroVar;
	ErrorCodeEnum m_testResult;
	ISensorManager *m_pSensorManager;
	CSimpleStringA m_csFWBVendor;
	GnssClass *m_pGnssClass;
	HMODULE m_hVerdorDll;
	lpCreateDevCom CreateDevComponent;
	lpReleaseDevCom ReleaseDevComponent;
	map<SensorType,GUID> m_mapGUID;
	map<SensorType,SensorValue> m_mapLastValue;
	ISensor *m_pLightSensor,*m_pGyroMeter3DSensor,*m_pInclinoMeter3DSensor,*m_pCompass3DSensor,*m_pAcceleroMeter3DSensor;
	ISensorEvents* m_pLightEvents,*m_pGyroMeter3DEvents,*m_pInclinoMeter3DEvents,*m_pCompass3DEvents,*m_pAcceleroMeter3DEvents;
	MyEvents *m_pLightEvtClass,*m_pGyroMeter3DClass,*m_pInclinoMeter3DClass,*m_pCompass3DClass,*m_pAcceleroMeter3DClass;
	GnssInfoStru m_gnssInfo,m_lastGnssInfo;
	ErrorCodeEnum LoadGnssVendorDLL();
	
};
struct DoInitTask : public ITaskSp
{
	CSensorsFSM *pFSM;
	DoInitTask(CSensorsFSM *f):pFSM(f){}
	virtual void Process()
	{
		FSMEvent *pEvt = new FSMEvent(USER_EVT_INIT_FINISHED);
		pEvt->param1 = pFSM->DoInit();
		pFSM->PostEventFIFO(pEvt);
	}
};
struct DoWorkTask : public ITaskSp
{
	CSensorsFSM *pFSM;
	DoWorkTask(CSensorsFSM *f):pFSM(f){}
	virtual void Process()
	{
		FSMEvent *pEvt = new FSMEvent(USER_EVT_WORK_FINISHED);
		pEvt->param1 = pFSM->DoWork();
		pFSM->PostEventFIFO(pEvt);
	}
};
struct DoGetGnssTask : public ITaskSp
{
	CSensorsFSM* pFSM;
	DoGetGnssTask(CSensorsFSM* f) :pFSM(f) {}
	virtual void Process()
	{
		pFSM->DoGetGnss();
	}
};
class MyEvents : public ISensorEvents
{
public:
	//MyEvents(CSensorsFSM *pFSM):m_pFSM(pFSM)
	MyEvents()
	{
		m_mapGUID[AMBIENT_LIGHT] = SENSOR_TYPE_AMBIENT_LIGHT;
		m_mapGUID[GYROMETER_3D] = SENSOR_TYPE_GYROMETER_3D;
		m_mapGUID[COMPASS_3D] = SENSOR_TYPE_COMPASS_3D;
		m_mapGUID[ACCELEROMETER_3D] = SENSOR_TYPE_ACCELEROMETER_3D;
		m_mapGUID[INCLINOMETER_3D] = SENSOR_TYPE_INCLINOMETER_3D;
	}
		STDMETHODIMP QueryInterface(REFIID iid, void** ppv)
	{
		if (ppv == NULL)
		{
			return E_POINTER;
		}
		if (iid == __uuidof(IUnknown))
		{
			*ppv = static_cast<IUnknown*>(this);
		}
		else if (iid == __uuidof(ISensorEvents))
		{
			*ppv = static_cast<ISensorEvents*>(this);
		}
		else
		{
			*ppv = NULL;
			return E_NOINTERFACE;
		}
		AddRef();
		m_count = 0;
		return S_OK;
	}
	STDMETHODIMP_(ULONG) AddRef()
	{
		return InterlockedIncrement(&m_cRef); 
	}
	STDMETHODIMP_(ULONG) Release()
	{
		ULONG count = InterlockedDecrement(&m_cRef);
		if (count == 0)
		{
			delete this;
			return 0;
		}
		return count;
	}
	// ISensorEvents methods.
	STDMETHODIMP OnEvent(ISensor *pSensor,REFGUID eventID,IPortableDeviceValues *pEventData)
	{
		HRESULT hr = S_OK;

		// Handle custom events here.

		return hr;
	}
	STDMETHODIMP OnLeave(REFSENSOR_ID sensorID)
	{
		HRESULT hr = S_OK;

		// Peform any housekeeping tasks for the sensor that is leaving.
		// For example, if you have maintained a reference to the sensor,
		// release it now and set the pointer to NULL.

		return hr;
	}
	STDMETHODIMP OnDataUpdated(ISensor *pSensor,ISensorDataReport *pNewData);
	STDMETHODIMP OnStateChanged(ISensor* pSensor,SensorState state)
	{
		HRESULT hr = S_OK;

		if(NULL == pSensor)
		{
			return E_INVALIDARG;
		}


		if(state == SENSOR_STATE_READY)
		{
			wprintf_s(L"\nTime sensor is now ready.");
		}
		else if(state == SENSOR_STATE_ACCESS_DENIED)
		{
			wprintf_s(L"\nNo permission for the time sensor.\n");
			wprintf_s(L"Enable the sensor in the control panel.\n");
		}


		return hr;
	}
	//on event
	void OnAmbientLightUpdate(ISensor *pSensor,ISensorDataReport *pNewData);
	void OnGyroMeter3DUpdate(ISensor *pSensor,ISensorDataReport *pNewData);
	void OnCompass3DUpdate(ISensor *pSensor,ISensorDataReport *pNewData);
	void OnInclinoMeter3DUpdate(ISensor *pSensor,ISensorDataReport *pNewData);
	void OnAcceleroMeter3DUpdate(ISensor *pSensor,ISensorDataReport *pNewData);

private:
	long m_cRef;
	int m_count;
	//CSensorsFSM *m_pFSM;
	map<SensorType,GUID> m_mapGUID;
};
template<class T>
class TimerOutHelper : public ITimerListener
{
public:
	typedef void (T::*FuncTimer)();

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

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