PhysicalDevice/Generator/IMD/DIOS.Dev.Generator.IMD/DIOS.Dev.Generator.IMD.cpp

// CCOS.Dev.GEN.IMD.cpp : 定义 DLL 应用程序的导出函数。
//

#include "stdafx.h"
#include <assert.h>
#include <functional>
#include <fstream>
using namespace std::placeholders;

//#include "logger.temp.h"
#include "CCOS.Dev.Generator.IMD.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)
#pragma comment(lib, "version.lib")

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


//-----------------------------------------------------------------------------
//		IMDDevice
//-----------------------------------------------------------------------------

std::vector <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 };
std::vector <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 };
std::vector <int> 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::IMDDevice::IMDDevice(std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF) : super(center, SCF)
{
	assert(EventCenter);
	string version;
	if (GetVersion(version, hMyModule))
		FINFO("\n===============IMD log begin : module version:{$} ===================\n", version.c_str());
	else
		FINFO("\n===============log begin : version:0.0.0.0 ===================\n");
	//获取delta动态库版本号
	string strDeltaPath;
	strDeltaPath = GetDynamicLibraryPath() + "\\CCOS.Dev.Generator.IMD64.dll";
	string strVersion;
	strVersion = GetFileVersion(strDeltaPath);
	FINFO("=====================log begin :delta dll version{$}===strDeltaPath {$}====================", strVersion, strDeltaPath);
	FINFO("Enter IMDDevice(std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF) : super(center, SCF)");
	m_DoseUnit.m_KV.reset(new KVMould(0.0, 40.0, 120.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.5, 1000.0, 0.01));
	m_DoseUnit.m_Techmode.reset(new TECHMODEMould(0, 0, 2, 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, 40.0, 120.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.5, 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(0, 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_ExpMode.reset(new EXPMODEMould(AttrKey::EXPMODE_TYPE::Single));
	m_DoseUnit.m_FrameRate.reset(new FRAMERATEMould(0, 0, 16, 1));
	m_DoseUnit.m_FLMode.reset(new FLUModeMould(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_NOTFLU));

	m_MSGUnit.reset(new nsDetail::MSGUnit(center, nsGEN::GeneratorUnitType));
	m_DAP.reset(new DevDAP::DOSEMould(0.0, 0.0, 1000.0, 0.01));
	m_DoseUnit.m_FLMode.reset(new FLUModeMould(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_NOTFLU));
	m_DoseUnit.m_FLIntTime.reset(new FLUIntTimeMould(0.0, 0.0, 100.0, 0.1));
	m_DoseUnit.m_FLAccTime.reset(new FLAccTimeMould(0.0, 0.0, 999.0, 0.1));
	m_DoseUnit.m_FLKV.reset(new FLUKVMould(0, 40, 125, 1));
	m_DoseUnit.m_FLMS.reset(new FLUMSMould(10.0, 10.0, 999999.0, 0.01));
	m_DoseUnit.m_FLMA.reset(new FLUMAMould(0.5, 0.5, 99.0, 0.1));
	m_DoseUnit.m_ABSStatus.reset(new FLUABSStatusMould(0, 0, 2, 1));
	m_DoseUnit.m_PPS.reset(new PPSMould(0.5, 0.5, 30, 0.1));
	m_DoseUnit.m_DoseLevel.reset(new FLUDoseLevelMould(0, 0, 2, 1));
	m_DoseUnit.m_Curve.reset(new FLUCurveMould(0, 0, 3, 1));
	m_hGenPostEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_pHardwareStatusThread = NULL;
	
	OnCallBack();

	Register();

	Reset();
		
	HWSend("SMK07");	//1 初始化时使能系统配置类型	指令system marker SMKnn		逸动C - ARM系统设置为7.

	HWSend("DSN01");

	RefreshData();

	StartHardwareStatusThread();

	
	FINFO("Exit IMDDevice(std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF) : super(center, SCF)");
}

std::string IMDDevice::GetDynamicLibraryPath()
{
	HMODULE hModule = GetModuleHandle("CCOS.Dev.Generator.IMD64.dll");
	char path[MAX_PATH];
	GetModuleFileName(hModule, path, MAX_PATH);
	std::string fullPath(path);
	size_t pos = fullPath.find_last_of("\\/");
	FINFO("Delta dll fullPath {$}", fullPath);
	return fullPath.substr(0, pos);
}

std::string IMDDevice::GetFileVersion(std::string strFilePathName)
{
	DWORD dwVerSize = GetFileVersionInfoSize(strFilePathName.c_str(), NULL);
	if (dwVerSize == 0)
	{
		return false;
	}

	LPVOID pVersionBuffer = malloc(dwVerSize);
	GetFileVersionInfo(strFilePathName.c_str(), 0, dwVerSize, pVersionBuffer);

	VS_FIXEDFILEINFO* pInfo;
	UINT nInfoLen;
	std::string strVersion = "";

	if (VerQueryValue(pVersionBuffer, "\\", (void**)&pInfo, &nInfoLen))
	{
		strVersion = to_string(HIWORD(pInfo->dwFileVersionMS)) + "." + to_string(LOWORD(pInfo->dwFileVersionMS)) + "."
			+ to_string(HIWORD(pInfo->dwFileVersionLS)) + "." + to_string(LOWORD(pInfo->dwFileVersionLS));
	}

	return strVersion;
}
bool CCOS::Dev::Detail::Generator::IMDDevice::LoadConfig(string configfile)
{
	std::ifstream file(configfile);
	if (!file) {
		// 文件不存在，直接返回空的Connection对象
		FINFO("Config file does not exist: {$}", configfile);
		return -1;
	}
	else
	{
		FINFO("load {$} successful", configfile.c_str());
	}

	if (m_bLoadConfigFile)
	{
		FINFO("Configuration already loaded.");
		return 0;
	}

	ResDataObject temp;
	m_strConfigPath = configfile;
	temp.loadFile(m_strConfigPath.c_str());
	m_GenConfig = temp["CONFIGURATION"];
	TransJsonText(m_GenConfig);
	m_bLoadConfigFile = true;
	return true;
}
nsGEN::IMDDevice::IMDDevice(std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF, string configfile) : super(center, SCF)
{
	assert(EventCenter);
	FINFO("verson:3.0.0.2");
	m_DoseUnit.m_KV.reset(new KVMould(0.0, 40.0, 120.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.5, 1000.0, 0.01));
	m_DoseUnit.m_Techmode.reset(new TECHMODEMould(0, 0, 2, 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, 40.0, 120.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.5, 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(0, 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_ExpMode.reset(new EXPMODEMould(AttrKey::EXPMODE_TYPE::Single));
	m_DoseUnit.m_FrameRate.reset(new FRAMERATEMould(0, 0, 16, 1));
	m_DoseUnit.m_FLMode.reset(new FLUModeMould(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_NOTFLU));

	m_MSGUnit.reset(new nsDetail::MSGUnit(center, nsGEN::GeneratorUnitType));
	m_DAP.reset(new DevDAP::DOSEMould(0.0, 0.0, 1000.0, 0.01));
	m_DoseUnit.m_FLMode.reset(new FLUModeMould(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_NOTFLU));
	m_DoseUnit.m_FLIntTime.reset(new FLUIntTimeMould(0.0, 0.0, 100.0, 0.1));
	m_DoseUnit.m_FLAccTime.reset(new FLAccTimeMould(0.0, 0.0, 999.0, 0.1));
	m_DoseUnit.m_FLKV.reset(new FLUKVMould(0, 40, 125, 1));
	m_DoseUnit.m_FLMS.reset(new FLUMSMould(10.0, 10.0, 999999.0, 0.01));
	m_DoseUnit.m_FLMA.reset(new FLUMAMould(0.5, 0.5, 99.0, 0.1));
	m_DoseUnit.m_ABSStatus.reset(new FLUABSStatusMould(0, 0, 2, 1));
	m_DoseUnit.m_PPS.reset(new PPSMould(0.5, 0.5, 30, 0.1));
	m_DoseUnit.m_DoseLevel.reset(new FLUDoseLevelMould(0, 0, 2, 1));
	m_DoseUnit.m_Curve.reset(new FLUCurveMould(0, 0, 3, 1));
	//m_DoseUnit.m_XwindowStatus.reset(new XWINDOWSITYMould(AttrKey::XWINDOW_OFF, AttrKey::XWINDOW_OFF, AttrKey::XWINDOW_ON, 1));
	m_hGenPostEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_pHardwareStatusThread = NULL;
	m_bLoadConfigFile = false;

	m_strConfigPath = configfile;

	OnCallBack();

	Register();

	Reset();

	//int nSMK = (int)(m_GenConfig["SMK"]);

	//char cmdTemp[50] = { 0 };
	//sprintf_s(cmdTemp, "SMK%02d", nSMK);
	//HWSend(cmdTemp);

	//int nDSN = (int)(m_GenConfig["DSN"]);
	//sprintf_s(cmdTemp, "DSN%02d", nDSN);
	//HWSend(cmdTemp);

	HWSend("RSM1");	  //表示脚闸的涵义，0 not used , 1 rad , 2 control  ,3 cine.
	HWSend("FLD2");	  //doselevel :H M L ,默认是2
	HWSend("FFP2");
	HWSend("FTO060"); //timeout 60s
	HWSend("XET0");
	HWSend("EST");

	RefreshData();

	StartHardwareStatusThread();
}

void nsGEN::IMDDevice::SubscribeSelf(ccos_mqtt_connection* conn)
{
	SubscribeTopic(conn, "CCOS/DEVICE/Subsystem/Notify/CurrentSMState");
}
nsGEN::IMDDevice::~IMDDevice()
{
	CloseHandle(m_hGenPostEvent);
}

std::string nsGEN::IMDDevice::GetGUID() const
{	
	FINFO("\n===============GetGUID : {$} ===================\n", GeneratorUnitType);
	return GeneratorUnitType;
}

void nsGEN::IMDDevice::Register()
{
	auto Disp = &Dispatch;

	superGen::Register(Disp);
	superGen::RegisterRAD(Disp);
	superGen::RegisterAEC(Disp);
	superGen::RegisterExpEnable(Disp);
	superGen::RegisterFluoro(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("SetExoStartTic", fun_StartMove);

	//auto fun_EndMove = [this](auto a, auto& b)
	//{
	//	return EndMove();
	//};
	//Disp->Action.Push("SetExoEndTic", fun_EndMove);
}

RET_STATUS nsGEN::IMDDevice::IncKV()
{
	if (!m_DoseUnit.m_KV->CanInc())  return RET_STATUS::RET_SUCCEED;
	return HWSend("RKVI");
}

RET_STATUS nsGEN::IMDDevice::DecKV()
{
	if (!m_DoseUnit.m_KV->CanDec())  return RET_STATUS::RET_SUCCEED;
	return HWSend("RKVD");
}

RET_STATUS nsGEN::IMDDevice::SetKV(float value)
{		
	if (!m_DoseUnit.m_KV->Verify(value))  return RET_STATUS::RET_SUCCEED;
	char temp[50] = { 0 };
	sprintf_s(temp, "RKV%03d", (int)value);
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::IncMA()
{
	if (!m_DoseUnit.m_MA->CanInc())  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is MAS, can't inc MA");
		return RET_STATUS::RET_FAILED;
	}
	return HWSend("RMAI");
}

RET_STATUS nsGEN::IMDDevice::DecMA()
{
	if (!m_DoseUnit.m_MA->CanDec())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is MAS, can't dec MA");
		return RET_STATUS::RET_FAILED;
	}
	return HWSend("RMAD");
}

RET_STATUS nsGEN::IMDDevice::SetMA(float value)
{
	if (!m_DoseUnit.m_MA->Verify(value))  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is MAS, can't set MA");
		return RET_STATUS::RET_FAILED;
	}

	char temp[50] = { 0 };
	sprintf_s(temp, "RMA%06d", (int)(value * 100));
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::IncMS()
{
	if (!m_DoseUnit.m_MS->CanInc())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is MAS, can't inc MS");
		return RET_STATUS::RET_FAILED;
	}

	return HWSend("RMSI");
}

RET_STATUS nsGEN::IMDDevice::DecMS()
{
	if (!m_DoseUnit.m_MS->CanDec())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is MAS, can't dec MS");
		return RET_STATUS::RET_FAILED;
	}

	return HWSend("RMSD");
}

RET_STATUS nsGEN::IMDDevice::SetMS(float value)
{
	if (!m_DoseUnit.m_MA->Verify(value))  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is MAS, can't set MS");
		return RET_STATUS::RET_FAILED;
	}
	char temp[50] { 0 };
	
	sprintf_s(temp, "RMS%07d", (int)(value * 100));
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::IncMAS()
{
	if (!m_DoseUnit.m_MAS->CanInc()) return RET_STATUS::RET_SUCCEED;
	
	if (m_DoseUnit.m_Techmode->Get() != AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is not MAS, can't inc MAS");
		return RET_STATUS::RET_FAILED;
	}

	return HWSend("RMXI");
}

RET_STATUS nsGEN::IMDDevice::DecMAS()
{
	if (!m_DoseUnit.m_MAS->CanDec())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get() != AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is not MAS, can't dec MAS");
		return RET_STATUS::RET_FAILED;
	}
	return HWSend("RMXD");
}

RET_STATUS nsGEN::IMDDevice::SetMAS(float value)
{
	if (!m_DoseUnit.m_MA->Verify(value))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() != AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		FINFO("\n Techmode is not MAS, can't set MAS");
		return RET_STATUS::RET_FAILED;
	}
	char temp[50] = { 0 };
	sprintf_s(temp, "RMX%06d", (int)(value * 1000));
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::SetTechmode(int value)
{
	if (!m_DoseUnit.m_Techmode->Verify(value))  return RET_STATUS::RET_SUCCEED;

	if (value == AttrKey::TECHMODE_V2TYPE::ET_AEC)//if AEC, translate to time. why? i need reason.
		value = AttrKey::TECHMODE_V2TYPE::ET_TIME;

	char temp[50] = { 0 };
	sprintf_s(temp, "RET%01d", (int)value);
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::SetFocus(int value)
{
	if (!m_DoseUnit.m_Focus->Verify(value)) return RET_STATUS::RET_SUCCEED;

	char temp[50] = { 0 };
	sprintf_s(temp, "RFO%01d", (int)value);
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::SetAECDensity(int value)
{
	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 };
	if (value >= 0)
	{
		sprintf_s(temp, "RFN+%01d", (int)value);
	}
	else
	{
		sprintf_s(temp, "RFN-%01d", (int)value);
	}

	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::SetAECField(int value)
{
	if (!m_DoseUnit.m_AECField->Verify(value))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
		return RET_STATUS::RET_FAILED;

	char temp[50] = { 0 };
	sprintf_s(temp, "RFI%03d", (int)value);
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::SetAECFilm(int value)
{
	if (!m_DoseUnit.m_AECFilm->Verify(value))  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
		return RET_STATUS::RET_FAILED;

	char temp[50] = { 0 };
	sprintf_s(temp, "RFS%03d", (int)value);
	return HWSend(temp);
}

RET_STATUS  nsGEN::IMDDevice::SetWS(const string value)
{
	int tempws = 0;
	if (value == "Table")  tempws = 0;
	else if (value == "Wall")  tempws = 1;
	else if (value == "Direct")  tempws = 2;
	else if (value == "Free")  tempws = 3;
	char temp[50] = { 0 };
	sprintf_s(temp, "EWS%01d", tempws);
	return HWSend(temp);
}


RET_STATUS nsGEN::IMDDevice::SetAPR(const _tAPRArgs& t)
{
	m_t = t;
	{
		FINFO("*********************Enter SetAPR**********************");
		if (!m_DoseUnit.m_KV->Verify(t.fKV))
		{
			FERROR("SetAPR:KV Out of bounds[{$}] \n", t.fKV);
		}
		else if (!m_DoseUnit.m_MA->Verify(t.fMA) && (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_3P ||
			m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_AEC_3P))
		{
			FERROR("SetAPR:MA Out of bounds[{$}] \n", t.fMA);
		}
		else if (!m_DoseUnit.m_MS->Verify(t.fMS) && (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_3P ||
			m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_AEC_3P))
		{
			FERROR("SetAPR:MS Out of bounds[{$}] \n", t.fMS);
		}
		else if (!m_DoseUnit.m_MAS->Verify(t.fMAS) && (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_2P ||
			m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_AEC_2P))
		{
			FERROR("SetAPR:MAS Out of bounds[{$}] \n", t.fMAS);
			//add by wxx for test
			float oldKV = m_DoseUnit.m_KV->Get();
			float oldMAS = m_DoseUnit.m_MAS->Get();
			float oldMA = m_DoseUnit.m_MA->Get();
			float oldMS = m_DoseUnit.m_MS->Get();
			int oldFocus = m_DoseUnit.m_Focus->Get();
			FERROR("SetAPR:old KV[{$}],MAS[{$}],MA[{$}],Focus[{$}]", oldKV, oldMAS, oldMA, oldFocus);
			char temp[50] = { 0 };
			if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_3P ||
				m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_AEC_3P)
			{
				SetKV(oldKV);
				SetMS(oldMA);
				SetMA(oldMA);
				SetFocus(oldFocus);
				//char temp[50] = { 0 };
				//sprintf_s(temp, "50,%d,%d,%d,%d,", (int)(oldMS), (int)round(oldKV * 1000 / 12.21), (int)round(oldMA / 0.04884), (int)(oldFocus));
				//return HWSend(temp);
			}
			else if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_2P ||
				m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_AEC_2P)
			{
				//char temp[50] = { 0 };

				//sprintf_s(temp, "10,%d,", (int)round(oldKV * 1000 / 12.21));
				//HWSend(temp);
				SetKV(oldKV);
				float tempValue = oldMAS;
				if (m_DoseUnit.m_MAS->CanToUpdate(tempValue, g_MAS_List))
				{
					FDEBUG("SetAPR:update MAS[{$}]->[{$}]->[{$}]", m_DoseUnit.m_MAS->Get(), oldFocus, tempValue);
					SetMAS(tempValue);
					//char temp[50] = { 0 };
					//sprintf_s(temp, "74,%d,", (int)round(tempValue / 0.1));
					//HWSend(temp);
				}
			}
		}
		else if (!m_DoseUnit.m_Focus->Verify(t.nFocus))
		{
			FERROR("SetAPR:Focus Out of bounds[{$}] \n", t.nFocus);
		}
		else
		{
			if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_3P ||
				m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_AEC_3P)
			{
				SetKV(t.fKV);
				SetMS(t.fMS);
				SetMA(t.fMA);
				SetFocus(t.nFocus);
				//char temp[50] = { 0 };
				//sprintf_s(temp, "50,%d,%d,%d,%d,", (int)(t.fMS), (int)round(t.fKV * 1000 / 12.21), (int)round(t.fMA / 0.04884), (int)(t.nFocus));
				//return HWSend(temp);
			}
			else if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_2P ||
				m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_TYPE::TECHMODE_AEC_2P)
			{
				//char temp[50] = { 0 };

				//sprintf_s(temp, "10,%d,", (int)round(t.fKV * 1000 / 12.21));
				//HWSend(temp);
				SetKV(t.fKV);
				float tempValue = t.fMAS;
				if (m_DoseUnit.m_MAS->CanToUpdate(tempValue, g_MAS_List))
				{
					SetMAS(tempValue);
					FDEBUG("SetAPR:update MAS[{$}]->[{$}]->[{$}]", m_DoseUnit.m_MAS->Get(), t.fMAS, tempValue);
					//char temp[50] = { 0 };
					//sprintf_s(temp, "74,%d,", (int)round(tempValue / 0.1));
					//HWSend(temp);
				}
			}
		}
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetAPF(const _tAPFArgs& t)
{
	FINFO("SetAPF: nWS={$}, Flu mode ={$}, ABS mode ={$}, DoseLever ={$}, nFlkv =={$}, FlMA ={$}", t.nWS, t.nFluMode, t.nABSMode, t.nDoseLever, t.nFLKV, t.fFLMA, t.nPPS);
	//SetABSMode(t.nABSMode);
	//SetFLFMode(to_string(t.nFluMode));
	//SetFluDoseLever(t.nDoseLever);
	SetFluKV(t.nFLKV);
	Sleep(20);
	SetFluMA(t.fFLMA);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::QueryHE(int& value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::QueryPostKV(float& value)
{
	value = m_DoseUnit.m_PostKV->Get();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::QueryPostMA(float& value)
{
	return HWSend("RAP?");
}

RET_STATUS nsGEN::IMDDevice::QueryPostMS(float& value)
{
	return HWSend("RAT?");
}

RET_STATUS nsGEN::IMDDevice::QueryPostMAS(float& value)
{
	value = m_DoseUnit.m_PostMAS->Get();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::Clear_DAP()
{
	char temp[50] = "EDZ";
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::GetValue_DAP(float& value)
{
	value = m_DAP->Get();
	return RET_STATUS::RET_SUCCEED;
}

void nsGEN::IMDDevice::StartMove()
{
	FINFO("Enter startMove");
	char temp[50] = { 0 };
	sprintf_s(temp, "RPW%04d", (int)(10));
	HWSend(temp);
	//点片EXO2  ，PF ：EXO1  CF:EXO3 from zhao??  不知道哪来的逻辑，应该是只有0和1才对
	if (m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::Single)
	{
		sprintf_s(temp, "EXO%01d", (int)(2));
		HWSend(temp);	
	}
	else if (m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::TOMO)
	{
		sprintf_s(temp, "EXO%01d", (int)(1));
		HWSend(temp);
	}
	else if (m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::CoutineSerial)
	{
		sprintf_s(temp, "EXO%01d", (int)(3));
		HWSend(temp);
	}
	else if (m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::PulseSerial)
	{
		sprintf_s(temp, "EXO%01d", (int)(1));
		HWSend(temp);
	}

	if (m_DoseUnit.m_ExpMode->JSGet() != AttrKey::EXPMODE_TYPE::CoutineSerial)
	{
		sprintf_s(temp, "TIC%01d", (int)(1));
		HWSend(temp);
	}

	FINFO("end startmove");
}

void nsGEN::IMDDevice::EndMove()
{
	printf("enter EndMove\n");
	FINFO("Enter endmove");
	char temp[50]{ 0 };
	sprintf_s(temp, "EXO%01d", (int)(0));
	HWSend(temp);
	
	sprintf_s(temp, "TIC%01d", (int)(0));
	HWSend(temp);
	printf("end EndMove\n");
	FINFO("end EndMove");
}

RET_STATUS nsGEN::IMDDevice::SetGenSynState(int value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetGenState(int value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetExpMode(std::string value)
{	
	FINFO("Enter SetExpMode...{$}",value);
	m_DoseUnit.m_ExpMode->Update(value);

	
	//退出CBCT,设置exp mode时，强制退出cbct，因为放在endmove中，偶发执行不到的问题。
	if (m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::Single)
	{
		FINFO("now is Single mode, send RPS0");
		SetRPS(0);
	}
	else if(m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::TOMO)
	{
		FINFO("now is Single mode, send RPS");
		SetRPS((int)(10 * (m_DoseUnit.m_FrameRate->Get())));
	}
	else if (m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::PulseSerial)
	{
		HWSend("FLF2");
	}
	else if (m_DoseUnit.m_ExpMode->JSGet() == AttrKey::EXPMODE_TYPE::CoutineSerial)
	{
		HWSend("FLF1");
	}
	HWSend("TIC0");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetFLFMode(std::string value)
{	
	if (value == AttrKey::FLFMODE_TYPE::FLF_CONTI)
	{
		m_DoseUnit.m_FLMode->Update(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_CF);
		return HWSend("FLF1");
	}
	else if (value == AttrKey::FLFMODE_TYPE::FLF_HL_CONTI)
	{
		m_DoseUnit.m_FLMode->Update(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_HCF);
		return HWSend("FLF1");
	}
	else if (value == AttrKey::FLFMODE_TYPE::FLF_PULSE)
	{
		m_DoseUnit.m_FLMode->Update(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_PF);
		return HWSend("FLF2");
	}
	else if (value == AttrKey::FLFMODE_TYPE::FLF_HL_PULSE)
	{
		m_DoseUnit.m_FLMode->Update(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_HPF);
		return HWSend("FLF2");
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetGenCurrentSMState(std::string value)
{
	m_strCurrentSMState = value;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetEXAMMode(std::string value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetFrameRate(FLOAT frameRate)
{
	m_DoseUnit.m_FrameRate->Update(frameRate);
	
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetRPS(int rps)
{
	char temp[50]{ 0 };	
	sprintf_s(temp, "RPS%03d", rps * 10);	
	return HWSend(temp);
}

RET_STATUS nsGEN::IMDDevice::RefreshData()
{
	HWSend("RKV?");
	HWSend("RMA?");
	HWSend("RMS?");
	HWSend("RR");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::IMDDevice::SetExpEnable()
{	
	if (m_DoseUnit.m_GenState->Get() != nsGEN::AttrKey::GENERATOR_STATUS_ERROR)
	{
		m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_STANDBY);
		FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
	}
	return HWSend("EXB1");
}

RET_STATUS nsGEN::IMDDevice::SetExpDisable()
{
	if (m_DoseUnit.m_GenState->Get() != nsGEN::AttrKey::GENERATOR_STATUS_ERROR)
	{
		m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_SLEEP);
		FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
	}
	return HWSend("EXB0");
}

RET_STATUS nsGEN::IMDDevice::Reset()
{
	return HWSend("ERE1");
}

RET_STATUS nsGEN::IMDDevice::HWSend(char* strCommand, int nTimeOut)
{
	if (!m_SCF)  return RET_STATUS::RET_FAILED;

	char strSendCommand[100] = { 0 };
	int len = strlen(strCommand);

	int tmpSum = 0;
	for (int i = 0; i < len; i++)
	{
		tmpSum += (int)strCommand[i];
	}
	char checkSum = char(tmpSum + 5);
	strSendCommand[0] = 0x02;
	memcpy(strSendCommand + 1, strCommand, len);
	strSendCommand[len + 1] = 0x03;
	strSendCommand[len + 2] = checkSum;

	printf("==OUT==: %s \n", strSendCommand);
	FINFO("==OUT==: {$} \n", strSendCommand);

	int retLength;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(strSendCommand, strlen(strSendCommand), nTimeOut, retLength);
	Sleep(nTimeOut);
	
	return RET_STATUS::RET_SUCCEED;
}

//-----------------------------------------------------------------------------
//		ProcessCmd
//-----------------------------------------------------------------------------

void nsGEN::IMDDevice::FireNotify(std::string key, std::string content)
{
	EventCenter->OnNotify(1, key, content);
}

struct tFrameMapping
{
	static const int MaxLen = 5;		//	前缀不能超超过 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);			//len最大只能是4
		strHead[0] = 0x02;				//STX
		for (int i = 0; i < len; i++)	//给strHead赋值
			strHead[i + 1] = str[i];
		NbOfCharOfHead = len + 1;
		fun = f;
	}
};

static std::list <tFrameMapping> arFrame;

static bool DecodeFrame(const char* strFrame, int length);

void nsGEN::IMDDevice::OnCallBack()
{
	auto HWNotProcess = [](const char* value, int length) -> void
	{
		printf("\n This commands didn't need to process!\n");
		FINFO("\n This commands didn't need to process!\n");
	};

	auto HWKV = [this](const char* value, int length) -> void
	{
		assert(value);
		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) / 1000.0;
		if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_TIME)
		{
			if (m_DoseUnit.m_MAS->Update(0))
				FireNotify(AttrKey::MAS, m_DoseUnit.m_MAS->JSGet());
		}
		else
		{
			if (m_DoseUnit.m_MAS->Update(fmas))
				FireNotify(AttrKey::MAS, m_DoseUnit.m_MAS->JSGet());
		}
	};

	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);
		if (m_DoseUnit.m_Techmode->Update(atoi(value)))
			FireNotify(AttrKey::TECHMODE, m_DoseUnit.m_Techmode->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)
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue == 2)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_READY);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			ResetEvent(m_hGenPostEvent);
			HWSend("PR2");
			m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::Single);
			StartMove();
		}
		else if (nValue == 1)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_PREPARE);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			HWSend("PR1");
		}
		else if (nValue == 0)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			HWSend("PR0");
			EndMove();
		}

	};
	auto HWXR = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue == 1)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON);
		}
		else if (nValue == 0)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
			HWSend("RAP?");
			HWSend("RAT?");
		}
		FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
	};
	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());

		//SetEvent(m_hGenPostEvent);

	};
	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());

		//SetEvent(m_hGenPostEvent);
	};
	auto HWDAP = [this](const char* value, int length)
	{
		//assert(value);
		//m_DoseUnit.m_da->Update(atof(value));
		//FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());
		//SetEvent(m_hGenPostEvent);
	};
	auto HWERROR = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue != 0)
		{
			char ErrorCode[10]{ "" };
			sprintf_s(ErrorCode, "IMDECOM_ERR_%d", nValue);
			int level = 1;
			m_MSGUnit->AddErrorMessage(ErrorCode, level, "");
		}
		else
		{
			int level = 1;
			char ErrorCode[10]{ "" };
			m_MSGUnit->DelErrorMessage(ErrorCode, level, "");
		}
	};
	auto HWWARN = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue != 0)
		{
			char WarnCode[10]{ "" };
			sprintf_s(WarnCode, "IMDECOM_WARN_%d", nValue);
			int level = 1;
			m_MSGUnit->AddWarnMessage(WarnCode, level, "");
		}
		else
		{
			int level = 1;
			char WarnCode[10]{ "" };
			m_MSGUnit->AddWarnMessage(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());
	};

	auto HWFLK = [this](const char* value, int length)
	{
		assert(value);
		if (m_DoseUnit.m_FLKV->Update(atof(value)))
			FireNotify(AttrKey::FLUKV, m_DoseUnit.m_FLKV->JSGet());
	};


	auto HWFLM = [this](const char* value, int length)
	{
		assert(value);
		if (m_DoseUnit.m_FLMA->Update(atof(value)/10.0))
			FireNotify(AttrKey::FLUMA, m_DoseUnit.m_FLMA->JSGet());
	};

	auto HWFLS = [this](const char* value, int length)
	{
		assert(value);
		if (m_DoseUnit.m_PPS->Update(atof(value)/10.0))
			FireNotify(AttrKey::FLUPPS, m_DoseUnit.m_PPS->JSGet());
	};

	auto HWFLX = [this](const char* value, int length)
	{
		assert(value);		
		int nValue = atoi(value);
		if (nValue == 1)
		{
			m_bXrayonProcess = true;
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_XRAYON);
		}
		else if (nValue == 0)
		{
			m_bXrayonProcess = false;
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_XRAYOFF);
		}
		FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
	};

	auto HWFLP = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		FINFO("FLP value [{$}]", nValue);
		if (nValue == 1)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_READY);		//根据全新定义 FLP1 才表示 ready。
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());

			if (m_DoseUnit.m_FLMode->JSGet() == to_string(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_CF))
			{
				m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::CoutineSerial);
			}
			else if (m_DoseUnit.m_FLMode->JSGet() == to_string(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_PF))
			{
				m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::PulseSerial);
			}
			StartMove();
		}
		else if (nValue == 4)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_READY);		//根据全新定义 FLP4 才表示 ready。
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			if (m_DoseUnit.m_FLMode->JSGet() == to_string(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_CF))
			{
				m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::CoutineSerial);
			}
			else if (m_DoseUnit.m_FLMode->JSGet() == to_string(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_PF))
			{
				m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::PulseSerial);
			}
			StartMove();
		}
		else if (nValue == 0)
		{
			m_bXrayonProcess = false;
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_OFF);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			EndMove();
		}
	};

	auto HWFLI = [this](const char* value, int length)
	{
		assert(value);
		if (m_DoseUnit.m_FLIntTime->Update(atof(value) / 10.0))
			FireNotify(AttrKey::FLUIntTime, m_DoseUnit.m_FLIntTime->JSGet());
	};

	auto HWEST = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		FINFO("EST [{$}]", nValue);
		assert(value);
		if (nValue == 1)
		{
			m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS_INIT);
		}
		else if ((nValue == 4) || (nValue == 5))
		{
			m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS_EXP);
		}
		else if (nValue == 6)
		{
			m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS_CALIBRATION);
		}
		else if (nValue == 7)
		{
			m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS_ERROR);
		}
		else
		{
			m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS_STANDBY);
		}
		FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
	};
	
	auto HWFLT = [this](const char* value, int length)
	{
		assert(value);
		float flt = atof(value) / 10.0;
		FINFO("flt: {$} ", flt);
		m_DoseUnit.m_FLAccTime->Update(flt);
		FireNotify(m_DoseUnit.m_FLAccTime->GetKey(), m_DoseUnit.m_FLAccTime->JSGet());
	};

	auto HWTIC = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		//try
		//{
		//	if ((int)m_GenConfig["SendXwindowToDetector"] == 1)
		//	{
		//		m_pSubSystemClient = new LogicClient("DV3_Detector", "", "NSQ", false);
		//		if (m_pSubSystemClient->Open("CCOS/DEVICE/Subsystem/Notify/CurrentSMState", ALL_ACCESS)) //换成探测器的路径
		//		{
		//			FDEBUG("Ccos_V3 Create DV3_SubSystem Client success");
		//		}
		//	}
		//}
		//catch (const std::exception&)
		//{

		//}
		//if (m_pSubSystemClient != NULL)
		//{
		//	if (!m_pSubSystemClient->IsClosed())
		//	{
		//		FINFO("m_pSubSystemClient is open");
		//		ResDataObject Request, Response;
		//		Request.add("P0", 1);
		//		m_pSubSystemClient->Action("DualSecondExpReady", Request, Response, 4993);
		//	}
		//	else
		//	{
		//		FINFO("DV3_Detector Client is Close");
		//	}
		//}
		//else
		//{
		//	FINFO("DV3_FullUCB Client is NULL");
		//}
		FINFO("m_strCurrentSMState [{$}] nValue [{$}]", m_strCurrentSMState, nValue);
		//while (strcmp(m_strCurrentSMState.c_str(), "FrameReady") == 0)
		//{
		//	if (nValue == 10)
		//	{
		//		m_DoseUnit.m_XwindowStatus->Update(AttrKey::XWINDOW_ON);
		//	}
		//	else if (nValue == 01)
		//	{
		//		m_DoseUnit.m_XwindowStatus->Update(AttrKey::XWINDOW_OFF);
		//	}
		//	FireNotify(m_DoseUnit.m_XwindowStatus->GetKey(), m_DoseUnit.m_XwindowStatus->JSGet());
		//}
	};
	//	有部分前缀是包含关系, 长的包含短的, 例如 KVS 包含了 KV.
	//	因此长的在前面, 短的在后面
	//	!!! Device 是个短寿命对象, 而 arFrame 是静态变量 !!!
	//	!!! 因此, 在添加到 arFrame 之前, 务必先清零 !!!
	arFrame.clear();

	
	arFrame.push_back(tFrameMapping("RKVI", 4, HWNotProcess));
	arFrame.push_back(tFrameMapping("RKVD", 4, HWNotProcess));
	arFrame.push_back(tFrameMapping("RMAI", 4, HWNotProcess));
	arFrame.push_back(tFrameMapping("RMAD", 4, HWNotProcess));
	arFrame.push_back(tFrameMapping("RMSI", 4, HWNotProcess));
	arFrame.push_back(tFrameMapping("RMSD", 4, HWNotProcess));
	arFrame.push_back(tFrameMapping("RMXI", 4, HWNotProcess));
	arFrame.push_back(tFrameMapping("RMXD", 4, HWNotProcess));
	arFrame.push_back(tFrameMapping("EXB", 3, HWNotProcess));
	arFrame.push_back(tFrameMapping("ERE", 3, HWNotProcess));
	arFrame.push_back(tFrameMapping("RR", 2, HWNotProcess));

	arFrame.push_back(tFrameMapping("RPS", 3, HWNotProcess));
	arFrame.push_back(tFrameMapping("EXO", 3, HWNotProcess));
	arFrame.push_back(tFrameMapping("TIC", 3, HWTIC));
	arFrame.push_back(tFrameMapping("RTS", 3, HWNotProcess));
	arFrame.push_back(tFrameMapping("DSN", 3, HWNotProcess));

	arFrame.push_back(tFrameMapping("RKV", 3, HWKV));
	arFrame.push_back(tFrameMapping("RMX", 3, HWMAS));
	arFrame.push_back(tFrameMapping("RMA", 3, HWMA));
	arFrame.push_back(tFrameMapping("RMS", 3, HWMS));
	arFrame.push_back(tFrameMapping("RET", 3, HWTechmode));
	arFrame.push_back(tFrameMapping("RFO", 3, HWFocus));
	arFrame.push_back(tFrameMapping("RFI", 3, HWAECField));
	arFrame.push_back(tFrameMapping("RFS", 3, HWAECFilm));
	arFrame.push_back(tFrameMapping("RFN", 3, HWAECDensity));
	arFrame.push_back(tFrameMapping("EWS", 3, HWWS));
	arFrame.push_back(tFrameMapping("PR", 2, HWPR));
	arFrame.push_back(tFrameMapping("XR", 2, HWXR));
	arFrame.push_back(tFrameMapping("RAP", 3, HWAPDOSE));
	arFrame.push_back(tFrameMapping("RAT", 3, HWATDOSE));
	arFrame.push_back(tFrameMapping("ERR", 3, HWERROR));
	arFrame.push_back(tFrameMapping("EWN", 3, HWWARN));
	arFrame.push_back(tFrameMapping("EHE", 3, HWEHE));
	arFrame.push_back(tFrameMapping("FLK", 3, HWFLK));
	arFrame.push_back(tFrameMapping("FLM", 3, HWFLM));
	arFrame.push_back(tFrameMapping("FLS", 3, HWFLS));
	arFrame.push_back(tFrameMapping("FLF", 3, HWNotProcess));
	arFrame.push_back(tFrameMapping("FLP", 3, HWFLP));
	arFrame.push_back(tFrameMapping("FLX", 3, HWFLX));
	arFrame.push_back(tFrameMapping("FLI", 3, HWFLI));
	arFrame.push_back(tFrameMapping("FLT", 3, HWFLT));
	arFrame.push_back(tFrameMapping("EST", 3, HWEST));
	
}

bool nsGEN::IMDDevice::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::IMDDevice::HardwareStatusThread(LPVOID pParam)
{
	IMDDevice* pCurGen = (IMDDevice*)pParam;
	if (pCurGen == NULL)
	{
		return false;
	}
	FINFO("HardwareStatusThread start");
	while (true)
	{
		Sleep(2000);
		if (!pCurGen->m_bXrayonProcess)
		{
			pCurGen->HWSend("EHE?");
			pCurGen->HWSend("EST");
			//pCurGen->GetFluAccTimer();
		}

	}

	FINFO("HardwareStatusThread stop");
	return true;
}

bool nsGEN::IMDDevice::GetFLIntTimer()
{
	FINFO("Enter GetFLIntTimer");
	HWSend("FLI?");
	return true;
}


//-----------------------------------------------------------------------------
//		IMDDriver
//-----------------------------------------------------------------------------

nsGEN::IMDDriver::IMDDriver()
{
}

nsGEN::IMDDriver::~IMDDriver()
{
}

auto nsGEN::IMDDriver::CreateDevice(int index) -> std::unique_ptr <IODevice>
{
	FINFO("CreateDevice");
	m_pDevice = new IMDDevice(EventCenter, m_SCF, m_ConfigFileName);

	auto dev = std::unique_ptr <IODevice>(new IODevice(m_pDevice));
	return dev;
}

void nsGEN::IMDDriver::FireNotify(int code, std::string key, std::string content)
{
	EventCenter->OnNotify(code, key, content);
}

Log4CPP::Logger* gLogger = nullptr;
void nsGEN::IMDDriver::Prepare()
{
	string strLogPath = GetProcessDirectory() + R"(\OEMDrivers\Generator\Conf\Log4CPP.Config.GEN.xml)";
	Log4CPP::GlobalContext::Map::Set(ECOM::Utility::Hash("LogFileName"), "GEN.IMD");
	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
	gLogger = Log4CPP::LogManager::GetLogger("GEN.IMD");

	FINFO("Enter Prepare.");
	m_SCFDllName = GetConnectDLL(m_ConfigFileName);

	super::Prepare();
}

bool  nsGEN::IMDDriver::Connect()
{
	FINFO("ConfigFileName: {$}", m_ConfigFileName);
	super::DisConnect();
	m_SCF.Disconnect();
	// 检查文件是否存在
	std::ifstream file(m_ConfigFileName);
	if (!file) {
		// 文件不存在，直接返回空的Connection对象
		FINFO("{$} does not exist", m_ConfigFileName);
		return false;
	}
	ResDataObject Connection = GetConnectParam(m_ConfigFileName);
	FINFO("Connections: {$}", Connection.encode());
	printf("connections:%s \n", Connection.encode());
	auto erCode = m_SCF.Connect(Connection.encode(), &nsGEN::IMDDriver::callbackPackageProcess, SCF_PACKET_TRANSFER, 3000);
	if (erCode != SCF_ERR::SCF_SUCCEED)
	{
		FINFO("SCF connection failed: erCode != SCF_ERR::SCF_SUCCEED");
		super::Disconnect();
		m_SCF.Disconnect();
		return false;
	}
	auto rc = super::Connect();
	if (!rc)
	{
		FINFO("super::Connect() failed");
		super::Disconnect();
		m_SCF.Disconnect();
		return false;
	}
	if (m_pDevice == nullptr)
	{
		return false;
	}
	FINFO("Connect Successful");
	return true;
}

void nsGEN::IMDDriver::Disconnect()
{
	super::Disconnect();
	m_SCF.Disconnect();

	Close();
	gLogger = nullptr;
}

bool nsGEN::IMDDriver::isConnected() const
{
	if (!super::isConnected())
	{
		FINFO("No valid connection!!!");
		return false;
	}

	if (m_pDevice == nullptr)
	{
		FINFO("m_pDevice == nullptr");
		return false;
	}

	if (!m_pDevice->LoadConfig(m_ConfigFileName))
	{
		return false;
	}

	int genState = m_pDevice->GetGenState();
	FINFO("m_pDevice->GetGenState(): {$}", genState);

	return genState > 0;  // 只有返回值大于 0 时才返回 true
}

std::string nsGEN::IMDDriver::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", "IMD");
		HardwareInfo.add("ProductID", "HF");
		HardwareInfo.add("SerialID", "Drv");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

std::string nsGEN::IMDDriver::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();
	printf("resDeviceResource :%s \n", resDeviceResource.encode());
	FINFO("resDeviceResource :{$} \n", resDeviceResource.encode());
	return res;
}

std::string nsGEN::IMDDriver::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", "IMD");
		HardwareInfo.add("ProductID", "HF");
		HardwareInfo.add("SerialID", "1234");
	}
	string ret = HardwareInfo.encode();
	return ret;
}
RET_STATUS nsGEN::IMDDevice::IncFluKV()
{
	if (!m_DoseUnit.m_FLKV->CanInc())  return RET_STATUS::RET_SUCCEED;
	return HWSend("FLK+");
}
RET_STATUS nsGEN::IMDDevice::DecFluKV()
{
	if (!m_DoseUnit.m_FLKV->CanDec())  return RET_STATUS::RET_SUCCEED;
	return HWSend("FLK-");
}
RET_STATUS nsGEN::IMDDevice::SetFluKV(float value)
{
	if (!m_DoseUnit.m_FLKV->Verify(value))  return RET_STATUS::RET_SUCCEED;
	char temp[50] = { 0 };
	sprintf_s(temp, "FLK%03d", (int)value);
	return HWSend(temp);
}
RET_STATUS nsGEN::IMDDevice::IncFluMA()
{
	if (!m_DoseUnit.m_FLMA->CanInc())  return RET_STATUS::RET_SUCCEED;
	return HWSend("FLM+");
}
RET_STATUS nsGEN::IMDDevice::DecFluMA()
{
	if (!m_DoseUnit.m_FLMA->CanDec())  return RET_STATUS::RET_SUCCEED;
	return HWSend("FLM-");
}
RET_STATUS nsGEN::IMDDevice::SetFluMA(float value)
{
	if (!m_DoseUnit.m_FLMA->Verify(value))  return RET_STATUS::RET_SUCCEED;
	char temp[50] = { 0 };
	sprintf_s(temp, "FLM%03d", (int)(value*10));
	return HWSend(temp);
}
RET_STATUS nsGEN::IMDDevice::IncFluMS()
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::DecFluMS()
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetFluMS(float value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetPPS(float frameRate)
{
	if (!m_DoseUnit.m_PPS->Verify(frameRate))  return RET_STATUS::RET_SUCCEED;
	char temp[50] = { 0 };
	sprintf_s(temp, "FLS%03d", (int)(frameRate * 10)); //pps 需要放大10倍
	return HWSend(temp);
}
RET_STATUS nsGEN::IMDDevice::INCPPS()
{
	if (!m_DoseUnit.m_PPS->CanInc())  return RET_STATUS::RET_SUCCEED;
	return HWSend("FLS+");
}
RET_STATUS nsGEN::IMDDevice::DECPPS()
{
	if (!m_DoseUnit.m_PPS->CanDec())  return RET_STATUS::RET_SUCCEED;
	return HWSend("FLS-");
}
RET_STATUS nsGEN::IMDDevice::SetPluseWidth(float fplusewidth)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetABSMode(int nMode)
{
	if (!m_DoseUnit.m_ABSStatus->Verify(nMode))  return RET_STATUS::RET_SUCCEED;

	char temp[50] = { 0 };
	FINFO("SetABSMode[{$}] \n", nMode);
	sprintf_s(temp, "FLA%1d", nMode);
	return HWSend(temp);
}
RET_STATUS nsGEN::IMDDevice::SetABSCurve(int curveNum)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::IncABSCurve()
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::DecABSCurve()
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetABSValue(float fABSValue)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetABSTargetEXI(float fEXIValue)
{
	return RET_STATUS::RET_SUCCEED;
}
float nsGEN::IMDDevice::GetFluIntTimer()
{
	return HWSend("FLI?");
}
float nsGEN::IMDDevice::GetFluAccTimer()
{
	return HWSend("FLT?");
}
RET_STATUS nsGEN::IMDDevice::ResetFluTimer(int ntype)
{
	char temp[50] = { 0 };
	sprintf_s(temp, "FLR%d", ntype);
	FINFO("ReSetFluAccTimer[{$}] \n", ntype);
	HWSend(temp);
	Sleep(200);
	GetFluAccTimer();
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetFluPre(int bPrepare)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetFluEXP(int bPrepare)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetFluMAG(int nsize)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::DisableMAG()
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetFluDoseLever(int nlever)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::SetHalfDose(int nlever)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::IMDDevice::TransferRadCurve(int ncurve)
{
	return RET_STATUS::RET_SUCCEED;
}
int nsGEN::IMDDevice::GetGenState()
{
	if (m_DoseUnit.m_GenState != NULL)
	{
		return m_DoseUnit.m_GenState->Get();
	}
	else
	{
		return 0;
	}
}
void nsGEN::IMDDriver::Dequeue(const char* Packet, DWORD Length)
{
	DecodeFrame(Packet, Length);
}

PACKET_RET nsGEN::IMDDriver::callbackPackageProcess(const char* RecData, DWORD nLength, DWORD& PacketLength)
{
	if (nLength < 1)
	{
		printf("nLength < 1, nLength==%d \n", nLength);
		FINFO("nLength < 1, nLength=={$} \n", nLength);
		return PACKET_USELESS;
	}

	for (DWORD i = 0; i < nLength - 1; i++)
	{
		//1 首先寻找包头
		if (RecData[i]==0x02)
		{			
			if (i!=0)
			{
				PacketLength = i;			//i之前的数据，全部扔掉
				char strtemp[100] = { 0 };
				memcpy(strtemp, RecData, i);
				strtemp[PacketLength + 1] = 0;
				printf("==IN error data ==:%s,PacketLength=%d,nLength=%d\n", strtemp, PacketLength, nLength);	
				return PACKET_USELESS;
			}
		}

		if (RecData[i] == 0x03)
		{
			PacketLength = i + 2;			//+2 because STX , sum.
			char strtemp[100] = { 0 };
			memcpy(strtemp, RecData, i);	// STX+RKC005(not include 03 + sum);  //only 复制 0x03之前的数据，这样解析时，后面的03 ，sum 都不要了。
			strtemp[PacketLength + 1] = 0;
			printf("==IN==:%s\n", strtemp);
			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;

	char data[100] = { 0 };
	memcpy(data, strFrame + Item.NbOfCharOfHead, length - Item.NbOfCharOfHead - 2);


	//pc += Item.NbOfCharOfHead;					//---------jk++:pc is value. why? plus NbOfCharOfHead.  意思是pc的指针后移几个数，

	Item.fun(data, length - Item.NbOfCharOfHead - 2);//第二个参数 不重要
	return true;
}

//-----------------------------------------------------------------------------
//		GetIODriver & CreateIODriver
//-----------------------------------------------------------------------------

static nsGEN::IMDDriver  gIODriver;

extern "C"  CCOS::Dev::IODriver * __cdecl GetIODriver()		// 返回静态对象的引用, 调用者不能删除 !
{
	return &gIODriver;
}

extern "C"  CCOS::Dev::IODriver * __cdecl CreateIODriver()  // 返回新对象, 调用者必须自行删除此对象 !
{
	return new nsGEN::IMDDriver();
}