PhysicalDevice/SynBox/FullUCB/DIOS.Dev.SyncBox.FullUCB_forKonica/DeviceFullUCB.cpp

#include "stdafx.h"
#include "DeviceFullUCB.hpp"
#include "Helper.JSON.hpp"

using namespace DIOS::Dev::Detail::SYNBOX;
namespace nsSYN = DIOS::Dev::Detail::SYNBOX;
//-----------------------------------------------------------------------------
//		DeviceFullUCB
//-----------------------------------------------------------------------------
nsSYN::DeviceFullUCB::DeviceFullUCB(std::shared_ptr <IOEventCenter> center, string configfile)
{
	EventCenter = center;

	m_SynBoxUnit.m_SynBoxState.reset(new SYNSTATEMould(AttrKey::SYNBOX_STATUS_STANDBY, AttrKey::SYNBOX_STATUS_SHUTDOWN, AttrKey::SYNBOX_STATUS_SERVICE, 1));
	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(AttrKey::HAND_OFF, AttrKey::HAND_OFF, AttrKey::HAND_MAX, 1));
	m_SynBoxUnit.m_GenSynState.reset(new GENSYNSTATEMould(AttrKey::GENERATOR_RAD_OFF, AttrKey::GENERATOR_RAD_OFF, AttrKey::GENERATOR_SYNC_MAX, 1));
	m_SynBoxUnit.m_TotalExpNumber.reset(new TOTALEXPNUMMould(0, 0, 10000, 1));
	m_SynBoxUnit.m_DetectorState.reset(new DETECTORSTATUSMould(AttrKey::DETECTOR_STATUS_SHUTDOWN, AttrKey::DETECTOR_STATUS_SHUTDOWN, AttrKey::DETECTOR_STATUS_MAX, 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(AttrKey::XGRID_DISABLE, AttrKey::XGRID_DISABLE, AttrKey::XGRID_ENABLE, 1));

	m_strCurrSYNMode = "SYN0";
	m_FullUCBMap_IN.clear();
	m_FullUCBMap_OUT.clear();
	m_WorkStationMap.clear();

	GetConfData(configfile);

	StartHardwareThread();
}
nsSYN::DeviceFullUCB::~DeviceFullUCB()
{
	SetEvent(m_hExitEvent);
	Sleep(1000);
	if (m_pHardwareThread != NULL)
	{
		TerminateThread(m_pHardwareThread, 0);
		m_pHardwareThread = NULL;
	}
}
void nsSYN::DeviceFullUCB::Register(Dispatch* Dispatch)
{
	superGen::Register(Dispatch);
}
RET_STATUS nsSYN::DeviceFullUCB::RefreshData()
{
	mLog::FDEBUG("Enter RefreshData");

	UCBCmdSEC();

	return RET_STATUS::RET_SUCCEED;
}
bool nsSYN::DeviceFullUCB::StartHardwareThread()
{
	mLog::FINFO("Enter Start HardwareStatus Thread");
	m_hExitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hPWMEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	if (m_pHardwareThread == NULL)
	{
		DWORD m_HardwareStatusID;
		m_pHardwareThread = CreateThread(0, 0, HardwareStatusThread, this, 0, &m_HardwareStatusID);
		if (m_pHardwareThread == NULL)
		{
			mLog::FERROR("Start HardwareStatus Thread Failed");
			return false;
		}
	}
	return true;
}
DWORD nsSYN::DeviceFullUCB::HardwareStatusThread(LPVOID pParam)
{
	DeviceFullUCB* pCurSyn = (DeviceFullUCB*)pParam;
	if (pCurSyn == NULL)
	{
		return false;
	}
	mLog::FINFO("HardwareStatusThread start");

	DWORD event = 0;
	bool bExit = false;
	vector<HANDLE> waitList; //事件等待列表
	waitList.push_back(pCurSyn->m_hExitEvent);
	waitList.push_back(pCurSyn->m_hPWMEvent);
	while (!bExit)
	{
		event = WaitForMultipleObjects(waitList.size(), waitList.data(), FALSE, INFINITE);
		switch (event)
		{
			case (WAIT_TIMEOUT):
			{
				mLog::FWARN("HardwareStatusThread: Get loop EVENT timeout");
			}
			case WAIT_OBJECT_0:
			{
				mLog::FDEBUG("HardwareStatusThread: exited");
				bExit = true;
				break;
			}break;
			case (WAIT_OBJECT_0 + 1):
			{
				mLog::FDEBUG("HardwareStatusThread: wait[{$}]ms to stop PWM Enable", pCurSyn->m_PulseWidth);
				auto item = pCurSyn->m_FullUCBMap_OUT.find(CONF_FRAMERATE);
				if (item != pCurSyn->m_FullUCBMap_OUT.end())
				{
					string strChannel = item->second.strChannel;
					Sleep(pCurSyn->m_PulseWidth);
					//pCurSyn->UCBCmdSPE(strChannel, '0', '0');
					pCurSyn->UCBCmdSWS(strChannel, 0);
					item->second.nCurrStateValue = 0;
					pCurSyn->SetAreaType();
				}
				else
				{
					mLog::FWARN("HardwareStatusThread: not find CONF_FRAMERATE in FullUCBMap_OUT");
				}

			}break;
			default:
			{
				mLog::FDEBUG("HardwareStatusThread: unknown event");
			}break;
		}
	}
	pCurSyn->m_pHardwareThread = NULL;
	mLog::FINFO("HardwareStatusThread stop");
	return true;
}
//配置项获取
bool nsSYN::DeviceFullUCB::GetConfData(string& configfile)
{
	try {
		ResDataObject r_config;
		if (r_config.loadFile(configfile.c_str()))
	{
		m_ResFullUCBConfig = r_config["CONFIGURATION"];
		TransJsonText(m_ResFullUCBConfig);
		//UCB信号名
		if (m_ResFullUCBConfig.GetKeyCount("UCBTool") > 0)
		{
			string UCBTool = m_ResFullUCBConfig["UCBTool"];
			mLog::FDEBUG("cfg UCBTool[{$}]", UCBTool.c_str());
		}
		//是否代为发送发生器曝光状态
		if (m_ResFullUCBConfig.GetKeyCount("IsUpdateGenStatus") > 0)
		{
			string value = m_ResFullUCBConfig["IsUpdateGenStatus"];
			if (value.length() == AttrKey::GENERATOR_SYNC_MAX)
				m_bUpdateGenSyncStatusFlag = value;
		    mLog::FDEBUG("cfg UpdateGenSyncStatusFlag[{$}]", m_bUpdateGenSyncStatusFlag.c_str());
		}
		//是否代为发送探测器开窗状态
		if (m_ResFullUCBConfig.GetKeyCount("IsUpdateFPDStatus") > 0)
		{
			string value = m_ResFullUCBConfig["IsUpdateFPDStatus"];
			if (value.length() == AttrKey::XWINDOW_MAX)
				m_bUpdateFPDXWinStatusFlag = value;
			mLog::FDEBUG("cfg UpdateFPDXWinStatusFlag[{$}]", m_bUpdateFPDXWinStatusFlag.c_str());
		}
		//是否在更新曝光模式时自动重置所有输出信号
		if (m_ResFullUCBConfig.GetKeyCount("IsAutoClearSignalFlag") > 0)
		{
			m_bIsAutoClearSignalFlag = (int)m_ResFullUCBConfig["IsAutoClearSignalFlag"];
			mLog::FDEBUG("cfg IsAutoClearSignalFlag[{$}]", m_bIsAutoClearSignalFlag);
		}
		//是否按模式控制PWM脉冲数量
		if (m_ResFullUCBConfig.GetKeyCount("IsCtlPWMWithModeFlag") > 0)
		{
			m_bIsCtlPWMWithMode = (int)m_ResFullUCBConfig["IsCtlPWMWithModeFlag"];
			mLog::FDEBUG("cfg IsCtlPWMWithModeFlag[{$}]", m_bIsCtlPWMWithMode);
		}
		//是否按发生器状态控制PWM使能
		if (m_ResFullUCBConfig.GetKeyCount("IsCtlPWMWithGenFlag") > 0)
		{
			m_bIsCtlPWMWithGen = (int)m_ResFullUCBConfig["IsCtlPWMWithGenFlag"];
			mLog::FDEBUG("cfg IsCtlPWMWithGenFlag[{$}]", m_bIsCtlPWMWithGen);
		}
		//同步信号表
		if (m_ResFullUCBConfig.GetKeyCount(CONF_TABLE) > 0)
		{
			string WS = m_ResFullUCBConfig[CONF_TABLE];
			m_WorkStationMap[CONF_TABLE] = WS;
			mLog::FDEBUG("cfg WS[{$}],SYN[{$}]", CONF_TABLE, WS.c_str());
		}
		if (m_ResFullUCBConfig.GetKeyCount(CONF_WALL) > 0)
		{
			string WS = m_ResFullUCBConfig[CONF_WALL];
			m_WorkStationMap[CONF_WALL] = WS;
			mLog::FDEBUG("cfg WS[{$}],SYN[{$}]", CONF_WALL, WS.c_str());
		}
		if (m_ResFullUCBConfig.GetKeyCount(CONF_FREE) > 0)
		{
			string WS = m_ResFullUCBConfig[CONF_FREE];
			m_WorkStationMap[CONF_FREE] = WS;
			mLog::FDEBUG("cfg WS[{$}],SYN[{$}]", CONF_FREE, WS.c_str());
		}
		if (m_ResFullUCBConfig.GetKeyCount(CONF_DIRE) > 0)
		{
			string WS = m_ResFullUCBConfig[CONF_DIRE];
			m_WorkStationMap[CONF_DIRE] = WS;
			mLog::FDEBUG("cfg WS[{$}],SYN[{$}]", CONF_DIRE, WS.c_str());
		}
	}
		else
		{
			mLog::FERROR("loadFullUCBConfigFile [{$}] failed", configfile.c_str());
		}
	}
	catch (ResDataObjectExption& e)
	{
		mLog::FERROR("GetConfData crashed: Exption[{$}]", e.what());
		return false;
	}
	catch (...)
	{
		mLog::FERROR("GetConfData crashed: unll[{$}]", configfile.c_str());
		return false;
	}
	return true;
}
bool nsSYN::DeviceFullUCB::GetConfChannel(string expMode)
{
	mLog::FDEBUG("Enter GetConfChannel:SYN[{$}],mode[{$}]", m_strCurrSYNMode.c_str(), m_SynBoxUnit.m_ExpMode->JSGet().c_str());
	try {
		if (m_ResFullUCBConfig.size() > 0)
		{
			if (!m_strCurrSYNMode.empty())
			{
				if (m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()].GetFirstOf(m_SynBoxUnit.m_ExpMode->JSGet().c_str()) < 0)
				{
					mLog::FERROR("Didn't find CurrentExpMode:[{$}]", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
					return false;
				}

				m_AreaID = (string)m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_AREAID];
				m_ExpCounts = (string)m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_EXOCOUNTS];
				mLog::FDEBUG("conf IO_MODE:AreaID[{$}], ExpCounts[{$}]", m_AreaID.c_str(), m_ExpCounts.c_str());
				//输入信号配置
				size_t count_in = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_INPUT].size();
				for (int i = 0; i < count_in; i++)
				{
					string strName = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_INPUT].GetKey(i);
					string confchannel = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_INPUT][strName.c_str()][CONF_CHANNEL];
					string confEnable = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_INPUT][strName.c_str()][CONF_ENABLE];
					string confDisable = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_INPUT][strName.c_str()][CONF_DISABLE];
					string confRelay = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_INPUT][strName.c_str()][CONF_RELAY];
					string confSetEnable = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_INPUT][strName.c_str()][CONF_SETENABLE];
					string confSetDisable = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_INPUT][strName.c_str()][CONF_SETDISABLE];
					mLog::FDEBUG("conf IO_IN:strName[{$}], confchannel[{$}]", strName.c_str(), confchannel.c_str());
					string strKey = confchannel;
					if (strKey.empty())
					{
						strKey = strName;
					}
					m_FullUCBMap_IN[strKey] = stru_IN_Signal(strName, confchannel, confEnable, confDisable, confRelay, confSetEnable, confSetDisable);
				}
				//输出信号配置
				size_t count_out = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_OUTPUT].size();
				for (int i = 0; i < count_out; i++)
				{
					string strName = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_OUTPUT].GetKey(i);
					string confchannel = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_OUTPUT][strName.c_str()][CONF_CHANNEL];
					string confEnableValue = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_OUTPUT][strName.c_str()][CONF_ENABLE];
					string confDisableValue = m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_OUTPUT][strName.c_str()][CONF_DISABLE];
					if (m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_OUTPUT][strName.c_str()].GetKeyCount(CONF_ALLOWANCE) > 0)
					{
						int confAllowance = (int)m_ResFullUCBConfig[CONFIG][m_strCurrSYNMode.c_str()][m_SynBoxUnit.m_ExpMode->JSGet().c_str()][CONF_OUTPUT][strName.c_str()][CONF_ALLOWANCE];
						m_FullUCBMap_OUT[strName] = stru_OUT_Signal(strName, confchannel, confEnableValue, confDisableValue, confAllowance);
						mLog::FDEBUG("conf IO_OUT:strName[{$}],confchannel[{$}],EnableValue[{$}],DisableValue[{$}],allowance[{$}]", 
									strName.c_str(), confchannel.c_str(), confEnableValue.c_str(), confDisableValue.c_str(), confAllowance);
					}
					else
					{
						m_FullUCBMap_OUT[strName] = stru_OUT_Signal(strName, confchannel, confEnableValue, confDisableValue);
						mLog::FDEBUG("conf IO_OUT:strName[{$}],confchannel[{$}],EnableValue[{$}],DisableValue[{$}]", 
									strName.c_str(), confchannel.c_str(), confEnableValue.c_str(), confDisableValue.c_str());
					}
					
				}
			}
			else
			{
				mLog::FERROR("strSYNMode is empty");
			}
		}
		else
		{
			mLog::FERROR("ResFullUCBConfig is empty");
		}
	}
	catch (ResDataObjectExption& e)
	{
		mLog::FERROR("GetConfChannel crashed: Exption[{$}]", e.what());
		return false;
	}
	catch (...)
	{
		mLog::FERROR("GetConfChannel crashed: unll[{$}]", expMode.c_str());
		return false;
	}
	return true;
}
// 同步盒方法
RET_STATUS nsSYN::DeviceFullUCB::SetWS(std::string value)
{
	mLog::FDEBUG("Enter SetWS:[{$}]", value.c_str());
	if (m_ResFullUCBConfig.GetFirstOf(value.c_str()) >= 0)
	{
		m_SynBoxUnit.m_WS->Update(value);
		string wsSYNValue = (string)m_ResFullUCBConfig[value.c_str()];
		if (wsSYNValue.find("SYN") != string::npos)
		{
			m_strCurrSYNMode = wsSYNValue;
		}
		else
		{
			m_strCurrSYNMode = "SYN" + wsSYNValue;
		}
	}
	else
	{
		m_strCurrSYNMode = "SYN0";
		mLog::FDEBUG("Syncbox configuration didn't find the workstation {$}, use defualt config SYN0", value.c_str());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetExpMode(std::string value)
{
	mLog::FDEBUG("Enter SetExpMode:[{$}]", value.c_str());
	if (value == CONF_DR ||
		value == CONF_SR ||
		value == CONF_CF ||
		value == CONF_PF ||
		value == CONF_TOMO ||
		value == CONF_Stitch)
	{
		if (m_bIsAutoClearSignalFlag)
		{
			ClearSignal();
		}
		if (m_SynBoxUnit.m_ExpMode->Update(value))
		{
			GetConfChannel(value);
			SetAreaType();
		}
		if (value == CONF_CF ||
			value == CONF_PF)
		{
			if (m_fPPS != 0)
			{
				SetPWMParam(m_fPPS, m_PulseWidth);
			}
		}
	}
	else
	{
		mLog::FERROR("SetExpMode:mode[{$}] failed", value.c_str());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetGenAECSignal(int signal)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SimulateFootSwitchSignal(int signal)
{
	mLog::FDEBUG("Enter SimulateFootSwitchSignal:[{$}]", signal);
	if (signal)
	{
		if (m_FootSwitchState >= AttrKey::FOOT_DWON1)
			SetSignal(CONF_FOOTSWITCHSTATUS, AttrKey::FOOT_DWON1);
	}
	else
	{
		SetSignal(CONF_FOOTSWITCHSTATUS, AttrKey::FOOT_OFF);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SimulateHandSwitchSignal(int signal)
{
	mLog::FDEBUG("Enter SimulateHandSwitchSignal:[{$}]", signal);
	if (signal)
	{
		if (m_SynBoxUnit.m_HandSwitchState->Get() >= AttrKey::HAND_DWON1)
			SetSignal(CONF_HANDSWITCHPREPREQUEST, AttrKey::HAND_DWON1);
		if (m_SynBoxUnit.m_HandSwitchState->Get() >= AttrKey::HAND_DWON2)
			SetSignal(CONF_HANDSWITCHREADYREQUEST, AttrKey::HAND_DWON1);
	}
	else
	{
		SetSignal(CONF_HANDSWITCHREADYREQUEST, AttrKey::HAND_OFF);
		SetSignal(CONF_HANDSWITCHPREPREQUEST, AttrKey::HAND_OFF);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetDirectSignal(string channel, bool state)
{
	mLog::FDEBUG("Enter SetDirectSignal:[{$}]", channel.c_str(), state);
	UCBCmdSWS(channel, state);
	return RET_STATUS::RET_SUCCEED;
}
//发生器方法
RET_STATUS nsSYN::DeviceFullUCB::SetGeneratorHandSwitchStatus(int state)
{
	mLog::FDEBUG("SetGeneratorHandSwitchStatus:[{$}->{$}]", m_SynBoxUnit.m_HandSwitchState->Get(), state);
	string strStateName = "";
	int nstate = -1;
	if (m_SynBoxUnit.m_HandSwitchState->Get() != state)
	{
		switch (state)
		{
			case AttrKey::HAND_OFF:
			{
			}break;
			case AttrKey::HAND_DWON1:
			{
			}break;
			case AttrKey::HAND_DWON2:
			{
			}break;
			default:
			{
				mLog::FERROR("SetGeneratorHandSwitchStatus:unknow HandStatus[{$}]", state);
				return RET_STATUS::RET_SUCCEED;
			}break;
		}
		if (m_SynBoxUnit.m_HandSwitchState->Update(state))
		{
			FireNotify(m_SynBoxUnit.m_HandSwitchState->GetKey(), m_SynBoxUnit.m_HandSwitchState->JSGet());
		}
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetGeneratorFootSwitchStatus(int state)
{
	mLog::FDEBUG("SetGeneratorFootSwitchStatus:[{$}->{$}]", m_FootSwitchState, state);
	string strStateName = "";
	int nstate = -1;
	if (m_FootSwitchState != state)
	{
		switch (state)
		{
			case AttrKey::FOOT_OFF:
			{
			}break;
			case AttrKey::FOOT_DWON1:
			{
			}break;
			default:
			{
				mLog::FERROR("SetGeneratorFootSwitchStatus:unknow HandStatus[{$}]", state);
				return RET_STATUS::RET_SUCCEED;
			}break;
		}
		m_FootSwitchState = state;
		FireNotify(AttrKey::DiosFootSwitch, m_FootSwitchState);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetGeneratortoSyncStatus(int state)
{
	mLog::FDEBUG("SetGeneratortoSyncStatus:[{$}->{$}],UpdateGenSynStatusFlag[{$}]", m_SynBoxUnit.m_GenSynState->Get(),state, m_bUpdateGenSyncStatusFlag.c_str());
	string strStateName = "";
	int nstate = -1;
	if (m_SynBoxUnit.m_GenSynState->Get() != state)
	{
		switch (state)
		{
			case AttrKey::GENERATOR_RAD_OFF:
			{
				m_nCurrentExpCount = 0;
				m_nExpMaxCount = -1;

				if(m_bINEEnable_Gen)
					m_bINEEnable_Gen = false;

				if (m_bIsCtlPWMWithGen)
					SetPWMState(false);
			}break;
			case AttrKey::GENERATOR_RAD_PREPARE:
			{
				m_nCurrentExpCount = 0;

				if (m_bINEEnable_Gen)
					m_bINEEnable_Gen = false;
			}break;
			case AttrKey::GENERATOR_RAD_READY:
			{
				m_nCurrentExpCount = 0;

				if (!m_bINEEnable_Gen)
					m_bINEEnable_Gen = true;
			}break;
			case AttrKey::GENERATOR_RAD_XRAYON:
			{
				m_nCurrentExpCount++;

				if (!m_bINEEnable_Gen)
					m_bINEEnable_Gen = true;
				
				if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_DR)
				{
					strStateName = CONF_GENEXPREQUEST;
					nstate = 1;
				}
				else if(m_SynBoxUnit.m_ExpMode->JSGet() == CONF_Stitch)//拼接特殊处理手闸信号
				{
					if (m_SynBoxUnit.m_HandSwitchState->Get() == AttrKey::HAND_DWON1)
					{
						SetSignal(CONF_HANDSWITCHPREPREQUEST, AttrKey::HAND_DWON1);
					}
					else if (m_SynBoxUnit.m_HandSwitchState->Get() == AttrKey::HAND_DWON2)
					{
						SetSignal(CONF_HANDSWITCHPREPREQUEST, AttrKey::HAND_DWON1);
						SetSignal(CONF_HANDSWITCHREADYREQUEST, AttrKey::HAND_DWON1);
					}
					else
					{
						mLog::FWARN("GeneratorHandSwitchStatus:[{$}] not press", m_SynBoxUnit.m_HandSwitchState->Get());
					}
				}
			}break;
			case AttrKey::GENERATOR_RAD_XRAYOFF:
			{
				if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_DR)
				{

					strStateName = CONF_GENEXPREQUEST;
					nstate = 0;
				}
				else if(m_SynBoxUnit.m_ExpMode->JSGet() == CONF_Stitch)//拼接特殊处理手闸信号
				{
					if (m_SynBoxUnit.m_HandSwitchState->Get() == AttrKey::HAND_DWON1)
					{
						SetSignal(CONF_HANDSWITCHPREPREQUEST, AttrKey::HAND_OFF);
					}
					else if (m_SynBoxUnit.m_HandSwitchState->Get() == AttrKey::HAND_DWON2)
					{
						SetSignal(CONF_HANDSWITCHPREPREQUEST, AttrKey::HAND_OFF);
						SetSignal(CONF_HANDSWITCHREADYREQUEST, AttrKey::HAND_OFF);
					}
					else
					{
						mLog::FWARN("GeneratorHandSwitchStatus:[{$}] not press", m_SynBoxUnit.m_HandSwitchState->Get());
					}
				}
			}break;
			case AttrKey::GENERATOR_FLU_OFF:
			{
				m_nCurrentExpCount = 0;
				m_nExpMaxCount = -1;

				if (m_bINEEnable_Gen)
					m_bINEEnable_Gen = false;

				if (m_bIsCtlPWMWithGen)
					SetPWMState(false);
			}break;
			case AttrKey::GENERATOR_FLU_READY:
			{
				m_nCurrentExpCount = 0;
				strStateName = CONF_FOOTSWITCHSTATUS;
				if (!m_bINEEnable_Gen)
					m_bINEEnable_Gen = true;
			}break;
			case AttrKey::GENERATOR_FLU_XRAYON:
			{
				m_nCurrentExpCount++;

				if (!m_bINEEnable_Gen)
					m_bINEEnable_Gen = true;
			}break;
			case AttrKey::GENERATOR_FLU_XRAYOFF:
			{
			}break;
			case AttrKey::GENERATOR_FLU_CINE_READY:
			{
			}break;
			default:
			{
				mLog::FERROR("SetGeneratortoSyncStatus:unknow GenSynStatus[{$}]", state);
				return RET_STATUS::RET_SUCCEED;
			}break;
		}
		if (m_SynBoxUnit.m_GenSynState->Update(state))
		{
			mLog::FDEBUG("Enter SetGeneratortoSyncStatus:[{$}]", strStateName.c_str());
			auto item_out = m_FullUCBMap_OUT.find(strStateName.c_str());
			if (item_out == m_FullUCBMap_OUT.end())
			{
				mLog::FERROR("SetGeneratortoSyncStatus:[{$}] not in m_FullUCBMap_OUT", strStateName.c_str());
			}
			else
			{
				string strChannel = item_out->second.strChannel;
				if (strChannel.empty())
					mLog::FERROR("SetGeneratortoSyncStatus:[{$}] Channel[{$}] is empty", strStateName.c_str(), strChannel.c_str());
				else
					UCBCmdSWS(strChannel, nstate);
			}
			if (m_bUpdateGenSyncStatusFlag.at(state) == '1')
				FireNotify(m_SynBoxUnit.m_GenSynState->GetKey(), m_SynBoxUnit.m_GenSynState->JSGet());
		}
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetExposureTimes(int nNum)
{
	mLog::FDEBUG("Enter SetExposureTimes:[{$}]", nNum);
	if (m_SynBoxUnit.m_ExpMode->JSGet() != CONF_TOMO)
	{
		m_nExpMaxCount = nNum;
	}
	else
	{
		m_nExpMaxCount = -1;
	}
	SetAreaType();
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetExpEnable()
{
	mLog::FDEBUG("Enter SetExpEnable");
	SetPWMState(true);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetExpDisable()
{
	mLog::FDEBUG("Enter SetExpDisable");
	StopWindowRequest();
	SimulateFootSwitchSignal(0);
	ClearSignal();
	return RET_STATUS::RET_SUCCEED;
}
//探测器方法
RET_STATUS nsSYN::DeviceFullUCB::SetFPDXwinStatus(int state)
{
	mLog::FDEBUG("SetFPDXwinStatus:[{$}->{$}],UpdateFPDXwinStatusFlag[{$}]", m_SynBoxUnit.m_DetectorWindowState->Get(), state, m_bUpdateFPDXWinStatusFlag.c_str());

	if (m_SynBoxUnit.m_DetectorWindowState->Get() != state)
	{
		switch (state)
		{
			case AttrKey::XWINDOW_OFF:
			{
				m_bINEEnable_FPD = false;
			}break;
			case AttrKey::XWINDOW_ON:
			{
				m_bINEEnable_FPD = true;
			}break;
			default:
			{
				mLog::FERROR("SetFPDXwinStatus:unknow FPDXwinStatus[{$}]", state);
				return RET_STATUS::RET_SUCCEED;
			}break;
		}
		if (m_SynBoxUnit.m_DetectorWindowState->Update(state))
		{
			if (m_bUpdateFPDXWinStatusFlag.at(state) == '1')
				FireNotify(m_SynBoxUnit.m_DetectorWindowState->GetKey(), m_SynBoxUnit.m_DetectorWindowState->JSGet());
		}
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::PrepareAcquisition()
{
	mLog::FDEBUG("Enter PrepareAcquisition");
	SetAreaType();
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::StartWindowRequest()
{
	mLog::FDEBUG("Enter StartWindowRequest");

	if(!m_bINEEnable_FPD)
	{
		m_bINEEnable_FPD = true;
		SetSignal(CONF_DETREACQREQUEST, 1);
		if(m_SynBoxUnit.m_ExpMode->JSGet() != CONF_Stitch)
			SetPWMState(m_bINEEnable_FPD);
	}
	else
	{
		mLog::FWARN("already INEEnable_FPD");
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::StopWindowRequest()
{
	mLog::FDEBUG("Enter StopWindowRequest"); 
	if (m_bINEEnable_FPD)
	{
		m_bINEEnable_FPD = false;
		SetSignal(CONF_DETREACQREQUEST, 0);
		if (m_SynBoxUnit.m_ExpMode->JSGet() != CONF_Stitch)
			SetPWMState(m_bINEEnable_FPD);
	}
	else
	{
		mLog::FWARN("already INEEnable_FPD");
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetFrameRate(FLOAT frameRate)
{
	mLog::FDEBUG("Enter SetFrameRate:[{$}]", frameRate);
	if (m_fPPS != frameRate)
	{
		m_fPPS = frameRate;
		SetPWMParam(frameRate, m_PulseWidth);
	}
	return RET_STATUS::RET_SUCCEED;
}
//由工作流调用
RET_STATUS nsSYN::DeviceFullUCB::SetDirectExpSignal(int signal)
{
	mLog::FDEBUG("Enter SetDirectExpSignal:[{$}]", signal);
	auto item_out = m_FullUCBMap_OUT.find(CONF_GENEXPREQUEST);
	if (item_out == m_FullUCBMap_OUT.end())
	{
		mLog::FERROR("SetDirectExpSignal:[{$}] not in m_FullUCBMap_OUT", CONF_GENEXPREQUEST);
	}
	else
	{
		string strChannel = item_out->second.strChannel;
		if(strChannel.empty())
			mLog::FERROR("SetDirectExpSignal:[{$}] Channel[{$}] is empty", CONF_GENEXPREQUEST, strChannel.c_str());
		else
			UCBCmdSWS(strChannel, signal);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetValue_PPS(FLOAT fluframerate)
{
	mLog::FDEBUG("Enter SetValue_PPS:[{$}]", fluframerate);
	if (m_fPPS != fluframerate)
	{
		m_fPPS = fluframerate;
		SetPWMParam(fluframerate, m_PulseWidth);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::ActiveSyncMode(_tSyncModeArgs value)
{
	mLog::FDEBUG("Enter ActiveSyncMode:Sync[{$},{$}],WS[{$}]", value.strSyncMode.c_str(), value.strSyncValue.c_str(), value.strWS.c_str());
	m_SynBoxUnit.m_WS->Update(value.strWS);
	if(!value.strSyncValue.empty())
	{
		string temp = "SYN" + value.strSyncValue;
		if (m_strCurrSYNMode != temp)
		{
			m_strCurrSYNMode = temp;
			mLog::FDEBUG("will read[{$}]signal table", m_strCurrSYNMode.c_str());
			GetConfChannel(m_strCurrSYNMode);
			SetAreaType();
		}
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsSYN::DeviceFullUCB::SetPulseWidth(int value)
{
	mLog::FDEBUG("Enter SetPulseWidth:[{$}]", value);
	if (m_PulseWidth != value)
	{
		m_PulseWidth = value;
		SetPWMState(false);
		SetPWMParam(m_fPPS, value);
	}
	return RET_STATUS::RET_SUCCEED;
}

//-----------------------------------------------------------------------------
//		ProcessCmd
//-----------------------------------------------------------------------------
//属性上报
void nsSYN::DeviceFullUCB::FireNotify(std::string key, std::string content)
{
	EventCenter->OnNotify(1, key, content);
}
void nsSYN::DeviceFullUCB::FireNotify(std::string key, int content)
{
	std::string str = to_string(content);
	EventCenter->OnNotify(1, key, str);
}
//设备属性处理
int nsSYN::DeviceFullUCB::NotifyUnitAttribute(const string& strname, int& state)
{
	mLog::FDEBUG("NotifyUnitAttribute: Name[{$}], State[{$}]", strname.c_str(), state);
	if (strname == CONF_HANDSWITCHPREP)//手闸
	{
		if (state)
		{
			SetGeneratorHandSwitchStatus(AttrKey::HAND_DWON1);
		}
		else
		{
			SetGeneratorHandSwitchStatus(AttrKey::HAND_OFF);
		}
	}
	else if (strname == CONF_HANDSWITCHREADY)
	{
		if (state)
		{
			SetGeneratorHandSwitchStatus(AttrKey::HAND_DWON2);
		}
		else
		{
			SetGeneratorHandSwitchStatus(AttrKey::HAND_OFF);
		}
	}
	else if (strname == CONF_FOOTSWITCHREADY)
	{
		if (state)
		{
			SetGeneratorFootSwitchStatus(AttrKey::FOOT_DWON1);
		}
		else
		{
			SetGeneratorFootSwitchStatus(AttrKey::FOOT_OFF);
		}
	}
	else if (strname == CONF_GENPREP)//发生器曝光状态
	{
		if (state)
		{
			SetGeneratortoSyncStatus(AttrKey::GENERATOR_RAD_PREPARE);
		}
		else
		{
			SetGeneratortoSyncStatus(AttrKey::GENERATOR_RAD_OFF);
		}
	}
	else if (strname == CONF_GENREADY)
	{
		if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_DR || m_SynBoxUnit.m_ExpMode->JSGet() == CONF_SR)
		{
			if (state)
			{
				SetGeneratortoSyncStatus(AttrKey::GENERATOR_RAD_READY);
			}
			else
			{
				SetGeneratortoSyncStatus(AttrKey::GENERATOR_RAD_OFF);
			}
		}
		else if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_CF || m_SynBoxUnit.m_ExpMode->JSGet() == CONF_PF)
		{
			if (state)
			{
				SetGeneratortoSyncStatus(AttrKey::GENERATOR_FLU_READY);
			}
			else
			{
				SetGeneratortoSyncStatus(AttrKey::GENERATOR_FLU_OFF);
			}
		}
		else
		{
			mLog::FWARN("NotifyUnitAttribute: Name[{$}], ignore ExpMode[{$}]", strname.c_str(), m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		}

	}
	else if (strname == CONF_GENEXPSTATUS)
	{
		if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_DR || m_SynBoxUnit.m_ExpMode->JSGet() == CONF_SR)
		{
			if (state)
			{
				SetGeneratortoSyncStatus(AttrKey::GENERATOR_RAD_XRAYON);
			}
			else
			{
				SetGeneratortoSyncStatus(AttrKey::GENERATOR_RAD_XRAYOFF);
			}
		}
		else if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_CF || m_SynBoxUnit.m_ExpMode->JSGet() == CONF_PF)
		{
			if (state)
			{
				SetGeneratortoSyncStatus(AttrKey::GENERATOR_FLU_XRAYON);
			}
			else
			{
				SetGeneratortoSyncStatus(AttrKey::GENERATOR_FLU_XRAYOFF);
			}
		}
		else
		{
			mLog::FWARN("NotifyUnitAttribute: Name[{$}], ignore ExpMode[{$}]", strname.c_str(), m_SynBoxUnit.m_ExpMode->JSGet().c_str());
		}

	}
	else if (strname == CONF_XWINDOWSTATUS)//开窗状态
	{
		if (state)
		{
			SetFPDXwinStatus(AttrKey::XWINDOW_ON);
		}
		else
		{
			SetFPDXwinStatus(AttrKey::XWINDOW_OFF);
		}
	}
	return 2;
}
//收到硬件的通知, 有包到达
void nsSYN::DeviceFullUCB::OnCallBack()
{
	
}

//处理信号
bool nsSYN::DeviceFullUCB::DealtheSignal(const string& channel, int& state)
{
	mLog::FDEBUG("DealtheSignal:channel[{$}],state[{$}]", channel.c_str(), state);
	
	if (channel.empty() || (state != 0 && state != 1))
	{
		return false;
	}
	if (m_FullUCBMap_IN.empty())
	{
		mLog::FERROR("DealtheSignal:m_FullUCBMap_IN is empty");
		return false;
	}
	//mLog::FDEBUG( "DealtheSignal: SYN[{$}],mode[{$}]", m_strSYNMode.c_str(), m_SynBoxUnit.m_ExpMode->JSGet().c_str());
	auto item_in = m_FullUCBMap_IN.find(channel);
	if (item_in == m_FullUCBMap_IN.end())
	{
		mLog::FERROR("DealtheSignal:m_FullUCBMap_IN not find[{$}]", channel.c_str());
		return false;
	}
	else
	{
		string strName = item_in->second.strSyncName;
		string strSetEnableSignal = item_in->second.strEnableIo;
		string strSetDisableSignal = item_in->second.strDisableIo;
		string strSetRelaySignal = item_in->second.strRELAYIo;

		NotifyUnitAttribute(strName, state);

		if (state)
		{
			mLog::FDEBUG("name[{$}] channel[{$}] state[{$}] Enable[{$}] Relay[{$}]",
						strName.c_str(), channel.c_str(), state, strSetEnableSignal.c_str(), strSetRelaySignal.c_str());
			if (!strSetRelaySignal.empty())
			{
				mLog::FDEBUG("Set Relay Signal = {$}", strSetRelaySignal.c_str());
				SetSignal(strSetRelaySignal.c_str(), state);
			}
			if (!strSetEnableSignal.empty())
			{
				mLog::FDEBUG("Set Signal = {$}", strSetEnableSignal.c_str());
				SetMultipleSignal(strSetEnableSignal.c_str(), state);
			}
		}
		else
		{
			mLog::FDEBUG("name[{$}] channel[{$}] state[{$}] Disable[{$}] Relay[{$}]",
						strName.c_str(), channel.c_str(), state, strSetDisableSignal.c_str(), strSetRelaySignal.c_str());
			if (!strSetRelaySignal.empty())
			{
				mLog::FDEBUG("Set Relay Signal = {$}", strSetRelaySignal.c_str());
				SetSignal(strSetRelaySignal.c_str(), state);
			}
			if (!strSetDisableSignal.empty())
			{
				mLog::FDEBUG("Set Signal = {$}", strSetDisableSignal.c_str());
				SetMultipleSignal(strSetDisableSignal.c_str(), state);
			}
		}

	}
	return true;
}

void nsSYN::DeviceFullUCB::SetMultipleSignal(const string& strname, int& state) //change by wxx:原截取字符串操作有问题
{
	string strtemp = strname;
	string strName = strtemp;
	bool lastFlag = false;
	std::size_t oldPos = 0;
	while (!strName.empty())
	{
		std::size_t findPos = strtemp.find(",", oldPos);
		if (findPos != string::npos)
		{
			strName = strtemp.substr(oldPos, findPos - oldPos);
		}
		else
		{
			strName = strtemp.substr(oldPos, strtemp.length() - oldPos);
			lastFlag = true;
		}
		SetSignal(strName, state);
		Sleep(10);

		if (lastFlag)
		{
			break;
		}
		else
		{
			oldPos = findPos + 1;
		}
	}
}
bool nsSYN::DeviceFullUCB::SetSignal(const string& strname, int state)
{
	auto item_out = m_FullUCBMap_OUT.find(strname);
	if (item_out == m_FullUCBMap_OUT.end())
	{
		mLog::FERROR("SetSignal:[{$}] not in m_FullUCBMap_OUT", strname.c_str());
		return false;
	}
	else
	{
		string strChannel = item_out->second.strChannel;
		string strEnable = item_out->second.strEnableValue;
		string strDisable = item_out->second.strDisableValue;

		//if (item_out->second.nCurrStateValue == state)
		//{
		//	mLog::FDEBUG("Set Name[{$}],Signal[{$}],state[{$}] already send at last once", strname.c_str(), strChannel.c_str(), state);
		//	return true;
		//}
		//else
		{
			mLog::FDEBUG("Set Name[{$}],Signal[{$}],state[{$}]", strname.c_str(), strChannel.c_str(), state);
			item_out->second.nCurrStateValue = state;
		}
		if (!strEnable.empty() && item_out->second.nConfAllowance > 0 && item_out->second.nCurrAllowance < item_out->second.nConfAllowance)
		{
			if (state == atoi(item_out->second.strEnableValue.c_str()))
			{
				mLog::FDEBUG("Set Name[{$}],need wait[{$}->{$}] count", strname.c_str(), item_out->second.nCurrAllowance, item_out->second.nConfAllowance);
				item_out->second.nCurrAllowance++;
				return false;
			}
		}
		if (strChannel != "")
		{
			if (strname == CONF_GENEXPREQUEST)
			{
				if (m_bINEEnable_Gen && m_bINEEnable_FPD)
				{
					if (m_nExpMaxCount > 0 && m_nCurrentExpCount > m_nExpMaxCount)
					{
						mLog::FWARN("m_nExpMaxCount[{$}] has been enough in this sequence[{$}]!", m_nExpMaxCount, m_nCurrentExpCount);
						return true;
					}
				}
				else
				{
					mLog::FWARN("Generator[{$}] or detector[{$}] not ready, So can't send INE to generator!", m_bINEEnable_Gen, m_bINEEnable_FPD);
					return true;
				}
			}
			switch (state)
			{
				case 0:
				{
					if (!strDisable.empty())
					{
						mLog::FDEBUG("Signal[{$}],state[{$}],confDisable[{$}]", strChannel.c_str(), state, strDisable.c_str());
						int confState = atoi(strDisable.c_str());
						UCBCmdSWS(strChannel, confState);
					}
					else
					{
						UCBCmdSWS(strChannel, state);
					}
				}break;
				case 1:
				{
					if (!strEnable.empty())
					{
						mLog::FDEBUG("Signal[{$}],state[{$}],confEnable[{$}]", strChannel.c_str(), state, strEnable.c_str());
						int confState = atoi(strEnable.c_str());
						UCBCmdSWS(strChannel, confState);
					}
					else
					{
						UCBCmdSWS(strChannel, state);
					}
				}break;
				default:
					break;
			}
			return true;
		}
	}
	return false;
}
void nsSYN::DeviceFullUCB::ClearSignal()
{
	mLog::FDEBUG("Enter ClearSignal");
	if (m_FullUCBMap_OUT.empty())
	{
		return;
	}
	for (auto & item : m_FullUCBMap_OUT)
	{
		string strDisable = item.second.strDisableValue;
		mLog::FDEBUG("out_IO [{$}=={$}],Disable[{$}]", item.first.c_str(), item.second.strChannel.c_str(), strDisable.c_str());
		if (!strDisable.empty())
		{
			int confState = atoi(strDisable.c_str());
			UCBCmdSWS(item.second.strChannel, confState);
		}
		else
		{
			UCBCmdSWS(item.second.strChannel, 0);
		}
		item.second.nCurrAllowance = 0;
	}
	SetPWMState(0);
}

// 指令发送前预处理
int nsSYN::DeviceFullUCB::SetPWMState(bool state)
{
	mLog::FDEBUG("Enter SetPWMState:[{$}]", state);
	auto item = m_FullUCBMap_OUT.find(CONF_FRAMERATE);
	if (item != m_FullUCBMap_OUT.end())
	{
		string strChannel = item->second.strChannel;
		if (item->second.nCurrStateValue == state)
		{
			mLog::FDEBUG("SetPWMState:Signal[{$}],state[{$}] already send at last once", strChannel.c_str(), state);
			return true;
		}
		else
		{
			item->second.nCurrStateValue = state;
		}
		if (strChannel != "")
		{
			//模式：0表示禁止，1表示允许，2表示发送一个脉冲，3表示连续发送脉冲
			//使能：通道信号打开或者关闭
			if (state)
			{
				if (m_bIsCtlPWMWithMode)
				{
					mLog::FDEBUG("in [{$}] mode", m_SynBoxUnit.m_ExpMode->JSGet().c_str());
					if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_SR || 
						m_SynBoxUnit.m_ExpMode->JSGet() == CONF_PF ||
						m_SynBoxUnit.m_ExpMode->JSGet() == CONF_TOMO)
					{
						UCBCmdSPE(strChannel, '3', '1');
					}
					else if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_CF)
					{
						UCBCmdSPE(strChannel, '1', '1');
					}
					else if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_DR)
					{
						int EXOcounts{ 0 };
						if (!m_ExpCounts.empty())
						{
							if (m_ExpCounts == "FF")
							{
								EXOcounts = 255;
							}
							else
							{
								EXOcounts = atoi(m_ExpCounts.c_str());
							}
						}
						if (EXOcounts <= 1)
						{
							//UCBCmdSPE(strChannel, '2', '1');
							//UCBCmdSPE(strChannel, '1', '1');
							UCBCmdSWS(strChannel, 1);
							SetEvent(m_hPWMEvent);
						}
						else
						{
							UCBCmdSPE(strChannel, '3', '1');
						}
					}
					else if (m_SynBoxUnit.m_ExpMode->JSGet() == CONF_Stitch)
					{
						int EXOcounts{ 0 };
						if (!m_ExpCounts.empty())
						{
							if (m_ExpCounts == "FF")
							{
								EXOcounts = 255;
							}
							else
							{
								EXOcounts = atoi(m_ExpCounts.c_str());
							}
						}
						if (EXOcounts <= 1)
						{
							//UCBCmdSPE(strChannel, '2', '1');
							//UCBCmdSPE(strChannel, '1', '1');
							UCBCmdSWS(strChannel, 1);
							SetEvent(m_hPWMEvent);
						}
						else
						{
							UCBCmdSPE(strChannel, '3', '1');
						}
					}
					else
					{
						UCBCmdSPE(strChannel, '3', '1');
					}
				}
				else
				{
					UCBCmdSPE(strChannel, '3', '1');
				}
			}
			else
			{
				UCBCmdSPE(strChannel, '0', '0');
			}
			return 1;
		}
	}
	return 0;
}
int nsSYN::DeviceFullUCB::SetPWMParam(float fpps, int width)
{
	mLog::FDEBUG("Enter SetPWM:[{$}]", fpps);
	if (fpps < 0.5)
	{
		mLog::FWARN( "PPS:[{$}]<0.5", fpps);
		return 1;
	}
	auto item = m_FullUCBMap_OUT.find(CONF_FRAMERATE);
	if (item != m_FullUCBMap_OUT.end())
	{
		string strChannel = item->second.strChannel;
		if (strChannel != "")
		{
			int nCycle = 10 * (1000.0 / fpps);
			int pulse = 10 * width;
			mLog::FDEBUG("Set PWM Signal[{$}] cycle[{$}] PulseWidth[{$}]", strChannel.c_str(), nCycle/10, pulse/10);
			UCBCmdSPS(strChannel, nCycle, pulse);
			return 1;
		}
	}
	return -1;
}
int nsSYN::DeviceFullUCB::SetAreaType()
{
	mLog::FDEBUG("Enter SetAreaType");
	char areaID{ 0 };
	int EXOcounts{ 0 };
	if (!m_AreaID.empty())
		areaID = m_AreaID.at(0);
	if (!m_ExpCounts.empty())
	{
		if (m_ExpCounts == "FF")
		{
			EXOcounts = 255;
		}
		else
		{
			EXOcounts = atoi(m_ExpCounts.c_str());
		}
	}
	mLog::FDEBUG("user area ID[{$}], exp max count[{$}]", areaID, EXOcounts);
	if ((areaID >= '0' && areaID <= '2') && (EXOcounts >= 0 && EXOcounts <= 255))
	{
		//曝光模式：0表示I/O通道设置的存取段1的配置，1表示存取段2，依次类推
		//可以设置曝光次数，范围0~200，值255表示一直曝光
		UCBCmdSMS(areaID, EXOcounts);
	}
	else
	{
		mLog::FERROR("areaID[{$:C}],EXOcounts[{$}] not right", areaID, EXOcounts);
	}
	return 1;
}

//通信(握手)测试
bool DeviceFullUCB::UCBCmdSEC()
{
	char cCmd[FullUCB_Com_NormalLen] = "SECA00";
	int nSize = 6;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	return false;
}
//读取版本号
bool DeviceFullUCB::UCBCmdSVR()
{
	char cCmd[FullUCB_Com_NormalLen] = "SVRA00";
	int nSize = 6;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SVR' ERROR!");
	}
	return false;
}
//写序列号
bool DeviceFullUCB::UCBCmdSSN(const string& strSerial)
{
	char cCmd[FullUCB_Com_NormalLen]{ 0 };
	int nSize = 6;
	sprintf_s(cCmd,"SSNA0F%s", strSerial.c_str());
	nSize += strSerial.length();
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SSN' false!");
	}
	return false;
}
//蜂鸣器提示功能
bool DeviceFullUCB::UCBCmdSSP()
{
	return true;
}
//输出端口初始化
bool DeviceFullUCB::UCBCmdSIT()
{
	return true;
}
//冷启动 
bool DeviceFullUCB::UCBCmdSRE()
{
	char cCmd[FullUCB_Com_NormalLen] = "SREA00";
	int nSize = 6;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SRE' false!");
	}
	return false;
}
//出厂恢复
bool DeviceFullUCB::UCBCmdSFR()
{
	char cCmd[FullUCB_Com_NormalLen] = "SFRA00";
	int nSize = 6;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SFR' false!");
	}
	return false;
}
//EEPROM拷贝
bool DeviceFullUCB::UCBCmdSEE(const char& cZ1, const char& cZ2)
{
	char cCmd[FullUCB_Com_NormalLen] = "SEEA02";
	int nSize = 6;
	mLog::FDEBUG("EEPROM Copy [{$:C}] -> [{$:C}]", cZ1, cZ2);
	if (cZ1 == cZ2)
	{
		mLog::FWARN("The same zone!");
		return false;
	}
	if (cZ1 != 'A' && cZ1 != 'B')
	{
		mLog::FERROR("Z1 ERROR");
		return false;
	}
	if (cZ2 != 'A' && cZ2 != 'B')
	{
		mLog::FERROR("Z2 ERROR");
		return false;
	}
	cCmd[6] = cZ1;
	cCmd[7] = cZ2;
	nSize = 8;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SEE' false!");
	}
	return false;
}
//工作状态查询命令
bool DeviceFullUCB::UCBCmdSRF(void)
{
	return true;
}
//清除工作状态存储区
bool DeviceFullUCB::UCBCmdSCF(void)
{
	return true;
}
//ABS输出
bool DeviceFullUCB::UCBCmdSAS(const string& strChannelID, const int& nValue, const char& cEnable)
{
	char cCmd[FullUCB_Com_NormalLen] = "SASB07";
	int nSize = 6;
	if(strChannelID.length() < 2)
	{
		mLog::FERROR("SAS param Error strChannelID:{$}", strChannelID.c_str());
		return false;
	}
	if (strChannelID[0] >= '0' && strChannelID[0] <= '9')
	{
		cCmd[6] = strChannelID[0];
	}
	else
	{
		mLog::FERROR("SAS param Error Channel:{$}", strChannelID[0]);
		return false;
	}
	if (strChannelID[1] == '0' || strChannelID[1] == '1')
	{
		cCmd[7] = strChannelID[1];
	}
	else
	{
		mLog::FERROR("SAS param Error Ampli{$}", strChannelID[1]);
		return false;
	}
	if (nValue < 0 || nValue > 65535)
	{
		mLog::FERROR("SAS param Error Value{$}", nValue);
		return false;
	}
	string strTemp = std::format("{:04X}", nValue);
	cCmd[8] = strTemp.at(0);
	cCmd[9] = strTemp.at(1);
	cCmd[10] = strTemp.at(2);
	cCmd[11] = strTemp.at(3);
	if (cEnable == '0' || cEnable == '1')
	{
		cCmd[12] = cEnable;
	}
	else
	{
		mLog::FERROR("SAS param Error Enable{$}", cEnable);
		return false;
	}
	nSize = 13;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SAS' false!");
	}
	return false;
}
//ADC开启/关闭命令
bool DeviceFullUCB::UCBCmdSAD(const string& strChannelID)
{
	char cCmd[FullUCB_Com_NormalLen] = "SADA02";
	int nSize = 6;
	if (strChannelID.length() < 2)
	{
		mLog::FERROR("SAD param Error strChannelID:{$}", strChannelID.c_str());
		return false;
	}
	if ((strChannelID[0] >= '0' && strChannelID[0] <= '9') || strChannelID[0] == 'F')
	{
		cCmd[6] = strChannelID[0];
	}
	else
	{
		mLog::FERROR("SAD param Error Channel{$}", strChannelID[0]);
		return false;
	}

	if (strChannelID[1] == '0' || strChannelID[1] == '1')
	{
		cCmd[7] = strChannelID[1];
	}
	else
	{
		mLog::FERROR("SAD param Error Enable{$}", strChannelID[1]);
		return false;
	}
	nSize = 8;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SAD' false!");
	}
	return false;
}
//ADC读取命令
bool DeviceFullUCB::UCBCmdSRA(const string& strChannelID)
{
	char cCmd[FullUCB_Com_NormalLen] = "SRAA01";
	int nSize = 6;
	if (strChannelID.length() < 1)
	{
		mLog::FERROR("SRA param Error strChannelID:{$}", strChannelID.c_str());
		return false;
	}
	if (strChannelID[0] >= '0' && strChannelID[0] <= '9')
	{
		cCmd[6] = strChannelID[0];
	}
	else
	{
		mLog::FERROR("SRA param Error Channel{$}", strChannelID[0]);
		return false;
	}
	nSize = 7;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	mLog::FERROR("Command: 'SAD' false!");
	return false;
}
//AEC开启/关闭功能
bool DeviceFullUCB::UCBCmdSAE(const char& cInChannel, const char& cOutChannel, const char& cIO, const char& cChannel, const int& nTime, const int& nMode, const bool& bEnable)
{
	char cCmd[FullUCB_Com_NormalLen] = "SAEA0A";
	int nSize = 6;

	if (HexUCtoInt(cInChannel) != -1)
	{
		cCmd[6] = cInChannel;
	}
	else
	{
		mLog::FERROR("SAE param Error cInChannel{$}", cInChannel);
		return false;
	}

	if (HexUCtoInt(cOutChannel) != -1)
	{
		cCmd[7] = cOutChannel;
	}
	else
	{
		mLog::FERROR("SAE param Error cOutChannel{$}", cOutChannel);
		return false;
	}

	if (cIO == 'I' || cIO == 'O')
	{
		cCmd[8] = cIO;
	}
	else
	{
		mLog::FERROR("SAE param Error cIO{$}", cIO);
		return false;
	}

	if (HexUCtoInt(cChannel) != -1)
	{
		cCmd[9] = cChannel;
	}
	else
	{
		mLog::FERROR("SAE param Error cChannel{$}", cChannel);
		return false;
	}

	string strTemp = std::format("{:04X}", nTime);
	cCmd[10] = strTemp.at(0);
	cCmd[11] = strTemp.at(1);
	cCmd[12] = strTemp.at(2);
	cCmd[13] = strTemp.at(3);

	if (0 <= nMode && nMode <= 2)
	{
		strTemp = std::format("{:x}", nMode);
		cCmd[14] = strTemp.at(0);
	}
	else
	{
		mLog::FERROR("SAE param Error nMode{$}", nMode);
		return false;
	}

	if (bEnable)
	{
		cCmd[15] = 0x31;
	}
	else
	{
		cCmd[15] = 0x30;
	}

	nSize = 16;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SAE' false!");
	}
	return false;
}
//PT_STOP时间读取功能
bool DeviceFullUCB::UCBCmdSPT(const char& cInChannel, const int& nTime)
{
	char cCmd[FullUCB_Com_NormalLen] = "SPTA01";
	int nSize = 6;

	if (HexUCtoInt(cInChannel) != -1)
	{
		cCmd[6] = cInChannel;
	}
	else
	{
		mLog::FERROR("SPT param Error cInChannel{$}", cInChannel);
		return false;
	}

	nSize = 7;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SAE' false!");
	}
	return false;
}
//Can发送数据
bool DeviceFullUCB::UCBCmdSTL(const int& nType, const char* cID, const int& nLen, const char* cData)
{
	char cCmd[FullUCB_Com_NormalLen] = "STLB";
	int nSize = 6;
	string strTemp = std::format("{:02X}", 2 * nLen + 10);
	cCmd[4] = strTemp.at(0);
	cCmd[5] = strTemp.at(1);
	memcpy((void*)(cCmd + 6), (void*)cID, 8);
	cCmd[14] = InttoHexUC(nType);
	cCmd[15] = InttoHexUC(nLen);
	memcpy((void*)(cCmd + 16), (void*)cData, nLen * 2);
	nSize = 2 * nLen + 16;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	mLog::FERROR("Command: 'STL' false!");
	return false;
}
//Can设置
bool DeviceFullUCB::UCBCmdSCS(const char& cProtocol, const char& cBaud, const char* cFilter, const char& cEnable)
{
	char cCmd[FullUCB_Com_NormalLen] = "SCSA13";
	int nSize = 6;
	if (cProtocol == '0' || cProtocol == '1')
	{
		cCmd[6] = cProtocol;
	}
	else
	{
		mLog::FERROR("SCS param Error Protocol{$}", cProtocol);
		return false;
	}

	if (HexUCtoInt(cBaud) != -1)
	{
		cCmd[7] = cBaud;
	}
	else
	{
		mLog::FERROR("SCS param Error Baud{$}", cBaud);
		return false;
	}

	memcpy((void*)(cCmd + 8), (void*)cFilter, 16);

	if (cEnable == '0' || cEnable == '1')
	{
		cCmd[24] = cEnable;
	}
	else
	{
		mLog::FERROR("SCS param Error Enable{$}", cEnable);
		return false;
	}
	nSize = 25;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SCS' false!"); 
	}
	return false;
}
//PWM设置
bool DeviceFullUCB::UCBCmdSPS(const string& strChannelID, const int& nCycle, const int& nPulse)
{
	char cCmd[FullUCB_Com_NormalLen] = "SPSB0A";
	int nSize = 6;

	if (strChannelID.length() != 2)
	{
		mLog::FERROR("SPS ChannelID[{$}] not right", strChannelID.c_str());
		return false;
	}
	else
	{
		cCmd[6] = strChannelID.at(0);
		cCmd[7] = strChannelID.at(1);
	}

	if (!(1 <= nCycle && nCycle <= 50000))
	{
		mLog::FERROR("SPS param Error Cycle{$}", nCycle);
		return false;
	}
	string strTemp = std::format("{:04X}", nCycle);
	cCmd[8] = strTemp.at(0);
	cCmd[9] = strTemp.at(1);
	cCmd[10] = strTemp.at(2);
	cCmd[11] = strTemp.at(3);

	if (!(0 <= nPulse && nPulse <= nCycle))
	{
		mLog::FERROR("SPS param Error Pulse:{$},Cycle:{$}", nPulse, nCycle);
		return false;
	}
	strTemp = std::format("{:04X}", nPulse);
	cCmd[12] = strTemp.at(0);
	cCmd[13] = strTemp.at(1);
	cCmd[14] = strTemp.at(2);
	cCmd[15] = strTemp.at(3);

	nSize = 16;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SPS' false!");
	}
	return false;
}
//PWM使能
bool DeviceFullUCB::UCBCmdSPE(const string& strChannelID, const char& cMode, const char& cEnable)
{
	char cCmd[FullUCB_Com_NormalLen] = "SPEA04";
	int nSize = 6;

	if (strChannelID.length() != 2)
	{
		mLog::FERROR("SPE ChannelID[{$}] not right", strChannelID.c_str());
		return false;
	}
	else
	{
		cCmd[6] = strChannelID.at(0);
		cCmd[7] = strChannelID.at(1);
	}

	if ('0' <= cMode && cMode <= '3')
	{
		cCmd[8] = cMode;
	}
	else
	{
		mLog::FERROR("SPE param Error Mode[{$:C}]", cMode);
		return false;
	}

	if ('0' == cEnable || '1' == cEnable)
	{
		cCmd[9] = cEnable;
	}
	else
	{
		mLog::FERROR("SPE param Error Enable[{$:C}]", cEnable);
		return false;
	}

	nSize = 10;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SPE' false!");
	}
	return false;
}
//曝光模式切换
bool DeviceFullUCB::UCBCmdSMS(const char& cExpMode, const int& nExpCount)
{
	char cCmd[FullUCB_Com_NormalLen] = "SMSA03";
	int nSize = 6;

	if (!('0' <= cExpMode && cExpMode <= '3'))
	{
		mLog::FERROR("SMS param Exposure Mode error!");
		return false;
	}
	if (!((0 <= nExpCount && nExpCount <= 200) || nExpCount == 255))
	{
		mLog::FERROR("SMS param nCount error!");
		return false;
	}
	cCmd[6] = cExpMode;
	string strTemp = std::format("{:02X}", nExpCount);
	cCmd[7] = strTemp.at(0);
	cCmd[8] = strTemp.at(1);
	nSize = 9;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return false;
	}
	else
	{
		mLog::FERROR("Command: 'SMS' false!");
	}
	return false;
}
//通道属性设置
bool DeviceFullUCB::UCBCmdSCP(const char& cZone, const int& cZoneIndex, const string& strChannelID, const char* cIOSet)
{
	char cCmd[FullUCB_Com_NormalLen] = "SCPA0A";
	int nSize = 6;
	if (cZone == 'A' || cZone == 'B')
	{
		cCmd[6] = cZone;
	}
	else
	{
		mLog::FERROR("SCP param Error Zone{$}", cZone);
		return false;
	}
	if ('0' <= cZoneIndex && cZoneIndex <= '3')
	{
		cCmd[7] = cZoneIndex;
	}
	else
	{
		mLog::FERROR("SCP param Error ZoneIndex{$}", cZoneIndex);
		return false;
	}
	
	if (strChannelID.length() != 2)
	{
		mLog::FERROR("SCP ChannelID[{$}] not right", strChannelID.c_str());
		return false;
	}
	else
	{
		cCmd[8] = strChannelID.at(0);
		cCmd[9] = strChannelID.at(1);
	}

	memcpy((void*)(cCmd + 10), (void*)cIOSet, 6);
	nSize = 16;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SCP' false!");
	}
	return false;
}
//通道属性读取确认
bool DeviceFullUCB::UCBCmdSCD(const char& cZone, const int& cZoneIndex, const string& strChannelID, const char* cIOSet)
{
	char cCmd[FullUCB_Com_NormalLen] = "SCDA04";
	int nSize = 6;
	if (cZone == 'A' || cZone == 'B')
	{
		cCmd[6] = cZone;
	}
	else
	{
		mLog::FERROR("SCD param Error Zone{$}", cZone);
		return false;
	}
	if ('0' <= cZoneIndex && cZoneIndex <= '3')
	{
		cCmd[7] = cZoneIndex;
	}
	else
	{
		mLog::FERROR("SCD param Error ZoneIndex{$}", cZoneIndex);
		return false;
	}

	if (strChannelID.length() != 2)
	{
		mLog::FERROR("SCD ChannelID[{$}] not right", strChannelID.c_str());
		return false;
	}
	else
	{
		cCmd[8] = strChannelID.at(0);
		cCmd[9] = strChannelID.at(1);
	}

	nSize = 10;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SCD' false!");
	}
	return false;
}
//写入通道版本
bool DeviceFullUCB::UCBCmdSPW(const char& cZone, const char* cIOConfVer)
{
	char cCmd[FullUCB_Com_NormalLen] = "SPWA11";
	int nSize = 6;
	if (cZone == 'A' || cZone == 'B')
	{
		cCmd[6] = cZone;
	}
	else
	{
		mLog::FERROR("SPW param Error Zone{$}", cZone);
		return false;
	}
	memcpy((void*)(cCmd + 7), (void*)cIOConfVer, 16);
	nSize = 23;
	FormatCmd(cCmd, nSize);
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SPW' false!");
	}
	return false;
}
//读取通道版本
bool DeviceFullUCB::UCBCmdSPR(const char& cZone, const char* cIOConfVer)
{
	char cCmd[FullUCB_Com_NormalLen] = "SPRA01";
	int nSize = 6;
	if (cZone == 'A' || cZone == 'B')
		cCmd[6] = cZone;
	else
	{
		mLog::FERROR("SPR param Error Zone{$}", cZone);
		return false;
	}
	nSize = 7;
	FormatCmd(cCmd, nSize);
	
	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SPW' false!");
	}
	return false;
}
//读取通道状态
bool DeviceFullUCB::UCBCmdSRS(const string& strChannelID, const char& cValue)
{
	char cCmd[FullUCB_Com_NormalLen] = "SRSA02";
	int nSize = 6;

	if (strChannelID.length() != 2)
	{
		mLog::FERROR("SWS ChannelID[{$}] not right", strChannelID.c_str());
		return false;
	}
	else
	{
		cCmd[6] = strChannelID.at(0);
		cCmd[7] = strChannelID.at(1);
	}

	nSize = 8;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SRS' false!");
	}
	return false;
}
//通道输出设置
bool DeviceFullUCB::UCBCmdSWS(const string& strChannelID, const bool& bValue)
{
	char cCmd[FullUCB_Com_NormalLen] = "SWSA03";
	int nSize = 6;

	if (strChannelID.length() != 2)
	{
		mLog::FERROR("SWS ChannelID[{$}] not right", strChannelID.c_str());
		return false;
	}
	else
	{
		cCmd[6] = strChannelID.at(0);
		cCmd[7] = strChannelID.at(1);
	}
	if (bValue)
		cCmd[8] = '1';
	else
		cCmd[8] = '0';
	nSize = 9;
	FormatCmd(cCmd, nSize);

	if (RET_STATUS::RET_SUCCEED == HWSendNormal(cCmd, nSize, FullUCB_Com_HeadLen))
	{
		return true;
	}
	else
	{
		mLog::FERROR("Command: 'SWS' false!");
	}
	return false;
}