#include "stdafx.h"
#include "GEN.DEV.ContainerExample.h"

namespace nsGEN = CCOS::Dev::Detail::Generator;
#define Example_LoopDefHBTime 1000

//生成命令校验和:cmdData 为 <CMD> [<,> <ARG>]...<,> 其长度要多出3个字符用于存放 STX、CSUM、ETX
char ComputeCheckSum(char* cmdData, int& size)
{
	if (size + 3 >= Example_Com_ReSendLen)
	{
		return 0x00;
	}
	int AsciiSum = Example_STX + Example_ETX;
	char TempCMD[Example_Com_ReSendLen] = { 0 };
	TempCMD[0] = Example_STX;
	for (int i = 0; i < size; i++) //每字节相加
	{
		AsciiSum += cmdData[i];
		TempCMD[i + 1] = cmdData[i];
	}
	TempCMD[size + 1] = (char)Example_ETX;
	{
		TempCMD[size + 2] = (char)AsciiSum;
		memcpy(cmdData, TempCMD, size + 4);
		size += 3;
		FDEBUG("ComputeCheckSum:[0x{$:x}]", AsciiSum);
		return (char)AsciiSum;
	}
	return 0xFF;
}

//-----------------------------------------------------------------------------
//		CGEN_DEV_ContainerExample
//-----------------------------------------------------------------------------

atomic<int> nsGEN::CGEN_DEV_ContainerExample::m_iLoopTime = Example_LoopDefHBTime;
CcosAttrKey::UNIT_CTRL_TYPE nsGEN::CGEN_DEV_ContainerExample::m_nNotifyType = CcosAttrKey::CTRL_CallBackFun;

nsGEN::CGEN_DEV_ContainerExample::CGEN_DEV_ContainerExample(string configfile)
{
	//其余属性初始化
	ResDataObject temp;
	temp.loadFile(configfile.c_str());
	m_GenConfig = temp["CONFIGURATION"];
	m_pHardwareStatusThread = NULL;
	m_bExpEnable = false;
	m_iHeartBeats = 0;
	m_bConnectFlag = true;
	m_pDevicePath = "UniversalUnit";

	//日志方式
	string version;
	if (GetVersion(version, hMyModule))
		FINFO("\n===============log begin : version:{$} ===================\n", version.c_str());
	else
		FINFO("\n===============log begin : version:0.0.0.0 ===================\n");

	//设置发生器属性集合各个值的范围及精度
//硬件参数
	m_TubeInfo.reset(new StringMould(CcosAttrKey::TUBEINFO, "unKnow"));        
	m_TubeTargetMaterial.reset(new StringMould(CcosAttrKey::TUBETARGETMATERIAL, CcosAttrKey::TYPE::MO));
	m_TubeAngle.reset(new IntMould(CcosAttrKey::TUBEANGLE,0.0, -180.0, 180.0, 1.0));
	m_TubeHE.reset(new FloatMould(CcosAttrKey::TUBEHEAT, 0.0, 0.0, 100.0, 1.0));
	m_GenHE.reset(new FloatMould(CcosAttrKey::DENHEAT, 0.0, 0.0, 100.0, 1.0));
	m_BatteryChargeState.reset(new IntMould(CcosAttrKey::BATTERYCHARGESTATE, CcosAttrKey::CHARGE_STATUS_OFF, CcosAttrKey::CHARGE_STATUS_OFF, CcosAttrKey::CHARGE_STATUS_MAX, 1));
	m_BatteryPowerState.reset(new IntMould(CcosAttrKey::BATTERYPOWERSTATE, 100, 0, 100, 1));
	m_GenSynState.reset(new IntMould(CcosAttrKey::GENHANDSWITCH, CcosAttrKey::GENERATOR_RAD_OFF, CcosAttrKey::GENERATOR_SYNC_ERR, CcosAttrKey::GENERATOR_SYNC_MAX, 1));
	m_GenState.reset(new IntMould(CcosAttrKey::GENSTATE, CcosAttrKey::GENERATOR_STATUS_STANDBY, CcosAttrKey::GENERATOR_STATUS_SHUTDOWN, CcosAttrKey::GENERATOR_STATUS_MAX, 1.0));
	m_Handswitch.reset(new IntMould(CcosAttrKey::GENHANDSWITCH, CcosAttrKey::HANDSWITCH_STATUS_Release, CcosAttrKey::HANDSWITCH_STATUS_Release, CcosAttrKey::HANDSWITCH_STATUS_MAX, 1.0));
	m_Footswitch.reset(new IntMould(CcosAttrKey::GENFOOTSWITCH, CcosAttrKey::FOOTSWITCH_STATUS_Release, CcosAttrKey::FOOTSWITCH_STATUS_Release, CcosAttrKey::FOOTSWITCH_STATUS_MAX, 1.0));
	//点片参数
	m_RadKV.reset(new FloatMould(CcosAttrKey::RADKV, 40.0, 40.0, 150.0, 1.0)); //接口协议范围:20-49
	m_RadMA.reset(new FloatMould(CcosAttrKey::RADMA, 10.0, 10.0, 1000.0, 1.0));
	m_RadMS.reset(new FloatMould(CcosAttrKey::RADMS, 1.0, 1.0, 6300, 1.0));
	m_RadMAS.reset(new FloatMould(CcosAttrKey::RADMAS, 0.1, 0.1, 1000.0, 1.0));
	m_RadTechmode.reset(new IntMould(CcosAttrKey::RADTECHMODE, CcosAttrKey::TECHMODE_NOAEC_2P, CcosAttrKey::TECHMODE_NOAEC_3P, CcosAttrKey::TECHMODE_MAX, 1));
	m_RadFocus.reset(new IntMould(CcosAttrKey::RADFOCUS, CcosAttrKey::FOCUS_SMALL, CcosAttrKey::FOCUS_SMALL, CcosAttrKey::FOCUS_MAX, 1));
	m_RadAECField.reset(new IntMould(CcosAttrKey::RADAECFIELD, 0, 0, 111, 1));
	m_RadAECFilm.reset(new IntMould(CcosAttrKey::RADAECFILM, 0, 0, 2, 1));
	m_RadAECDensity.reset(new FloatMould(CcosAttrKey::RADAECDENSITY, 0, -4, 4, 1));
	m_RadFrameRate.reset(new IntMould(CcosAttrKey::FRAMERATE, 0, 0, 16, 1));
	m_PostKV.reset(new FloatMould(CcosAttrKey::POSTKV, 0.0, 0.0, 50.0, 1.0));
	m_PostMA.reset(new FloatMould(CcosAttrKey::POSTMA, 0.0, 0.0, 200.0, 0.1));
	m_PostMS.reset(new FloatMould(CcosAttrKey::POSTMS, 0.0, 0.0, 12000.0, 0.01));
	m_PostMAS.reset(new FloatMould(CcosAttrKey::POSTMAS, 0.0, 0.0, 600.0, 0.01));
	m_ExpMode.reset(new StringMould(CcosAttrKey::EXPMODE, CcosAttrKey::TYPE::Single));
	m_EXAMMode.reset(new StringMould(CcosAttrKey::EXAMMODE, CcosAttrKey::TYPE::MANUAL));
	//透视参数
	m_FluKV.reset(new FloatMould(CcosAttrKey::FLUKV, 40.0, 40.0, 125.0, 1.0));
	m_FluMA.reset(new FloatMould(CcosAttrKey::FLUMA, 0.5, 0.5, 20.0, 1.0));
	m_FluMS.reset(new FloatMould(CcosAttrKey::FLUMS, 1.0, 1.0, 1000.0, 1.0));
	m_FluMAS.reset(new FloatMould(CcosAttrKey::FLUMAS, 0.5, 0.5, 1000.0, 1.0));
	m_FluPPS.reset(new IntMould(CcosAttrKey::FLUPPS, 0, 0, 16, 1));
	m_FluABSStatus.reset(new IntMould(CcosAttrKey::FLUABSStatus, 0, 0, 4, 1));
	m_FluDoseLever.reset(new IntMould(CcosAttrKey::FLUDoseLevel, 0, 0, 10, 1));
	m_FluFMode.reset(new IntMould(CcosAttrKey::FLUMode, CcosAttrKey::GENERATOR_FLMODE_NOTFLU, CcosAttrKey::GENERATOR_FLMODE_NOTFLU, CcosAttrKey::GENERATOR_FLMODE_MAX, 1));
	m_FluIntTime.reset(new FloatMould(CcosAttrKey::FLUIntTime, 0.0, 0.0, 300000.0, 1.0));
	m_FluAccTime.reset(new FloatMould(CcosAttrKey::FLUAccTime, 0.0, 0.0, 300000.0, 1.0));

	//发生器告警及错误消息
	m_MSGUnit.reset(new nsDetail::MSGUnit(m_pDevicePath));
	//读取配置固定值
	GetUnitHWValueFromCFG();

	m_nCMDType_WaitTime = glo_tDelivermodule.SetPriority(true, false, false, true, 100);
	m_nCMDType_HB = glo_tDelivermodule.SetPriority(false, true, false, true, 100);
	m_nCMDType_WaitACK = glo_tDelivermodule.SetPriority(true, false, 3, false, 0, true, 1000);
	FINFO("m_nCMDType_WaitTime[{$}]m_nCMDType_HB[{$}] m_nCMDType_WaitACK[{$}]", m_nCMDType_WaitTime, m_nCMDType_HB, m_nCMDType_WaitACK);

	//配置响应操作对照表 供发生器回传的数据触发相应的操作
	OnCallBack();

	//重置发生器
	Reset();
	Sleep(500);

	//以下进行默认设置，需要注意默认值是否正确	
	RefreshData(); //刷新初始数值

	//启动硬件状态轮询进程
	StartHardwareStatusThread();
}
nsGEN::CGEN_DEV_ContainerExample::~CGEN_DEV_ContainerExample()
{
	FINFO("\n===============log GEN end ===================\n");
	
	if (m_pHardwareStatusThread != NULL)
	{
		TerminateThread(m_pHardwareStatusThread, 0);
		m_pHardwareStatusThread = NULL;
	}
	glo_arFrame.clear();
}
std::string nsGEN::CGEN_DEV_ContainerExample::GetGUID()
{
	FINFO("===============GetGUID : {$} ===================\n", GeneratorUnitType);
	return GeneratorUnitType;
}
std::string nsGEN::CGEN_DEV_ContainerExample::GetResource()
{
	return "";
}
void nsGEN::CGEN_DEV_ContainerExample::GetUnitHWValueFromCFG()
{
	//发生器模块消息上报方式
	if (m_GenConfig.GetKeyCount("NotifyType") > 0)
	{
		int data = (int)m_GenConfig["NotifyType"];
		m_nNotifyType = (CcosAttrKey::UNIT_CTRL_TYPE)data;
		switch (m_nNotifyType)
		{
			case CcosAttrKey::CTRL_PlatformInterface:
			{
				FDEBUG("NotifyType:PlatformInterface");
			}break;
			case CcosAttrKey::CTRL_Center:
			{
				FDEBUG("NotifyType:Center");
				m_EventCenter.reset(new IOEventCenter);
			}break;
			case CcosAttrKey::CTRL_CallBackFun:
			{
				FDEBUG("NotifyType:CallBackFun");
			}break;
			default:
				break;
		}
	}
	//同步模式
	m_arrWSMap.clear();
	if (m_GenConfig.GetKeyCount("WSTable") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSTable"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNTable"]);
		m_arrWSMap[cfgWorkStationKey("Table", CcosAttrKey::TABLE)] = cfgWorkStationData("Table", WSNamber, WSSYN);
		FDEBUG("cfg Table WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	if (m_GenConfig.GetKeyCount("WSWall") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSWall"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNWall"]);
		m_arrWSMap[cfgWorkStationKey("Wall", CcosAttrKey::WALL)] = cfgWorkStationData("Wall", WSNamber, WSSYN);
		FDEBUG("cfg Wall WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	if (m_GenConfig.GetKeyCount("WSFree") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSFree"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNFree"]);
		m_arrWSMap[cfgWorkStationKey("Free", CcosAttrKey::MOBILE)] = cfgWorkStationData("Free", WSNamber, WSSYN);
		FDEBUG("cfg Free WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	if (m_GenConfig.GetKeyCount("WSTomo") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSTomo"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNTomo"]);
		m_arrWSMap[cfgWorkStationKey("Tomo", CcosAttrKey::TOMO)] = cfgWorkStationData("Tomo", WSNamber, WSSYN);
		FDEBUG("cfg Tomo WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	if (m_GenConfig.GetKeyCount("WSConventional") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSConventional"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNConventional"]);
		m_arrWSMap[cfgWorkStationKey("Direct", CcosAttrKey::CONVENTIONAL)] = cfgWorkStationData("Direct", WSNamber, WSSYN);
		FDEBUG("cfg Conventional WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	//球管信息
	if (m_GenConfig.GetKeyCount(CcosConfKey::CcosTubeInfo) > 0)
	{
		string data = m_GenConfig[CcosConfKey::CcosTubeInfo];
		m_TubeInfo->Update(data);
		FireNotify(m_TubeInfo->GetKey(), m_TubeInfo->JSGet());
	}
	if (m_GenConfig.GetKeyCount(CcosConfKey::CcosFocusSmall) > 0)
	{
		float data = (float)m_GenConfig[CcosConfKey::CcosFocusSmall];
		m_FocusSmall = data;
	}
	if (m_GenConfig.GetKeyCount(CcosConfKey::CcosFocusLarge) > 0)
	{
		float data = (float)m_GenConfig[CcosConfKey::CcosFocusLarge];
		m_FocusLarge = data;
	}
}
RET_STATUS  nsGEN::CGEN_DEV_ContainerExample::SetWS(const string value) //发生器无此设置
{
	FDEBUG("Enter SetWS {$}", value.c_str());
	int tempws = 1;
	string strWS = "";
	cfgWorkStationKey trWS = cfgWorkStationKey(value.c_str());
	if (m_arrWSMap.find(trWS) != m_arrWSMap.end())
	{
		m_strCurrentWSName = trWS;
		tempws = m_arrWSMap[m_strCurrentWSName].nWSNamber;
		strWS = m_arrWSMap[m_strCurrentWSName].strWSNAme;
		FDEBUG("Set WS number [{$}][{$}]", strWS.c_str(), tempws);
	}
	else
	{
		FDEBUG("Set WS number default 1");
		m_strCurrentWSName = cfgWorkStationKey(1);
	}

	char temp[50] = { 0 };
	sprintf_s(temp, "WS%1d", tempws);
	return HWSendWaittimeCMD(temp, strlen(temp));
}
RET_STATUS  nsGEN::CGEN_DEV_ContainerExample::SetExpSYN(EnSYNMode value)
{
	FDEBUG("Enter SetExpSYN {$}", (int)value);
	int tempws = 0;
	switch (value)
	{
		case EnSYNMode::EXPOSURE_SYNMODE_HARDWARE_SYNBOX:
		case EnSYNMode::EXPOSURE_SYNMODE_DIRCETCONNECT_NOSYNBOX:
		case EnSYNMode::EXPOSURE_SYNMODE_SOFTWARE_NOSYNBOX:
		default:
			break;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetExpEnable() //发生器无此设置
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetExpDisable() //发生器无此设置
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::Reset()
{
	FDEBUG("Enter Reset");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::RefreshData()
{
	FDEBUG("Enter RefreshData");
	return RET_STATUS::RET_SUCCEED;
}RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetGenSynState(int value) //发生器无此设置:AEC二阶段曝光使用
{
	FDEBUG("Enter SetGenSynState[{$}]->[{$}]", m_GenSynState->Get(), value);
	switch (value)
	{
		case CcosAttrKey::GENERATOR_RAD_OFF:
		{}break;
		case CcosAttrKey::GENERATOR_RAD_PREPARE:
		{}break;
		case CcosAttrKey::GENERATOR_RAD_READY:
		{}break;
		case CcosAttrKey::GENERATOR_RAD_XRAYON:
		{}break;
		case CcosAttrKey::GENERATOR_RAD_XRAYOFF:
		{}break;
		case CcosAttrKey::GENERATOR_FLU_OFF:
		{}break;
		case CcosAttrKey::GENERATOR_FLU_READY:
		{}break;
		case CcosAttrKey::GENERATOR_FLU_XRAYON:
		{}break;
		case CcosAttrKey::GENERATOR_FLU_XRAYOFF:
		{}break;
		default:
			break;
	}
	if (m_GenSynState->Update(value))
		FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetGenState(int value) //发生器无此设置
{
	FDEBUG("Enter SetGenSynState[{$}]->[{$}]", m_GenState->Get(), value);
	switch (value)
	{
		case CcosAttrKey::GENERATOR_STATUS_SHUTDOWN:
		{}break;
		case CcosAttrKey::GENERATOR_STATUS_INIT:
		{}break;
		case CcosAttrKey::GENERATOR_STATUS_SLEEP:
		{}break;
		case CcosAttrKey::GENERATOR_STATUS_CHARGING:
		{}break;
		case CcosAttrKey::GENERATOR_STATUS_STANDBY:
		{}break;
		case CcosAttrKey::GENERATOR_STATUS_EXP:
		{}break;
		case CcosAttrKey::GENERATOR_STATUS_ERROR:
		{}break;
		default:
			break;
	}
	if (m_GenState->Update(value))
		FireNotify(m_GenState->GetKey(), m_GenState->JSGet());
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::Clear_DAP()
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::GetValue_DAP(float& value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetDetectorWindow(bool value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetExposurePermit(bool value)
{
	return RET_STATUS::RET_SUCCEED;
}
void nsGEN::CGEN_DEV_ContainerExample::SetNotifyCallBack(callBackFun fun)
{
	m_funV2DynamicCallBackFun = fun;
}

//发生器支持的通用点片命令
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncRadKV()
{
	if (!m_RadKV->CanInc()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecRadKV()
{
	if (!m_RadKV->CanDec()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetRadKV(float value)
{
	if (!m_RadKV->Verify(value)) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncRadMA()
{
	if (!m_RadMA->CanInc()) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_2P)
	{
		FINFO("Techmode is 2Point, Cannot inc MA \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecRadMA()
{
	if (!m_RadMA->CanDec()) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_2P)
	{
		FINFO("Techmode is 2Point, Cannot dec MA \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetRadMA(float value)
{
	if (!m_RadMA->Verify(value)) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_2P)
	{
		FINFO("Techmode is 2Point, Cannot set MA \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncRadMS()
{
	if (!m_RadMS->CanInc()) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_2P)
	{
		FINFO("Techmode is 2Point, Cannot inc MS \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecRadMS()
{
	if (!m_RadMS->CanDec()) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_2P)
	{
		FINFO("Techmode is 2Point, Cannot dec MS \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetRadMS(float value)
{
	if (!m_RadMS->Verify(value)) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_2P)
	{
		FINFO("Techmode is 2Point, Cannot set MS \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncRadMAS()
{
	if (!m_RadMAS->CanInc()) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_3P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_3P)
	{
		FINFO("Techmode is 3Point, Cannot inc MAS \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecRadMAS()
{
	if (!m_RadMAS->CanDec()) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_3P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_3P)
	{
		FINFO("Techmode is 3Point, Cannot dec MAS \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetRadMAS(float value)
{
	if (!m_RadMAS->Verify(value)) return RET_STATUS::RET_FAILED;
	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_3P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_AEC_3P)
	{
		FINFO("Techmode is 3Point, Cannot set MAS \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFocus(int value)
{
	if (!m_RadFocus->Verify(value)) return RET_STATUS::RET_FAILED;

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetTechmode(int value)
{
	if (!m_RadTechmode->Verify(value)) return RET_STATUS::RET_FAILED;

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetAECDensity(int value) //发生器无此设置
{
	if (!m_RadAECDensity->Verify(value)) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_3P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P)
	{
		FINFO("Techmode is not AEC, Cannot set Density \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetAECField(int value) //发生器无此设置
{
	if (!m_RadAECField->Verify(value)) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_3P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P)
	{
		FINFO("Techmode is not AEC, Cannot set Field \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetAECFilm(int value) //发生器无此设置
{
	if (!m_RadAECFilm->Verify(value)) return RET_STATUS::RET_FAILED;

	if (m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_3P ||
		m_RadTechmode->Get() == CcosAttrKey::TECHMODE_NOAEC_2P)
	{
		FINFO("Techmode is not AEC, Cannot set Film \n");
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetAPR(const _tAPRArgs& t)
{
	FINFO("APR:WS={$},Focus={$},Techmode={$},KV={$},MA={$},MS={$},MAS={$},AECDensity={$},AECFilm={$},AECField={$}", 
			   t.nWS, t.nFocus, t.nTechmode, t.fKV, t.fMA, t.fMS, t.fMAS, t.nAECDensity, t.nAECFilm, t.nAECField);
	
	int tempws = 1;
	if (m_arrWSMap.find(cfgWorkStationKey(t.nWS)) != m_arrWSMap.end())
	{
		m_strCurrentWSName = cfgWorkStationKey(t.nWS);
		tempws = m_arrWSMap[m_strCurrentWSName].nWSNamber;
		FDEBUG("Set WS number {$}", tempws);
	}
	else
	{
		FDEBUG("Set WS number default 1");
		m_strCurrentWSName = cfgWorkStationKey(t.nWS);
		tempws = t.nWS;
	}
	if (!m_RadKV->Verify(t.fKV))
	{
		FERROR("SetAPR:KV Out of bounds[{$}] \n", t.fKV);
		return RET_STATUS::RET_FAILED;
	}
	else if (!m_RadMA->Verify(t.fMA) && (t.nTechmode == CcosAttrKey::TECHMODE_NOAEC_3P ||
										 t.nTechmode == CcosAttrKey::TECHMODE_AEC_3P ||
										 t.nTechmode == CcosAttrKey::TECHMODE_AEC_ReduceMA ||
										 t.nTechmode == CcosAttrKey::TECHMODE_NOAEC_MAS_MA ||
										 t.nTechmode == CcosAttrKey::TECHMODE_AEC_MAS_MA))
	{
		FERROR("SetAPR:MA Out of bounds[{$}] \n", t.fMA);
		return RET_STATUS::RET_FAILED;
	}
	else if (!m_RadMS->Verify(t.fMS) && (t.nTechmode == CcosAttrKey::TECHMODE_NOAEC_3P ||
										 t.nTechmode == CcosAttrKey::TECHMODE_AEC_3P))
	{
		FERROR("SetAPR:MS Out of bounds[{$}] \n", t.fMS);
		return RET_STATUS::RET_FAILED;
	}
	else if (!m_RadMAS->Verify(t.fMAS) && (t.nTechmode == CcosAttrKey::TECHMODE_NOAEC_2P ||
										   t.nTechmode == CcosAttrKey::TECHMODE_AEC_2P || 
										   t.nTechmode == CcosAttrKey::TECHMODE_NOAEC_MAS_MA ||
										   t.nTechmode == CcosAttrKey::TECHMODE_AEC_MAS_MA))
	{
		FERROR("SetAPR:MAS Out of bounds[{$}] \n", t.fMAS);
		return RET_STATUS::RET_FAILED;
	}
	else if (!m_RadFocus->Verify(t.nFocus))
	{
		FERROR("SetAPR:Focus Out of bounds[{$}] \n", t.nFocus);
		return RET_STATUS::RET_FAILED;
	}
	
	char temp[50] = { 0 };

	switch (t.nTechmode)
	{
		case CcosAttrKey::TECHMODE_NOAEC_3P:
		{}break;
		case CcosAttrKey::TECHMODE_NOAEC_2P:
		{}break;
		case CcosAttrKey::TECHMODE_AEC_3P:
		{}break;
		case CcosAttrKey::TECHMODE_AEC_2P:
		{}break;
		case CcosAttrKey::TECHMODE_AEC_1P:
		{}break;
		case CcosAttrKey::TECHMODE_AEC_ReduceMA:
		{}break;
		case CcosAttrKey::TECHMODE_NOAEC_MAS_MA:
		{}break;
		case CcosAttrKey::TECHMODE_AEC_MAS_MA:
		{}break;
		default:
		{}break;
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::CGEN_DEV_ContainerExample::QueryPostKV(float& value) //实际为主动上报
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::QueryPostMA(float& value) //实际为主动上报
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::QueryPostMS(float& value) //实际为主动上报
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::QueryPostMAS(float& value) //实际为主动上报
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetRadFrameRate(FLOAT frameRate) //发生器无此动态设置
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetExpMode(std::string value) //发生器无此设置
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetEXAMMode(std::string value) //DMOC实际是通过此接口设置是否启用AEC
{
	return RET_STATUS::RET_SUCCEED;
}

//发生器支持的通用透视命令
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncFluKV() 
{
	if (!m_FluKV->CanInc()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecFluKV() 
{
	if (!m_FluKV->CanDec()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluKV(float value) 
{
	if (!m_FluKV->Verify(value)) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncFluMA() 
{ 
	if (!m_FluMA->CanInc()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecFluMA() 
{
	if (!m_FluMA->CanDec()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluMA(float value) 
{ 
	if (!m_FluMA->Verify(value)) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncFluMS() 
{ 
	if (!m_FluMS->CanInc()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecFluMS() 
{ 
	if (!m_FluMS->CanDec()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluMS(float value) 
{ 
	if (!m_FluMS->Verify(value)) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncFluMAS() 
{ 
	if (!m_FluMAS->CanInc()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecFluMAS() 
{
	if (!m_FluMAS->CanDec()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluMAS(float value) 
{ 
	if (!m_FluMAS->Verify(value)) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetPPS(float frameRate) 
{ 
	if (!m_FluPPS->CanDec()) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::GetPPS() 
{ 
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::INCPPS() 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DECPPS() 
{ 
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetPluseWidth(float fplusewidth)
{
	if (!m_FluMS->Verify(fplusewidth)) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetABSMode(int nMode) 
{
	if (!m_FluABSStatus->Verify(nMode)) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetABSCurve() 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::IncABSCurve() 
{ 
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DecABSCurve() 
{ 
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetABSValue(float fABSValue)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetABSTargetEXI(float fEXIValue)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetAPF(const _tAPFArgs& t)
{
	FINFO("APF:WS={$},FluMode={$},ABSMode={$},DoseLever={$},KV={$},MA={$},PPS={$}", 
			   t.nWS, t.nFluMode, t.nABSMode, t.nDoseLever, t.nFLKV, t.fFLMA, t.nPPS);

	int tempws = 1;
	if (m_arrWSMap.find(cfgWorkStationKey(t.nWS)) != m_arrWSMap.end())
	{
		m_strCurrentWSName = cfgWorkStationKey(t.nWS);
		tempws = m_arrWSMap[m_strCurrentWSName].nWSNamber;
		FDEBUG("Set WS number {$}", tempws);
	}
	else
	{
		FDEBUG("Set WS number default 1");
		m_strCurrentWSName = cfgWorkStationKey(t.nWS);
		tempws = t.nWS;
	}
	if (!m_RadKV->Verify(t.nFLKV))
	{
		FERROR("SetAPR:KV Out of bounds[{$}] \n", t.nFLKV);
		return RET_STATUS::RET_FAILED;
	}
	else if (!m_RadMA->Verify(t.fFLMA))
	{
		FERROR("SetAPR:MA Out of bounds[{$}] \n", t.fFLMA);
		return RET_STATUS::RET_FAILED;
	}
	else if (!m_FluPPS->Verify(t.nPPS) && (t.nFluMode == CcosAttrKey::GENERATOR_FLMODE_PF ||
										   t.nFluMode == CcosAttrKey::GENERATOR_FLMODE_HPF))
	{
		FERROR("SetAPR:PPS Out of bounds[{$}] \n", t.nPPS);
		return RET_STATUS::RET_FAILED;
	}
	else if (!m_FluDoseLever->Verify(t.nDoseLever))
	{
		FERROR("SetAPR:DoseLever Out of bounds[{$}] \n", t.nDoseLever);
		return RET_STATUS::RET_FAILED;
	}

	char temp[50] = { 0 };

	switch (t.nFluMode)
	{
		case CcosAttrKey::GENERATOR_FLMODE_NOTFLU:
		{}break;
		case CcosAttrKey::GENERATOR_FLMODE_CF:
		{}break;
		case CcosAttrKey::GENERATOR_FLMODE_PF:
		{}break;
		case CcosAttrKey::GENERATOR_FLMODE_HCF:
		{}break;
		case CcosAttrKey::GENERATOR_FLMODE_HPF:
		{}break;
		default:
		{}break;
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::GetFluIntTimer() 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::GetFluAccTimer() 
{ 
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::ResetFluTimer(int ntype) 
{ 
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluPre(int bPrepare) 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluEXP(int bPrepare) 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluMode(std::string value) 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluMAG(int nsize) 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::DisableMAG() 
{ 
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetFluDoseLever(int nlever) 
{ 
	if (!m_FluDoseLever->Verify(nlever)) return RET_STATUS::RET_FAILED;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::SetHalfDose(int nlever)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::TransferRadCurve(int ncurve)
{
	return RET_STATUS::RET_SUCCEED;
}

//-----------------------------------------------------------------------------
//		                    ProcessCmd
//-----------------------------------------------------------------------------
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::HWSendWaittimeCMD(char* strCommand, int lengh, int headLengh)
{
	return glo_tDelivermodule.ProcessCommand(strCommand, lengh, m_nCMDType_WaitTime, headLengh);
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::HWSendHBCMD(char* strCommand, int lengh, int headLengh)
{
	return glo_tDelivermodule.ProcessCommand(strCommand, lengh, m_nCMDType_HB, headLengh);
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::HWSendWaitACKCMD(char* strCommand, int lengh, int headLengh)
{
	return glo_tDelivermodule.ProcessCommand(strCommand, lengh, m_nCMDType_WaitACK, headLengh);
}
RET_STATUS nsGEN::CGEN_DEV_ContainerExample::HWSend(const char* strCommand, int lengh, bool reSend, int nTimeOut)
{
	if (!m_bConnectFlag)
	{
		FERROR("==OUT==: not Connect,[{$}] send failed \n", strCommand);
		return RET_STATUS::RET_FAILED;
	}

	char strSendCommand[Example_Com_ReSendLen] = { 0 };
	int len = strlen(strCommand);
	if (len <= 0)
	{
		FERROR("HWSend: cmd is null\n");
		return RET_STATUS::RET_FAILED;
	}
	else if (lengh <= 0)
	{
		FERROR("HWSend: Expected length too small but cmd[{$}] is not null\n", strCommand);
		return RET_STATUS::RET_FAILED;
	}
	else if (len > lengh)
	{
		FERROR("HWSend: Actual length[{$}] >  Expected length[{$}] \n", len, lengh);
		return RET_STATUS::RET_FAILED;
	}
	len = lengh;
	::memcpy(strSendCommand, strCommand, len);
	if (ComputeCheckSum(strSendCommand, len) == 0x00)
	{
		FWARN("HWSend: cmd[{$}] Check Summing failed \n", strCommand);
	}
	//strSendCommand[0] = Example_STX;
	//strSendCommand[len - 1] = Example_ETX;

	if (true)
	{
		char strCommandHead[3] = { 0 };
		::memcpy(strCommandHead, strCommand, 2);
		auto find_item = glo_arFrame.find(strCommandHead);
		if ((find_item != glo_arFrame.end()) && reSend)
		{
			FINFO("==OUT==: [{$}] wait for ACK \n", strSendCommand);
		}
		else
		{
			FINFO("==OUT==: [{$}] \n", strSendCommand);
		}
	}
	int retLength;
	glo_obCommObj.m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(strSendCommand, len, nTimeOut, retLength);

	return RET_STATUS::RET_SUCCEED;
}

void nsGEN::CGEN_DEV_ContainerExample::FireNotify(string key, const int context)
{
	std::string str = std::format("{:d}", context);
	switch (m_nNotifyType)
	{
		case CcosAttrKey::CTRL_PlatformInterface:
		{
			PlatformInterface::CCOSNotifyCallBackEntry(PACKET_CMD::PACKET_CMD_UPDATE, key, str, m_pDevicePath); 
		}break;
		case CcosAttrKey::CTRL_Center:
		{
			if (m_EventCenter != nullptr)
			{
				m_EventCenter->OnNotify(1, key, str);
			}
			else
			{
				FERROR("m_EventCenter:[{$}:{$}] is null", key.c_str(), str.c_str());
			}
		}break;
		case CcosAttrKey::CTRL_CallBackFun:
		{
			if (m_funV2DynamicCallBackFun != NULL)
			{
				m_funV2DynamicCallBackFun(key, str);
			}
			else
			{
				FERROR("V2DynamicCallBackFun:[{$}:{$}] is null", key.c_str(), str.c_str());
			}
		}break;
		default:
			FERROR("FireNotify:unknow[{$}]m_nNotifyType", (int)m_nNotifyType);
			break;
	}
}
void nsGEN::CGEN_DEV_ContainerExample::FireNotify(string key, const float context)
{
	std::string str = std::format("{:.2f}", context);
	switch (m_nNotifyType)
	{
		case CcosAttrKey::CTRL_PlatformInterface:
		{
			PlatformInterface::CCOSNotifyCallBackEntry(PACKET_CMD::PACKET_CMD_UPDATE, key, str, m_pDevicePath);
		}break;
		case CcosAttrKey::CTRL_Center:
		{
			if (m_EventCenter != nullptr)
			{
				m_EventCenter->OnNotify(1, key, str);
			}
			else
			{
				FERROR("m_EventCenter:[{$}:{$}] is null", key.c_str(), str.c_str());
			}
		}break;
		case CcosAttrKey::CTRL_CallBackFun:
		{
			if (m_funV2DynamicCallBackFun != NULL)
			{
				m_funV2DynamicCallBackFun(key, str);
			}
			else
			{
				FERROR("V2DynamicCallBackFun:[{$}:{$}] is null", key.c_str(), str.c_str());
			}
		}break;
		default:
			FERROR("FireNotify:unknow[{$}]m_nNotifyType", (int)m_nNotifyType);
			break;
	}
}
void nsGEN::CGEN_DEV_ContainerExample::FireNotify(string key, const string context)
{
	switch (m_nNotifyType)
	{
		case CcosAttrKey::CTRL_PlatformInterface:
		{
			PlatformInterface::CCOSNotifyCallBackEntry(PACKET_CMD::PACKET_CMD_UPDATE, key, context, m_pDevicePath);
		}break;
		case CcosAttrKey::CTRL_Center:
		{
			if (m_EventCenter != nullptr)
			{
				m_EventCenter->OnNotify(1, key, context);
			}
			else
			{
				FERROR("m_EventCenter:[{$}:{$}] is null", key.c_str(), context.c_str());
			}
		}break;
		case CcosAttrKey::CTRL_CallBackFun:
		{
			if (m_funV2DynamicCallBackFun != NULL)
			{
				m_funV2DynamicCallBackFun(key, context);
			}
			else
			{
				FERROR("V2DynamicCallBackFun:[{$}:{$}] is null", key.c_str(), context.c_str());
			}
		}break;
		default:
			FERROR("FireNotify:unknow[{$}]m_nNotifyType", (int)m_nNotifyType);
			break;
	}
}

void nsGEN::CGEN_DEV_ContainerExample::FireErrorMessage(const bool Act, const int Code, const char* ResInfo)
{
	string ErrorCode("Example_ERR_");
	ErrorCode += std::to_string(Code);
	int level = CcosAttrKey::UNIT_REGULATION_LEVEL::REG_ERRO;
	if (Act)
	{
		FERROR("add {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->AddErrorMessage(ErrorCode.c_str(), level, ResInfo);
	}
	else
	{
		FERROR("del {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->DelErrorMessage(ErrorCode.c_str(), level, ResInfo);
	}
}
void nsGEN::CGEN_DEV_ContainerExample::FireWarnMessage(const bool Act, const int Code, const char* ResInfo)
{
	string ErrorCode("Example_WAR_");
	ErrorCode += std::to_string(Code);
	int level = CcosAttrKey::UNIT_REGULATION_LEVEL::REG_WARN;
	if (Act)
	{
		FERROR("add {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->AddWarnMessage(ErrorCode.c_str(), level, ResInfo);
	}
	else
	{
		FERROR("del {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->DelWarnMessage(ErrorCode.c_str(), level, ResInfo);
	}
}

void nsGEN::CGEN_DEV_ContainerExample::OnCallBack()
{
	//无 操作
	auto HWNotProcess = [](const char* value, int length) -> void
	{
		FINFO("This commands[{$}] didn't need to process", value);
	};

	//校验和错误
	auto HWERROR_1 = [this](char* value, int length) -> void
	{
		char* nextTokenPtr = NULL;
		char* tokenPtr = strtok_s(value, ",", &nextTokenPtr);
		if (tokenPtr != NULL)
		{
			FERROR("== HWERROR_1 == : error CheckSum:[{$}]", tokenPtr);
		}
		else
		{
			FERROR("== HWERROR_1 == : error CheckSum:no csum");
		}
	};

	//RADIOGRAPHIC COMMANDS
	auto HWRKV = [this](char* value, int length) -> void
	{
		FireNotify(m_RadKV->GetKey(), value);
	};
	auto HWRMA = [this](char* value, int length) -> void
	{
		FireNotify(m_RadMA->GetKey(), value);
	};
	auto HWRMS = [this](char* value, int length) -> void
	{
		FireNotify(m_RadMS->GetKey(), value);
	};
	auto HWRMX = [this](char* value, int length) -> void
	{
		FireNotify(m_RadMAS->GetKey(), value);
	};
	auto HWRET = [this](char* value, int length) -> void
	{
		FireNotify(m_RadTechmode->GetKey(), value);
	};
	auto HWRFO = [this](char* value, int length) -> void
	{
		FireNotify(m_RadFocus->GetKey(), value);
	};
	auto HWRFN = [this](char* value, int length) -> void
	{
		FireNotify(m_RadAECDensity->GetKey(), value);
	};
	auto HWRFI = [this](char* value, int length) -> void
	{
		FireNotify(m_RadAECField->GetKey(), value);
	};
	auto HWRFS = [this](char* value, int length) -> void
	{
		FireNotify(m_RadAECFilm->GetKey(), value);
	};
	auto HWRAP = [this](char* value, int length) -> void
	{
		FireNotify(m_PostMAS->GetKey(), value);
	};
	auto HWRAT = [this](char* value, int length) -> void
	{
		FireNotify(m_PostMS->GetKey(), value);
	};
	auto HWPR  = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Rad PR[{$}]", data);
		switch (data)
		{
			case 0: //RAD Preparation inactive
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_RAD_OFF))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			case 1: //RAD Preparation active
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_RAD_PREPARE))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			case 2: //RAD Generator Ready
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_RAD_READY))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			default:
			{}break;
		}
	};
	auto HWXR  = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Rad XR[{$}]", data);
		switch (data)
		{
			case 0: //RAD Exposure inactive
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_RAD_XRAYOFF))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			case 1: //RAD Exposure active
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_RAD_XRAYON))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			default:
			{}break;
		}
	};
	auto HWPS  = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Rad First handswitch[{$}]", data);
		switch (data)
		{
			case 0: //Release First HandSwitch
			{
				if (m_Handswitch->Update(CcosAttrKey::HANDSWITCH_STATUS_Release))
					FireNotify(m_Handswitch->GetKey(), m_Handswitch->JSGet());
			}break;
			case 1: //Hold First handswitch
			{
				if (m_GenSynState->Update(CcosAttrKey::HANDSWITCH_STATUS_Hold))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			default:
			{}break;
		}
	};
	auto HWXS  = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Rad XR[{$}]", data);
		switch (data)
		{
			case 0: //Release Second handswitch
			{
				if (m_Handswitch->Update(CcosAttrKey::HANDSWITCH_STATUS_Release))
					FireNotify(m_Handswitch->GetKey(), m_Handswitch->JSGet());
			}break;
			case 1: //Press Second handswitch
			{
				if (m_GenSynState->Update(CcosAttrKey::FOOTSWITCH_STATUS_Press))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			default:
			{}break;
		}
	};
	auto HWRPS = [this](char* value, int length) -> void
	{
		FireNotify(m_RadFrameRate->GetKey(), value);
	};
	auto HWRMM = [this](char* value, int length) -> void
	{
		FireNotify(m_ExpMode->GetKey(), value);
	};
	//FLUOROSCOPIC COMMANDS
	auto HWFLK = [this](char* value, int length) -> void
	{
		FireNotify(m_FluKV->GetKey(), value);
	};
	auto HWFLM = [this](char* value, int length) -> void
	{
		FireNotify(m_FluMA->GetKey(), value);
	};
	auto HWFLI = [this](char* value, int length) -> void
	{
		FireNotify(m_FluIntTime->GetKey(), value);
	};
	auto HWFLT = [this](char* value, int length) -> void
	{
		FireNotify(m_FluAccTime->GetKey(), value);
	};
	auto HWFLS = [this](char* value, int length) -> void
	{
		FireNotify(m_FluPPS->GetKey(), value);
	};
	auto HWFPW = [this](char* value, int length) -> void
	{
		FireNotify(CcosAttrKey::FLUpulseWidth, value);
	};
	auto HWFLF = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Fluoroscopy Mode[{$}]", data);
		switch (data)
		{
			case 0: //Fluoro Disabled
			{
				if (m_FluFMode->Update(CcosAttrKey::GENERATOR_FLMODE_NOTFLU))
					FireNotify(m_FluFMode->GetKey(), m_FluFMode->JSGet());
			}break;
			case 1: //Continuous Fluoroscopy
			{
				if (m_FluFMode->Update(CcosAttrKey::GENERATOR_FLMODE_CF))
					FireNotify(m_FluFMode->GetKey(), m_FluFMode->JSGet());

			}break;
			case 2: //Pulsed Fluoroscopy
			{
				if (m_FluFMode->Update(CcosAttrKey::GENERATOR_FLMODE_PF))
					FireNotify(m_FluFMode->GetKey(), m_FluFMode->JSGet());

			}break;
			case 3: //High Level Continuous Fluoroscopy
			{
				if (m_FluFMode->Update(CcosAttrKey::GENERATOR_FLMODE_HCF))
					FireNotify(m_FluFMode->GetKey(), m_FluFMode->JSGet());

			}break;
			case 4: //High Level Pulsed Fluoroscopy
			{
				if (m_FluFMode->Update(CcosAttrKey::GENERATOR_FLMODE_HPF))
					FireNotify(m_FluFMode->GetKey(), m_FluFMode->JSGet());

			}break;
			default:
			{}break;
		}
	};
	auto HWFLP = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Fluoroscopy Preparation[{$}]", data);
		switch (data)
		{
			case 0: //Fluoroscopy Prep inactive
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_FLU_OFF))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			case 1: //Fluoroscopy Prep active
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_FLU_READY))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			case 2: //Boost Fluoroscopy or Cine Prep active
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_FLU_CINE_READY))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			default:
			{}break;
		}
	};
	auto HWFLX = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Fluoroscopy Exposure[{$}]", data);
		switch (data)
		{
			case 0: //Fluoroscopy Exposure inactive
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_FLU_XRAYOFF))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			case 1: //Fluoroscopy Exposure active
			{
				if (m_GenSynState->Update(CcosAttrKey::GENERATOR_FLU_XRAYON))
					FireNotify(m_GenSynState->GetKey(), m_GenSynState->JSGet());
			}break;
			default:
			{}break;
		}
	};
	auto HWFLA = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Fluoroscopy ABS[{$}]", data);
		switch (data)
		{
			case 0: //ABS inactive
			{
				if (m_FluABSStatus->Update(CcosAttrKey::GENERATOR_ABS_OFF))
					FireNotify(m_FluABSStatus->GetKey(), m_FluABSStatus->JSGet());
			}break;
			case 1: //ABS active (KV only)
			{
				if (m_FluABSStatus->Update(CcosAttrKey::GENERATOR_ABS_ON_KV))
					FireNotify(m_FluABSStatus->GetKey(), m_FluABSStatus->JSGet());
			}break;
			case 2: //ABS active (KV / mA)
			{
				if (m_FluABSStatus->Update(CcosAttrKey::GENERATOR_ABS_ON_KVMA))
					FireNotify(m_FluABSStatus->GetKey(), m_FluABSStatus->JSGet());
			}break;
			default:
			{}break;
		}
	};
	auto HWFLZ = [this](char* value, int length) -> void
	{
		FireNotify(CcosAttrKey::FLUMag, 0);
	};
	auto HWFLR = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Fluoroscopy Time Reset[{$}]", data);
		switch (data)
		{
			case 0: //Reset Fluoroscopy Interval Timer
			{
				if (m_FluIntTime->Update(data))
					FireNotify(m_FluIntTime->GetKey(), m_FluIntTime->JSGet());
			}break;
			case 1: //Reset Fluoroscopy Accumulative Timer
			{
				if (m_FluAccTime->Update(data))
					FireNotify(m_FluAccTime->GetKey(), m_FluAccTime->JSGet());
			}break;
			default:
			{}break;
		}
	};
	auto HWFLD = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Fluoroscopy Dose Level[{$}]", data);
		if (m_FluDoseLever->Update(data))
		{
			FireNotify(m_FluDoseLever->GetKey(), data);
		}
	};
	//SYSTEM COMMANDS
	auto HWEWS = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Work Station[{$}]", data);
		int tempws = 1;
		if (m_arrWSMap.find(cfgWorkStationKey(data)) != m_arrWSMap.end())
		{
			m_strCurrentWSName = cfgWorkStationKey(data);
			tempws = m_arrWSMap[m_strCurrentWSName].nWSNamber;
			FDEBUG("Set WS number {$}", tempws);
			SetExpSYN(m_arrWSMap[m_strCurrentWSName].nWSSYN);
		}
		else
		{
			FDEBUG("Set WS number default 1");
			m_strCurrentWSName = cfgWorkStationKey(data);
		}
		FireNotify(CcosAttrKey::WORKSTATION, data);
	};
	auto HWEHE = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Tube Heat[{$}]", data);
		if (m_TubeHE->Update(0))
		{
			FireNotify(m_TubeHE->GetKey(), data);
		}
	};
	auto HWEHH = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv GEN Heat[{$}]", data);
		if (m_GenHE->Update(data))
		{
			FireNotify(m_GenHE->GetKey(), data);
		}
	};
	auto HWERR = [this](char* value, int length) -> void
	{
		FireErrorMessage(true, 0, "nuknow");
	};
	auto HWEWN = [this](char* value, int length) -> void
	{
		FireWarnMessage(true, 0, "nuknow");
	};
	auto HWEST = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Generator Status[{$}]", data);
		switch (data)
		{
			case 1: //Initialization Phase
			{
				if (m_GenState->Update(CcosAttrKey::GENERATOR_STATUS_INIT))
					FireNotify(m_GenState->GetKey(), m_GenState->JSGet());
			}break;
			case 2: //Standby Phase
			{
				if (m_GenState->Update(CcosAttrKey::GENERATOR_STATUS_STANDBY))
					FireNotify(m_GenState->GetKey(), m_GenState->JSGet());
			}break;
			case 3: //Rad Preparation (Ready) Phase
			{
			}break;
			case 4: //Rad Exposure (X-ray) Phase
			{
				if (m_GenState->Update(CcosAttrKey::GENERATOR_STATUS_EXP))
					FireNotify(m_GenState->GetKey(), m_GenState->JSGet());
			}break;
			case 5: //Fluoroscopy Exposure Phase
			{
				if (m_GenState->Update(CcosAttrKey::GENERATOR_STATUS_EXP))
					FireNotify(m_GenState->GetKey(), m_GenState->JSGet());
			}break;
			case 6: //Calibration Phase
			{
			}break;
			case 7: //Error Phase
			{
				if (m_GenState->Update(CcosAttrKey::GENERATOR_STATUS_ERROR))
					FireNotify(m_GenState->GetKey(), m_GenState->JSGet());
			}break;
			case 8: //Service Phase
			{
			}break;
			default:
			{}break;
		}
	};
	auto HWEXM = [this](char* value, int length) -> void
	{
		assert(value);
		int data = atoi(value);
		FDEBUG("Recv Exposure mode[{$}]", data);
		EnSYNMode tempSYN = EnSYNMode::EXPOSURE_SYNMODE_HARDWARE_SYNBOX;
		switch (data)
		{
			case 0:
				tempSYN = EnSYNMode::EXPOSURE_SYNMODE_HARDWARE_SYNBOX;
				break;
			case 1:
				tempSYN = EnSYNMode::EXPOSURE_SYNMODE_SOFTWARE_NOSYNBOX;
				break;
			default:
				break;
		}
		m_bSoftExpPermit = tempSYN;
	};
	
	//初始化指令对照表
	glo_arFrame.clear();
	//glo_arFrame[""] = tFrameMapItem(HWERROR_1);//命令格式:校验和错误
	//3.1 RADIOGRAPHIC COMMANDS
	glo_arFrame["RKV"] = tFrameMapItem(HWRKV);
	glo_arFrame["RMA"] = tFrameMapItem(HWRMA);
	glo_arFrame["RMS"] = tFrameMapItem(HWRMS);
	glo_arFrame["RMX"] = tFrameMapItem(HWRMX);
	glo_arFrame["RET"] = tFrameMapItem(HWRET);
	glo_arFrame["RFO"] = tFrameMapItem(HWRFO);
	glo_arFrame["RFN"] = tFrameMapItem(HWRFN);
	glo_arFrame["RFI"] = tFrameMapItem(HWRFI);
	glo_arFrame["RFS"] = tFrameMapItem(HWRFS);
	glo_arFrame["RAP"] = tFrameMapItem(HWRAP);
	glo_arFrame["RAT"] = tFrameMapItem(HWRAT);
	glo_arFrame["PR"]  = tFrameMapItem(HWPR);
	glo_arFrame["XR"]  = tFrameMapItem(HWXR);
	glo_arFrame["PS"]  = tFrameMapItem(HWPS);
	glo_arFrame["XS"]  = tFrameMapItem(HWXS);
	glo_arFrame["RPS"] = tFrameMapItem(HWRPS);
	glo_arFrame["RMM"] = tFrameMapItem(HWRMM);
	//3.2 FLUOROSCOPIC COMMANDS
	glo_arFrame["FLK"] = tFrameMapItem(HWFLK);
	glo_arFrame["FLM"] = tFrameMapItem(HWFLM);
	glo_arFrame["FLI"] = tFrameMapItem(HWFLI);
	glo_arFrame["FLT"] = tFrameMapItem(HWFLT);
	glo_arFrame["FLS"] = tFrameMapItem(HWFLS);
	glo_arFrame["FPW"] = tFrameMapItem(HWFPW);
	glo_arFrame["FLF"] = tFrameMapItem(HWFLF);
	glo_arFrame["FLP"] = tFrameMapItem(HWFLP);
	glo_arFrame["FLX"] = tFrameMapItem(HWFLX);
	glo_arFrame["FLA"] = tFrameMapItem(HWFLA);
	glo_arFrame["FLZ"] = tFrameMapItem(HWFLZ);
	glo_arFrame["FLR"] = tFrameMapItem(HWFLR);
	glo_arFrame["FLD"] = tFrameMapItem(HWFLD);
	//SYSTEM COMMANDS
	glo_arFrame["EWS"] = tFrameMapItem(HWEWS);
	glo_arFrame["EHE"] = tFrameMapItem(HWEHE);
	glo_arFrame["EHH"] = tFrameMapItem(HWEHH);
	glo_arFrame["ERR"] = tFrameMapItem(HWERR);
	glo_arFrame["EWN"] = tFrameMapItem(HWEWN);
	glo_arFrame["EST"] = tFrameMapItem(HWEST);
	glo_arFrame["EXM"] = tFrameMapItem(HWEXM);
	
}

bool nsGEN::CGEN_DEV_ContainerExample::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)
		{
			FERROR("Start HardwareStatus Thread Failed");
			return false;
		}
	}
	return true;
}
DWORD nsGEN::CGEN_DEV_ContainerExample::HardwareStatusThread(LPVOID pParam)
{
	CGEN_DEV_ContainerExample* pCurGen = (CGEN_DEV_ContainerExample*)pParam;
	if (pCurGen == NULL)
	{
		return false;
	}
	FINFO("HardwareStatusThread start");
	if ((int)pCurGen->m_GenConfig["loopTime"] >= 0)
	{
		pCurGen->m_iLoopTime = (int)pCurGen->m_GenConfig["loopTime"];
	}
	FINFO("loopTime = {$}", pCurGen->m_iLoopTime.load());
	int currtTime = pCurGen->m_iLoopTime;
	while (pCurGen->m_iLoopTime > 0)
	{
		//心跳包统计加1
		pCurGen->m_iHeartBeats++;
		int tempHeartBeat = pCurGen->m_iHeartBeats;
		if (tempHeartBeat > 10) //无返回信息认为连接断开
		{
			pCurGen->m_iHeartBeats = 0;
			FINFO("ExampleGEN: lost Connect \n");
			pCurGen->m_bConnectFlag = false;
			continue;
		}
		//发送心跳
		pCurGen->HWSendHBCMD("xxx", 3); //轮询发生器温度信息

	}

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