PhysicalDevice/SynBox/DYN/DIOS.Dev.SyncBox.DYN/DynBoxDevice.cpp

#include "stdafx.h"
#include "CommonFun.h"
#include "DynBoxDevice.hpp"
#include "Helper.JSON.hpp"


using namespace DIOS::Dev::Detail::SYNBOX;
namespace nsSYN = DIOS::Dev::Detail::SYNBOX;
//-----------------------------------------------------------------------------
//		DynBoxDevice
//-----------------------------------------------------------------------------
nsSYN::DynBoxDevice::DynBoxDevice(std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF)
{
	m_SCF = SCF;
	EventCenter = center;
	m_SynBoxUnit.m_WS.reset(new WORKSTATIONMould(""));
	m_SynBoxUnit.m_CurrentExpNumber.reset(new CUREXPNUMMould(0, 0, 10000, 1));
	m_SynBoxUnit.m_HandSwitchState.reset(new HANDSWITCHMould(0, 0, 10000, 1));
	m_SynBoxUnit.m_GenSynState.reset(new GENSYNSTATEMould(0, 0, 10000, 1));
	m_SynBoxUnit.m_TotalExpNumber.reset(new TOTALEXPNUMMould(0, 0, 10000, 1));
	m_SynBoxUnit.m_DetectorState.reset(new DETECTORSTATUSMould(0, 0, 10000, 1));
	m_SynBoxUnit.m_DetectorWindowState.reset(new XWINDOWSTATUSMould(AttrKey::XWINDOW_OFF, AttrKey::XWINDOW_OFF, AttrKey::XWINDOW_ON, 1));
	m_SynBoxUnit.m_ExpMode.reset(new EXPMODEMould(""));
	m_SynBoxUnit.m_GenExpFrameRate.reset(new EXPFRAMERATEMould(0, 0, 100, 1));
	m_SynBoxUnit.m_GenExpTimes.reset(new EXPTIMESMould(0, 0, 255, 1));
	m_SynBoxUnit.m_GridStatue.reset(new GRIDSYNSTATEMould(0, 0, 20, 1));

	m_DYNMap.m_MapChannelState["I0"] = 0;
	m_DYNMap.m_MapChannelState["I1"] = 0;
	m_DYNMap.m_MapChannelState["I2"] = 0;
	m_DYNMap.m_MapChannelState["I3"] = 0;
	m_DYNMap.m_MapChannelState["I4"] = 0;
	m_DYNMap.m_MapChannelState["I5"] = 0;
	m_DYNMap.m_MapChannelState["I6"] = 0;
	m_DYNMap.m_MapChannelState["I7"] = 0;
	m_DYNMap.m_MapChannelState["I8"] = 0;
	m_DYNMap.m_MapChannelState["I9"] = 0;
	m_DYNMap.m_MapChannelState["IA"] = 0;
	m_DYNMap.m_MapChannelState["IB"] = 0;
	m_DYNMap.m_MapChannelState["IC"] = 0;
	m_DYNMap.m_MapChannelState["ID"] = 0;
	m_DYNMap.m_MapChannelState["IE"] = 0;
	m_DYNMap.m_MapChannelState["IF"] = 0;

	m_DYNMap.m_MapChannelState["O0"] = 0;
	m_DYNMap.m_MapChannelState["O1"] = 0;
	m_DYNMap.m_MapChannelState["O2"] = 0;
	m_DYNMap.m_MapChannelState["O3"] = 0;
	m_DYNMap.m_MapChannelState["O4"] = 0;
	m_DYNMap.m_MapChannelState["O5"] = 0;
	m_DYNMap.m_MapChannelState["O6"] = 0;
	m_DYNMap.m_MapChannelState["O7"] = 0;
	m_DYNMap.m_MapChannelState["O8"] = 0;
	m_DYNMap.m_MapChannelState["O9"] = 0;
	m_DYNMap.m_MapChannelState["OA"] = 0;
	m_DYNMap.m_MapChannelState["OB"] = 0;
	m_DYNMap.m_MapChannelState["OC"] = 0;
	m_DYNMap.m_MapChannelState["OD"] = 0;
	m_DYNMap.m_MapChannelState["OE"] = 0;
	m_DYNMap.m_MapChannelState["OF"] = 0;

	m_strSYNMode = "SYN0";
}

nsSYN::DynBoxDevice::~DynBoxDevice()
{

}
void nsSYN::DynBoxDevice::Register(Dispatch* Dispatch)
{
	superGen::Register(Dispatch);
}
RET_STATUS nsSYN::DynBoxDevice::SetWS(std::string value)
{
	if (ResDYNConfig.GetFirstOf(value.c_str()) >= 0)
	{
		m_SynBoxUnit.m_WS->Update(value);
		m_strSYNMode = (string)ResDYNConfig[value.c_str()];
	}
	else
	{
		m_strSYNMode = "SYN0";
		mLog::Info("Syncbox configuration didn't find the workstation {$}, use defualt config SYN0", value.c_str());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetExpMode(std::string value)
{
	mLog::Info("Syncbox SetExpMode {$}", value.c_str());
	m_SynBoxUnit.m_ExpMode->Update(value);
	if (m_SynBoxUnit.m_ExpMode->JSGet() != "SingleRad" && m_strPreExpMode == "SingleRad")
	{
		m_SynBoxUnit.m_GenExpFrameRate->Update(m_DefaultExpFrameRate);
		FireNotify(m_SynBoxUnit.m_GenExpFrameRate->GetKey(), m_SynBoxUnit.m_GenExpFrameRate->JSGet());
		SetFrameRate(m_DefaultExpFrameRate);
		m_SynBoxUnit.m_GenExpTimes->Update(m_DefaultExpTimes);
		FireNotify(m_SynBoxUnit.m_GenExpTimes->GetKey(), m_SynBoxUnit.m_GenExpTimes->JSGet());
		SetExposureTimes(m_DefaultExpTimes);
	}
	m_strPreExpMode = value;
	ClearSignal();
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetGeneratortoSyncStatus(int state)
{
	string strStateName = "";
	int nstate = -1;
	mLog::Info("\n SetGeneratortoSyncStatus :{$} m_bSynUpdataGenerStatus :{$}", state, m_bSynUpdataGenerStatus);
	if (state == AttrKey::GENERATOR_FLU_OFF || state == AttrKey::GENERATOR_RAD_OFF)//如果是采集结束的消息，直接恢复同步盒状态
	{
		ClearSignal();
	}
	if (m_SynBoxUnit.m_GenSynState->Get() != state || state == AttrKey::GENERATOR_RAD_XRAYON || state == AttrKey::GENERATOR_RAD_XRAYOFF
		|| state == AttrKey::GENERATOR_FLU_XRAYON || state == AttrKey::GENERATOR_FLU_XRAYOFF)
	{
		mLog::Info("switch :{$}\n", state);
		switch (state)
		{
		case AttrKey::GENERATOR_RAD_PREPARE:
			m_nCurrentExpTimes = 0;
			strStateName = "HANDSWITCHPREPREQUEST";
			nstate = 1;
			m_nInExpState = true;
			m_wStartEXPTime = GetTickCount();
			break;
		case AttrKey::GENERATOR_RAD_READY:
			m_nCurrentExpTimes = 0;
			strStateName = "HANDSWITCHREADYREQUEST";
			nstate = 1;
			break;
		case AttrKey::GENERATOR_RAD_OFF:
			m_nCurrentExpTimes = 0;
			m_nExpTimes = -1;
			m_nInExpState = false;
			/*strStateName = "HANDSWITCHREADYREQUEST";
			nstate = 0;
			((DYNSyncBox*)GetDrvDPC())->SetSignal(strStateName.c_str(), state);
			Sleep(30);
			strStateName = "GENEXPREQUEST";
			nstate = 0;
			((DYNSyncBox*)GetDrvDPC())->SetSignal(strStateName.c_str(), state);
			Sleep(30);
			strStateName = "HANDSWITCHPREPREQUEST";
			nstate = 0;*/
			break;
		case AttrKey::GENERATOR_FLU_READY:
			m_nCurrentExpTimes = 0;
			strStateName = "HANDSWITCHPREPREQUEST";
			nstate = 1;
			SetSignal(strStateName.c_str(), nstate);
			Sleep(30);
			strStateName = "HANDSWITCHREADYREQUEST";
			nstate = 1;
			break;
		case AttrKey::GENERATOR_FLU_OFF:
			m_nCurrentExpTimes = 0;
			m_nExpTimes = -1;
			/*strStateName = "HANDSWITCHREADYREQUEST";
			nstate = 0;
			((DYNSyncBox*)GetDrvDPC())->SetSignal(strStateName.c_str(), nstate);
			Sleep(30);
			strStateName = "HANDSWITCHPREPREQUEST";*/
			break;
		case AttrKey::GENERATOR_RAD_XRAYON:
			m_bINEEnable = true;
			strStateName = "GENEXPREQUEST";
			nstate = 1;
			if (m_bSynUpdataGenerStatus)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
			}
			break;
		case AttrKey::GENERATOR_RAD_XRAYOFF:
			if (m_SynBoxUnit.m_ExpMode->JSGet() != "ContinueSerial")
			{
				strStateName = "GENEXPREQUEST";
				nstate = 0;
			}
			m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYOFF);
			FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
			break;
		case AttrKey::GENERATOR_FLU_XRAYON:
			m_bINEEnable = true;
			strStateName = "GENEXPREQUEST";
			nstate = 1;
			if (m_bSynUpdataGenerStatus)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_XRAYON);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
			}
			break;
		case AttrKey::GENERATOR_FLU_XRAYOFF:
			if (m_SynBoxUnit.m_ExpMode->JSGet() != "ContinueSerial")
			{
				strStateName = "GENEXPREQUEST";
				nstate = 0;
			}
			m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_XRAYOFF);
			FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
			break;
			
		default:
			strStateName = "";
			nstate = -1;
			break;
		}
		if (state == AttrKey::GENERATOR_FLU_OFF || state == AttrKey::GENERATOR_RAD_OFF)//如果是采集结束的消息，直接恢复同步盒状态
		{
			if (!m_bClear)
			{
				ClearSignal();
				m_bClear = true;
			}
			m_SynBoxUnit.m_GenSynState->Update(state);
		}
		else if (strStateName != "" && nstate >= 0)
		{
			m_bClear = false;
			SetSignal(strStateName.c_str(), nstate);
			m_SynBoxUnit.m_GenSynState->Update(state);
		}
	}
	else
	{
		mLog::Info("switch :{$}, PreSetGeneratortoSyncStatus=false\n", state);
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsSYN::DynBoxDevice::SetExpEnable()
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetExpDisable()
{
	ClearSignal();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsSYN::DynBoxDevice::PrepareAcquisition()
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::StartWindowRequest()
{
	m_bINEEnable = true;
	string strStateName = "DETREACQREQUEST";
	int state = 1;
	SetSignal(strStateName.c_str(), state);
	SetPWMState(true);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetExposureTimes(int nNum)
{
	if ((m_SynBoxUnit.m_ExpMode->JSGet() == "SingleRad") || (m_SynBoxUnit.m_ExpMode->JSGet() == "TOMO"))
	{
		m_nExpTimes = 1;
	}
	else
	{
		m_nExpTimes = nNum;
	}
	SetAreaType();
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::StopWindowRequest()
{
	m_bINEEnable = false;
	string strStateName = "DETREACQREQUEST";
	int state = 0;
	SetSignal(strStateName.c_str(), state);
	SetPWMState(false);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetFrameRate(FLOAT frameRate)
{
	SetPWM(frameRate);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SimulateFootSwitchSignal(int signal)
{
	SetFootSwitchStatus(signal);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetValue_PPS(FLOAT fluframeRate)
{
	SetPWM(fluframeRate);
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsSYN::DynBoxDevice::SetGenAECSignal(int signal)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SimulateHandSwitchSignal(string channel, int state)
{
	mLog::Info("Enter SimulateHandSwitchSignal:[{$}:{$}]", channel.c_str(), state);
	DealtheSignal(channel.c_str(), state);
	return RET_STATUS::RET_SUCCEED;
}
//RET_STATUS nsSYN::DynBoxDevice::SetV3GentoSyncStatus(int status)
//{
//	return RET_STATUS::RET_SUCCEED;
//}
//-----------------------------------------------------------------------------
//		ProcessCmd
//-----------------------------------------------------------------------------

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


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


//	收到硬件的通知, 有包到达
//	按照设计, 仅当数据有变化时, 才发通知到上层, 因此里面有大量的 if (..) FireNotify (..)
void nsSYN::DynBoxDevice::OnCallBack()
{
	//auto HWNotProcess = [](const char* value, int length) -> void
	//{
	//	printf("\n This commands didn't need to process!\n");
	//};


	//auto HWSignal = [this](const char* value, int length)
	//{
	//	string sCmdID = ((string)value).substr(8, 3);
	//	int nlen = value[11] * 256 + value[12];
	//};

	////	有部分前缀是包含关系, 长的包含短的, 例如 KVS 包含了 KV.
	////	因此长的在前面, 短的在后面
	////	!!! Device 是个短寿命对象, 而 arFrame 是静态变量 !!!
	////	!!! 因此, 在添加到 arFrame 之前, 务必先清零 !!!
	//

	//arFrame.push_back(tFrameMapping("SRA", 3, HWNotProcess));
	//arFrame.push_back(tFrameMapping("SEC", 3, HWNotProcess));
	//arFrame.push_back(tFrameMapping("SPT", 3, HWNotProcess));
	//arFrame.push_back(tFrameMapping("SRS", 3, HWNotProcess));
	//arFrame.push_back(tFrameMapping("SAI", 3, HWSignal));
	//arFrame.push_back(tFrameMapping("SWS", 3, HWSignal));
}

int nsSYN::DynBoxDevice::DealtheSignal(const char* channel, int state)
{
	string strchannel = channel;
	m_DYNMap.m_MapChannelState[strchannel] = state;
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::Error( "DealtheSignal Didn't find SynMode :  {$}", m_strSYNMode.c_str());
		return -1;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
	{
		mLog::Error( "DealtheSignal Didn't find CurrentExamMode :  {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return -1;
	}
	size_t count = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"].size();
	string strSignalName = "";
	int nState = -1;
	mLog::Info( "CurrentExamMode = {$}, strchannel = {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str(), strchannel.c_str());
	for (int i = 0; i < count; i++)
	{
		string strKey = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"].GetKey(i);
		string confchannel = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"][strKey.c_str()]["CHANNEL"];
		mLog::Info( "strKey = {$}, confchannel = {$}", strKey.c_str(), confchannel.c_str());
		if (confchannel == strchannel)
		{
			strSignalName = strKey;
			nState = state;
			mLog::Info( "Signal Name = {$}", strSignalName.c_str());
			mLog::Info("\nSignal Name = {$}, state = {$}\n", strSignalName.c_str(), nState);
			break;
		}
	}

	if (strSignalName != "" && nState >= 0)
	{
		if (strSignalName == "XWINDOWSTATUS")
		{
			strSignalName = "XWINDOWSTATUS";
		}
		else if (strSignalName == "GENREADY")
		{
			strSignalName = "GENREADY";
		}
		NotifySignal(strSignalName.c_str(), nState);
		string strSetEnableSignal = (string)ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"][strSignalName.c_str()]["SETENABLE"];
		string strSetDisableSignal = (string)ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"][strSignalName.c_str()]["SETDISABLE"];
		if (nState == 1 && strSetEnableSignal != "")
		{
			string strRelaySignal = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"][strSignalName.c_str()]["RELAY"];
			if (strRelaySignal != "")
			{
				string channel = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"][strRelaySignal.c_str()]["CHANNEL"];
				if (nState == m_DYNMap.m_MapChannelState[channel])
				{
					mLog::Info( "Set Enable Signal = {$}", strSetEnableSignal.c_str());
					SetSignal(strSetEnableSignal.c_str(), nState);
				}
			}
			else
			{
				mLog::Info( "Set Enable Signal = {$}", strSetEnableSignal.c_str());
				SetSignal(strSetEnableSignal.c_str(), nState);
			}
		}
		else if (state == 0 && strSetDisableSignal != "")
		{
			string strRelaySignal = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"][strSignalName.c_str()]["RELAY"];
			if (strRelaySignal != "")
			{
				string channel = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["INPUT"][strRelaySignal.c_str()]["CHANNEL"];
				if (1 == m_DYNMap.m_MapChannelState[channel])
				{
					mLog::Info( "Set Disable Signal = {$}", strSetDisableSignal.c_str());
					SetSignal(strSetDisableSignal.c_str(), state);
				}
			}
			else
			{
				mLog::Info( "Set Disable Signal = {$}", strSetDisableSignal.c_str());
				SetSignal(strSetDisableSignal.c_str(), state);
			}
		}
	}
	return 2;
}
int nsSYN::DynBoxDevice::NotifySignal(const char* name, int state)
{
	string strname = name;
	mLog::Info( "Send Notify : Name = {$}, State = {$}", name, state);
	if (strname == "HANDSWITCHPREP")
	{
		if (state)
		{
			m_SynBoxUnit.m_HandSwitchState->Update(1);
			FireNotify(m_SynBoxUnit.m_HandSwitchState->GetKey(), m_SynBoxUnit.m_HandSwitchState->JSGet());
		}
		else
		{
			m_SynBoxUnit.m_HandSwitchState->Update(0);
			FireNotify(m_SynBoxUnit.m_HandSwitchState->GetKey(), m_SynBoxUnit.m_HandSwitchState->JSGet());
		}
	}
	else if (strname == "HANDSWITCHREADY")
	{
		//if (state)
		//{
		//	m_SynBoxUnit.m_HandSwitchState->Update(2);
		//	FireNotify(m_SynBoxUnit.m_HandSwitchState->GetKey(), m_SynBoxUnit.m_HandSwitchState->JSGet());
		//}
		//else
		//{
		//	m_SynBoxUnit.m_HandSwitchState->Update(0);
		//	FireNotify(m_SynBoxUnit.m_HandSwitchState->GetKey(), m_SynBoxUnit.m_HandSwitchState->JSGet());
		//}
		if (m_SynBoxUnit.m_ExpMode->JSGet() != "SingleRad")
		{
			if (state)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_READY);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_bSendXindowOnMessage = true;
				m_bSendXindowOffMessage = false;
			}
			else
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_OFF);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				if (m_SynBoxUnit.m_ExpMode->JSGet() == "ContinueSerial")
				{
					StopWindowRequest();
				}
				m_bSendXindowOnMessage = false;
				m_bSendXindowOffMessage = true;
			}
		}
		else
		{
			if (state)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_READY);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_bSendXindowOnMessage = true;
				m_bSendXindowOffMessage = false;
			}
			else
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_bSendXindowOnMessage = false;
				m_bSendXindowOffMessage = true;
			}

		}
	}
	else if (strname == "GENPREP")
	{
		if (state)
		{
			m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_PREPARE);
			FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
		}
		else
		{
			m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
			FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
		}
	}
	else if (strname == "GENREADY")
	{
		if (m_SynBoxUnit.m_ExpMode->JSGet() != "SingleRad")
		{
			if (state)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_READY);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_bSendXindowOnMessage = true;
				m_bSendXindowOffMessage = false;
			}
			else
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_OFF);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				if (m_SynBoxUnit.m_ExpMode->JSGet() == "ContinueSerial")
				{
					StopWindowRequest();
				}
				m_bSendXindowOnMessage = false;
				m_bSendXindowOffMessage = true;
			}
		}
		else
		{
			if (state)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_READY);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_bSendXindowOnMessage = true;
				m_bSendXindowOffMessage = false;
			}
			else
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_bSendXindowOnMessage = false;
				m_bSendXindowOffMessage = true;
			}

		}

	}
	else if (strname == "XWINDOWSTATUS")
	{
		if (state )
		{
			if (m_bSendXindowOnMessage == true  && m_bINEEnable)
			{
				m_SynBoxUnit.m_DetectorWindowState->Update(AttrKey::XWINDOW_ON);
				FireNotify(m_SynBoxUnit.m_DetectorWindowState->GetKey(), m_SynBoxUnit.m_DetectorWindowState->JSGet());
				m_bSendXindowOnMessage = false;
			}
		}
		else
		{
			if (m_bSendXindowOffMessage == true)
			{
				m_SynBoxUnit.m_DetectorWindowState->Update(AttrKey::XWINDOW_OFF);
				FireNotify(m_SynBoxUnit.m_DetectorWindowState->GetKey(), m_SynBoxUnit.m_DetectorWindowState->JSGet());
				m_bSendXindowOffMessage = false;

			}
		}
	}
	else if (strname == "GENEXPSTATUS")
	{
		if (m_SynBoxUnit.m_ExpMode->JSGet() != "SingleRad")
		{
			if (state)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_XRAYON);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_nCurrentExpTimes++;
			}
			else
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_XRAYOFF);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
			}
		}
		else
		{
			if (state)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_nCurrentExpTimes++;
			}
			else
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYOFF);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
			}
		}

	}
	return 2;
}
int nsSYN::DynBoxDevice::SetSignal(const char* name, int state)
{
	string strtemp = name;
	string strName = "";
	std::size_t npos;
	while ((npos = strtemp.find_first_of(",")) != string::npos)
	{
		strName = strtemp.substr(0, npos);
		npos++;
		strtemp = strtemp.substr(npos, strtemp.size() - npos);
		if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
		{
			mLog::Error( "SetSignal Didn't find SynMode :  {$}", m_strSYNMode.c_str());
			return -1;
		}
		if (ResDYNConfig[m_strSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
		{
			mLog::Error( "Set Signal {$}, state {$} ", name, state);
			mLog::Error( "Didn't find m_SynBoxUnit.m_ExpMode->JSGet() :  {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
			return -1;
		}
		string strChannel = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"][strName.c_str()]["CHANNEL"];
		if (strChannel != "")
		{
			if (strName == "GENEXPREQUEST")
			{
				if (m_bINEEnable)
				{
					//m_nCurrentExpTimes++;
					if (m_nExpTimes > 0 && m_nCurrentExpTimes > m_nExpTimes)
					{
						mLog::Warn( "m_nExpTimes has been enough in this sequence! m_nExpTimes={$},m_nCurrentExpTimes={$}", m_nExpTimes, m_nCurrentExpTimes);
						return true;
					}
				}
				else
				{
					mLog::Warn( "Generator didn't ready or detector didn't startAcq, So can't send INE to generator!");
					return true;
				}
			}
			mLog::Info( "Set Signal {$}, state {$} ", name, state);
			SendBySCF(strChannel.c_str(), state);
			//Sleep(10);
		}
	}
	strName = strtemp;
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::Error( "ResDYNConfig Didn't find SynMode :  {$}", m_strSYNMode.c_str());
		return -1;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
	{
		mLog::Error( "Set Signal {$}, state {$} ", name, state);
		mLog::Error( "Didn't find CurrentExamMode :  {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return -1;
	}
	string strChannel = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"][strName.c_str()]["CHANNEL"];
	if (strChannel != "")
	{
		if (strName == "GENEXPREQUEST")
		{
			if (m_bINEEnable)
			{
				//m_nCurrentExpTimes++;
				if (m_nExpTimes > 0 && m_nCurrentExpTimes > m_nExpTimes)
				{
					mLog::Warn( "m_nExpTimes has been enough in this sequence! m_nExpTimes={$},m_nCurrentExpTimes={$}", m_nExpTimes, m_nCurrentExpTimes);
					return true;
				}
			}
			else
			{
				mLog::Warn( "Generator didn't ready or detector didn't startAcq, So can't send INE to generator!");
				return true;
			}
		}
		mLog::Info( "Set Signal {$}, state {$} ", name, state);
		SendBySCF(strChannel.c_str(), state);
		return 1;
	}
	return -1;
}
void nsSYN::DynBoxDevice::ClearSignal()
{
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::Error( "ClearSignal Didn't find SynMode :  {$}", m_strSYNMode.c_str());
		return;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
	{
		mLog::Error( "Didn't find CurrentExamMode :  {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return;
	}
	SetPWMState(false);
	size_t nsize = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"].size();
	for (int i = 0; i < nsize; i++)
	{
		string strChannel = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"][i]["CHANNEL"];
		string name = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"].GetKey(i);
		mLog::Info( "Clear Name :{$},CurrentExamMode ={$}", name.c_str(), m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		if (strChannel != "" && "FRAMERATE" != name)
		{
			mLog::Info( "Clear Signal {$} ", strChannel);
			SendBySCF(strChannel.c_str(), false);
			Sleep(10);
		}
	}

	return;
}
int nsSYN::DynBoxDevice::SetPWMState(bool state)
{
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::Error( "SetPWMState Didn't find SynMode :  {$}", m_strSYNMode.c_str());
		return -1;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
	{
		mLog::Warn( "SetPWMState Didn't find CurrentExamMode :  {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return -1;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"].GetFirstOf("FRAMERATE") < 0)
	{
		return 1;
	}
	string strChannel = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"]["FRAMERATE"]["CHANNEL"];
	if (strChannel != "")
	{
		if (state)
		{
			SendSPEBySCF(strChannel.c_str(), 3, 1, 500);
		}
		else
		{
			SendSPEBySCF(strChannel.c_str(), 0, 0, 500);
		}
		return 1;
	}
	return -1;
}
int nsSYN::DynBoxDevice::SetPWM(float fpps)
{
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::Error( "SetPWM Didn't find SynMode :  {$}", m_strSYNMode.c_str());
		return -1;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
	{
		mLog::Warn( "SetPWM Didn't find CurrentExamMode :  {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return -1;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"].GetFirstOf("FRAMERATE") < 0)
	{
		mLog::Warn( "SetPWM CurrentExamMode :  {$} didn't find FRAMERATE configration", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return 1;
	}
	if (fpps < 0.5)
	{
		mLog::Warn( "fpps :  %f <0.5", fpps);
		return 1;
	}
	string strChannel = ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["OUTPUT"]["FRAMERATE"]["CHANNEL"];
	if (strChannel != "")
	{
		mLog::Info("\n Set PWM {$} \n", strChannel.c_str());
		int nCycle = (int)((float)10000 / fpps + 0.5);
		//m_nCircleTime = nCycle;
		int pulse = 100;

		SendSPSBySCF(strChannel.c_str(), nCycle, pulse, 500);
		//SendSPEBySCF(strChannel.c_str(),3,1,500);
		return 1;
	}
	return -1;
}
int nsSYN::DynBoxDevice::SetAreaType()
{
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::Error( "SetAreaType Didn't find SynMode :  {$}", m_strSYNMode.c_str());
		return 0;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
	{
		mLog::Error( "SetAreaType Didn't find CurrentExamMode :  {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return 0;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()].GetFirstOf("AREAID") >= 0 && ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()].GetFirstOf("EXOCOUNTS") >= 0)
	{
		string areaid = (string)ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["AREAID"];
		string exocounts = (string)ResDYNConfig[m_strSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()]["EXOCOUNTS"];
		if (areaid.size() > 0 && exocounts.size() >= 2)
		{
			if (m_nExpTimes != 0)
			{
				mLog::Info("SetAreaType m_nExpTimes Value {$}", m_nExpTimes);
				exocounts = std::to_string(m_nExpTimes);
			}
			SendSMSBySCF(areaid.c_str(), exocounts.c_str(), 500);
		}
		return 1;
	}
	else
	{
		mLog::Error( "CurrentExamMode :  {$} didn't have AREAID or EXOCOUNTS", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return 0;
	}
}

RET_STATUS nsSYN::DynBoxDevice::SendBySCF(const char* chChannelID, bool bStatus)
{
	int nTimeout = 100;

	char cCmd[MAX_COMMAND_LEN] = "SWSA03";
	cCmd[6] = chChannelID[0];
	cCmd[7] = chChannelID[1];
	if (bStatus)
		cCmd[8] = '1';
	else
		cCmd[8] = '0';

	int nSize = 9;
	FormatCmd(cCmd, nSize);

	mLog::Info( "[Send:{$}]", cCmd);
	if (!m_SCF)
	{
		mLog::Error("SCF is NULL");
		return RET_STATUS::RET_FAILED;
	}

	mLog::Info("==OUT==: {$} \n", cCmd);
	int ret = 0;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(cCmd, nSize, nTimeout, ret);
	Sleep(nTimeout);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SendSPSBySCF(const char* chChannelID, int nCycle, int nPulse, int nWaitTime)
{
	int nTimeout = nWaitTime;

	char cCmd[MAX_COMMAND_LEN] = "SPSB0A";
	cCmd[6] = chChannelID[0];
	cCmd[7] = chChannelID[1];
	char chrtemp[8];
	sprintf_s(chrtemp, 8, "%04x", nCycle);
	cCmd[8] = chrtemp[0];
	cCmd[9] = chrtemp[1];
	cCmd[10] = chrtemp[2];
	cCmd[11] = chrtemp[3];


	sprintf_s(chrtemp, 8, "%04x", nPulse);
	cCmd[12] = chrtemp[0];
	cCmd[13] = chrtemp[1];
	cCmd[14] = chrtemp[2];
	cCmd[15] = chrtemp[3];

	int nSize = 16;
	FormatCmd(cCmd, nSize);

	mLog::Info("==OUT==: {$} \n", cCmd);

	int ret = 0;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(cCmd, nSize, nTimeout, ret);
	Sleep(nTimeout);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SendSPEBySCF(const char* chChannelID, UCHAR cMode, UCHAR cEnable, int nWaitTime)
{
	int nTimeout = nWaitTime;


	char cCmd[MAX_COMMAND_LEN] = "SPEA04";
	cCmd[6] = chChannelID[0];
	cCmd[7] = chChannelID[1];

	char chrtemp[2];
	sprintf_s(chrtemp, 2, "%01x", cMode);
	cCmd[8] = chrtemp[0];
	sprintf_s(chrtemp, 2, "%01x", cEnable);
	cCmd[9] = chrtemp[0];

	int nSize = 10;
	FormatCmd(cCmd, nSize);

	mLog::Info("==OUT==: {$} \n", cCmd);
	int ret = 0;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(cCmd, nSize, nTimeout, ret);
	Sleep(nTimeout);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SendSMSBySCF(const char* cExpMode, const char* cExpCount, int nWaitTime)
{
	int nTimeout = nWaitTime;
	char cCmd[MAX_COMMAND_LEN] = "SMSA03";
	string strExpMode = cExpMode;
	string strExpCount = cExpCount;
	cCmd[6] = strExpMode[0];
	cCmd[7] = strExpCount[0];
	cCmd[8] = strExpCount[1];
	int nSize = 9;
	FormatCmd(cCmd, nSize);

	mLog::Info("==OUT==: {$} \n", cCmd);
	int ret = 0;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(cCmd, nSize, nTimeout, ret);
	Sleep(nTimeout);
	return RET_STATUS::RET_SUCCEED;
}
int nsSYN::DynBoxDevice::SetFootSwitchStatus(int signal)
{
	string strStateName = "FOOTSWITCHSATUS";
	SetSignal(strStateName.c_str(), signal);
	return 1;
}