VMI发生器windows原始代码提交

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/CCOS.Dev.CollimatorMoudle.cpp

@@ -0,0 +1,284 @@
+#include "stdafx.h"
+
+#include "CCOS.Dev.CollimatorMoudle.hpp"
+#include "CCOSDICOMInfo.h"
+
+using namespace CCOS::Dev;
+using namespace CCOS::Dev::Detail::Collimator;
+namespace nsColli = CCOS::Dev::Detail::Collimator;
+
+nsColli::CollimatorDevice::CollimatorDevice(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter) :super(EventCenter)
+{
+	m_EventCenter = EventCenter;
+
+	m_nXSize = 0;
+	m_nYSize = 0;
+	m_nFilter = 0;
+	m_nSID = 0;
+	m_nAngle = 0;
+	m_nMode = -1;
+}
+
+nsColli::CollimatorDevice::~CollimatorDevice()
+{
+}
+
+void nsColli::CollimatorDevice::FireNotify(string key, WORD value)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", value);
+	std::string str = szInfo;
+	m_EventCenter->OnNotify(1, key, str);//(int)ATTRACTION_SET 2
+
+}
+
+void nsColli::CollimatorDevice::Register()
+{
+	auto Disp = &Dispatch;
+	Disp->Action.Push("SetCollimatorSize", this, &nsColli::CollimatorDevice::JSSetCollimatorSize);
+	Disp->Get.Push("Mode", this, &nsColli::CollimatorDevice::JSGetCollimatorMode);
+
+}
+
+bool nsColli::CollimatorDevice::Prepare()
+{
+	Register();
+	return true;
+}
+
+std::string nsColli::CollimatorDevice::GetGUID() const
+{
+	return CollimatorUnitType;
+}
+
+
+
+RET_STATUS  CollimatorDevice::JSSetStudyInfo(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+
+	return SetStudyInfo(json);
+}
+
+RET_STATUS  CollimatorDevice::JSSetTechParamsInfo(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+
+	return SetTechParamsInfo(json);
+}
+
+RET_STATUS  CollimatorDevice::JSSetCollimatorSize(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+	WORD xsize, ysize;
+
+	xsize = json[0];
+	ysize = json[1];
+
+	return SetCollimatorSize(xsize, ysize);
+}
+
+RET_STATUS  CollimatorDevice::JSSetCollimatorSID(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+	WORD nParam = json[0];
+
+	return SetCollimatorSID(nParam);
+}
+
+RET_STATUS  CollimatorDevice::JSSetCollimatorFilter(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+	WORD nParam = json[0];
+
+	return SetCollimatorFilter(nParam);
+}
+
+RET_STATUS  CollimatorDevice::JSSetCollimatorAngle(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+	WORD nParam = json[0];
+
+	return SetCollimatorAngle(nParam);
+}
+
+RET_STATUS  CollimatorDevice::JSSetCollimatorMode(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+	WORD nParam = json[0];
+
+	return SetCollimatorMode(nParam);
+}
+
+RET_STATUS  CollimatorDevice::JSSetCollimatorLight(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+	WORD nParam = json[0];
+
+	return SetCollimatorLight(nParam);
+}
+
+
+
+RET_STATUS CollimatorDevice::JSGetCollimatorXSize(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_nXSize);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::JSGetCollimatorYSize(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_nYSize);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::JSGetCollimatorSID(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_nSID);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::JSGetCollimatorFilter(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_nFilter);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::JSGetCollimatorAngle(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_nAngle);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::JSGetCollimatorMode(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_nMode);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS  CollimatorDevice::SetCollimatorSize(WORD xsize, WORD ysize)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS  CollimatorDevice::SetCollimatorSID(WORD sid)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS  CollimatorDevice::SetCollimatorFilter(WORD pParams)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS  CollimatorDevice::SetCollimatorAngle(WORD pParams)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS  CollimatorDevice::SetCollimatorMode(WORD Param)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS  CollimatorDevice::SetCollimatorLight(WORD Param)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS CollimatorDevice::UpdateCollimatorXSize(WORD Param)
+{
+	m_nXSize = Param;
+	FireNotify("XSize", Param);
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::UpdateCollimatorYSize(WORD Param)
+{
+	m_nYSize = Param;
+	FireNotify("YSize", Param);
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::UpdateCollimatorSID(WORD Param)
+{
+	m_nSID = Param;
+	FireNotify("SID", Param);
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::UpdateCollimatorAngle(WORD Param)
+{
+	m_nAngle = Param;
+	FireNotify("Angle", Param);
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::UpdateCollimatorFilter(WORD Param)
+{
+	m_nFilter = Param;
+	FireNotify("Filter", Param);
+	return RET_STATUS::RET_SUCCEED;
+}
+RET_STATUS CollimatorDevice::UpdateCollimatorMode(WORD Param)
+{
+	m_nMode = Param;
+	FireNotify("Mode", Param);
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS CollimatorDevice::SetStudyInfo(ResDataObject & pParam)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS CollimatorDevice::SetTechParamsInfo(ResDataObject & pParam)
+{
+	TECHPARAM_INFO info;
+	info.SetVal(pParam.encode());
+	string strcollimatorwidth = info.m_CollimatorWidth;
+	string strcollimatorheight = info.m_CollimatorHeight;
+	string strcollimatorfilter = info.m_CollimatorFilter;
+	DWORD Width = 0;
+	DWORD Height = 0;
+	DWORD dwFilter = 0;
+
+	if (strcollimatorwidth.find("IN") != string::npos)
+	{
+		Width = (DWORD)(atof(strcollimatorwidth.substr(0, strcollimatorwidth.size() - 2).c_str()) * 2.54);
+	}
+	else
+	{
+		Width = (DWORD)(atoi(strcollimatorwidth.substr(0, strcollimatorwidth.size() - 2).c_str()));
+	}
+	if (strcollimatorheight.find("IN") != string::npos)
+	{
+		Height = (DWORD)(atof(strcollimatorheight.substr(0, strcollimatorheight.size() - 2).c_str()) * 2.54);
+	}
+	else
+	{
+		Height = (DWORD)(atoi(strcollimatorheight.substr(0, strcollimatorheight.size() - 2).c_str()));
+	}
+	if (Width != 0 && Height != 0)
+	{
+		SetCollimatorSize(Width, Height);
+	}
+	dwFilter = (DWORD)atoi(strcollimatorfilter.c_str());
+	if (dwFilter >= 0)
+	{
+		SetCollimatorFilter(dwFilter);
+	}
+	return RET_STATUS::RET_SUCCEED;
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/CCOS.Dev.CollimatorMoudle.hpp

@@ -0,0 +1,76 @@
+#pragma once
+#include <string>
+#include <minwindef.h>
+
+#include "ResDataObject.h"
+
+#include "CCOS.Dev.IODevice.hpp"
+#include "CCOS.Dev.IODevice.Detail.hpp"
+
+
+namespace CCOS::Dev::Detail::Collimator
+{
+	//-----------------------------------------------------------------------------
+	//		Collimator
+	//-----------------------------------------------------------------------------
+	namespace nsDev = CCOS::Dev;
+	static const char* CollimatorUnitType = "{566EC9F1-CE5A-4B31-9D2A-E9E80B4CA0CC}";
+
+	class CollimatorDevice : public IODeviceDetail
+	{
+		using super = IODeviceDetail;
+		WORD m_nXSize;
+		WORD m_nYSize;
+		WORD m_nFilter;
+		WORD m_nSID;
+		WORD m_nAngle;
+		WORD m_nMode;
+
+		void FireNotify(string key, WORD value);
+
+	protected:
+		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;
+
+	public:
+		CollimatorDevice(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
+		~CollimatorDevice();
+		virtual std::string GetGUID() const override;
+		virtual bool Prepare();
+		virtual void Register();
+
+		RET_STATUS JSSetStudyInfo(std::string in, std::string& out);
+		RET_STATUS JSSetTechParamsInfo(std::string in, std::string& out);
+		RET_STATUS JSSetCollimatorSize(std::string in, std::string& out);
+		RET_STATUS JSSetCollimatorSID(std::string in, std::string& out);
+		RET_STATUS JSSetCollimatorFilter(std::string in, std::string& out);
+		RET_STATUS JSSetCollimatorAngle(std::string in, std::string& out);
+		RET_STATUS JSSetCollimatorMode(std::string in, std::string& out);
+		RET_STATUS JSSetCollimatorLight(std::string in, std::string& out);
+
+		RET_STATUS JSGetCollimatorXSize(std::string& out);
+		RET_STATUS JSGetCollimatorYSize(std::string& out);
+		RET_STATUS JSGetCollimatorSID(std::string& out);
+		RET_STATUS JSGetCollimatorFilter(std::string& out);
+		RET_STATUS JSGetCollimatorAngle(std::string& out);
+		RET_STATUS JSGetCollimatorMode(std::string& out);
+		//RET_STATUS JSGetCollimatorLight(std::string& out);
+
+		virtual RET_STATUS SetStudyInfo(ResDataObject& pParam);
+		virtual RET_STATUS SetTechParamsInfo(ResDataObject& pParam);
+
+		virtual RET_STATUS  SetCollimatorSize(WORD xsize, WORD ysize);
+		virtual RET_STATUS  SetCollimatorSID(WORD sid);
+		virtual RET_STATUS  SetCollimatorFilter(WORD pParams);
+		virtual RET_STATUS  SetCollimatorAngle(WORD pParams);
+		virtual RET_STATUS  SetCollimatorMode(WORD pParams);
+		virtual RET_STATUS  SetCollimatorLight(WORD pParams);
+
+		RET_STATUS UpdateCollimatorXSize(WORD Param);
+		RET_STATUS UpdateCollimatorYSize(WORD Param);
+		RET_STATUS UpdateCollimatorSID(WORD Param);
+		RET_STATUS UpdateCollimatorAngle(WORD Param);
+		RET_STATUS UpdateCollimatorFilter(WORD Param);
+		RET_STATUS UpdateCollimatorMode(WORD Param);
+	};
+
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/CCOS.Dev.DapMoudle.cpp

@@ -0,0 +1,95 @@
+#include "stdafx.h"
+
+#include "CCOS.Dev.DapMoudle.hpp"
+#include "CCOSDICOMInfo.h"
+
+using namespace CCOS::Dev;
+using namespace CCOS::Dev::Detail::DAP;
+namespace nsDAP = CCOS::Dev::Detail::DAP;
+
+nsDAP::DapDevice::DapDevice(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter) :super(EventCenter)
+{
+	m_EventCenter = EventCenter;
+
+	//m_nXSize = 0;
+	//m_nYSize = 0;
+	//m_nFilter = 0;
+	//m_nSID = 0;
+	//m_nAngle = 0;
+	//m_nMode = -1;
+	m_fDAP = 0;
+}
+
+nsDAP::DapDevice::~DapDevice()
+{
+}
+
+void nsDAP::DapDevice::FireNotify(string key, WORD value)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", value);
+	std::string str = szInfo;
+	m_EventCenter->OnNotify(1, key, str);//(int)ATTRACTION_SET 2
+
+}
+
+void nsDAP::DapDevice::Register()
+{
+	auto Disp = &Dispatch;
+	Disp->Action.Push("Clear_DAP", this, &nsDAP::DapDevice::JSClearDAP);
+	Disp->Action.Push("Query_DAP", this, &nsDAP::DapDevice::JSQueryDAP);
+	Disp->Get.Push("DAP", this, &nsDAP::DapDevice::JSGetDAP);
+
+}
+
+bool nsDAP::DapDevice::Prepare()
+{
+	Register();
+	return true;
+}
+
+std::string nsDAP::DapDevice::GetGUID() const
+{
+	return DapUnitType;
+}
+
+
+RET_STATUS  DapDevice::JSClearDAP(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+
+	return ClearDAP(json);
+}
+RET_STATUS  DapDevice::JSQueryDAP(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+
+	return QueryDAP(json);
+}
+RET_STATUS  DapDevice::JSGetDAP(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%f", m_fDAP);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS DapDevice::ClearDAP(ResDataObject& pParam)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS DapDevice::QueryDAP(ResDataObject& pParam)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+
+void DapDevice::UpdateMammo_DAP(float Value)
+{
+	 m_fDAP = Value;
+	FireNotify("DAP", Value);
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/CCOS.Dev.DapMoudle.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <string>
+#include <minwindef.h>
+#include "ResDataObject.h"
+#include "CCOS.Dev.IODevice.hpp"
+#include "CCOS.Dev.IODevice.Detail.hpp"
+
+namespace CCOS::Dev::Detail::DAP
+{
+	//-----------------------------------------------------------------------------
+	//		Dap
+	//-----------------------------------------------------------------------------
+	namespace nsDev = CCOS::Dev;
+	static const char* DapUnitType = "{DFCB1BE5-C0D7-411B-8DF3-57EA097923CB}";
+
+	class DapDevice : public IODeviceDetail
+	{
+		using super = IODeviceDetail;
+		float m_fDAP;
+		void FireNotify(string key, WORD value);
+
+	protected:
+		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;
+
+	public:
+		DapDevice(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
+		~DapDevice();
+		virtual std::string GetGUID() const override;
+		virtual bool Prepare();
+		virtual void Register();
+
+		RET_STATUS JSClearDAP(std::string in, std::string& out);
+		RET_STATUS JSQueryDAP(std::string in, std::string& out);
+		RET_STATUS JSGetDAP(std::string& out);
+
+		virtual RET_STATUS ClearDAP(ResDataObject& pParam);
+		virtual RET_STATUS QueryDAP(ResDataObject& pParam);
+
+		void UpdateMammo_DAP(float Value);
+
+	};
+
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/CCOS.Dev.Generator.VMIMAMMO.cpp

@@ -0,0 +1,2017 @@
+
+// CCOS.Dev.GEN.VMIMAMMO.cpp : 定义 DLL 应用程序的导出函数。
+//
+//所有jk++的地方，都是不确定，或者需修改的
+
+#include "stdafx.h"
+
+#include <assert.h>
+
+#include <functional>
+using namespace std::placeholders;
+
+//#include "logger.temp.h"
+#include "CCOS.Dev.Generator.VMIMAMMO.h"
+#include "Helper.JSON.hpp"
+
+using namespace CCOS::Dev::Detail::Generator;
+namespace nsGEN = CCOS::Dev::Detail::Generator;
+
+#pragma warning (disable:4244) 
+#pragma warning (disable:4305) 
+#pragma warning (disable:4267) 
+
+
+static const int msTimeOut_Lock = 500;
+
+
+#ifdef _WIN64
+#ifdef _DEBUG
+static const auto COM_SCFDllName = "Ccos.Dev.SerialSCFX64D.dll";
+#else
+static const auto COM_SCFDllName = "Ccos.Dev.SerialSCFX64.dll";
+#endif
+#endif
+
+#ifdef _WIN64
+#ifdef _DEBUG
+static const auto TCP_SCFDllName = "Ccos.Dev.TcpipSCFX64D.dll";
+#else
+static const auto TCP_SCFDllName = "Ccos.Dev.TcpipSCFX64.dll";
+#endif
+#endif
+
+
+//-----------------------------------------------------------------------------
+//		VMIMAMMODevice
+//-----------------------------------------------------------------------------
+
+float g_MA_List[] = { 8, 10, 12.5, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640 };
+float g_MAS_List[] = { 1, 1.25, 1.6, 2, 2.5, 3.2, 4, 5, 6.4, 8, 10, 12.5, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000 };
+float g_MS_List[] = { 1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400, 8000, 10000 };
+
+int g_AECFIELD_List[] = { 1, 10, 100, 11, 101, 111 };
+
+std::vector <float> gf_MA_List = { 8, 10, 12.5, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640 };
+
+
+string GetProcessDirectory()
+{
+	string ret = "";
+	char szFilename[MAX_PATH] = { 0 };
+	DWORD res = GetModuleFileNameA(0, szFilename, MAX_PATH);
+	if (res == 0)
+	{
+		return ret;
+	}
+
+	string fullpath = szFilename;
+	string::size_type firstHit = fullpath.find_last_of('\\');
+	if (firstHit == string::npos || firstHit == 0)
+	{
+		return ret;
+	}
+
+	ret = fullpath.substr(0, firstHit);//kick last \
+
+	return ret;
+}
+
+nsGEN::VMIMAMMODevice::VMIMAMMODevice(std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF) : super(center, SCF)
+{
+	assert(EventCenter);
+
+
+	//CreateLogger("VMIMAMMO");
+	FINFO("VMIMAMMO ver 3.0.0.18");
+	m_DoseUnit.m_KV.reset(new KVMould(0.0, 20.0, 49.0, 1.0));
+	m_DoseUnit.m_MA.reset(new MAMould(0.0, 1.0, 1000.0, 0.1));
+	m_DoseUnit.m_MS.reset(new MSMould(0.0, 1.0, 10000.0, 0.01));
+	m_DoseUnit.m_MAS.reset(new MASMould(0.0, 0.1, 1000.0, 0.01));
+	m_DoseUnit.m_Techmode.reset(new TECHMODEMould(1, 0, 11, 1));
+	m_DoseUnit.m_WS.reset(new WORKSTATIONMould(1, 0, 5, 1));
+	m_DoseUnit.m_Focus.reset(new FOCUSMould(1, 0, 1, 1));
+	m_DoseUnit.m_AECField.reset(new AECFIELDMould(0, 0, 111, 1));
+	m_DoseUnit.m_AECFilm.reset(new AECFILMMould(0, 0, 2, 1));
+	m_DoseUnit.m_AECDensity.reset(new AECDENSITYMould(0, -4, 4, 1));
+	m_DoseUnit.m_HE.reset(new TUBEHEATMould(0, 0, 100, 1));
+	m_DoseUnit.m_PostKV.reset(new POSTKVMould(0.0, 20.0, 49.0, 1.0));
+	m_DoseUnit.m_PostMA.reset(new POSTMAMould(0.0, 1.0, 1000.0, 0.1));
+	m_DoseUnit.m_PostMS.reset(new POSTMSMould(0.0, 1.0, 10000.0, 0.01));
+	m_DoseUnit.m_PostMAS.reset(new POSTMASMould(0.0, 0.1, 1000.0, 0.01));
+	
+	m_DoseUnit.m_GenSynState.reset(new GENSYNSTATEMould(0, AttrKey::GENERATOR_SYNC_ERR, AttrKey::GENERATOR_SYNC_MAX, 1));
+	m_DoseUnit.m_GenState.reset(new GENSTATEMould(4, AttrKey::GENERATOR_STATUS_SHUTDOWN, AttrKey::GENERATOR_STATUS_MAX, 1));
+	m_DoseUnit.m_GenTotalExpNumber.reset(new TOTALEXPNUMMould(0, 0, 9999, 1));
+	m_DoseUnit.m_GenTotalAcqTimes.reset(new TOTALACQTIMESMould(0, 0, 9999, 1));
+	m_DoseUnit.m_GenTubeCoolWaitTimes.reset(new TUBECOOLTIMEMould(0, 0, 9999, 1));
+	m_DoseUnit.m_GenTubeOverLoadNumber.reset(new TUBEOVERLOADNUMMould(0, 0, 9999, 1));
+	m_DoseUnit.m_GenCurrentExpNumber.reset(new CUREXPNUMMould(0, 0, 9999, 1));
+
+	m_DoseUnit.m_FrameRate.reset(new FRAMERATEMould(0.0, 0.0, 16.0, 1.0));
+	m_DoseUnit.m_ExpMode.reset(new EXPMODEMould(nsGEN::AttrKey::EXPMODE_TYPE::Single));
+	m_DoseUnit.m_FLMode.reset(new FLUModeMould(nsGEN::AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_NOTFLU));
+	m_DoseUnit.m_EXAMMode.reset(new EXAMMODEMould(AttrKey::EXAMMODE_TYPE::MANUAL));
+
+	m_DoseUnit.m_TubeTargetMaterial.reset(new TUBETARGETMATERIALMould(AttrKey::TUBETARGETMATERIAL_TYPE::MO));
+	m_DoseUnit.m_TubeAngle.reset(new TUBEANGLEMould(0,0,360,1));
+
+
+	m_MSGUnit.reset(new nsDetail::MSGUnit(center, nsGEN::GeneratorUnitType));
+	m_DAP.reset(new DevDAP::DOSEMould(0.0, 0.0, 1000.0, 0.01));
+	m_hGenPostEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	m_pHardwareStatusThread = NULL;
+	m_SettingExamMode = AttrKey::EXAMMODE_TYPE::MANUAL; //default is Manual
+	OnCallBack();
+
+	Register();
+
+	Reset();
+
+	HWSend("RR?");
+		
+	m_bRREnable = true;
+	m_strPreWKStatus = "WK0";
+	//启动定时器，定时查询
+	StartHardwareStatusThread();
+}
+
+nsGEN::VMIMAMMODevice::~VMIMAMMODevice()
+{
+	CloseHandle(m_hGenPostEvent);
+}
+
+std::string nsGEN::VMIMAMMODevice::GetGUID() const
+{	
+	FINFO("\n===============GetGUID : {$} ===================\n", GeneratorUnitType);
+	return GeneratorUnitType;
+}
+
+void nsGEN::VMIMAMMODevice::Register()
+{
+	auto Disp = &Dispatch;
+
+	superGen::Register(Disp);
+	superGen::RegisterRAD(Disp);
+	superGen::RegisterAEC(Disp);
+	superGen::RegisterExpEnable(Disp);
+	superGen::RegisterGeneratortoSyncStatus(Disp);
+
+	Disp->Get.Push(m_MSGUnit->GetKey().c_str(), [this](std::string& out) { out = m_MSGUnit->JSGet(); return RET_STATUS::RET_SUCCEED; });
+
+	auto fun_Clear_DAP = [this](auto a, auto&)
+	{
+		return Clear_DAP();
+	};
+	Disp->Action.Push("Clear_DAP", fun_Clear_DAP);
+	auto fun_GetValue_DAP = [this](auto a, auto& b)
+	{
+		float value = 0;
+		RET_STATUS ret = GetValue_DAP(value);
+		b = ToJSON(value);
+		return ret;
+	};
+	Disp->Action.Push("GetValue_DAP", fun_GetValue_DAP);
+
+	auto fun_StartMove = [this](auto a,auto& b)
+	{
+		return StartMove();
+	};
+	Disp->Action.Push("StartMove", fun_StartMove);
+
+	auto fun_EndMove = [this](auto a, auto& b)
+	{
+		return EndMove();
+	};
+	Disp->Action.Push("EndMove", fun_EndMove);
+
+
+	auto fun_EnterExam = [this](auto a, auto& b)
+	{
+		return EnterExam();
+	};
+	Disp->Action.Push("EnterExam", fun_EnterExam);
+
+	auto fun_ExitExam = [this](auto a, auto& b)
+	{		
+		return ExitExam();
+	};
+	Disp->Action.Push("ExitExam", fun_ExitExam);
+
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::IncKV()
+{
+	if (!m_DoseUnit.m_KV->CanInc())  return RET_STATUS::RET_SUCCEED;
+	return HWSend("IV01");
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::DecKV()
+{
+	if (!m_DoseUnit.m_KV->CanDec())  return RET_STATUS::RET_SUCCEED;
+	return HWSend("DV01");
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetKV(float value)
+{
+	if (!m_DoseUnit.m_KV->Verify(value))  return RET_STATUS::RET_SUCCEED;
+	char temp[50] = { 0 };
+	sprintf_s(temp, "KV%03d", (int)value);
+	return HWSend(temp);
+
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::IncMA()
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::DecMA()
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetMA(float value)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::IncMS()
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::DecMS()
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetMS(float value)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::IncMAS()
+{
+	if (!m_DoseUnit.m_MAS->CanInc()) return RET_STATUS::RET_SUCCEED;
+	
+	return HWSend("IS01");
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::DecMAS()
+{
+	if (!m_DoseUnit.m_MAS->CanDec())  return RET_STATUS::RET_SUCCEED;
+	return HWSend("DS01");
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetMAS(float value)
+{
+	if (!m_DoseUnit.m_MAS->Verify(value))  return RET_STATUS::RET_SUCCEED;
+
+	char temp[50] = { 0 };
+	sprintf_s(temp, "MX%03d", (int)(value * 10));
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetTechmode(int value)
+{
+	FINFO("\n SetTechmode = {$}\n", value);
+
+	if (!m_DoseUnit.m_Techmode->Verify(value))  return RET_STATUS::RET_SUCCEED;
+
+	return RET_STATUS::RET_SUCCEED;
+
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetFocus(int value)
+{
+	if (!m_DoseUnit.m_Focus->Verify(value)) return RET_STATUS::RET_SUCCEED;
+
+	char temp[50] = { 0 };
+	sprintf_s(temp, "FO%01d", (int)value);
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetAECDensity(int value)
+{
+	return RET_STATUS::RET_SUCCEED;//jk++
+
+	if (!m_DoseUnit.m_AECDensity->Verify(value))  return RET_STATUS::RET_SUCCEED;
+
+	if (m_DoseUnit.m_Techmode->Get() != AttrKey::TECHMODE_V2TYPE::ET_AEC)
+		return RET_STATUS::RET_FAILED;
+
+	char temp[50] = { 0 };		
+	sprintf_s(temp, "AD%02d", (int)value);	
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetAECField(int value)
+{
+	return RET_STATUS::RET_SUCCEED;//jk++
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetAECFilm(int value)
+{
+	return RET_STATUS::RET_SUCCEED;//jk++
+}
+
+RET_STATUS  nsGEN::VMIMAMMODevice::SetWS(const string value)
+{
+	return RET_STATUS::RET_SUCCEED;//jk++
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetAPR(const _tAPRArgs& t)
+{
+	m_t = t;
+	m_DoseUnit.m_KV->Update(m_t.fKV);
+	m_DoseUnit.m_MAS->Update(m_t.fMAS);
+	m_DoseUnit.m_Focus->Update(m_t.nFocus);
+
+	FINFO("Enter SetAPR,do nothing");
+	
+	FINFO("t.fKV={$},t.fMA={$},t.fMAS={$},t.nAECDensity={$},t.nAECField={$},t.nAECFilm={$},t.nFocus={$},t.nTechmode={$}", t.fKV, t.fMA, t.fMAS, t.nAECDensity, t.nAECField, t.nAECFilm, t.nFocus, t.nTechmode);
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::QueryHE(int& value)
+{
+	value = m_DoseUnit.m_HE->Get();
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::QueryPostKV(float& value)
+{	
+	value = m_DoseUnit.m_KV->Get();
+	FINFO("jk++:QueryPostKV= {$}",value);
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::QueryPostMA(float& value)
+{
+	value = m_DoseUnit.m_PostMA->Get();  //postMA默认是0.上层查询时，就取0.
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::QueryPostMS(float& value)
+{
+	value = m_DoseUnit.m_PostMS->Get();
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::QueryPostMAS(float& value)
+{
+	value = m_DoseUnit.m_PostMAS->Get();
+	FINFO("jk++:QueryPostMAS= {$}", value);
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::QueryDAP()
+{
+	FINFO("jk++:QueryDAP");
+	return HWSend("AG?");
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::Clear_DAP()
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::GetValue_DAP(float& value)
+{
+	value = m_DAP->Get();
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::StartMove()
+{
+	FINFO("Enter startMove do nothing");
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::EndMove()
+{
+	FINFO("Enter endmove do nothing");
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::EnterExam()
+{
+	HWSend("EXB1");
+	return RET_STATUS::RET_SUCCEED;
+}
+/*有的时候，exitexam并不会执行*/
+RET_STATUS nsGEN::VMIMAMMODevice::ExitExam()
+{
+	HWSend("EXB0");
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetGenSynState(int value)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetGenState(int value)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetExpMode(std::string value)
+{	
+	FINFO("Enter SetExpMode:{$},m_strPreWKStatus={$}",value, m_strPreWKStatus.c_str());
+	m_DoseUnit.m_ExpMode->Update(value);
+		
+	if (m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::TOMO)
+	{
+		if (m_strPreWKStatus != "WK1")
+		{
+			HWSend("WK1");
+		}
+	}
+	else
+	{
+		if (m_strPreWKStatus != "WK0")
+		{
+			HWSend("WK0");
+		}
+	}
+
+	//必发,有点多余，但是可以防止设置WK返回错误ET值的问题
+	if (m_SettingExamMode != m_DoseUnit.m_EXAMMode->JSGet())
+	{
+		FINFO("m_SettingExamMode={$}, m_DoseUnit.m_EXAMMode->JSGet()={$}", m_SettingExamMode, m_DoseUnit.m_EXAMMode->JSGet().c_str());
+		if (m_SettingExamMode == AttrKey::EXAMMODE_TYPE::MANUAL)
+		{
+			HWSend("ET2");
+		}
+		else if (m_SettingExamMode == AttrKey::EXAMMODE_TYPE::SEMIAUTO)
+		{
+			HWSend("ET1");
+		}
+		else if (m_SettingExamMode == AttrKey::EXAMMODE_TYPE::AUTOMATIC)
+		{
+			HWSend("ET0");
+		}
+	}
+
+	//SetKV(m_DoseUnit.m_KV->Get());
+	//SetMAS(m_DoseUnit.m_MAS->Get());
+	//SetFocus(m_DoseUnit.m_Focus->Get());
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetFLFMode(std::string value)
+{	
+	return RET_STATUS::RET_SUCCEED;
+}
+
+/*由于发送WK指令，偶尔会返回错误的ET值，故在setexpmode中，发送WK的时候，主动发送ET2，后续不能固定，
+需要再SetEXAMMode中，记录上层传入的exammode，然后在setexpmode中，再次设定。
+需要确认，当手动切换至auto或semi时，退出，重进检查，此时exammode会不会冲突。
+*/
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetEXAMMode(std::string value)
+{
+	//上层给我设置exam mode。（manual semi  atuo）对应（2 1 0）,
+	FINFO("\nEnter setexammode func value = {$}\n", value);
+	m_SettingExamMode = value;
+	if (value == AttrKey::EXAMMODE_TYPE::MANUAL)
+	{
+		HWSend("ET2");
+	}
+	else if (value == AttrKey::EXAMMODE_TYPE::SEMIAUTO)
+	{
+		HWSend("ET1");
+	}
+	else if (value == AttrKey::EXAMMODE_TYPE::AUTOMATIC)
+	{
+		HWSend("ET0");
+	}
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetFrameRate(FLOAT frameRate)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetRPS(int rps)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::RefreshData()
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetExpEnable()
+{	
+	return HWSend("EXB1");
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetExpDisable()
+{
+	return HWSend("EXB0");
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::Reset()
+{
+	return HWSend("RE");
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetFilter(int nFilterType)
+{
+	char temp[50]{ 0 };
+	switch (nFilterType)
+	{
+	case 0:
+	case 4:
+		HWSend("FT0");
+		break;
+	case 1:
+	case 5:
+		HWSend("FT1");
+		break;
+	case 2:
+		HWSend("FT2");
+		break;
+	default:
+		break;
+	}
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetMammoDensity(int unMDensity)
+{
+	char temp[50]{ 0 };
+	sprintf_s(temp, "DE%01d", unMDensity);
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetCollimatorDev(OemCollimator* dev)
+{
+	if (dev)
+		m_pCollDev.reset(dev);
+	
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetMechDev(OemMechanical* dev)
+{
+	if (dev)
+		m_pMechDev.reset(dev);
+	
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetDapDev(OemDap* dev)
+{
+	if(dev) 
+		m_pDapDev.reset(dev);
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::HWSend(char* strCommand, int nTimeOut)
+{
+	if (!m_SCF)  return RET_STATUS::RET_FAILED;
+
+	unsigned char strSendCommand[100] = { 0 };
+	int len = strlen(strCommand);
+
+	int tmpSum = 0;
+	for (int i = 0; i < len; i++)
+	{
+		tmpSum += (int)strCommand[i];
+	}
+	unsigned char checkSum = unsigned char(tmpSum + 3);
+		
+	memcpy(strSendCommand, strCommand, len);
+	strSendCommand[len] = 0x03;
+	strSendCommand[len + 1] = checkSum;
+
+	FINFO("==OUT==: {$} \n", strSendCommand);
+
+	int retLength;
+	m_SCF.Lock(msTimeOut_Lock)
+		.SendPacket((char*)strSendCommand, strlen((char*)strSendCommand), nTimeOut, retLength);
+	Sleep(nTimeOut);
+	
+	return RET_STATUS::RET_SUCCEED;
+}
+
+//-----------------------------------------------------------------------------
+//		ProcessCmd
+//-----------------------------------------------------------------------------
+
+void nsGEN::VMIMAMMODevice::FireNotify(std::string key, std::string content)
+{
+	EventCenter->OnNotify(1, key, content);
+}
+
+struct tFrameMapping
+{
+	static const int MaxLen = 5;
+	using cbFun = std::function <void(const char*, int)>;
+
+	char strHead[MaxLen];
+	int NbOfCharOfHead;
+	cbFun fun;
+
+	tFrameMapping(char* str, int len, cbFun f)
+	{
+		assert(len < MaxLen);
+		for (int i = 0; i < len; i++)
+			strHead[i] = str[i];
+		NbOfCharOfHead = len;
+		fun = f;
+	}
+
+};
+
+static std::list <tFrameMapping> arFrame;
+
+static bool DecodeFrame(const char* strFrame, int length);
+
+void nsGEN::VMIMAMMODevice::OnCallBack()
+{
+	auto HWNotProcess = [](const char* value, int length) -> void
+	{
+		FINFO("\n This commands didn't need to process!\n");
+	};
+
+	auto HWKV = [this](const char* value, int length) -> void
+	{
+		FINFO("\n recv KV={$},m_DoseUnit.m_KV={$}\n", atoi(value), m_DoseUnit.m_KV->JSGet().c_str());		
+		if(m_DoseUnit.m_KV->Update(atof(value)))
+			
+			
+		FireNotify(AttrKey::KV, m_DoseUnit.m_KV->JSGet());
+		
+	};
+
+	auto HWMAS = [this](const char* value, int length)
+	{
+		assert(value);
+		float fmas = atof(value) / 10.0;
+	
+		if (m_DoseUnit.m_MAS->Update(fmas))		
+		FireNotify(AttrKey::MAS, m_DoseUnit.m_MAS->JSGet());		//无论mas是否更新，都主动notify。
+ 
+
+	};
+
+	auto HWMA = [this](const char* value, int length)
+	{
+		assert(value);
+		float fma = atof(value) / 100.0;
+		if (m_DoseUnit.m_MA->Update(fma))
+			FireNotify(AttrKey::MA, m_DoseUnit.m_MA->JSGet());
+	};
+
+	auto HWMS = [this](const char* value, int length)
+	{
+		assert(value);
+		if (m_DoseUnit.m_MS->Update(atof(value) / 100.0))
+			FireNotify(AttrKey::MS, m_DoseUnit.m_MS->JSGet());
+	};
+	auto HWFocus = [this](const char* value, int length)
+	{
+		assert(value);
+		if (m_DoseUnit.m_Focus->Update(atoi(value)))
+			FireNotify(AttrKey::FOCUS, m_DoseUnit.m_Focus->JSGet());
+
+	};
+	auto HWTechmode = [this](const char* value, int length)
+	{
+		assert(value);
+		std::string strCurrentET = AttrKey::EXAMMODE_TYPE::MANUAL;
+		if (2 == atoi(value))
+		{
+			strCurrentET = AttrKey::EXAMMODE_TYPE::MANUAL;
+		}
+		else if (1 == atoi(value))
+		{
+			strCurrentET = AttrKey::EXAMMODE_TYPE::SEMIAUTO;
+		}
+		else if (0 == atoi(value))
+		{
+			strCurrentET = AttrKey::EXAMMODE_TYPE::AUTOMATIC;
+		}
+		if (m_DoseUnit.m_EXAMMode->Update(strCurrentET))
+			FireNotify(AttrKey::EXAMMODE, m_DoseUnit.m_EXAMMode->JSGet());
+	};
+
+	auto HWAECField = [this](const char* value, int length)
+	{
+		assert(value);
+		int nvalue = atoi(value);
+		if (m_DoseUnit.m_AECField->Update(nvalue))
+			FireNotify(AttrKey::AECFIELD, m_DoseUnit.m_AECField->JSGet());
+	};
+	auto HWAECFilm = [this](const char* value, int length)
+	{
+		assert(value);
+		if (m_DoseUnit.m_AECFilm->Update(atoi(value)))
+			FireNotify(AttrKey::AECFILM, m_DoseUnit.m_AECFilm->JSGet());
+	};
+	auto HWAECDensity = [this](const char* value, int length)
+	{
+		assert(value);
+		if (m_DoseUnit.m_AECDensity->Update(atoi(value)))
+			FireNotify(AttrKey::AECDENSITY, m_DoseUnit.m_AECDensity->JSGet());
+	};
+	auto HWWS = [this](const char* value, int length)
+	{
+		assert(value);
+		int nValue = atoi(value);
+		if (m_DoseUnit.m_WS->Update(nValue))
+		{
+			FireNotify(m_DoseUnit.m_WS->GetKey(), m_DoseUnit.m_WS->JSGet());
+		}
+	};
+	auto HWPR = [this](const char* value, int length)
+	{
+		
+	};
+	auto HWXR = [this](const char* value, int length)
+	{
+		
+	};
+	auto HWAPDOSE = [this](const char* value, int length)//mas
+	{
+		assert(value);
+		if(m_DoseUnit.m_PostMAS->Update(atof(value) / 1000.0))
+			FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());
+
+		float fMS = atof(value) / m_DoseUnit.m_MA->Get();
+
+		if (m_DoseUnit.m_PostMS->Update(fMS))
+			FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());
+
+		FINFO("\n post MAS={$} postMS={$}\n", m_DoseUnit.m_PostMAS->Get(), m_DoseUnit.m_PostMS->Get());
+
+	};
+	auto HWATDOSE = [this](const char* value, int length)
+	{
+		assert(value);
+		if(m_DoseUnit.m_PostMS->Update(atof(value)))
+			FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());
+
+	};
+
+	//note: AG<0000> 并不是dap的意思，是计量的意思
+	auto HWAG = [this](const char* value, int length)
+	{
+		assert(value);
+		if (m_pMechDev)
+		{
+			m_pMechDev->UpdateMammo_AGD(atof(value) / 10000.0);	
+		}
+	};
+	auto HWGS = [this](const char* value, int length)
+	{
+		assert(value);
+		switch (atoi(value))
+		{
+
+		case 0:
+		{
+			if (this->m_bInExposurePeriod)
+			{				
+				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);	//pr0
+				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
+			}
+			this->m_bInExposurePeriod = false;
+		}
+		break;
+		case 1:
+		{
+			if (this->m_bInExposurePeriod)
+			{
+				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);	//pr0
+				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
+				FINFO("\n recv GS1 ,and send  GENERATOR_RAD_OFF out \n");
+			}
+			this->m_bInExposurePeriod = false;					
+			//char ErrorCode[10]{ "" };
+			//sprintf_s(ErrorCode, "VMIMAMMO_GS_%d", 1);
+			//int level = 1;
+			//m_MSGUnit->AddWarnMessage(ErrorCode, level, "");		
+
+		}
+		break;
+		case 2:
+		{
+			if (!this->m_bInExposurePeriod)
+			{
+				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_PREPARE);	//pr1
+				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
+				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_READY);		//pr2
+				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
+
+			}
+			this->m_bInExposurePeriod = true;
+		}
+		break;
+		case 3:
+		{
+			if (this->m_bInExposurePeriod)
+			{
+				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);		//pr0
+				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
+				FINFO("\n recv GS3 ,and send  GENERATOR_RAD_OFF out \n");
+
+			}
+			this->m_bInExposurePeriod = false;
+			//char ErrorCode[100]{ "" };
+			//sprintf_s(ErrorCode, "Generator Blocked VMIMAMMO_GS_%d", 3);			
+			//int level = 1;
+			//m_MSGUnit->AddWarnMessage(ErrorCode, level, "");
+		}
+		break;
+		default:
+			break;
+		}
+	};
+
+
+
+	auto HWST = [this](const char* value, int length)
+	{
+		assert(value);		
+		switch (atoi(value))
+		{
+		case 4:
+		{
+			//读取配置文件，软同步or直连时，
+			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON);	//xr1
+			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
+			this->m_bInExposurePeriod = true;
+
+#if 1
+
+
+			//send post param
+			m_DoseUnit.m_PostMAS->Update(m_DoseUnit.m_MAS->Get());
+			FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());
+			FINFO("\n recv ST4 post MAS={$}\n", m_DoseUnit.m_PostMAS->Get());
+			FINFO("\n recv ST4 m_MAS={$}\n", m_DoseUnit.m_MAS->Get());
+
+			//send post kv
+			m_DoseUnit.m_PostKV->Update(m_DoseUnit.m_KV->Get());
+			FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());
+			FINFO("\n recv ST4 postkv={$},\n", m_DoseUnit.m_PostKV->Get());
+			FINFO("\n recv ST4 kv={$},\n", m_DoseUnit.m_KV->Get());
+#endif // 0
+		}
+		break;
+		case 5:
+		{
+			if (this->m_bInExposurePeriod)
+			{
+				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYOFF);	//xr0
+
+#if 0
+
+
+				//send post param
+				m_DoseUnit.m_PostMAS->Update(m_DoseUnit.m_MAS->Get());				
+				FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());
+				FINFO("\n recv ST5 post MAS={$}\n", m_DoseUnit.m_PostMAS->Get());
+				FINFO("\n recv ST5 m_MAS={$}\n", m_DoseUnit.m_MAS->Get());
+				
+				//send post kv
+				m_DoseUnit.m_PostKV->Update(m_DoseUnit.m_KV->Get());				
+				FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());
+				FINFO("\n recv ST5 postkv={$},\n", m_DoseUnit.m_PostKV->Get());
+				FINFO("\n recv ST5 kv={$},\n", m_DoseUnit.m_KV->Get());
+#endif // 0
+			}
+			this->m_bInExposurePeriod = false;
+		}
+		break;
+		default:
+			break;
+		}
+	};
+
+
+
+	auto HWERROR = [this](const char* value, int length)
+	{
+		assert(value);
+		int nValue = atoi(value);
+		if (nValue != 0)
+		{
+			char ErrorCode[10]{ "" };
+			sprintf_s(ErrorCode, "VMIMAMMO_ERR_%d", nValue);
+			int level = 1;
+			m_MSGUnit->AddErrorMessage(ErrorCode, level, ErrorCode);
+			m_localErrorlist.push_back(ErrorCode);
+		}
+		else
+		{
+			int level = 1;
+			//char ErrorCode[10]{ "" };
+			//m_MSGUnit->DelErrorMessage(ErrorCode, level, "");
+
+			for (auto errorStr : m_localErrorlist)
+			{
+				m_MSGUnit->DelErrorMessage(errorStr.c_str(), level, "");
+				FINFO("clear error =  {$}\n", errorStr);
+			}
+			m_localErrorlist.clear();
+		}
+	};
+	auto HWWARN = [this](const char* value, int length)
+	{
+		assert(value);
+		int nValue = atoi(value);
+		if (nValue != 0)
+		{
+			char WarnCode[100]{ "" };
+			sprintf_s(WarnCode, "VMIMAMMO_WARN_%d", nValue);
+			int level = 1;
+			m_MSGUnit->AddWarnMessage(WarnCode, level, WarnCode);
+			FINFO("\n recv WN? ,and AddWarnMessage \n");
+			m_localWarnlist.push_back(WarnCode);
+		}
+		else
+		{
+			int level = 1;
+			//char WarnCode[100]{ "" };
+			//m_MSGUnit->DelWarnMessage(WarnCode, level, "");
+			FINFO("\n recv WN0 ,and DelWarnMessage \n");
+
+			for (auto warnStr : m_localWarnlist)
+			{
+				m_MSGUnit->DelWarnMessage(warnStr.c_str(), level, "");
+				FINFO("clear warn =  {$}\n", warnStr);
+			}
+			m_localWarnlist.clear();
+		}
+	};
+
+	auto HWRE = [this](const char* value, int length) -> void
+	{
+		assert(value);
+		int nValue = atoi(value);
+		if (nValue == 1) //reset success		
+		{
+			int level = 1;
+			for (auto errorStr : m_localErrorlist)
+			{
+				m_MSGUnit->DelErrorMessage(errorStr.c_str(), level, "");
+				FINFO("clear error =  {$}\n", errorStr);
+			}
+			m_localErrorlist.clear();
+
+			//char WarnCode[10]{ "" };
+			//m_MSGUnit->DelErrorMessage(WarnCode, level, "");
+		}
+	};
+
+
+	auto HWEHE = [this](const char* value, int length)
+	{
+		assert(value);
+		if(m_DoseUnit.m_HE->Update(atoi(value)))
+			FireNotify(m_DoseUnit.m_HE->GetKey(), m_DoseUnit.m_HE->JSGet());
+	};
+
+	//当前认为TGA就是球馆角度
+	auto HWTG = [this](const char* value, int length)
+	{
+		assert(value);
+
+		int tempnum = atoi(value);
+		int nExpIndex = tempnum / 100000;
+		int nSign = (tempnum % 100000) / 10000;
+		int Angle = tempnum % 10000;
+
+		if (nSign == 0)
+		{
+			Angle = Angle * -1;
+		}
+		float fAngle = (float)Angle;
+		m_resultAngle_tmp.clear();
+		char Key[4] = { 0 };
+		sprintf_s(Key, "%d", nExpIndex);
+		m_resultAngle_tmp.add(Key, fAngle / 10.0f);
+		if (m_pMechDev)
+		{			
+			GetTomoResults(m_resultAngle_tmp, m_resultAngle_tmp);
+		}
+
+		if (m_DoseUnit.m_TubeAngle->Update(fAngle/10))
+		{
+			FireNotify(m_DoseUnit.m_TubeAngle->GetKey(), m_DoseUnit.m_TubeAngle->JSGet());
+		}
+
+	};
+
+
+
+	auto HWFS = [this](const char* value, int length) -> void
+	{
+		assert(value);
+		if (length == 8)
+		{
+			int number = atoi(value);			//aaabbb
+			int xsize = number % 1000/10;		//bbb -->转为cm
+			int ysize = number / 1000/10;		//aaa -->转为cm
+			if (m_pCollDev)
+			{
+				m_pCollDev->UpdateCollimatorXSize(xsize);
+				m_pCollDev->UpdateCollimatorYSize(ysize);
+			}
+		}
+	};
+
+	auto HWFY = [this](const char* value, int length) -> void
+	{
+		assert(value);
+		//if (m_pCollDev)	
+		//	m_pCollDev->UpdateCollimatorFilter(atoi(value));
+	};
+
+	auto HWWK = [this](const char* value, int length) -> void
+	{
+		assert(value);
+		if (0 == atoi(value))
+		{
+			m_strPreWKStatus = "WK0";
+		}
+		else if (1 == atoi(value))
+		{
+			m_strPreWKStatus = "WK1";
+		}
+	};
+
+	auto HWMG = [this](const char* value, int length) -> void
+	{
+		assert(value);
+		int temp = atoi(value);
+		float _fMag;
+		if (2 == temp)
+		{
+			_fMag = 1.8f;
+		}
+		else if (1 == temp)
+		{
+			_fMag = 1.5f;
+		}
+		else
+		{
+			_fMag = 1.0f;
+		}
+				
+		if (m_pMechDev)
+		{
+			m_pMechDev->UpdateMammo_MAG(_fMag);
+			FINFO("\n get mag ={$}\n", _fMag);
+		}
+		else
+		{
+			FINFO("\n get mag ={$},but mechdev is null,so not send out.!!!!\n", _fMag);
+		}
+
+	};
+
+	//UpdateMammo_CompressPaddle
+	//关于压迫板信息，gen应该能收到相关信息，解析后，更新 UpdateMammo_CompressPaddle 属性，这样上层可以收到。
+
+	auto HWMT = [this](const char* value, int length)
+	{
+		assert(value);
+		int nValue = atoi(value);
+		int direction = nValue / 1000;
+		float angle = nValue % 1000;
+
+		if (direction == 1)
+		{
+			angle = -1 * angle;
+		}
+
+		if (m_pMechDev)
+			m_pMechDev->UpdateMammo_MechAngle(angle);
+
+	};
+	//原code中，PE 有两个含义。
+	auto HWPE = [this](const char* value, int length) -> void
+	{
+		assert(value);
+		if (m_pMechDev)
+			m_pMechDev->UpdateMammo_PressureState(atoi(value));
+		//GEN_PARAM_MAMMO_MAMMMECHNICALHEIGH
+		if (m_pMechDev)
+			m_pMechDev->UpdateMammo_MechHeight(atof(value));
+	};
+	auto HWPF = [this](const char* value, int length) -> void
+	{
+		assert(value);		
+		if (m_pMechDev)
+			m_pMechDev->UpdateMammo_PressureValue(atof(value));
+
+	};
+	auto HWFT = [this](const char* value, int length) -> void
+	{
+		assert(value);		
+		if (m_pMechDev)
+		{
+			/*补充一项对应关系：（0--4，收到FT0，转为4，发给上层。），（1--5），（2--2，不变 发给上层）*/
+			int nFilterType = atoi(value);
+			if (0 == nFilterType)
+			{
+				m_pMechDev->UpdateMammo_FT(4);						
+			}
+			else if (1 == nFilterType)
+			{
+				m_pMechDev->UpdateMammo_FT(5);
+			}
+			else if (2 == nFilterType)
+			{
+				m_pMechDev->UpdateMammo_FT(5);
+			}
+		}
+
+		if (m_pCollDev)
+		{
+			/*补充一项对应关系：（0--4，收到FT0，转为4，发给上层。），（1--5），（2--2 不变， 发给上层）*/
+			int nFilterType = atoi(value);
+			if (0 == nFilterType)
+			{
+				m_pCollDev->UpdateCollimatorFilter(4);
+			}
+			else if (1 == nFilterType)
+			{
+				m_pCollDev->UpdateCollimatorFilter(5);
+			}
+			else if (2 == nFilterType)
+			{
+				m_pCollDev->UpdateCollimatorFilter(5);
+			}
+		}
+
+
+
+	};
+
+	auto HWGR = [this](const char* value, int length) -> void
+	{
+		assert(value);
+		if (m_pMechDev)
+			m_pMechDev->UpdateGrid(atoi(value));
+
+	};
+
+	auto HWDF = [this](const char* value, int length) -> void
+	{
+		assert(value);
+		
+		if (m_pMechDev)
+			m_pMechDev->UpdateMammo_Depress(atoi(value));
+
+	};
+
+
+
+
+
+	//	有部分前缀是包含关系, 长的包含短的, 例如 KVS 包含了 KV.
+	//	因此长的在前面, 短的在后面
+	//	!!! Device 是个短寿命对象, 而 arFrame 是静态变量 !!!
+	//	!!! 因此, 在添加到 arFrame 之前, 务必先清零 !!!
+	arFrame.clear();
+
+	arFrame.push_back(tFrameMapping("WK", 2, HWWK));
+	arFrame.push_back(tFrameMapping("KV", 2, HWKV));
+	arFrame.push_back(tFrameMapping("MX", 2, HWMAS));
+	arFrame.push_back(tFrameMapping("ET", 2, HWTechmode));
+	arFrame.push_back(tFrameMapping("FO", 2, HWFocus));
+	arFrame.push_back(tFrameMapping("AD", 2, HWAECDensity));
+	arFrame.push_back(tFrameMapping("AG", 2, HWAG));
+	arFrame.push_back(tFrameMapping("GS", 2, HWGS));
+	arFrame.push_back(tFrameMapping("MT", 2, HWMT));
+	//MG -- 2  1  0 对应  1.8 1.5 1.0 ，GEN_PARAM_MAMMO_MAG 发送后者给上层
+	arFrame.push_back(tFrameMapping("MG", 2, HWMG));
+	arFrame.push_back(tFrameMapping("FY", 2, HWFY));//不知道何意
+	arFrame.push_back(tFrameMapping("PE", 2, HWPE));
+	arFrame.push_back(tFrameMapping("PF", 2, HWPF));
+	arFrame.push_back(tFrameMapping("FT", 2, HWFT));
+	//FS -- 得到 长和宽 。（不知道啥啥的）
+	arFrame.push_back(tFrameMapping("FS", 2, HWFS));
+	arFrame.push_back(tFrameMapping("GR", 2, HWGR));
+	arFrame.push_back(tFrameMapping("DF", 2, HWDF));
+	arFrame.push_back(tFrameMapping("ST", 2, HWST));
+	arFrame.push_back(tFrameMapping("ERR", 3, HWERROR)); //==IN==:ERR003 客户反馈的log中第一次遇见
+	arFrame.push_back(tFrameMapping("WN", 2, HWWARN));
+	arFrame.push_back(tFrameMapping("HE", 2, HWEHE));
+	arFrame.push_back(tFrameMapping("TGA",3, HWTG));
+	arFrame.push_back(tFrameMapping("RE", 2, HWRE));
+}
+
+bool nsGEN::VMIMAMMODevice::StartHardwareStatusThread()
+{
+	FINFO("enter Start HardwareStatus Thread ");
+	if (m_pHardwareStatusThread == NULL)
+	{
+		DWORD m_HardwareStatusID;
+		m_pHardwareStatusThread = CreateThread(0, 0, HardwareStatusThread, this, 0, &m_HardwareStatusID);
+		if (m_pHardwareStatusThread == NULL)
+		{
+			Fatal("Start HardwareStatus Thread Failed");
+			return false;
+		}
+	}
+	return true;
+}
+
+DWORD nsGEN::VMIMAMMODevice::HardwareStatusThread(LPVOID pParam)
+{
+	VMIMAMMODevice* pCurGen = (VMIMAMMODevice*)pParam;
+	if (pCurGen == NULL)
+	{
+		return false;
+	}
+	FINFO("HardwareStatusThread start");
+	
+	while (true)
+	{
+		if (pCurGen->m_bRREnable)
+		{
+			Sleep(1000);
+			pCurGen->HWSend("RR?");			//延迟发送，是因为，当时gen下面的设备还没创建完毕。但是也不能延迟太久，因为进入检查之前 最好能得到WK的状态。
+			pCurGen->m_bRREnable = false;
+		}
+		else
+		{
+			Sleep(2000);
+			pCurGen->HWSend("HE?");
+			//pCurGen->m_bRREnable = true;
+		}
+	}
+	FINFO("HardwareStatusThread stop");
+	return true;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SelectPP(int nPostionID)
+{
+	char temp[50] = { 0 };
+	sprintf_s(temp, "PO%01d", nPostionID);
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetNeedleBiopsyEnable(unsigned int unNBEnable)
+{
+	char temp[50] = { 0 };
+	sprintf_s(temp, "NB%01d", unNBEnable);
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetNeedleBiopsyDepth(unsigned int unNBDepth)
+{
+	char temp[50] = { 0 };
+	sprintf_s(temp, "ND%01d", unNBDepth);
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetGrid(int nGridType)
+{
+	char temp[50] = { 0 };
+	sprintf_s(temp, "GR%02d", nGridType);
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetCollimatorSize(int xsize, int ysize)
+{
+	char temp[50] = { 0 };
+	sprintf_s(temp, "FS%03d%03d", xsize * 10, ysize * 10);
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetCollimatorLight(WORD pParams)
+{
+	//此处应该发送指令给GEN，并且该指令可以控制 coll 的LED。
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::SetAutoTracking(int nAutoTracking)
+{
+	char temp[50] = { 0 };
+	sprintf_s(temp, "DF%d", nAutoTracking);
+	return HWSend(temp);
+}
+
+RET_STATUS nsGEN::VMIMAMMODevice::GetTomoResults(ResDataObject& resultAngle, ResDataObject& resultHeight)
+{
+	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
+	if (resultAngle.size() == 1 && resultHeight.size() == 1)
+	{
+		m_resultAngle.update(resultAngle.GetKey(0), (float)resultAngle[0]);
+		FINFO("GetTomoResults insert, key={$},value={$}",resultAngle.GetKey(0), (float)resultAngle[0]);
+	}
+	else
+	{
+		FINFO("GetTomoResults size={$}", m_resultAngle.size());
+
+		for (int i = 0; i < m_resultAngle.size(); i++)
+		{
+			resultAngle.update(m_resultAngle.GetKey(i), (float)m_resultAngle[i]);
+			FINFO("GetTomoResults ket={$} ,resule={$}", m_resultAngle.GetKey(i), (float)m_resultAngle[i]);
+		}
+
+		resultHeight.update("0", 63.71);
+		resultHeight.update("1", 63.97);
+		resultHeight.update("2", 64.21);
+		resultHeight.update("3", 64.41);
+		resultHeight.update("4", 64.59);
+		resultHeight.update("5", 64.73);
+		resultHeight.update("6", 64.84);
+		resultHeight.update("7", 64.92);
+		resultHeight.update("8", 64.97);
+		resultHeight.update("9", 64.99);
+		resultHeight.update("10", 64.98);
+		resultHeight.update("11", 64.94);
+		resultHeight.update("12", 64.87);
+		resultHeight.update("13", 64.72);
+		resultHeight.update("14", 64.63);
+		resultHeight.update("15", 64.47);
+		resultHeight.update("16", 64.28);
+		resultHeight.update("17", 64.05);
+
+		m_resultAngle.clear();
+	}
+	return ret;
+}
+
+
+//-----------------------------------------------------------------------------
+//		VMIMAMMODriver
+//-----------------------------------------------------------------------------
+
+nsGEN::VMIMAMMODriver::VMIMAMMODriver()
+{
+	m_pDriGenDev = nullptr;
+	m_pDriCollDev = nullptr;
+	m_pDriMechDev = nullptr;
+	m_pDriDapDev = nullptr;
+
+	m_bDemoConnected = false;
+
+
+	m_pAttribute.reset(new ResDataObject());
+	m_pDescription.reset(new ResDataObject());
+}
+
+nsGEN::VMIMAMMODriver::~VMIMAMMODriver()
+{
+	if (m_pDriGenDev)
+	{
+		delete m_pDriGenDev;
+		m_pDriGenDev = nullptr;
+	}
+	if (m_pDriCollDev)
+	{
+		delete m_pDriCollDev;
+	m_pDriCollDev = nullptr;
+	}
+	if (m_pDriMechDev)
+	{
+		delete m_pDriMechDev;
+	m_pDriMechDev = nullptr;
+	}
+	if (m_pDriDapDev)
+	{
+		delete m_pDriDapDev;
+	m_pDriDapDev = nullptr;
+	}
+}
+
+auto nsGEN::VMIMAMMODriver::CreateDevice(int index) -> std::unique_ptr <IODevice>
+{	
+	FINFO("Enter CreateDevice, index={$}", index);
+	
+	if (!m_SCF.isConnected())
+		return nullptr;
+	
+	if (index == 0)
+	{
+		m_pDriGenDev = new VMIMAMMODevice(EventCenter, m_SCF);
+		auto dev = std::unique_ptr<IODevice>(new IODevice(m_pDriGenDev));
+		return dev;
+		
+	}
+	else if (index == 1)
+	{
+		FINFO("Enter CreateDevice COLL");
+		m_pDriCollDev = new OemCollimator(std::shared_ptr<IOEventCenter>(new IOEventCenter()));
+		auto dev = std::unique_ptr <IODevice>(new IODevice(m_pDriCollDev));
+		m_pDriCollDev->SetCtrlDev(m_pDriGenDev);
+		m_pDriGenDev->SetCollimatorDev(m_pDriCollDev);
+		FINFO("Leave CreateDevice COLL");
+		return dev;
+	}
+	else if (index == 2)
+	{
+		FINFO("Enter CreateDevice Mech");
+		
+		m_pDriMechDev = new OemMechanical(std::shared_ptr<IOEventCenter>(new IOEventCenter()));
+		auto dev = std::unique_ptr <IODevice>(new IODevice(m_pDriMechDev));
+		m_pDriMechDev->SetCtrlDev(m_pDriGenDev);
+		m_pDriGenDev->SetMechDev(m_pDriMechDev);
+		FINFO("Leave CreateDevice Mech");
+		return dev;
+	}
+	else if (index == 3)
+	{
+		FINFO("Enter CreateDevice DAP");
+		m_pDriDapDev = new OemDap(std::shared_ptr<IOEventCenter>(new IOEventCenter()));
+		auto dev = std::unique_ptr <IODevice>(new IODevice(m_pDriDapDev));
+		m_pDriDapDev->SetCtrlDev(m_pDriGenDev);
+		m_pDriGenDev->SetDapDev(m_pDriDapDev);		
+		FINFO("Leave CreateDevice DAP");
+		return dev;
+	}
+	
+}
+
+void nsGEN::VMIMAMMODriver::FireNotify(int code, std::string key, std::string content)
+{
+	EventCenter->OnNotify(code, key, content);
+}
+
+
+
+Log4CPP::Logger* gLogger = nullptr;
+void nsGEN::VMIMAMMODriver::Prepare()
+{
+
+	string strLogPath = GetProcessDirectory() + R"(\OEMDrivers\Generator\Conf\Log4CPP.Config.GEN.xml)";
+	//Log4CPP::ThreadContext::Map::Set("LogFileName", "GEN.VMIMAMMO");
+	Log4CPP::GlobalContext::Map::Set(ECOM::Utility::Hash("LogFileName"), "GEN.PSG_MG");
+	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
+	gLogger = Log4CPP::LogManager::GetLogger("GEN.VMIMAMMO");
+	
+	m_SCFDllName = GetConnectDLL(m_ConfigFileName);
+
+	super::Prepare();
+}
+
+bool DATA_ACTION  nsGEN::VMIMAMMODriver::Connect()
+{
+	ResDataObject Connection = GetConnectParam(m_ConfigFileName);
+	FINFO("connections:{$} \n", Connection.encode());
+	auto erCode = m_SCF.Connect(Connection.encode(), &nsGEN::VMIMAMMODriver::callbackPackageProcess, SCF_PACKET_TRANSFER, 3000);
+	if (erCode != SCF_ERR::SCF_SUCCEED)
+		return false;
+
+	auto rc = super::Connect();
+	if (!rc)
+		return false;
+	//return (erCode == SCF_ERR::SCF_SUCCEED);
+	
+	return true;
+}
+
+void nsGEN::VMIMAMMODriver::Disconnect()
+{
+	super::Disconnect();
+	m_SCF.Disconnect();
+
+	m_bDemoConnected = false;
+}
+
+bool nsGEN::VMIMAMMODriver::isConnected() const
+{
+	return super::isConnected();
+}
+
+std::string nsGEN::VMIMAMMODriver::DriverProbe()
+{
+	ResDataObject r_config, HardwareInfo;
+	if (r_config.loadFile(m_ConfigFileName.c_str()))
+	{
+		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
+		HardwareInfo.add("MinorID", r_config["CONFIGURATION"]["MinorID"]);
+		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
+		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
+		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
+	}
+	else
+	{
+		HardwareInfo.add("MajorID", "Generator");
+		HardwareInfo.add("MinorID", "Dr");
+		HardwareInfo.add("VendorID", "VMIMAMMO");
+		HardwareInfo.add("ProductID", "HF");
+		HardwareInfo.add("SerialID", "Drv");
+	}
+	string ret = HardwareInfo.encode();
+	return ret;
+}
+
+/*
+std::string nsGEN::VMIMAMMODriver::GetResource()
+{
+	ResDataObject temp;
+	if (!temp.loadFile(m_ConfigFileName.c_str()))
+		return std::string();
+
+	auto r_config = temp["CONFIGURATION"];
+	for (auto& Item : m_ConfigInfo)
+	{
+		string key = Item.GetKey();
+		if (key == ConfKey::CcosGeneratorType)
+		{
+			Item.SetCurrentValue(((string)r_config["VendorID"]).c_str());
+		}
+		else if (key == ConfKey::CcosGeneratorModel)
+		{
+			Item.SetCurrentValue(((string)r_config["ProductID"]).c_str());
+		}
+		else if (key == ConfKey::CcosWSTable || key == ConfKey::CcosWSWall || key == ConfKey::CcosWSFree
+			|| key == ConfKey::CcosWSTomo || key == ConfKey::CcosWSConventional)
+		{
+			Item.SetCurrentValue(((string)r_config[key.c_str()]).c_str());
+		}
+		else if (key == ConfKey::CcosSynTable || key == ConfKey::CcosSynWall || key == ConfKey::CcosSynFree
+			|| key == ConfKey::CcosSynTomo || key == ConfKey::CcosSynConventional)
+		{
+			Item.SetCurrentValue(((string)r_config[key.c_str()]).c_str());
+		}
+		else if (key == ConfKey::CcosSCFType)
+		{
+			Item.SetCurrentValue(((string)r_config["connections"][0]["type"]).c_str());
+		}
+		else if (key == ConfKey::CcosSCFPort || key == ConfKey::CcosSCFBaudrate || key == ConfKey::CcosSCFBytesize
+			|| key == ConfKey::CcosSCFParity || key == ConfKey::CcosSCFStopbits || key == ConfKey::CcosSCFIP)
+		{
+			if (r_config["connections"][0].GetFirstOf(key.c_str()) >= 0)
+			{
+				Item.SetCurrentValue(((string)r_config["connections"][0][key.c_str()]).c_str());
+			}
+		}
+	}
+	ResDataObject resAttr, resDescription;
+	for (auto Item : m_ConfigInfo)
+	{
+		resAttr.add(Item.GetKey(), Item.GetCurrentValue());
+		resDescription.add(Item.GetKey(), Item.GetDescription());
+	}
+	ResDataObject resDeviceResource;
+	resDeviceResource.add(ConfKey::CcosGeneratorAttribute, resAttr);
+	resDeviceResource.add(ConfKey::CcosGeneratorDescription, resDescription);
+	string res = resDeviceResource.encode();
+	FINFO("resDeviceResource :{$} \n", resDeviceResource.encode());
+	return res;
+}
+*/
+
+bool nsGEN::VMIMAMMODriver::GetDeviceConfig(std::string& Cfg)
+{
+	Cfg = m_DeviceConfigSend.encode();
+
+	printf("GetDeviceConfig over , %s", Cfg.c_str());
+
+	return true;
+}
+
+bool nsGEN::VMIMAMMODriver::SetDeviceConfig(std::string Cfg)
+{
+	FINFO("--Func-- SetDeviceConfig {$}\n", Cfg.c_str());
+
+	printf("\n--Func-- SetDeviceConfig %s\n", Cfg.c_str());
+
+	ResDataObject DeviceConfig;
+	DeviceConfig.decode(Cfg.c_str());
+
+	ResDataObject DescriptionTempEx;
+	DescriptionTempEx = DeviceConfig["DeviceConfig"]["Attribute"];
+	FDEBUG("Attribute:{$}", DescriptionTempEx.encode());
+
+	bool bSaveFile = false; //true:重新保存配置文件
+	string strAccess = "";
+	for (int i = 0; i < DescriptionTempEx.size(); i++)
+	{
+		string strKey = DescriptionTempEx.GetKey(i);
+		FINFO("{$}", strKey.c_str());
+		printf("%s\n", strKey.c_str());
+		try
+		{
+			if (m_pAttribute->GetFirstOf(strKey.c_str()) >= 0)
+			{
+				strAccess = (string)(*m_pDescription)[strKey.c_str()]["Access"];
+				if ("RW" == strAccess)
+				{
+					//修改对应配置，在其他单元的配置项要同时调用其修改函数修改真实值
+					//1. 修改内存中的值，用于给上层发消息
+					(*m_pAttribute)[strKey.c_str()] = DescriptionTempEx[i];
+					//2. 拿到Innerkey
+					int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
+					FINFO("nConfigInfoCount {$}", nConfigInfoCount);
+					string strTemp = ""; //存储AttributeKey
+					for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
+					{
+						strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
+						if (strTemp == strKey)
+						{
+							strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
+							break;
+						}
+					}
+					//3. 修改配置文件中的值
+					if (SetDeviceConfigValue(m_Configurations, strTemp.c_str(), 1, DescriptionTempEx[i]))
+					{
+						FDEBUG("SetDeviceConfigValue over");
+						bSaveFile = true;
+					}
+				}
+				else
+				{
+					FINFO("{$} is not a RW configuration item", strKey.c_str());
+				}
+			}
+			else
+			{
+				FINFO("without this attribute {$}", strKey.c_str());
+			}
+		}
+		catch (ResDataObjectExption& e)
+		{
+			printf("\nSetDriverConfig crashed: %s\n", e.what());
+			FERROR("SetDriverConfig crashed: {$}", e.what());
+			return false;
+		}
+	}
+
+	if (bSaveFile)
+	{
+		//3. 重新保存配置文件
+		SaveConfigFile(true);
+	}
+	return true;
+}
+
+bool nsGEN::VMIMAMMODriver::SaveConfigFile(bool bSendNotify)
+{
+	m_ConfigAll["CONFIGURATION"] = m_Configurations;
+
+	bool bRt = m_ConfigAll.SaveFile(m_ConfigFileName.c_str());
+	FINFO("SaveConfigFile over {$}", bRt);
+	return true;
+}
+
+bool nsGEN::VMIMAMMODriver::GetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, string& strValue)
+{
+	strValue = "";
+	string strTemp = pInnerKey;
+	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
+	{
+		int pos = 0;
+		ResDataObject resTemp = config;
+		while ((pos = strTemp.find_first_of(',')) != string::npos)
+		{
+			string Key = strTemp.substr(0, pos);
+			string TempValue = resTemp[Key.c_str()].encode();
+
+			//	printf("-TempValue=== %s", TempValue.c_str());
+
+			resTemp.clear();
+			resTemp.decode(TempValue.c_str());
+			strTemp = strTemp.substr(pos + 1, strTemp.length() - pos - 1);
+
+			//printf("-************--%s", strTemp.c_str());
+
+		}
+		if (strTemp != "")
+		{
+			strValue = (string)resTemp[strTemp.c_str()];
+		}
+		else
+		{
+			strValue = (string)resTemp;
+		}
+	}
+
+	//printf("------------%s", strValue.c_str());
+
+	return true;
+}
+
+bool nsGEN::VMIMAMMODriver::SetDeviceConfigValue(ResDataObject& config, const char* pInnerKey, int nPathID, const char* szValue)
+{
+	string strTemp = pInnerKey;
+	FDEBUG("Begin to change {$} item value to {$}", pInnerKey, szValue);
+	printf("\nbbbbbbbbbbbbbbBegin to change {%s} item value to {%s}\n", pInnerKey, szValue);
+	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
+	{
+		try {
+			int pos = 0;
+			ResDataObject* resTemp = &config;
+			while ((pos = strTemp.find_first_of(',')) != string::npos)
+			{
+				string Key = strTemp.substr(0, pos);
+				resTemp = &(*resTemp)[Key.c_str()];
+				strTemp = strTemp.substr(pos + 1, strTemp.length() - pos - 1);
+			}
+			if (strTemp != "")
+			{
+				//if ((strTemp.compare("WSTable") == 0) ||
+				//	(strTemp.compare("WSWall") == 0) ||
+				//	(strTemp.compare("WSFree") == 0) ||
+				//	(strTemp.compare("WSTomo") == 0) ||
+				//	(strTemp.compare("WSConventional") == 0)
+				//	)
+				//{
+				//	int sum = (*szValue) + 1;
+				//	(*resTemp)[strTemp.c_str()] = (char*)(&sum);
+
+				//}
+				//else
+				//	(*resTemp)[strTemp.c_str()] = szValue;
+
+				(*resTemp)[strTemp.c_str()] = szValue;
+			}
+			else
+			{
+				*resTemp = szValue;
+			}
+		}
+		catch (ResDataObjectExption& e)
+		{
+			FERROR("SetDriverConfigvalue crashed: {$}", e.what());
+			return false;
+		}
+	}
+	return true;
+}
+
+
+std::string nsGEN::VMIMAMMODriver::GetResource()
+{
+	ResDataObject r_config, temp;
+	if (!temp.loadFile(m_ConfigFileName.c_str()))
+	{
+		return "";
+	}
+
+	m_ConfigAll = temp;
+
+	r_config = temp["CONFIGURATION"];
+	m_Configurations = r_config;
+
+	ResDataObject DescriptionTemp;
+	ResDataObject DescriptionSend;
+	ResDataObject m_DescriptionSend;
+	ResDataObject ListTemp;
+	string strTemp = "";			//用于读取字符串配置信息
+	string strIndex = "";			//用于读取配置信息中的List项
+	int nTemp = -1;					//用于读取整型配置信息
+	char sstream[10] = { 0 };		//用于转换值
+	string strValue = "";			//用于存储配置的值
+	string strType = "";			//用于存储配置的类型 int/float/string...
+
+	/***
+	* 1. 通过循环，将所有配置项写到pDeviceConfig
+	* 2. 记录配置项的内部key以及配置类型，类型对应了不同配置文件路径，用于读写真实值
+	***/
+	try
+	{
+		//便利ConfigToolInfo 中 所有的AttributeInfo 属性段
+		int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
+		m_pAttribute->clear();
+		m_pDescription->clear();
+		for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
+		{
+			DescriptionTemp.clear();
+			DescriptionSend.clear();
+			ListTemp.clear();
+
+			//AttributeType
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Type"];
+			DescriptionTemp.add(ConfKey::CcosType, strTemp.c_str());//CcosGeneratorAttribute
+			DescriptionSend.add(ConfKey::CcosType, strTemp.c_str());//CcosGeneratorAttribute
+
+			strType = strTemp; //记录配置项的类型
+
+			//AttributeKey
+			//1. 根据AttributeType，内部key和配置路径，拿到当前的真实值
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
+			nTemp = (int)m_Configurations["ConfigToolInfo"][nInfoIndex]["PathID"];
+			GetDeviceConfigValue(r_config, strTemp.c_str(), nTemp, strValue);	//得到strValue的值
+
+			//printf("********************************innerkey=%s --strValue = %s\n", strTemp.c_str(), strValue.c_str());
+
+			//2. 赋值
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
+
+
+			if ("int" == strType)
+			{
+				(*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str()));
+			}
+			else if ("float" == strType)
+			{
+				(*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str()));
+			}
+			else //其它先按string类型处理
+			{
+				(*m_pAttribute).add(strTemp.c_str(), strValue.c_str());
+			}
+
+			//printf("********************************outkey =%s --strValue = %s\n", strTemp.c_str(), strValue.c_str());
+
+			//AttributeAccess
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Access"];
+			DescriptionTemp.add(ConfKey::CcosAccess, strTemp.c_str());
+			DescriptionSend.add(ConfKey::CcosAccess, strTemp.c_str());
+
+
+			/*
+			//AttributeRangeMin
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMin"];
+			if (strTemp != "") //不需要的配置项为空
+			{
+				DescriptionTemp.add(ConfKey::CcosRangeMin, strTemp.c_str());
+			}
+
+			//AttributeRangeMax
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMax"];
+			if (strTemp != "") //不需要的配置项为空
+			{
+				DescriptionTemp.add(ConfKey::CcosRangeMax, strTemp.c_str());
+			}
+			*/
+
+			//AttributeList
+			nTemp = m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListNum"];
+			if (nTemp > 0) //ListNum不大于0时说明不需要list配置
+			{
+				for (int nListIndex = 0; nListIndex < nTemp; nListIndex++)
+				{
+					strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListInfo"][nListIndex];
+					auto temKey = std::to_string(nListIndex);
+					ListTemp.add(temKey.c_str(), strTemp.c_str());
+				}
+				DescriptionTemp.add(ConfKey::CcosList, ListTemp);
+				DescriptionSend.add(ConfKey::CcosList, ListTemp.encode());
+			}
+
+			//AttributeRequired
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Required"];
+			DescriptionTemp.add(ConfKey::CcosRequired, strTemp.c_str());
+			DescriptionSend.add(ConfKey::CcosRequired, strTemp.c_str());
+
+			//AttributeDefaultValue
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["DefaultValue"];
+			if (strTemp != "") //不需要的配置项为空
+			{
+				DescriptionTemp.add(ConfKey::CcosDefaultValue, strTemp.c_str());
+				DescriptionSend.add(ConfKey::CcosDefaultValue, strTemp.c_str());
+			}
+
+			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
+			(*m_pDescription).add(strTemp.c_str(), DescriptionTemp);
+			m_DescriptionSend.add(strTemp.c_str(), DescriptionSend.encode());
+		}
+	}
+	catch (ResDataObjectExption& e)
+	{
+		FERROR("Get config error: {$}", e.what());
+		return "";
+	}
+
+	ResDataObject resDeviceResource;
+	resDeviceResource.add(ConfKey::CcosGeneratorAttribute, (*m_pAttribute));
+	resDeviceResource.add(ConfKey::CcosGeneratorDescription, (*m_pDescription));
+
+	ResDataObject DescriptionTempEx;
+	DescriptionTempEx.add(ConfKey::CcosGeneratorConfig, resDeviceResource);
+	m_DeviceConfig.clear();
+	m_DeviceConfig = DescriptionTempEx;
+
+	FDEBUG("local ************* get resource over {$}", DescriptionTempEx.encode());
+	printf("local ************* get resource over %s \n", DescriptionTempEx.encode());
+
+
+	resDeviceResource.clear();
+
+	resDeviceResource.add(ConfKey::CcosGeneratorAttribute, (*m_pAttribute));
+	resDeviceResource.add(ConfKey::CcosGeneratorDescription, m_DescriptionSend);
+	DescriptionTempEx.clear();
+	DescriptionTempEx.add(ConfKey::CcosGeneratorConfig, resDeviceResource);
+
+	m_DeviceConfigSend.clear();
+
+	m_DeviceConfigSend = DescriptionTempEx;
+
+	string res = m_DeviceConfigSend.encode();
+
+	//printf("%s", res.c_str());
+
+	FDEBUG("get resource over {$}", DescriptionTempEx.encode());
+	printf("************* get resource over %s \n", DescriptionTempEx.encode());
+
+	return res;
+}
+
+
+std::string nsGEN::VMIMAMMODriver::DeviceProbe()
+{
+	ResDataObject r_config, HardwareInfo;
+	if (r_config.loadFile(m_ConfigFileName.c_str()))
+	{
+		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
+		HardwareInfo.add("MinorID", r_config["CONFIGURATION"]["MinorID"]);
+		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
+		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
+		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
+	}
+	else
+	{
+		HardwareInfo.add("MajorID", "Generator");
+		HardwareInfo.add("MinorID", "Dr");
+		HardwareInfo.add("VendorID", "VMIMAMMO");
+		HardwareInfo.add("ProductID", "HF");
+		HardwareInfo.add("SerialID", "1234");
+	}
+	string ret = HardwareInfo.encode();
+	return ret;
+}
+
+void nsGEN::VMIMAMMODriver::Dequeue(const char* Packet, DWORD Length)
+{
+	DecodeFrame(Packet, Length);
+}
+
+PACKET_RET nsGEN::VMIMAMMODriver::callbackPackageProcess(const char* RecData, DWORD nLength, DWORD& PacketLength)
+{
+	if (nLength < 1)
+	{
+		FINFO("nLength < 1, nLength=={$} \n", nLength);
+		return PACKET_USELESS;
+	}
+
+	for (DWORD i = 0; i < nLength - 1; i++)
+	{
+		if (RecData[i] == 0x03)
+		{
+			PacketLength = i + 2;			//data+etx+checksum
+			char strtemp[100] = { 0 };
+			memcpy(strtemp, RecData, i);	// STX+RKC005(not include 03 + sum);  //only 复制 0x03之前的数据，这样解析时，后面的03 ，sum 都不要了。
+			strtemp[PacketLength + 1] = 0;
+			FINFO("==IN==:{$}\n", strtemp);
+			return PACKET_ISPACKET;
+		}
+	}
+
+	return PACKET_NOPACKET;
+}
+
+//-----------------------------------------------------------------------------
+//		DecodeFrame
+//-----------------------------------------------------------------------------
+static bool DecodeFrame(const char* strFrame, int length)
+{
+	auto pr = [strFrame, length](const tFrameMapping& Item)
+	{
+		for (int i = 0; i < Item.NbOfCharOfHead; i++)
+		{
+			if (strFrame[i] != Item.strHead[i])
+			{
+				return false;
+			}
+		}
+		return true;
+	};
+	auto found = std::find_if(arFrame.begin(), arFrame.end(), pr);
+	if (found == arFrame.end())
+	{
+		return false;
+	}
+	const auto& Item = *found;
+	auto pc = strFrame;
+	pc += Item.NbOfCharOfHead;
+	Item.fun(pc, length - Item.NbOfCharOfHead);
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//		GetIODriver & CreateIODriver
+//-----------------------------------------------------------------------------
+
+static nsGEN::VMIMAMMODriver  gIODriver;
+
+extern "C"  CCOS::Dev::IODriver * __cdecl GetIODriver()		// 返回静态对象的引用, 调用者不能删除 !
+{
+	return &gIODriver;
+}
+
+extern "C"  CCOS::Dev::IODriver * __cdecl CreateIODriver()  // 返回新对象, 调用者必须自行删除此对象 !
+{
+	return new nsGEN::VMIMAMMODriver();
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/CCOS.Dev.Generator.VMIMAMMO.h

@@ -0,0 +1,242 @@
+#pragma once
+
+
+#include "CCOS.Dev.Generator.Mould.hpp"
+#include "IODeviceWithSCF.tlh"
+#include "IODeviceWithSCF.tli"
+
+#include "DAP.BasicMoulds.hpp"
+#include "CCOS.Dev.MSGMould.hpp"
+
+#include "OEM.Collimator.h"
+#include "OEM.Mechanical.h"
+#include "OEM.Dap.h"
+
+
+#include "CCOS.Dev.IODevice.Detail.hpp"
+
+#ifdef CCOSDEVGENVMIMAMMO_EXPORTS
+#define _CCOSDEVGENVMIMAMMO_API __declspec(dllexport)
+#else
+#define _CCOSDEVGENVMIMAMMO_API __declspec(dllimport)
+#endif
+
+
+namespace CCOS::Dev::Detail::Generator
+{
+	static const int TIMEOUTVALUE = 100;
+
+//-----------------------------------------------------------------------------
+//		VMIMAMMODevice
+//-----------------------------------------------------------------------------
+	namespace nDev = CCOS::Dev;
+	namespace DevDAP = CCOS::Dev::Detail::DAP;
+	class  _CCOSDEVGENVMIMAMMO_API  VMIMAMMODevice : public IODeviceWithSCF <IODeviceDetail>,public GeneratorMould
+	{
+		using super = IODeviceWithSCF <IODeviceDetail>;
+		using superGen = GeneratorMould;
+		
+	public:
+		VMIMAMMODevice (std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF);
+		~VMIMAMMODevice ();
+
+		virtual std::string GetGUID() const override;
+	private:
+		RET_STATUS  HWSend (char * strCommand, int nTimeOut = TIMEOUTVALUE);
+		void OnCallBack ();		
+		std::unique_ptr<DevDAP::DOSEMould> m_DAP;
+		std::unique_ptr<nsDetail::MSGUnit> m_MSGUnit;
+
+		std::unique_ptr<OemCollimator> m_pCollDev;
+		std::unique_ptr<OemMechanical> m_pMechDev;
+		std::unique_ptr<OemDap> m_pDapDev;
+
+
+
+
+		bool StartHardwareStatusThread();				//定时查询EHE?
+		static DWORD HardwareStatusThread(LPVOID pParam);
+		HANDLE m_pHardwareStatusThread;
+		bool m_bInExposurePeriod;
+		
+	private:
+		void Register();
+
+	public:
+		virtual RET_STATUS IncKV() override;
+		virtual RET_STATUS DecKV() override;
+		virtual RET_STATUS SetKV(float value) override;
+
+		virtual RET_STATUS IncMA() override;
+		virtual RET_STATUS DecMA() override;
+		virtual RET_STATUS SetMA(float value) override;
+
+		virtual RET_STATUS IncMS() override;
+		virtual RET_STATUS DecMS() override;
+		virtual RET_STATUS SetMS(float value) override;
+
+		virtual RET_STATUS IncMAS() override;
+		virtual RET_STATUS DecMAS() override;
+		virtual RET_STATUS SetMAS(float value) override;
+
+		virtual RET_STATUS SetTechmode(int value) override;
+
+		virtual RET_STATUS SetFocus(int value) override;
+
+		virtual RET_STATUS SetAECDensity(int value) override;
+		virtual RET_STATUS SetAECField(int value) override;
+		virtual RET_STATUS SetAECFilm(int value) override;
+		virtual RET_STATUS SetWS(const std::string value) override;
+		virtual RET_STATUS SetAPR(const _tAPRArgs& t) override;
+
+		virtual RET_STATUS QueryHE(int& value) override;
+
+		virtual RET_STATUS QueryPostKV(float& value) override;
+
+		virtual RET_STATUS QueryPostMA(float& value) override;
+
+		virtual RET_STATUS QueryPostMS(float& value) override;
+
+		virtual RET_STATUS QueryPostMAS(float& value) override;
+
+
+		virtual RET_STATUS SetGenSynState(int value) override;
+
+		virtual RET_STATUS SetGenState(int value) override;
+
+		virtual RET_STATUS SetExpEnable() override;
+		virtual RET_STATUS SetExpDisable()override;
+
+		virtual RET_STATUS Reset()override;
+		virtual RET_STATUS SetExpMode(std::string value) override;
+		virtual RET_STATUS SetFrameRate(FLOAT frameRate) override;
+		virtual RET_STATUS SetFLFMode(std::string value) override;
+		virtual RET_STATUS SetEXAMMode(std::string value) override;
+
+
+		RET_STATUS Clear_DAP();
+		RET_STATUS GetValue_DAP(float& value);
+
+		RET_STATUS StartMove();
+		RET_STATUS EndMove();
+		
+		RET_STATUS EnterExam();
+		RET_STATUS ExitExam();
+
+		RET_STATUS QueryDAP();
+		
+
+		typedef struct tagCollimator
+		{
+			float fWidth;   //cm
+			float fHeight;  //cm
+
+		}ECOM_COLLIMATOR_INFO;
+
+		RET_STATUS SetCollimatorSize(int xsize,int ysize);
+		RET_STATUS SetCollimatorLight(WORD pParams);
+
+		RET_STATUS SetAutoTracking(int nAutoTracking);
+		RET_STATUS SetFilter(int nFilterType);
+		RET_STATUS SetGrid(int nGridType);
+
+		RET_STATUS GetTomoResults(ResDataObject& resultAngle, ResDataObject& resultHeight);
+		ResDataObject m_resultAngle;
+		ResDataObject m_resultAngle_tmp;	//仅用于insert数据
+		ResDataObject m_resultHeight;
+
+
+		//为了将gen和其他设备关联，能相互调用接口
+		RET_STATUS SetCollimatorDev(OemCollimator* dev);
+		RET_STATUS SetMechDev(OemMechanical* dev);
+		RET_STATUS SetDapDev(OemDap* dev);
+
+	protected:
+		RET_STATUS RefreshData ();
+		RET_STATUS SetRPS(int rps);//设置连续点片帧率
+
+		RET_STATUS SetMammoDensity(int unMDensity);
+		RET_STATUS SelectPP(int nPostionID);
+		RET_STATUS SetNeedleBiopsyEnable(unsigned int unNBEnable);
+		RET_STATUS SetNeedleBiopsyDepth(unsigned int unNBDepth);
+
+	private:
+		void FireNotify (std::string key, std::string context);
+		HANDLE m_hGenPostEvent;			//暂时不使用了.		
+		_tAPRArgs m_t;					//保存服务传入的参数
+		bool m_bRREnable;				//是否可以发送RR指令
+		
+		std::string m_strPreWKStatus;	//
+		std::string m_SettingExamMode;	//上层设定的exammode。（主要是因为WK，会引发ET错误值，故，发送WK之后，使用该变量，再次纠正ET值。
+
+		vector<string> m_localErrorlist;	//本地error list，用于清除error时，使用里面的string。
+		vector<string> m_localWarnlist;		//本地warn  list，用于清除warn 时，使用里面的string。
+	};
+
+}
+
+
+	//-----------------------------------------------------------------------------
+	//		VMIMAMMODriver
+	//-----------------------------------------------------------------------------
+
+namespace CCOS::Dev::Detail::Generator
+{
+	class  _CCOSDEVGENVMIMAMMO_API  VMIMAMMODriver : public IODriverWithSCF <DriverMould>
+	{
+		using super = IODriverWithSCF <DriverMould>;
+
+	public:
+		VMIMAMMODriver();
+		virtual ~VMIMAMMODriver();
+
+	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;
+
+		virtual bool GetDeviceConfig(std::string& Cfg) override;
+		virtual bool SetDeviceConfig(std::string Cfg) override;
+
+
+		bool SaveConfigFile(bool bSendNotify);
+		bool GetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, string& strValue);
+		bool SetDeviceConfigValue(ResDataObject& config, const char* pInnerKey, int nPathID, const char* szValue);
+
+
+
+	private:
+		static PACKET_RET callbackPackageProcess (const char* RecData, DWORD nLength, DWORD& PacketLength);
+
+		bool m_bDemoConnected;	//	在 DEMO 模式下, 调用过 Connect 吗?
+
+		VMIMAMMODevice* m_pDriGenDev;// = nullptr;
+		OemCollimator* m_pDriCollDev;// = nullptr;
+		OemMechanical* m_pDriMechDev;// = nullptr;
+		OemDap* m_pDriDapDev;// = nullptr;
+
+		ResDataObject m_DeviceConfigSend;
+		ResDataObject m_DeviceConfig;
+		string g_strAppPath;
+		ResDataObject m_ConfigAll; //存储当前的配置，用于修改配置时写回文件
+		ResDataObject m_Configurations; //存储当前配置中“CONFIGURATION”节点的内容
+		std::unique_ptr <ResDataObject> m_pAttribute;
+		std::unique_ptr <ResDataObject>  m_pDescription;
+
+
+		
+	};
+
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/CCOS.Dev.MechanicalMoudle.cpp

@@ -0,0 +1,319 @@
+#include "stdafx.h"
+
+#include "CCOS.Dev.MechanicalMoudle.hpp"
+#include "CCOSDICOMInfo.h"
+
+using namespace CCOS::Dev;
+using namespace CCOS::Dev::Detail::Mechanical;
+namespace nsMech = CCOS::Dev::Detail::Mechanical;
+
+nsMech::MechanicalDevice::MechanicalDevice(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter) :super(EventCenter)
+{
+	m_EventCenter = EventCenter;
+
+	m_Grid = 0;
+	m_Mammo_AE = 0;
+	m_Mammo_FT = 0;
+	m_Mammo_PressureState = 0;
+	m_Mammo_CompPressureDEC = 0;
+	m_Mammo_Depress = 0;
+	m_Mammo_MechAngle = 0.0f;
+	m_Mammo_MechHeight = 0.0f;
+	m_Mammo_PressureValue = 0.0f;
+	m_Mammo_AGD = 0.0f;
+	m_Mammo_MAG = 0.0f;
+	m_Mammo_CompressPaddle = "";
+}
+
+nsMech::MechanicalDevice::~MechanicalDevice()
+{
+}
+
+void nsMech::MechanicalDevice::FireNotify(string key, unsigned int value)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", value);
+	std::string str = szInfo;
+	m_EventCenter->OnNotify(1, key, str);//(int)ATTRACTION_SET 2
+
+}
+
+void nsMech::MechanicalDevice::FireNotify(string key, float value)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%f", value);
+	std::string str = szInfo;
+	m_EventCenter->OnNotify(1, key, str);//(int)ATTRACTION_SET 2
+
+}
+
+void nsMech::MechanicalDevice::FireNotify(string key, string value)
+{
+	std::string str = value;
+	m_EventCenter->OnNotify(1, key, str);//(int)ATTRACTION_SET 2
+
+}
+
+void nsMech::MechanicalDevice::Register()
+{
+	auto Disp = &Dispatch;
+	Disp->Action.Push("SetGrid", this, &nsMech::MechanicalDevice::JSSetGrid);
+	Disp->Action.Push("SetAutoTracking", this, &nsMech::MechanicalDevice::JSSetAutoTracking);
+	Disp->Action.Push("GetTomoResults", this, &nsMech::MechanicalDevice::JSGetTomoResults);
+
+	Disp->Get.Push("GRID", this, &nsMech::MechanicalDevice::JSGetGrid);
+	Disp->Get.Push("AE", this, &nsMech::MechanicalDevice::JSGetMammo_AE);
+	Disp->Get.Push("Filter", this, &nsMech::MechanicalDevice::JSGetMammo_FT);
+	Disp->Get.Push("Thickness", this, &nsMech::MechanicalDevice::JSGetMammo_PressureState);
+	Disp->Get.Push("CompPressureDEC", this, &nsMech::MechanicalDevice::JSGetMammo_CompPressureDEC);
+	Disp->Get.Push("Depress", this, &nsMech::MechanicalDevice::JSGetMammo_Depress);
+	Disp->Get.Push("MechanicalAngle", this, &nsMech::MechanicalDevice::JSGetMammo_MechAngle);
+	Disp->Get.Push("MechanicalHeight", this, &nsMech::MechanicalDevice::JSGetMammo_MechHeight);
+	Disp->Get.Push("CompPressure", this, &nsMech::MechanicalDevice::JSGetMammo_PressureValue);
+	Disp->Get.Push("AGD", this, &nsMech::MechanicalDevice::JSGetMammo_AGD);
+	Disp->Get.Push("MAG", this, &nsMech::MechanicalDevice::JSGetMammo_MAG);
+	Disp->Get.Push("CompressPaddle", this, &nsMech::MechanicalDevice::JSGetMammo_CompressPaddle);
+}
+
+bool nsMech::MechanicalDevice::Prepare()
+{
+	Register();
+	return true;
+}
+
+std::string nsMech::MechanicalDevice::GetGUID() const
+{
+	return MechanicalUnitType;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSSetGrid(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+	unsigned int nValue = json[0];
+
+	return SetGrid(nValue);
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSSetAutoTracking(std::string in, std::string& out)
+{
+	ResDataObject json;
+	json.decode(in.c_str());
+	unsigned int nValue = json[0];
+
+	return SetAutoTracking(nValue);
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetTomoResults(std::string in, std::string& out)
+{
+	ResDataObject json;
+	ResDataObject resultAngle;
+	ResDataObject resultHeight;
+
+	RET_STATUS ret = GetTomoResults(resultAngle, resultHeight);
+	if(ret != RET_STATUS::RET_SUCCEED)
+	{
+		return RET_STATUS::RET_FAILED;
+	}
+
+	json.add("P0", resultAngle);
+	json.add("P1", resultHeight);
+	out = json.encode();
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetGrid(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_Grid);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_AE(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_Mammo_AE);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_FT(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_Mammo_FT);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_PressureState(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_Mammo_PressureState);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_CompPressureDEC(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_Mammo_CompPressureDEC);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_Depress(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%d", m_Mammo_Depress);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_MechAngle(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%f", m_Mammo_MechAngle);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_MechHeight(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%f", m_Mammo_MechHeight);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_PressureValue(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%f", m_Mammo_PressureValue);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_AGD(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%f", m_Mammo_AGD);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_MAG(std::string& out)
+{
+	char szInfo[64] = { 0 };
+	sprintf_s(szInfo, "%f", m_Mammo_MAG);
+	out = szInfo;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS nsMech::MechanicalDevice::JSGetMammo_CompressPaddle(std::string& out)
+{
+	//char szInfo[64] = { 0 };
+	//sprintf_s(szInfo, "%s", m_Mammo_CompressPaddle);
+	out = m_Mammo_CompressPaddle;
+
+	return RET_STATUS::RET_SUCCEED;
+}
+
+void MechanicalDevice::UpdateGrid(unsigned int Value)
+{
+	m_Grid = Value;
+	FireNotify("GRID", Value);
+}
+
+void MechanicalDevice::UpdateMammo_AE(unsigned int Value)
+{
+	m_Mammo_AE = Value;
+	FireNotify("AE", Value);
+}
+
+void MechanicalDevice::UpdateMammo_FT(unsigned int Value)
+{
+	m_Mammo_FT = Value;
+	FireNotify("Filter", Value);
+}
+
+void MechanicalDevice::UpdateMammo_PressureState(unsigned int Value)
+{
+	m_Mammo_PressureState = Value;
+	FireNotify("Thickness", Value);
+}
+
+void MechanicalDevice::UpdateMammo_CompPressureDEC(unsigned int Value)
+{
+	m_Mammo_CompPressureDEC = Value;
+	FireNotify("CompPressureDEC", Value);
+}
+
+void MechanicalDevice::UpdateMammo_Depress(unsigned int Value)
+{
+	m_Mammo_Depress = Value;
+	FireNotify("Depress", Value);
+}
+
+void MechanicalDevice::UpdateMammo_MechAngle(float Value)
+{
+	m_Mammo_MechAngle = Value;
+	FireNotify("MechanicalAngle", Value);
+}
+
+void MechanicalDevice::UpdateMammo_MechHeight(float Value)
+{
+	m_Mammo_MechHeight = Value;
+	FireNotify("MechanicalHeight", Value);
+}
+
+void MechanicalDevice::UpdateMammo_PressureValue(float Value)
+{
+	m_Mammo_PressureValue = Value;
+	FireNotify("CompPressure", Value);
+}
+
+void MechanicalDevice::UpdateMammo_AGD(float Value)
+{
+	m_Mammo_AGD = Value;
+	FireNotify("AGD", Value);
+}
+
+void MechanicalDevice::UpdateMammo_MAG(float Value)
+{
+	m_Mammo_MAG = Value;
+	FireNotify("MAG", Value);
+}
+
+void MechanicalDevice::UpdateMammo_CompressPaddle(std::string Value)
+{
+	m_Mammo_CompressPaddle = Value;
+	FireNotify("CompressPaddle", Value);
+}
+
+RET_STATUS  MechanicalDevice::SetGrid(unsigned int GridType)
+{
+	return RET_STATUS::RET_SUCCEED;
+}
+
+RET_STATUS  MechanicalDevice::SetAutoTracking(unsigned int nAutoTracking)
+{
+	return RET_STATUS::RET_FAILED;
+}
+RET_STATUS MechanicalDevice::GetTomoResults(ResDataObject& resultAngle, ResDataObject& resultHeight)
+{
+	return RET_STATUS::RET_SUCCEED;
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/CCOS.Dev.MechanicalMoudle.hpp

@@ -0,0 +1,89 @@
+#pragma once
+#include <string>
+#include <minwindef.h>
+
+#include "ResDataObject.h"
+
+#include "CCOS.Dev.IODevice.hpp"
+#include "CCOS.Dev.IODevice.Detail.hpp"
+
+
+namespace CCOS::Dev::Detail::Mechanical
+{
+	//-----------------------------------------------------------------------------
+	//		Collimator
+	//-----------------------------------------------------------------------------
+	namespace nsDev = CCOS::Dev;
+	static const char* MechanicalUnitType = "{A6C288B9-8C4F-3A6C-9C5F-12345A0F7284}";
+
+	class MechanicalDevice : public IODeviceDetail
+	{
+		using super = IODeviceDetail;
+
+		unsigned int m_Grid;
+		unsigned int m_Mammo_AE;
+		unsigned int m_Mammo_FT;
+		unsigned int m_Mammo_PressureState;
+		unsigned int m_Mammo_CompPressureDEC;
+		unsigned int m_Mammo_Depress;
+		float m_Mammo_MechAngle;
+		float m_Mammo_MechHeight;
+		float m_Mammo_PressureValue;
+		float m_Mammo_AGD;
+		float m_Mammo_MAG;
+
+		//压迫板信息(主要是尺寸，目前不确定）
+		string m_Mammo_CompressPaddle;
+
+
+		void FireNotify(string key, unsigned int value);
+		void FireNotify(string key, float value);
+		void FireNotify(string key, string value);
+
+	protected:
+		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;
+
+	public:
+		MechanicalDevice(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
+		~MechanicalDevice();
+		virtual std::string GetGUID() const override;
+		virtual bool Prepare();
+		virtual void Register();
+
+		RET_STATUS JSSetGrid(std::string in, std::string& out);
+		RET_STATUS JSSetAutoTracking(std::string in, std::string& out);
+		RET_STATUS JSGetTomoResults(std::string in, std::string& out);
+
+		RET_STATUS JSGetGrid(std::string& out);
+		RET_STATUS JSGetMammo_AE(std::string& out);
+		RET_STATUS JSGetMammo_FT(std::string& out);
+		RET_STATUS JSGetMammo_PressureState(std::string& out);
+		RET_STATUS JSGetMammo_CompPressureDEC(std::string& out);
+		RET_STATUS JSGetMammo_Depress(std::string& out);
+		RET_STATUS JSGetMammo_MechAngle(std::string& out);
+		RET_STATUS JSGetMammo_MechHeight(std::string& out);
+		RET_STATUS JSGetMammo_PressureValue(std::string& out);
+		RET_STATUS JSGetMammo_AGD(std::string& out);
+		RET_STATUS JSGetMammo_MAG(std::string& out);
+		RET_STATUS JSGetMammo_CompressPaddle(std::string& out);
+
+		virtual RET_STATUS GetTomoResults(ResDataObject& resultAngle, ResDataObject& resultHeight);
+		virtual RET_STATUS SetGrid(unsigned int GridType);
+		virtual RET_STATUS SetAutoTracking(unsigned int nAutoTracking);
+
+		void UpdateGrid(unsigned int Value);
+		void UpdateMammo_AE(unsigned int Value);
+		void UpdateMammo_FT(unsigned int Value);
+		void UpdateMammo_PressureState(unsigned int Value);
+		void UpdateMammo_CompPressureDEC(unsigned int Value);
+		void UpdateMammo_Depress(unsigned int Value);
+		void UpdateMammo_MechAngle(float Value);
+		void UpdateMammo_MechHeight(float Value);
+		void UpdateMammo_PressureValue(float Value);
+		void UpdateMammo_AGD(float Value);
+		void UpdateMammo_MAG(float Value);
+		void UpdateMammo_CompressPaddle(std::string Value);
+
+	};
+
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/OEM.Collimator.cpp

@@ -0,0 +1,68 @@
+#include "stdafx.h"
+#include "OEM.Collimator.h"
+//#include "CCOS.Dev.FPD.Demo.h"
+#include "CCOS.Dev.Generator.VMIMAMMO.h"
+
+OemCollimator::OemCollimator(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter): super(EventCenter)
+{
+
+}
+
+OemCollimator::~OemCollimator()
+{
+
+}
+bool OemCollimator::Prepare()
+{
+	printf("OemCollimator::Prepare\n");
+	Register();
+
+	return true;
+}
+void OemCollimator::Register()
+{
+	printf("OemCollimator::Register\n");
+	auto p = static_cast <CollimatorDevice*> (this);
+	auto Disp = &Dispatch;
+	Disp->Action.Push("SetCollimatorSize", p, &CollimatorDevice::JSSetCollimatorSize);
+	Disp->Action.Push("SetCollimatorFilter", p, &CollimatorDevice::JSSetCollimatorFilter);
+	Disp->Action.Push("SetCollimatorSID", p, &CollimatorDevice::JSSetCollimatorSID);
+	Disp->Action.Push("SetCollimatorAngle", p, &CollimatorDevice::JSSetCollimatorAngle);
+	Disp->Action.Push("SetCollimatorLight", p, &CollimatorDevice::JSSetCollimatorLight);
+	Disp->Get.Push("XSize", p, &CollimatorDevice::JSGetCollimatorXSize);
+	Disp->Get.Push("YSize", p, &CollimatorDevice::JSGetCollimatorYSize);
+	Disp->Get.Push("SID", p, &CollimatorDevice::JSGetCollimatorSID);
+	Disp->Get.Push("Filter", p, &CollimatorDevice::JSGetCollimatorFilter);
+	Disp->Get.Push("Angle", p, &CollimatorDevice::JSGetCollimatorAngle);
+}
+
+void OemCollimator::SetCtrlDev(VMIMAMMODevice* pCtrlDev)
+{
+	m_pGEN = pCtrlDev;
+}
+
+RET_STATUS OemCollimator::SetCollimatorFilter(WORD pParams)
+{
+	RET_STATUS ret = RET_STATUS::RET_FAILED;
+	
+	
+	ret = m_pGEN->SetFilter(pParams);
+
+	return ret;
+}
+
+RET_STATUS OemCollimator::SetCollimatorSize(WORD xsize, WORD ysize)
+{
+	RET_STATUS ret = RET_STATUS::RET_FAILED;
+	ret = m_pGEN->SetCollimatorSize(xsize,  ysize);
+	return ret;
+}
+
+RET_STATUS OemCollimator::SetCollimatorLight(WORD pParams)
+{
+	//RET_STATUS ret = RET_STATUS::RET_FAILED;
+		
+	RET_STATUS ret = m_pGEN->SetCollimatorLight(pParams);
+
+	return ret;
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/OEM.Collimator.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "CCOS.Dev.CollimatorMoudle.hpp"
+
+namespace CCOS::Dev::Detail::Generator
+{
+	class VMIMAMMODevice;
+}
+
+using namespace CCOS::Dev::Detail::Collimator;
+using namespace CCOS::Dev::Detail::Generator;
+
+class OemCollimator :public CollimatorDevice
+{
+	using super = CollimatorDevice;
+
+	class	VMIMAMMODevice* m_pGEN;
+
+public:
+	OemCollimator(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
+	~OemCollimator();
+
+	void SetCtrlDev(VMIMAMMODevice* pCtrlDev);
+
+	virtual bool Prepare() override;
+	virtual void Register() override;
+
+
+	virtual RET_STATUS  SetCollimatorFilter(WORD pParams) override;
+	virtual RET_STATUS  SetCollimatorSize(WORD xsize, WORD ysize) override;
+
+	//virtual int GetCollimatorLight();
+	virtual RET_STATUS  SetCollimatorLight(WORD pParams) override;
+
+
+};

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/OEM.Dap.cpp

@@ -0,0 +1,57 @@
+#include "stdafx.h"
+#include "OEM.Dap.h"
+//#include "CCOS.Dev.FPD.Demo.h"
+#include "CCOS.Dev.Generator.VMIMAMMO.h"
+
+OemDap::OemDap(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter): super(EventCenter)
+{
+
+}
+
+OemDap::~OemDap()
+{
+
+}
+bool OemDap::Prepare()
+{
+	printf("OemDap::Prepare\n");
+	Register();
+
+	return true;
+}
+void OemDap::Register()
+{
+	printf("OemDap::Register\n");
+
+	auto p = static_cast <DapDevice*> (this);
+	super::Register();
+
+	//auto Disp = Dispatch.Lock().As();
+	//Disp->Action.Push("ClearDAP", p, &OemDap::JSClearDAP);
+	//Disp->Action.Push("QueryDAP", p, &OemDap::JSQueryDAP);
+
+	//Disp->Get.Push("DAP", p, &OemDap::JSGetDAP);
+	
+}
+
+void OemDap::SetCtrlDev(VMIMAMMODevice* pCtrlDev)
+{
+	m_pGEN = pCtrlDev;
+}
+
+RET_STATUS OemDap::ClearDap()
+{
+	RET_STATUS ret = RET_STATUS::RET_FAILED;
+	
+	
+	ret = m_pGEN->Clear_DAP();
+
+	return ret;
+}
+
+RET_STATUS OemDap::QueryDap()
+{
+	RET_STATUS ret = RET_STATUS::RET_FAILED;
+	ret = m_pGEN->QueryDAP();
+	return ret;
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/OEM.Dap.h

@@ -0,0 +1,32 @@
+#pragma once
+#include "CCOS.Dev.DapMoudle.hpp"
+
+
+namespace CCOS::Dev::Detail::Generator
+{
+	class VMIMAMMODevice;
+}
+
+using namespace CCOS::Dev::Detail::DAP;
+using namespace CCOS::Dev::Detail::Generator;
+
+class OemDap :public DapDevice
+{
+	using super = DapDevice;
+
+	class	VMIMAMMODevice* m_pGEN;
+
+public:
+	OemDap(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
+	~OemDap();
+
+	void SetCtrlDev(VMIMAMMODevice* pCtrlDev);
+
+	virtual bool Prepare() override;
+	virtual void Register() override;
+
+	RET_STATUS  ClearDap();
+	RET_STATUS  QueryDap();
+	//virtual RET_STATUS  SetCollimatorFilter(WORD pParams) override;
+
+};

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/OEM.Mechanical.cpp

@@ -0,0 +1,56 @@
+#include "stdafx.h"
+#include "OEM.Mechanical.h"
+#include "CCOS.Dev.Generator.VMIMAMMO.h"
+
+OemMechanical::OemMechanical(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter): super(EventCenter)
+{
+	m_pGEN = nullptr;
+}
+
+OemMechanical::~OemMechanical()
+{
+
+}
+bool OemMechanical::Prepare()
+{
+	printf("OemMechanical::Prepare\n");
+	Register();
+
+	return true;
+}
+void OemMechanical::Register()
+{
+	printf("OemMechanical::Register\n");
+	super::Register();
+}
+
+void OemMechanical::SetCtrlDev(VMIMAMMODevice* pCtrlDev)
+{
+	m_pGEN = pCtrlDev;
+}
+
+RET_STATUS OemMechanical::GetTomoResults(ResDataObject& resultAngle, ResDataObject& resultHeight)
+{
+	RET_STATUS ret = RET_STATUS::RET_FAILED;
+	
+	ret = m_pGEN->GetTomoResults(resultAngle, resultHeight);
+
+	return ret;
+}
+
+RET_STATUS OemMechanical::SetGrid(unsigned int GridType)
+{
+	RET_STATUS ret = RET_STATUS::RET_FAILED;
+	
+	//ysj++v1的逻辑是首先获取，如果不同，再set，相同则不做动作。
+
+	ret = m_pGEN->SetGrid(GridType);
+	return ret;
+}
+//这个接口，UI层 可能是叫setpress
+RET_STATUS OemMechanical::SetAutoTracking(unsigned int nAutoTracking)
+{
+	RET_STATUS ret = RET_STATUS::RET_FAILED;
+	ret = m_pGEN->SetAutoTracking(nAutoTracking);
+	return ret;
+}

Generator/VMI/CCOS.Dev.Generator.VMIMAMMO/OEM.Mechanical.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "CCOS.Dev.MechanicalMoudle.hpp"
+
+namespace CCOS::Dev::Detail::Generator
+{
+	class VMIMAMMODevice;
+}
+
+using namespace CCOS::Dev::Detail::Mechanical;
+using namespace CCOS::Dev::Detail::Generator;
+
+class OemMechanical :public MechanicalDevice
+{
+	using super = MechanicalDevice;
+
+	class	VMIMAMMODevice* m_pGEN;
+
+public:
+	OemMechanical(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
+	~OemMechanical();
+
+	void SetCtrlDev(VMIMAMMODevice* pCtrlDev);
+
+	virtual bool Prepare() override;
+	virtual void Register() override;
+
+	virtual RET_STATUS GetTomoResults(ResDataObject& resultAngle, ResDataObject& resultHeight) override;
+	virtual RET_STATUS SetGrid(unsigned int GridType) override;
+	virtual RET_STATUS SetAutoTracking(unsigned int nAutoTracking) override;
+};