#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_GridStatue.reset(new GRIDSYNSTATEMould(0, 0, 20, 1));
	m_DYNMap.m_MapChannelState["TB"] = 0;
	m_DYNMap.m_MapChannelState["WB"] = 0;
	m_DYNMap.m_MapChannelState["GT"] = 0;
	m_DYNMap.m_MapChannelState["GW"] = 0;
	m_DYNMap.m_MapChannelState["PT"] = 0;
	m_DYNMap.m_MapChannelState["PW"] = 0;
	m_DYNMap.m_MapChannelState["ER"] = 0;

	m_DYNMap.m_MapChannelState["RT"] = 0;
	m_DYNMap.m_MapChannelState["RW"] = 0;
	m_DYNMap.m_MapChannelState["OT"] = 0;
	m_DYNMap.m_MapChannelState["OW"] = 0;
	m_DYNMap.m_MapChannelState["PR"] = 0;
	m_DYNMap.m_MapChannelState["FT"] = 0;
	m_DYNMap.m_MapChannelState["FW"] = 0;
	m_DYNMap.m_MapChannelState["TT"] = 0;
	m_DYNMap.m_MapChannelState["TW"] = 0;
	RefreshSignal();
}

nsSYN::DynBoxDevice::~DynBoxDevice()
{

}
void nsSYN::DynBoxDevice::Register(Dispatch* Dispatch)
{
	superGen::Register(Dispatch);
}
RET_STATUS nsSYN::DynBoxDevice::SetWS(std::string value)
{
	mLog::Info("SetWS");
	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)
{
	m_SynBoxUnit.m_ExpMode->Update(value);
	mLog::Info("SetExpMode {$}", value.c_str());
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetGeneratortoSyncStatus(int state)
{
	string strStateName = "";
	int nstate = -1;
	mLog::Info("SetGeneratortoSyncStatus :{$}", state);
	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)
	{
		mLog::Info("switch :{$}", 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;
			break;
		case AttrKey::GENERATOR_RAD_XRAYOFF:
			if (m_SynBoxUnit.m_ExpMode->JSGet() != "ContinueSerial")
			{
				strStateName = "GENEXPREQUEST";
				nstate = 0;
			}
			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::Error("switch :{$}, PreSetGeneratortoSyncStatus=false", state);
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsSYN::DynBoxDevice::SetExpEnable()
{
	mLog::Info("SetExpEnable");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetExpDisable()
{
	mLog::Info("SetExpDisable");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsSYN::DynBoxDevice::PrepareAcquisition()
{
	mLog::Info("PrepareAcquisition");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::StartWindowRequest()
{
	mLog::Info("StartWindowRequest");
	m_bINEEnable = true;
	string strStateName = "DETREACQREQUEST";
	int state = 1;
	SetSignal(strStateName.c_str(), state);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetExposureTimes(int nNum)
{
	mLog::Info("SetExposureTimes");
	if (m_SynBoxUnit.m_ExpMode->JSGet() != "TOMO")
	{
		m_nExpTimes = nNum;
	}
	else
	{
		m_nExpTimes = 0;
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::StopWindowRequest()
{
	mLog::Info("StopWindowRequest");
	m_bINEEnable = false;
	string strStateName = "DETREACQREQUEST";
	int state = 0;
	SetSignal(strStateName.c_str(), state);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetFrameRate(FLOAT frameRate)
{
	mLog::Info("SetFrameRate");
	SetPWM(frameRate);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetGenAECSignal(int signal)
{
	return RET_STATUS::RET_SUCCEED;
}
//-----------------------------------------------------------------------------
//		ProcessCmd
//-----------------------------------------------------------------------------

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


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


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

	auto HWSignal = [this](const char* value, int length) -> void
	{
		assert(value && length>=3);
		char	cChannelValue;
		cChannelValue = value[2]; //status : on /off
		string strChannel = ((string)value).substr(0, 2);
		bool bStatus = ChartoInt(cChannelValue);
		DealtheSignal(strChannel.c_str(), bStatus);
	};

	auto HWCAN = [this](const char* value, int length)
	{
		char data_can[MAX_COMMAND_LEN] = { 0 };
		for (int i = 0; i < length; i++)
		{
			if (value[i] == 0x30)
				data_can[i] = 0x0;
			else if (value[i] == 0x61)
				data_can[i] = 0x0a;
			else if (value[i] == 0x64)
				data_can[i] = 0x0d;
			else
				data_can[i] = value[i];
		}
		string strcmd = data_can;
		string sCmdID = strcmd.substr(2, 2);
		DealReceiveData(sCmdID, &data_can[4], length - 4);
	};

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

	arFrame.push_back(tFrameMapping("GR", 2, HWCAN));
	arFrame.push_back(tFrameMapping("CR", 2, HWCAN));
	arFrame.push_back(tFrameMapping("TB", 2, HWSignal));
	arFrame.push_back(tFrameMapping("WB", 2, HWSignal));
	arFrame.push_back(tFrameMapping("GT", 2, HWSignal));
	arFrame.push_back(tFrameMapping("GW", 2, HWSignal));
	arFrame.push_back(tFrameMapping("PT", 2, HWSignal));
	arFrame.push_back(tFrameMapping("PW", 2, HWSignal));
	arFrame.push_back(tFrameMapping("ER", 2, HWSignal));
	arFrame.push_back(tFrameMapping("RT", 2, HWSignal));
	arFrame.push_back(tFrameMapping("RW", 2, HWSignal));
	arFrame.push_back(tFrameMapping("OT", 2, HWSignal));
	arFrame.push_back(tFrameMapping("OW", 2, HWSignal));
	arFrame.push_back(tFrameMapping("PR", 2, HWSignal));
	arFrame.push_back(tFrameMapping("FT", 2, HWSignal));
	arFrame.push_back(tFrameMapping("FW", 2, HWSignal));
	arFrame.push_back(tFrameMapping("TT", 2, HWSignal));
	arFrame.push_back(tFrameMapping("TW", 2, HWSignal));
}
int nsSYN::DynBoxDevice::DealReceiveData(string sCmdID, const char* pData, int Datalen)
{
	mLog::Info("DynBoxDevice::DealReceiveData");
	if (strtol(("0x" + sCmdID).c_str(), NULL, 16) == 0x626)
	{

		string strCmd = pData;
		if (strtol(("0x" + strCmd.substr(0, 2)).c_str(), NULL, 16) == 0x14)
		{
			/*bool bUpdateSize = false, bUpdateFilter = false;
			if (strtol(("0x" + strCmd.substr(3, 1)).c_str(), NULL, 16) & 0x01)
			{
				m_nXSize = strtol(("0x" + strCmd.substr(4, 2)).c_str(), NULL, 16) + strtol(("0x" + strCmd.substr(6, 2)).c_str(), NULL, 16) * 256;
				bUpdateSize = true;
				m_nXSize = m_nXSize / 100;
				printf("m_nXSize = {$}", m_nXSize);

			}
			if (strtol(("0x" + strCmd.substr(3, 1)).c_str(), NULL, 16) & 0x02)
			{
				m_nYSize = strtol(("0x" + strCmd.substr(8, 2)).c_str(), NULL, 16) + strtol(("0x" + strCmd.substr(10, 2)).c_str(), NULL, 16) * 256;
				m_nYSize = m_nYSize / 100;
				bUpdateSize = true;
				printf("m_nYSize = {$}", m_nYSize);
			}

			if (strtol(("0x" + strCmd.substr(2, 1)).c_str(), NULL, 16) & 0x04)
			{
				m_nFilter = strtol(("0x" + strCmd.substr(12, 2)).c_str(), NULL, 16) + strtol(("0x" + strCmd.substr(14, 2)).c_str(), NULL, 16) * 256;
				bUpdateFilter = true;
				printf("m_nFilter = {$}", m_nFilter);
			}

			if (bUpdateSize)
			{
				CollimatorLogic::SetCollimatorSize(m_nXSize, m_nYSize);
			}

			if (bUpdateFilter)
			{
				CollimatorLogic::SetCollimatorFilter(m_nFilter);
			}*/
		}
	}

	return 1;
}
int nsSYN::DynBoxDevice::DealtheSignal(const char* channel, int state)
{
	mLog::Info("DynBoxDevice::DealtheSignal:{$}", channel);
	string strchannel = channel;
	m_DYNMap.m_MapChannelState[strchannel] = state;
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::Error("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("Didn't find CurrentExamMode :  {$}", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		return -1;
	}
	int 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("Signal Name = {$}, state = {$}", strSignalName.c_str(), nState);
			break;
		}
	}
	//当前没有跑到这里调用NotifySignal   需要单步调试一下。看看为什么没进去
	if (strSignalName != "" && nState >= 0)
	{
		//if (strSignalName == "WALLWINDOWSTATUS" || strSignalName == "TABLEWINDOWSTATUS")
		//{
		//	strSignalName = "XWINDOWSTATUS";
		//}
		//else if (strSignalName == "GENREADY")
		//{
		//	strSignalName = "GENREADY";
		//}
		//else if (strSignalName == "TABLEGRIDSTATUS" || strSignalName == "WALLGRIDSTATUS")
		//{

		//}
		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)
{
	mLog::Info("DynBoxDevice::NotifySignal");
	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());
		}
	}
	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 (state)
		{
			if (m_bSendRadReady)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_READY);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
			}
		}
		else
		{
			if (m_bSendRadOff)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
			}
		}
	}
	else if (strname == "TABLEWINDOWSTATUS" || strname == "WALLWINDOWSTATUS")
	{
		if (state)
		{
			if (m_bSendXwindowOn)
			{
				m_SynBoxUnit.m_DetectorWindowState->Update(AttrKey::XWINDOW_ON);
				FireNotify(m_SynBoxUnit.m_DetectorWindowState->GetKey(), m_SynBoxUnit.m_DetectorWindowState->JSGet());
			}
		}
		else
		{
			if (m_bSendXwindowOff)
			{
				m_SynBoxUnit.m_DetectorWindowState->Update(AttrKey::XWINDOW_OFF);
				FireNotify(m_SynBoxUnit.m_DetectorWindowState->GetKey(), m_SynBoxUnit.m_DetectorWindowState->JSGet());
			}
		}
	}
	else if (strname == "GENEXPSTATUS")
	{
		if (state)
		{
			if (m_bSendRadXrayOn)
			{
				m_SynBoxUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON);
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
				m_nCurrentExpTimes++;
			}

		}
		else
		{
			if (m_bSendRadXrayOff)
			{
				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)
{
	mLog::Info("DynBoxDevice::SetSignal");
	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("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("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()
{
	mLog::Info("DynBoxDevice::ClearSignal");
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::Error("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;
	}
	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::SetPWM(float fpps)
{
	mLog::Info("DynBoxDevice::SetPWM");
	return -1;
}
RET_STATUS nsSYN::DynBoxDevice::SendBySCF(const char* chChannelID, bool bStatus)
{
	mLog::Info("DynBoxDevice::SendBySCF");
	int nTimeout = 100;

	char cCmd[MAX_COMMAND_LEN] = { 0 };
	cCmd[0] = chChannelID[0];
	cCmd[1] = chChannelID[1];
	if (bStatus)
		cCmd[2] = '1';
	else
		cCmd[2] = '0';

	int nSize = 3;
	FormatCmd(cCmd, nSize);
	string strLog;
	CmdtoString(cCmd, nSize, strLog);

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

	mLog::Info("==OUT==: {$} ", cCmd);
	int ret = 0;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(cCmd, nSize, nTimeout, ret);
	Sleep(nTimeout);
	return RET_STATUS::RET_SUCCEED;
}

void nsSYN::DynBoxDevice::RefreshSignal()
{
	mLog::Info("Clearing Signal Begin");
	ResetGenExpSignal();
	ResetPanelReqSignal();
	ResetPanelPreSignal();
	mLog::Info("Clearing Signal End");
}


void  nsSYN::DynBoxDevice::ResetPanelPreSignal(void)
{
	mLog::Info("DynBoxDevice::ResetPanelPreSignal");
	int nTimeout = 100;

	char cCmd[MAX_COMMAND_LEN] = "RT0";// "SECA00";

	int nCmdSize = 3;// 6;
	FormatCmd(cCmd, nCmdSize);
	string strLog;
	CmdtoString(cCmd, nCmdSize, strLog);

	mLog::Info("[Send:{$}]", strLog.c_str());

	mLog::Info("ResetPanelPreSignal ==OUT==: {$} ", cCmd);
	int ret = 0;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(cCmd, nCmdSize, nTimeout, ret);
	Sleep(nTimeout);
}

void nsSYN::DynBoxDevice::ResetPanelReqSignal(void)
{
	mLog::Info("DynBoxDevice::ResetPanelReqSignal");
	int nTimeout = 100;

	char cCmd[MAX_COMMAND_LEN] = "RW0";// "SECA00";

	int nCmdSize = 3;// 6;
	FormatCmd(cCmd, nCmdSize);
	string strLog;
	CmdtoString(cCmd, nCmdSize, strLog);

	mLog::Info("[Send:{$}]", strLog.c_str());

	mLog::Info("ResetPanelReqSignal ==OUT==: {$} ", cCmd);
	int ret = 0;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(cCmd, nCmdSize, nTimeout, ret);
	Sleep(nTimeout);
}

void nsSYN::DynBoxDevice::ResetGenExpSignal(void)
{
	mLog::Info("DynBoxDevice::ResetGenExpSignal");
	int nTimeout = 100;

	char cCmd[MAX_COMMAND_LEN] = "OT0";

	int nCmdSize = 3;// 6;
	FormatCmd(cCmd, nCmdSize);
	string strLog;
	CmdtoString(cCmd, nCmdSize, strLog);

	mLog::Info("[Send:{$}]", strLog.c_str());

	mLog::Info("ResetGenExpSignal ==OUT==: {$} ", cCmd);
	int ret = 0;
	m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(cCmd, nCmdSize, nTimeout, ret);
	Sleep(nTimeout);
}
RET_STATUS nsSYN::DynBoxDevice::SimulateFootSwitchSignal(int signal)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::SetValue_PPS(FLOAT fluframeRate)
{
	return RET_STATUS::RET_SUCCEED;
}