PhysicalDevice/SynBox/2000ST/DIOS.Dev.SyncBox.2000ST/2000TBoxDevice.cpp

#include "stdafx.h"
#include "CommonFun.h"
#include "2000TBoxDevice.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, string configfile)
{
	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;
	m_strSYNMode = "SYN0";

	try
	{
		ResDataObject r_config;
		if (r_config.loadFile(configfile.c_str()))
		{
			ResDYNConfig = r_config["CONFIGURATION"]["DeviceConfig"]["Value"];
			TransJsonText(ResDYNConfig);
			ResDataObject temp;
			temp = r_config["CONFIGURATION"];
			TransJsonText(temp);
			if (temp.GetKeyCount("SendRadOffMsg") > 0)
			{
				m_bSendRadOff = (int)temp["SendRadOffMsg"];
				mLog::FINFO("SendRadOffMsg {$} ", m_bSendRadOff);
			}
			if (temp.GetKeyCount("SendRadPrepareMsg") > 0)
			{
				m_bSendRadPrepare = (int)temp["SendRadPrepareMsg"];
				mLog::FINFO("SendRadPrepareMsg {$} ", m_bSendRadPrepare);
			}
			if (temp.GetKeyCount("SendRadReadyMsg") > 0)
			{
				m_bSendRadReady = (int)temp["SendRadReadyMsg"];
				mLog::FINFO("SendRadReadyMsg {$} ", m_bSendRadReady);
			}
			if (temp.GetKeyCount("SendRadOXrayOnMsg") > 0)
			{
				m_bSendRadXrayOn = (int)temp["SendRadOXrayOnMsg"];
				mLog::FINFO("SendRadOXrayOnMsg {$} ", m_bSendRadXrayOn);
			}
			if (temp.GetKeyCount("SendRadXrayOffMsg") > 0)
			{
				m_bSendRadXrayOff = (int)temp["SendRadXrayOffMsg"];
				mLog::FINFO("SendRadXrayOffMsg {$} ", m_bSendRadXrayOff);
			}
			if (temp.GetKeyCount("SendXwindowOnMsg") > 0)
			{
				m_bSendXwindowOn = (int)temp["SendXwindowOnMsg"];
				mLog::FINFO("SendXwindowOnMsg {$} ", m_bSendXwindowOn);
			}
			if (temp.GetKeyCount("SendXwindowOffMsg") > 0)
			{
				m_bSendXwindowOff = (int)temp["SendXwindowOffMsg"];
				mLog::FINFO("SendXwindowOffMsg {$} ", m_bSendXwindowOff);
			}
		}
	}
	catch (const std::exception&)
	{
		
	}
}

nsSYN::DynBoxDevice::~DynBoxDevice()
{

}
void nsSYN::DynBoxDevice::Register(Dispatch* Dispatch)
{
	superGen::Register(Dispatch);
}
RET_STATUS nsSYN::DynBoxDevice::SetWS(std::string value)
{
	mLog::FINFO("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::FINFO("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::FINFO("SetExpMode {$}", value.c_str());
	ClearSignal();
	return RET_STATUS::RET_FAILED;
}
RET_STATUS nsSYN::DynBoxDevice::SetGeneratortoSyncStatus(int state)
{
	string strStateName = "";
	int nstate = -1;
	mLog::FINFO("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::FINFO("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::FERROR("switch :{$}, PreSetGeneratortoSyncStatus=false", state);
	}
	return RET_STATUS::RET_SUCCEED;
}

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

RET_STATUS nsSYN::DynBoxDevice::PrepareAcquisition()
{
	mLog::FINFO("PrepareAcquisition");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DynBoxDevice::StartWindowRequest()
{
	mLog::FINFO("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::FINFO("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::FINFO("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::FINFO("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::FINFO("Enter FireNotify");
	EventCenter->OnNotify(1, key, content);
}
int nsSYN::DynBoxDevice::DealReceiveData(string sCmdID, const char* pData, int Datalen)
{
	mLog::FINFO("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::FINFO("DynBoxDevice::DealtheSignal:{$}", channel);
	string strchannel = channel;
	m_DYNMap.m_MapChannelState[strchannel] = state;
	if (ResDYNConfig.GetKeyCount(m_strSYNMode.c_str()) <= 0)
	{
		mLog::FERROR("Didn't find SynMode :  {$}", m_strSYNMode.c_str());
		return -1;
	}
	if (ResDYNConfig[m_strSYNMode.c_str()].GetKeyCount(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) <= 0)
	{
		mLog::FERROR("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::FINFO("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::FINFO("strKey = {$}, confchannel = {$}", strKey.c_str(), confchannel.c_str());
		if (confchannel == strchannel)
		{
			strSignalName = strKey;
			nState = state;
			mLog::FINFO("Signal Name = {$}, state = {$}", strSignalName.c_str(), nState);
			break;
		}
	}
	//当前没有跑到这里调用NotifySignal   需要单步调试一下。看看为什么没进去
	if (strSignalName != "" && nState >= 0)
	{
		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::FINFO("Set Enable Signal = {$}", strSetEnableSignal.c_str());
					SetSignal(strSetEnableSignal.c_str(), nState);
				}
			}
			else
			{
				mLog::FINFO("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::FINFO("Set Disable Signal = {$}", strSetDisableSignal.c_str());
					SetSignal(strSetDisableSignal.c_str(), state);
				}
			}
			else
			{
				mLog::FINFO("Set Disable Signal = {$}", strSetDisableSignal.c_str());
				SetSignal(strSetDisableSignal.c_str(), state);
			}
		}
	}
	return 2;
}
int nsSYN::DynBoxDevice::NotifySignal(const char* name, int state)
{
	mLog::FINFO("DynBoxDevice::NotifySignal");
	string strname = name;
	mLog::FINFO("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 == "XWINDOWSTATUS")
	{
		if (state)
		{
			//if (m_cfgCurrentWSSYN.strSyncMode == "FULL")
			{
				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_cfgCurrentWSSYN.strSyncMode == "FULL")
			{
				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::FINFO("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::FERROR("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::FERROR("Set Signal {$}, state {$} ", name, state);
			mLog::FERROR("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::FWARN("m_nExpTimes has been enough in this sequence! m_nExpTimes={$},m_nCurrentExpTimes={$}", m_nExpTimes, m_nCurrentExpTimes);
						return true;
					}
				}
				else
				{
					mLog::FWARN("Generator didn't ready or detector didn't startAcq, So can't send INE to generator!");
					return true;
				}
			}
			mLog::FINFO("Set Signal {$}, state {$} ", name, state);
			SendBySCF(strChannel.c_str(), state);
			//Sleep(10);
		}
	}
	strName = strtemp;
	if (ResDYNConfig[m_strSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
	{
		mLog::FERROR("Set Signal {$}, state {$} ", name, state);
		mLog::FERROR("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::FWARN("m_nExpTimes has been enough in this sequence! m_nExpTimes={$},m_nCurrentExpTimes={$}", m_nExpTimes, m_nCurrentExpTimes);
					return true;
				}
			}
			else
			{
				mLog::FWARN("Generator didn't ready or detector didn't startAcq, So can't send INE to generator!");
				return true;
			}
		}
		mLog::FINFO("Set Signal {$}, state {$} ", name, state);
		SendBySCF(strChannel.c_str(), state);
		return 1;
	}
	return -1;
}
void nsSYN::DynBoxDevice::ClearSignal()
{
	mLog::FINFO("DynBoxDevice::ClearSignal");
	if (ResDYNConfig.GetFirstOf(m_strSYNMode.c_str()) < 0)
	{
		mLog::FERROR("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::FERROR("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::FINFO("Clear Name :{$},CurrentExamMode ={$}", name.c_str(), m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		if (strChannel != "")
		{
			mLog::FINFO("Clear Signal {$} ", strChannel);
			SendBySCF(strChannel.c_str(), false);
			Sleep(10);
		}
	}
	return;
}
int nsSYN::DynBoxDevice::SetPWM(float fpps)
{
	mLog::FINFO("DynBoxDevice::SetPWM");
	return -1;
}
RET_STATUS nsSYN::DynBoxDevice::SendBySCF(const char* chChannelID, bool bStatus)
{
	mLog::FINFO("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::FINFO("[Send:{$}]", cCmd);
	if (!m_SCF)
	{
		mLog::FERROR("SCF is NULL");
		return RET_STATUS::RET_FAILED;
	}

	mLog::FINFO("==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::ResetPanelPreSignal(void)
{
	mLog::FINFO("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::FINFO("[Send:{$}]", strLog.c_str());

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

void nsSYN::DynBoxDevice::ResetPanelReqSignal(void)
{
	mLog::FINFO("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::FINFO("[Send:{$}]", strLog.c_str());

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

void nsSYN::DynBoxDevice::ResetGenExpSignal(void)
{
	mLog::FINFO("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::FINFO("[Send:{$}]", strLog.c_str());

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

RET_STATUS nsSYN::DynBoxDevice::ActiveSyncMode(_tSyncModeArgs value)
{
	mLog::FINFO("WS{$}, SyncMode{$}, SyncValue{$}", m_cfgCurrentWSSYN.strWS, m_cfgCurrentWSSYN.strSyncMode, m_cfgCurrentWSSYN.strSyncValue);
	m_cfgCurrentWSSYN = value;
	return RET_STATUS::RET_SUCCEED;
}
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;
}