#include "stdafx.h"
#include "DriverDefine.h"
#include "GEN.DRV.IDETEC_Almax.h"
#include "common_api.h"
#include "Helper.JSON.hpp"


//设置对应通信接口库
#ifdef _WIN64
#ifdef _DEBUG
static const auto COM_SCFDllName = "Ccos.Dev.SerialSCFX64D.dll";
#else
static const auto COM_SCFDllName = "Ccos.Dev.SerialSCFX64.dll";
#endif
#endif

#ifdef _WIN64
#ifdef _DEBUG
static const auto TCP_SCFDllName = "Ccos.Dev.TcpipSCFX64D.dll";
#else
static const auto TCP_SCFDllName = "Ccos.Dev.TcpipSCFX64.dll";
#endif
#endif


//-----------------------------------------------------------------------------
//		                       全局定义
//-----------------------------------------------------------------------------
Log4CPP::Logger* gLogger = nullptr;

namespace nsGEN = CCOS::Dev::Detail::Generator;

//串口处理层
void ProcessClientData(const char* pData, unsigned long nDataLength, void* lparam)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		nsGEN::m_pGenLogical->HWSend(pData, nDataLength);
	}
}
void WriteLog(const char* pData, nsSerialGPM::LOG_V2_LEVEL level)
{
	switch (level)
	{
		case nsSerialGPM::LOG_V2_FATAL:
		case nsSerialGPM::LOG_V2_ERROR:
			FERROR(pData);
			break;
		case nsSerialGPM::LOG_V2_WARNING:
			FWARN(pData);
			break;
		case nsSerialGPM::LOG_V2_DEBUG:
			FDEBUG(pData);
			break;
		case nsSerialGPM::LOG_V2_INFO:
			FINFO(pData);
			break;
		default:
			break;
	}
}
//解析指令
PACKET_RET nsGEN::callbackPackageProcess(const char* RecData, DWORD nLength, DWORD& PacketLength)
{
#if 0
	if (nLength > 1)
	{
		FERROR("receive data_len[{$}]", nLength);
		for (int i = 0; i < nLength; i++)
		{
			if (i != nLength - 1)
			{
				FERROR("receive data[{$}][{$}]", i, RecData[i]);
			}
			else
			{
				FERROR("receive data[{$}][{$}]", i, RecData[i]);
			}
		}
	}
#endif
	bool bHasHead = false;
	if (nLength < 5)
	{
		PacketLength = 0;
		FERROR("nLength too small, nLength=={$}", nLength);
		return PACKET_NOPACKET;
	}
	else if (nLength > Almax_Com_ReSendLen)
	{
		PacketLength = nLength;
		FERROR("nLength too big, nLength=={$}", nLength);
		return PACKET_USELESS;
	}

	for (DWORD i = 0; i < nLength; i++)
	{
		//寻找包头
		if (RecData[i] == Almax_STX)
		{
			if (i != 0) //包头之前的数据格式不对，全部扔掉
			{
				PacketLength = i;
				char strtemp[Almax_Com_ReSendLen] = { 0 };
				memcpy(strtemp, RecData, PacketLength);
				FERROR("==IN unknown format data ==:[{$}],UselessDataLength={$},TotalLength={$} \n", strtemp, PacketLength, nLength);
				return PACKET_USELESS;
			}
			else
			{
				bHasHead = true;
			}
		}
		//寻找包尾
		if (RecData[i] == Almax_ETX)
		{
			if (bHasHead)
			{
				if (i >= 4) //正常指令
				{
					PacketLength = i + 2;			        //+2 because ETX SUM
#if 1 //暂时强检查校验和
					if (PacketLength > nLength)
					{
						PacketLength = 0;
					    return PACKET_NOPACKET;
					}
#endif
					char strtemp[Almax_Com_ReSendLen] = { 0 };
					memcpy(strtemp, RecData + 1, i - 1);	//只有数据，+1 排除 STX
					if (true)
					{
						FINFO("==IN==:[{$}],currLengh[{$}],totalLengh[{$}]", strtemp, PacketLength, nLength);
						glo_tDelivermodule.CheckReceive(strtemp, 2);
					}
					return PACKET_ISPACKET;
				}
				else //空指令
				{
					PacketLength = i + 1;
					char strtemp[Almax_Com_ReSendLen] = { 0 };
					memcpy(strtemp, RecData, PacketLength);	//空数据，格式正确但无有效命令。
					FERROR("==IN  uselss data==:[{$}] \n", strtemp);
					return PACKET_USELESS;
				}
			}
			else //有包尾但无包头
			{
				PacketLength = i + 1;
				char strtemp[Almax_Com_ReSendLen] = { 0 };
				memcpy(strtemp, RecData, PacketLength);
				FERROR("==IN no head data ==:[{$}],NoHeadDataLength={$},TotalLength={$} \n", strtemp, PacketLength, nLength);
				return PACKET_USELESS;
			}
		}
	}
	if (bHasHead)
	{
		PacketLength = 0;
	}
	return PACKET_NOPACKET;
}
//查找响应操作对照表执行对应操作
#define HeadLeng
void nsGEN::Dequeue(const char* Packet, const DWORD Length)
{
#if 1
	//指令原样返回
	int retLength;
	glo_obCommObj.m_SCF.Lock(msTimeOut_Lock)
		.SendPacket(Packet, Length, TIMEOUTVALUE, retLength);
#endif
	int length = Length;
	char data[Almax_Com_ReSendLen] = { 0 };
	int copyLengh = Length-3 > Almax_Com_HeadLen ? Almax_Com_HeadLen : Length-3;
	for (int i = 0; i < copyLengh; i++)
	{
		if (Packet[i+1] >= 'A' && Packet[i+1] <= 'Z')
			data[i] = Packet[i+1];
		else
			break;
	}
	auto found = glo_arFrame.find(data);//此处pr用来在glo_arFrame中找到对于的包头
	if (found == glo_arFrame.end())
	{
		return;
	}
	memset(data, 0, Almax_Com_ReSendLen);
	int cmdHead = found->first.length();
	memcpy(data, Packet + cmdHead + 1, length - cmdHead - 3);
	found->second.m_fFun(data, length - cmdHead);//第二个参数 不重要

}
//判断发生器对象指针
inline bool CCOS::Dev::Detail::Generator::isGenDevNotEmpty()
{
	if (m_pGenLogical)
	{
		return true;
	}
	else
	{
		FERROR("GenLogical is empty");
	}
	return false;
}

//输入参数转换
template <typename T>
bool InputParamConversion(string& In, T &value)
{
	if (nsGEN::CGEN_DEV_IDETEC_Almax::m_nNotifyType == CcosAttrKey::CTRL_CallBackFun)
	{
		if (typeid(T) == typeid(int))
		{
			value = atoi(In.c_str());
		}
		else if(typeid(T) == typeid(float))
		{
			value = atof(In.c_str());
		}
		else if (typeid(T) == typeid(double))
		{
			value = atof(In.c_str());
		}
	}
	else
	{
		value = JSONTo <T>(In);
	}
	return true;
}


//-----------------------------------------------------------------------------
//		            对外提供的必须实现的标准方法
//-----------------------------------------------------------------------------

//==========================驱动==========================
bool DRV_DriverEntry(std::string CfgFileName)
{
	string strLogPath = GetProcessDirectory() + R"(\Ccos_Gen\OEMDrivers\Generator\Conf\Log4CPP.Config.GEN.xml)";
	Log4CPP::GlobalContext::Map::Set(ECOM::Utility::Hash("LogFileName"), "GEN.Almax");
	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
	gLogger = Log4CPP::LogManager::GetLogger("GEN.Almax");

	try
	{
		if (!CfgFileName.empty())
		{
			nsGEN::m_ConfigFileName = CfgFileName;
			if (nsGEN::m_Configurations.loadFile(nsGEN::m_ConfigFileName.c_str()))
			{
				return true;
			}
			return false;
			}
		}
	catch (...)
	{
		FERROR("Open Configuration File failed");
	}
	return false;
}
void DRV_Prepare()
{
	string SCFDllName;
	if (nsGEN::CGEN_DEV_IDETEC_Almax::m_nNotifyType == CcosAttrKey::CTRL_CallBackFun)
	{
		SCFDllName = GetProcessDirectory() + R"(\Ccos_Gen\OEMDrivers\Generator\IDETEC_Almax\)";
	}
	ResDataObject r_config;
	if (r_config.loadFile(nsGEN::m_ConfigFileName.c_str()))
	{
		nsGEN::m_bDemoMode = (atoi)(((string)r_config["CONFIGURATION"]["IsDemo"]).c_str());
		ResDataObject Connection = r_config["CONFIGURATION"]["connections"][0];
		if ((string)Connection["type"] == "COM")
			SCFDllName += COM_SCFDllName;
		else
			SCFDllName += TCP_SCFDllName;
		glo_obCommObj.Prepare(SCFDllName);
	}
}
bool DRV_OnHeartBeat()
{
	return true;
}
bool DRV_ReLoadConfig()
{
	try
	{
		if (!nsGEN::m_ConfigFileName.empty())
		{
			if (nsGEN::m_Configurations.loadFile(nsGEN::m_ConfigFileName.c_str()))
			{
				return false;
			}
			return true;
		}
	}
	catch (...)
	{
		FERROR("reOpen Configuration File failed");
	}
	return false;
}
bool DRV_Connect()
{
	if (nsGEN::m_bDemoMode)
	{
		return true;
	}
	else
	{
		ResDataObject r_config;
		if (!r_config.loadFile(nsGEN::m_ConfigFileName.c_str()))
			return false;
		ResDataObject Connection = r_config["CONFIGURATION"]["connections"][0];
		FDEBUG("connections:{$} \n", Connection.encode());
		if (!glo_obCommObj.Connect(Connection.encode(), &nsGEN::callbackPackageProcess, SCF_PACKET_TRANSFER, 3000))
			return false; // erCode;

		auto rc = glo_obCommObj.Run(nsGEN::Dequeue);
		if (!rc)
			return false;

		glo_tDelivermodule.InitSendModle(NULL, &ProcessClientData, WriteLog);
	}
	return true;
}
void DRV_Disconnect()
{
	glo_obCommObj.Disconnect();
}
bool DRV_isConnected()
{
	return glo_obCommObj.isConnected();
}
DEVICE_HANDLE DRV_CreateDevice(int index)
{
	if(!DRV_isConnected())
	{
		DRV_Connect();
	}
	DEVICE_HANDLE ptrDev = nullptr;
	if (DRV_isConnected())
	{
		if (nsGEN::m_bDemoMode)
		{
			//dev = new DemoDevice(EventCenter);
			return ptrDev;
		}

		if (!glo_obCommObj.isConnected())
		{
			FERROR("CreateDevice:CcosConnect is not Connected \n");
			return nullptr;
		}

		nsGEN::m_pGenLogical = new nsGEN::CGEN_DEV_IDETEC_Almax(nsGEN::m_ConfigFileName);
		if (nullptr != nsGEN::m_pGenLogical)
		{

		}
		else
		{}

	}
	return nsGEN::m_pGenLogical;
}
void DRV_FreeDevice(DEVICE_HANDLE hDevice)
{
	DRV_Disconnect();
	if (hDevice != NULL)
	{
		delete hDevice;
	}
	FINFO("\n===============log Driver end ===================\n");
	Close();
	gLogger = nullptr;
}
int	 DRV_Get(const std::string attrName, std::string& Out)
{
	return RET_STATUS::RET_SUCCEED;
}

//==========================设备==========================
std::string DEV_GetGUID(DEVICE_HANDLE hDev)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->GetGUID();
	}
	else
		return "";
}
std::string DEV_GetResource(DEVICE_HANDLE hDev)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->GetResource();
	}
	else
		return "";
}
void DEV_CompleteInit(DEVICE_HANDLE hDev)
{}
bool DEV_Prepare(DEVICE_HANDLE hDev)
{
	return true;
}
void DEV_CompleteUnInit(DEVICE_HANDLE hDev)
{}
void DEV_GetSubscribeTopicList(DEVICE_HANDLE hDev, std::vector<string>& TopicList)
{}
std::string DEV_GetPath(DEVICE_HANDLE hDev)
{
	return nsGEN::m_pGenLogical->m_pDevicePath;
}
int  DEV_Add(DEVICE_HANDLE hDev, const std::string funcName, std::string In, std::string& Out)
{
	return RET_STATUS::RET_SUCCEED;
}
int  DEV_Delete(DEVICE_HANDLE hDev, const std::string funcName, std::string In, std::string& Out)
{
	return RET_STATUS::RET_SUCCEED;
}
int  DEV_Update(DEVICE_HANDLE hDev, const std::string funcName, std::string In, std::string& Out)
{
	return RET_STATUS::RET_SUCCEED;
}
int  DEV_Action(DEVICE_HANDLE hDev, const std::string funcName, std::string In, std::string& Out)
{
	return RET_STATUS::RET_SUCCEED;
}
int  DEV_Get(DEVICE_HANDLE hDev, const std::string funcName, std::string& Out)
{
	return RET_STATUS::RET_SUCCEED;
}
int  DEV_Set(DEVICE_HANDLE hDev, const std::string funcName, std::string In)
{
	return RET_STATUS::RET_SUCCEED;
}

//==========================硬件参数==========================
int DEV_Action_NotifyCallBack(callBackFun fun)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		nsGEN::m_pGenLogical->SetNotifyCallBack(fun);
	}
	return RET_STATUS::RET_SUCCEED;
}

int DEV_Get_TubeInfo(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_TubeInfo->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_TubeTargetMaterial(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_TubeTargetMaterial->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_TubeAngle(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_TubeAngle->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_TubeHE(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_TubeHE->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_GenHE(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_GenHE->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_BatteryChargeState(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_BatteryChargeState->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_BatteryPowerState(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_BatteryPowerState->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_GenSynState(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_GenSynState->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_GenState(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_GenState->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_Handswitch(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_Handswitch->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_Footswitch(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_Footswitch->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}

//==========================发生器支持的通用点片命令==========================
int DEV_Action_IncRadKV(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncRadKV();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecRadKV(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecRadKV();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetRadKV(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetRadKV(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_IncRadMA(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncRadMA();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecRadMA(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecRadMA();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetRadMA(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetRadMA(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_IncRadMS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncRadMS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecRadMS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecRadMS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetRadMS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetRadMS(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_IncRadMAS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncRadMAS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecRadMAS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecRadMAS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetRadMAS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetRadMAS(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFocus(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetFocus(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetTechmode(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetTechmode(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetWS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->SetWS(In);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetAECDensity(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetAECDensity(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetAECField(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetAECField(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetAECFilm(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetAECFilm(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetAPR(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		_tAPRArgs t{ 0 };
		if (nsGEN::CGEN_DEV_IDETEC_Almax::m_nNotifyType == CcosAttrKey::CTRL_CallBackFun)
		{
			vector<string> paramList;
			if (paramList.size() < 10)
			{
				FERROR("DEV_Action_SetAPR paramList[{$}] too less", paramList.size());
				for(auto item : paramList)
					FWARN("paramList item[{$}]", item.c_str());
			}
			StrSubstrData(In.c_str(),',', paramList);
			t.nWS         = atoi(paramList[0].c_str());
			t.nTechmode   = atof(paramList[1].c_str());
			t.nFocus      = atoi(paramList[2].c_str());
			t.fKV         = atof(paramList[3].c_str());
			t.fMA         = atof(paramList[4].c_str());
			t.fMS         = atof(paramList[5].c_str());
			t.fMAS        = atof(paramList[6].c_str());
			t.nAECFilm    = atof(paramList[7].c_str());
			t.nAECField   = atof(paramList[8].c_str());
			t.nAECDensity = atof(paramList[9].c_str());
		}
		else
		{
			ResDataObject json;
			json.decode(In.c_str());
			auto& R0 = json[0];
			t.nWS         = atoi(((string)R0[CcosAttrKey::WORKSTATION]).c_str());
			t.nTechmode   = (int)R0[CcosAttrKey::RADTECHMODE];
			t.nFocus      = atoi(((string)R0[CcosAttrKey::RADFOCUS]).c_str());
			t.fKV         = atof(((string)R0[CcosAttrKey::RADKV]).c_str());
			t.fMA         = atof(((string)R0[CcosAttrKey::RADMA]).c_str());
			t.fMS         = atof(((string)R0[CcosAttrKey::RADMS]).c_str());
			t.fMAS        = atof(((string)R0[CcosAttrKey::RADMAS]).c_str());
			t.nAECFilm    = R0[CcosAttrKey::RADAECFILM];
			t.nAECField   = R0[CcosAttrKey::RADAECFIELD];
			t.nAECDensity = R0[CcosAttrKey::RADAECDENSITY];
		}
		return nsGEN::m_pGenLogical->SetAPR(t);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_QueryPostKV(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		RET_STATUS res = nsGEN::m_pGenLogical->QueryPostKV(value);
		Out = to_string(value);
		return res;
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_QueryPostMA(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		RET_STATUS res = nsGEN::m_pGenLogical->QueryPostMA(value);
		Out = to_string(value);
		return res;
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_QueryPostMS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		RET_STATUS res = nsGEN::m_pGenLogical->QueryPostMS(value);
		Out = to_string(value);
		return res;
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_QueryPostMAS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		RET_STATUS res = nsGEN::m_pGenLogical->QueryPostMAS(value);
		Out = to_string(value);
		return res;
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetExpEnable(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->SetExpEnable();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetExpDisable(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->SetExpDisable();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_Reset(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->Reset();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_RefreshData(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->RefreshData();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetRadFrameRate(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetRadFrameRate(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetExpMode(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->SetExpMode(In);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetEXAMMode(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->SetEXAMMode(In);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetGenSynState(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetGenSynState(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetGenState(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetGenState(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_Clear_DAP(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->Clear_DAP();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_GetValue_DAP(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		RET_STATUS res = nsGEN::m_pGenLogical->GetValue_DAP(value);
		Out = to_string(value);
		return res;
	}
	else
		return RET_STATUS::RET_FAILED;
}

//==========================点片参数==========================
int DEV_Get_RadKV(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadKV->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadMA(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadMA->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadMS(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadMS->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadMAS(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadMAS->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadTechmode(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadTechmode->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadFocus(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadFocus->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadAECField(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadAECField->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadAECFilm(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadAECFilm->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadAECDensity(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadAECDensity->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_RadFrameRate(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_RadFrameRate->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_WS(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_strCurrentWSName.nWSID;
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_PostKV(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_PostKV->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_PostMA(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_PostMA->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_PostMS(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_PostMS->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_PostMAS(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_PostMAS->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_ExpMode(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_ExpMode->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_EXAMMode(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_EXAMMode->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FocusSmall(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = to_string(nsGEN::m_pGenLogical->m_FocusSmall);
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FocusLarge(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = to_string(nsGEN::m_pGenLogical->m_FocusLarge);
	}return RET_STATUS::RET_SUCCEED;
}

//==========================发生器支持的通用透视命令==========================
int DEV_Action_IncFluKV(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncFluKV();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecFluKV(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecFluKV();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluKV(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetFluKV(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_IncFluMA(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncFluMA();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecFluMA(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecFluMA();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluMA(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetFluMA(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_IncFluMS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncFluMS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecFluMS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecFluMS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluMS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetFluMS(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_IncFluMAS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncFluMAS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecFluMAS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecFluMAS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluMAS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetFluMAS(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetPPS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetPPS(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_GetPPS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->GetPPS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_INCPPS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->INCPPS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DECPPS(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DECPPS();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetPluseWidth(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetPluseWidth(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetABSMode(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetABSMode(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetABSCurve(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->SetABSCurve();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetABSValue(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		float value{ 0 };
		InputParamConversion<float>(In, value);
		return nsGEN::m_pGenLogical->SetABSValue(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetABSTargetEXI(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetABSTargetEXI(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_IncABSCurve(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->IncABSCurve();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DecABSCurve(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DecABSCurve();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetAPF(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{

		_tAPFArgs t{ 0 };
		if (nsGEN::CGEN_DEV_IDETEC_Almax::m_nNotifyType == CcosAttrKey::CTRL_CallBackFun)
		{
			vector<string> paramList;
			if (paramList.size() < 7)
			{
				FERROR("DEV_Action_SetAPF paramList[{$}] too less", paramList.size());
				for (auto item : paramList)
					FWARN("paramList item[{$}]", item.c_str());
			}
			StrSubstrData(In.c_str(), ',', paramList);
			t.nFluMode   = atoi(paramList[1].c_str());
			t.nABSMode   = atof(paramList[2].c_str());
			t.nDoseLever = atoi(paramList[3].c_str());
			t.nFLKV      = atof(paramList[4].c_str());
			t.fFLMA      = atof(paramList[5].c_str());
			t.nPPS       = atof(paramList[6].c_str());
		}
		else
		{
			ResDataObject json;
			json.decode(In.c_str());
			auto& R0 = json[0];
			t.nFluMode   = atoi(((string)R0[CcosAttrKey::FLUMode]).c_str());
			t.nABSMode   = (int)R0[CcosAttrKey::FLUABSStatus];
			t.nDoseLever = atof(((string)R0[CcosAttrKey::FLUDoseLevel]).c_str());
			t.nFLKV      = atof(((string)R0[CcosAttrKey::FLUKV]).c_str());
			t.fFLMA      = atof(((string)R0[CcosAttrKey::FLUMA]).c_str());
			t.nPPS       = atoi(((string)R0[CcosAttrKey::FLUPPS]).c_str());
		}
		return nsGEN::m_pGenLogical->SetAPF(t);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_GetFluIntTimer(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->GetFluIntTimer();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_GetFluAccTimer(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->GetFluAccTimer();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_ResetFluTimer(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->ResetFluTimer(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluPre(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetFluPre(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluEXP(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetFluEXP(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluMode(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->SetFluMode(In);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluMAG(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetFluMAG(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_DisableMAG(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		return nsGEN::m_pGenLogical->DisableMAG();
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetFluDoseLever(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetFluDoseLever(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_TransferRadCurve(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetFluDoseLever(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}

//==========================透视参数==========================
int DEV_Get_FluKV(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluKV->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluMA(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluMA->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluMS(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluMS->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluMAS(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluMAS->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluPPS(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluPPS->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluABSStatus(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluABSStatus->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluDoseLever(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluDoseLever->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluFMode(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluFMode->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluIntTime(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluIntTime->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}
int DEV_Get_FluAccTime(DEVICE_HANDLE hDev, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		Out = nsGEN::m_pGenLogical->m_FluAccTime->JSGet();
	}return RET_STATUS::RET_SUCCEED;
}

//==========================Almax特有==========================
int DEV_Action_SetPanelField(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetPanelField(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetShutDown(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetShutDown(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetExamView(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetExamView(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetDSA(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetDSA(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}
int DEV_Action_SetRoadMap(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->SetRoadMap(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}

int DEV_Action_EnterExam(DEVICE_HANDLE hDev, std::string In, std::string& Out)
{
	if (nsGEN::isGenDevNotEmpty())
	{
		int value{ 0 };
		InputParamConversion<int>(In, value);
		return nsGEN::m_pGenLogical->EnterExam(value);
	}
	else
		return RET_STATUS::RET_FAILED;
}