PhysicalDevice/DME/NormalDME/DIOS.Dev.DME.NormalDME/DIOS.Dev.DME.NormalDME.h

#pragma once


#include "DIOS.Dev.DME.Mould.hpp"

#include "IODeviceWithSCF.tlh"
#include "IODeviceWithSCF.tli"

#include "DIOS.Dev.MSGMould.hpp"
#include "DIOS.Dev.IODevice.Detail.hpp"
#include "DeliverModule.h"
#include <queue>
#include <thread> // ÓÃÓÚ std::this_thread::sleep_for
#include <chrono> // ÓÃÓÚ std::chrono::milliseconds

#ifdef DIOSDMENormalDME_EXPORTS
#define _DIOSDMENormalDME_API __declspec(dllexport)
#else
#define _DIOSDEVDMEDEMO_API __declspec(dllimport) DME
#endif


namespace DIOS::Dev::Detail::DME
{
	static const int TIMEOUTVALUE = 100;

	typedef struct tagNormalDMECommand
	{
		UINT8 nFrameHeader1;
		UINT8 nFrameHeader2;
		UINT8 nCommand;
		UINT8 nData;
		UINT8 nCheckSum;
		UINT8 nEndFlag;
	}NormalDMECOMMAND;
	//-----------------------------------------------------------------------------
	//		DMEDevice
	//-----------------------------------------------------------------------------
	namespace nDev = DIOS::Dev;
	class  _DIOSDMENormalDME_API  DMENormalDMEDevice : public IODeviceWithSCF <IODeviceDetail>, public DMEMould
	{
		using super = IODeviceWithSCF <IODeviceDetail>;
		using superGen = DMEMould;

	public:
		DMENormalDMEDevice(std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF, string configfile);
		~DMENormalDMEDevice();

		void Register();

		virtual std::string GetGUID() const override;

		virtual RET_STATUS FetchDistance() override;
		virtual RET_STATUS SetCalibrateValue(int pParams) override;
		virtual RET_STATUS SetMeasurementInterval(int pParams) override;
		virtual RET_STATUS SetStartEndPoints(int pParams) override;
		virtual RET_STATUS SetRange(int pParams) override;
		virtual RET_STATUS SetFrequency(int pParams) override;
		virtual RET_STATUS SetResolution(int pParams) override;
		virtual RET_STATUS SetLaserState(int pParams) override;
		virtual RET_STATUS ShutDown();

		bool isChecksumValid(const char* package, size_t length);
		void SendNextCommand();
		
		void OnCallBack(const char* strPackage, DWORD Length);


		int m_nCalibrateValue;
		int m_nMeasurementInterval;
		int m_nPosition;
		int m_nRange;
		int m_nFrequency;
		int m_nResolution;
		int m_nMeasureSID;
		int m_nMeasureAngle;
	private:
		RET_STATUS  HWSend(const char* strCommand,int length,int nTimeOut = TIMEOUTVALUE);
		RET_STATUS  SetCommand(std::string &str);

		std::unique_ptr<nsDetail::MSGUnit> m_MSGUnit;

		NormalDMECOMMAND m_Command;
		std::queue<std::string> commandQueue; 
		ResDataObject m_DMEConfig;  //driver's config file.

	private:
		void FireNotify(std::string key, std::string context);
	};
}


//-----------------------------------------------------------------------------
//		DMEDriver
//-----------------------------------------------------------------------------

namespace DIOS::Dev::Detail::DME
{
	class  _DIOSDMENormalDME_API  DMENormalDMEDriver : public IODriverWithSCF <DriverMould>
	{
		using super = IODriverWithSCF <DriverMould>;

	public:
		DMENormalDMEDriver();
		virtual ~DMENormalDMEDriver();

	public:

		virtual void Prepare() override;

		virtual bool DATA_ACTION  Connect() override;
		virtual void Disconnect() override;
		virtual bool isConnected() const override;

		virtual void Dequeue(const char* Packet, DWORD Length) override;
		virtual void FireNotify(int code, std::string key, std::string content) override;

		virtual auto CreateDevice(int index)->std::unique_ptr <IODevice> override;

		virtual std::string DriverProbe() override;
		virtual std::string GetResource() override;
		virtual std::string DeviceProbe() override;

	private:
		static PACKET_RET callbackPackageProcess(const char* RecData, DWORD nLength, DWORD& PacketLength);
		DMENormalDMEDevice* m_pDevice{ nullptr };
	};
}