PhysicalDevice/Detector/XiuYuan/DIOS.Dev.FPD.XiuYuanDR/DIOS.Dev.FPD.XiuYuan.cpp

// CCOS.Dev.FPD.XiuYuan.cpp : 定义 DLL 的导出函数。

#include "stdafx.h"
#include <stdio.h>
#include <OleAuto.h>
#include <sys/stat.h>
#include "FileVersion.hpp"
#include "common_api.h"
#include "GridSuppression.h"
#include "TemperatureCheck.h"
#include "DICOMImageHeadKey.h"
#include "CCOS.Dev.FPD.XiuYuan.h"
#include "XiuYuanCtrl.h"


#pragma comment(lib, "Version.lib")

namespace nsFPD = CCOS::Dev::Detail::Detector;

Log4CPP::Logger* gLogger = nullptr;

static nsFPD::XiuYuanDriver  gIODriver;

//-----------------------------------------------------------------------------
//		GetIODriver & CreateIODriver
//-----------------------------------------------------------------------------
extern "C"  CCOS::Dev::IODriver * __cdecl GetIODriver()		// 返回静态对象的引用, 调用者不能删除 !
{
	return &gIODriver;
}

extern "C"  CCOS::Dev::IODriver * __cdecl CreateIODriver()  // 返回新对象, 调用者必须自行删除此对象 !
{
	return new nsFPD::XiuYuanDriver();
}

//-----------------------------------------------------------------------------
//		XiuYuanDriver
//-----------------------------------------------------------------------------
nsFPD::XiuYuanDriver::XiuYuanDriver()
{
	dev = nullptr;
	m_bConnect = false;
	m_pAttribute.reset(new ResDataObject());
	m_pDescription.reset(new ResDataObject());
}

nsFPD::XiuYuanDriver::~XiuYuanDriver()
{
}

extern const char* g_szMouldPath;
void nsFPD::XiuYuanDriver::Prepare()
{
	string strLogPath = GetProcessDirectory() + DetectorLogPath;
	Log4CPP::GlobalContext::Map::Set(ZSKK::Utility::Hash("LogFileName"), "FPD.XiuYuanDR");
	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
	gLogger = Log4CPP::LogManager::GetLogger("FPD.XiuYuanDR");

#ifdef WIN64
	Force("------------------------ Version: {$} (64-bit) ------------------------", FileVersion(g_szMouldPath).GetVersionString());
#else
	Force("------------------------ Version: {$} (32-bit)------------------------", FileVersion(g_szMouldPath).GetVersionString());
#endif

	FINFO("new FPDDeviceXiuYuan over");
}

bool nsFPD::XiuYuanDriver::Connect()
{
	FINFO("--Func-- driver connect");
	dev = new FPDDeviceXiuYuan(EventCenter, m_ConfigFileName);
	m_bConnect = true;
	return true;
}

void nsFPD::XiuYuanDriver::Disconnect()
{
	FINFO("--Func-- driver disconnect");
	m_bConnect = false;
}

bool nsFPD::XiuYuanDriver::isConnected() const
{
	return m_bConnect;
}

auto nsFPD::XiuYuanDriver::CreateDevice(int index) -> std::unique_ptr <IODevice>
{
	FINFO("--Func-- dirver createdevice");
	auto Driver = std::unique_ptr <IODevice>(new IODevice(dev));
	dev->CreateDevice();
	dev->Register();

	return Driver;
}

std::string nsFPD::XiuYuanDriver::DriverProbe()
{
	FINFO("XiuYuanDriver::DriverProbe config name:{$}", m_ConfigFileName);
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
		HardwareInfo.add("MinorID", r_config["CONFIGURATION"]["MinorID"]);
		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
	}
	else
	{
		HardwareInfo.add("MajorID", "Generator");
		HardwareInfo.add("MinorID", "Dr");
		HardwareInfo.add("VendorID", "XiuYuan");
		HardwareInfo.add("ProductID", "4343S");
		HardwareInfo.add("SerialID", "Driver");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

bool nsFPD::XiuYuanDriver::GetDeviceConfig(std::string& Cfg)
{
	Cfg = m_DeviceConfig.encode();
	FINFO("GetDeviceConfig Cfg:{$}", Cfg);
	return true;
}

bool nsFPD::XiuYuanDriver::SetDeviceConfig(std::string Cfg)
{
	FINFO("--Func-- SetDeviceConfig {$}\n", Cfg.c_str());
	ResDataObject DeviceConfig;
	DeviceConfig.decode(Cfg.c_str());

	ResDataObject DescriptionTempEx;
	DescriptionTempEx = DeviceConfig["DeviceConfig"];

	bool bSaveFile = false; //true:重新保存配置文件
	string strAccess = "";
	for (int i = 0; i < DescriptionTempEx.size(); i++)
	{
		ResDataObject temp = DescriptionTempEx[i];
		FINFO("{$}", temp.encode());
		for (int j = 0; j < temp.size(); j++)
		{
			string strKey = temp.GetKey(j);
			FINFO("{$}", strKey.c_str());
			try
			{
				if (m_pAttribute->GetFirstOf(strKey.c_str()) >= 0)
				{
					strAccess = (string)(*m_pDescription)[strKey.c_str()]["Access"];
					if ("RW" == strAccess || "rw" == strAccess)
					{
						//修改对应配置，在其他单元的配置项要同时调用其修改函数修改真实值
						//1. 修改内存中的值，用于给上层发消息
						(*m_pAttribute)[strKey.c_str()] = temp[j];
						//2. 拿到Innerkey
						int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
						FINFO("ConfigInfo Count: {$}", nConfigInfoCount);
						string strTemp = ""; //存储AttributeKey
						for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
						{
							strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
							if (strTemp == strKey)
							{
								strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
								break;
							}
						}
						//3. 修改配置文件中的值
						if (SetDeviceConfigValue(m_Configurations, strTemp.c_str(), 1, temp[j]))
						{
							bSaveFile = true;
						}
					}
					else
					{
						FINFO("{$} is not a RW configuration item", strKey.c_str());
					}
				}
			}
			catch (ResDataObjectExption& e)
			{
				FERROR("SetDriverConfig crashed: {$}", e.what());
				return false;
			}
		}
	}

	if (bSaveFile)
	{
		//3. 重新保存配置文件
		SaveConfigFile(true);
	}

	return true;
}

bool nsFPD::XiuYuanDriver::SaveConfigFile(bool bSendNotify)
{
	FINFO("SaveConfigFile m_ConfigFileName:{$}", m_ConfigFileName);
	m_ConfigAll["CONFIGURATION"] = m_Configurations;
	bool ret = m_ConfigAll.SaveFile(m_ConfigFileName.c_str());
	if (ret)
	{
		FINFO("SaveConfigFile Success!");
		return true;
	}
	else
	{
		FERROR("SaveConfigFile Fail!");
		return false;
	}
}

bool nsFPD::XiuYuanDriver::GetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, string& strValue)
{
	strValue = "";
	string strTemp = pInnerKey;
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		if (WiredIP == strTemp || WirelessIP == strTemp || LocalIP == strTemp)
		{
			strValue = (string)config["connections"][pInnerKey];
		}
		else if (DetectorVender == strTemp || DetectorModel == strTemp ||
			DetectorDescription == strTemp || DetectorSerialNumber == strTemp)
		{
			strValue = (string)config[pInnerKey];
		}
		else if (SyncType == strTemp || FPDWorkStation == strTemp ||
			ImageWidth == strTemp || ImageHeight == strTemp)
		{
			strValue = (string)config["ModeTable"]["DetectorMode"][pInnerKey];
		}
		else if (TempMaxLimit == strTemp || ReConnect == strTemp ||
			TempUpperLimit == strTemp || TempLowerLimit == strTemp || TempMinLimit == strTemp ||
			BatLowerLimit == strTemp || BatMiniLimit == strTemp ||
			BatLowerLimitInCali == strTemp || WifiLowerLimit == strTemp ||
			WifiMiniLimit == strTemp || HighPowerTimeout == strTemp ||
			ShowTemperature == strTemp || ShowWifi == strTemp ||
			ShowBattery == strTemp || ShowBluetooth == strTemp ||
			FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp ||
			CcosDetectorAttachedFlag == strTemp)
		{
			strValue = (string)config[pInnerKey];
		}
		else
		{
			strValue = "";
			FERROR("FERROR Configuration item: {$}", pInnerKey);
		}
	}
	return true;
}

/***
***说明: 设置配置文件内容
***/
bool nsFPD::XiuYuanDriver::SetDeviceConfigValue(ResDataObject& config, const char* pInnerKey, int nPathID, const char* szValue)
{
	FINFO("SetDeviceConfigValue change {$} item value to {$}", pInnerKey, szValue);
	string strTemp = pInnerKey;
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		if (WiredIP == strTemp || WirelessIP == strTemp || LocalIP == strTemp)
		{
			config["connections"][pInnerKey] = szValue;
		}
		else if (DetectorVender == strTemp || DetectorModel == strTemp ||
			DetectorDescription == strTemp || DetectorSerialNumber == strTemp)
		{
			config[pInnerKey] = szValue;
		}
		else if (SyncType == strTemp || FPDWorkStation == strTemp ||
			ImageWidth == strTemp || ImageHeight == strTemp)
		{
			config["ModeTable"]["DetectorMode"][pInnerKey] = szValue;
		}
		else if (TempMaxLimit == strTemp || ReConnect == strTemp ||
			TempUpperLimit == strTemp || TempLowerLimit == strTemp ||
			BatLowerLimit == strTemp || BatMiniLimit == strTemp ||
			BatLowerLimitInCali == strTemp || WifiLowerLimit == strTemp ||
			WifiMiniLimit == strTemp || HighPowerTimeout == strTemp ||
			ShowTemperature == strTemp || ShowWifi == strTemp ||
			ShowBattery == strTemp || ShowBluetooth == strTemp ||
			FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp ||
			CcosDetectorAttachedFlag == strTemp)
		{
			config[pInnerKey] = szValue;
		}
		else
		{
			FERROR("FERROR Configuration item: {$}", pInnerKey);
			return false;
		}
	}
	return true;
}

std::string nsFPD::XiuYuanDriver::GetResource()
{
	FINFO("XiuYuanDriver GetResource");
	ResDataObject r_config, temp;
	FINFO("m_ConfigFileName:{$}", m_ConfigFileName);
	if (!temp.loadFile(m_ConfigFileName.c_str()))
	{
		return "";
	}
	m_ConfigAll = temp;
	r_config = temp["CONFIGURATION"];
	m_Configurations = r_config;

	ResDataObject DescriptionTemp;
	ResDataObject ListTemp;
	string strTemp = ""; //用于读取字符串配置信息
	string strIndex = ""; //用于读取配置信息中的List项
	int nTemp = -1; //用于读取整型配置信息
	char sstream[10] = { 0 }; //用于转换值
	string strValue = ""; //用于存储配置的值
	string strType = ""; //用于存储配置的类型 int/float/string...
	string strAccess = ""; //用于存储权限的类型 R/W/RW
	string strRequired = ""; // TRUE/FALSE
	string strDefaultValue = "";
	string strRangeMin = "";
	string strRangeMax = "";

	try
	{
		int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
		m_pAttribute->clear();
		m_pDescription->clear();
		for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
		{
			DescriptionTemp.clear();
			ListTemp.clear();
			//AttributeType
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Type"];
			DescriptionTemp.add(AttributeType, strTemp.c_str());
			strType = strTemp; //记录配置项的类型

			//AttributeKey
			//1. 根据AttributeType，内部key和配置路径，拿到当前的真实值
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
			nTemp = (int)m_Configurations["ConfigToolInfo"][nInfoIndex]["PathID"];
			GetDeviceConfigValue(r_config, strTemp.c_str(), nTemp, strValue);
			//2. 赋值
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
			if ("int" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str()));
			}
			else if ("float" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atof(strValue.c_str()));
			}
			else //其它先按string类型处理
			{
				(*m_pAttribute).add(strTemp.c_str(), strValue.c_str());
			}

			//AttributeAccess
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Access"];
			DescriptionTemp.add(AttributeAccess, strTemp.c_str());

			//AttributeRangeMin
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMin"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(AttributeRangeMin, strTemp.c_str());
			}

			//AttributeRangeMax
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMax"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(AttributeRangeMax, strTemp.c_str());
			}

			//AttributeList
			nTemp = m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListNum"];
			if (nTemp > 0) //ListNum不大于0时说明不需要list配置
			{
				for (int nListIndex = 0; nListIndex < nTemp; nListIndex++)
				{
					strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListInfo"][nListIndex];
					auto temKey = std::to_string(nListIndex);
					ListTemp.add(temKey.c_str(), strTemp.c_str());
				}
				DescriptionTemp.add(AttributeList, ListTemp);
			}

			//AttributeRequired
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Required"];
			DescriptionTemp.add(AttributeRequired, strTemp.c_str());

			//AttributeDefaultValue
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["DefaultValue"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(AttributeDefaultValue, strTemp.c_str());
			}

			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
			(*m_pDescription).add(strTemp.c_str(), DescriptionTemp);
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Get config FERROR: {$}", e.what());
		return "";
	}

	ResDataObject resDeviceResource;
	resDeviceResource.add(ConfKey::CcosDetectorAttribute, (*m_pAttribute));
	resDeviceResource.add(ConfKey::CcosDetectorDescription, (*m_pDescription));

	ResDataObject DescriptionTempEx;
	DescriptionTempEx.add(ConfKey::CcosDetectorConfig, resDeviceResource);

	m_DeviceConfig = DescriptionTempEx;

	string res = DescriptionTempEx.encode();

	FINFO("XiuYuanDriver module: get resource over");
	return res;
}

std::string nsFPD::XiuYuanDriver::DeviceProbe()
{
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
		HardwareInfo.add("MinorID", "Device");
		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
	}
	else
	{
		HardwareInfo.add("MajorID", "Detector");
		HardwareInfo.add("MinorID", "Device");
		HardwareInfo.add("VendorID", "XiuYuan");
		HardwareInfo.add("ProductID", "4343S");
		HardwareInfo.add("SerialID", "1234");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

extern XiuYuanCtrl* g_pXiuYuanCtrl;
const float ABS_ZERO_TEMPERATURE = -273.15f; //绝对零度

nsFPD::FPDDeviceXiuYuan::FPDDeviceXiuYuan(std::shared_ptr <IOEventCenter> center, string ConfigPath)
	:m_nFullImgWidth{},
	m_nFullImgHeight{},
	m_nImageBits{},
	m_nAngle{},
	m_nPixelSpacing{},
	m_nSensitivity{},
	m_nPreviewEnable{},
	m_nPreviewImageWidth{},
	m_nPreviewImageHeight{},
	m_nCalibCurrentCalibrationRound{},
	m_nCalibCurrentExposureIndex{},
	m_nCalibCurrentExposureNum{},
	m_nCalibTotalExposureNum{},
	m_fFactorEXI2UGY{},
	m_pFullImgBuffer{},
	m_pPreviewImgBuffer{},
	m_eAppStatus(APP_STATUS_WORK_END),
	m_CalibType(CCOS_CALIBRATION_TYPE_MAX),
	m_bSaveRaw(false),
	m_bConnectStatus(false),
	m_bOffsetCalibRunning(false)
{
	super::EventCenter = center;
	m_strWorkPath = GetProcessDirectory();
	
	m_AcqUnit.reset(new OemAcq(center, this));
	m_SyncUnit.reset(new OemSync(center, this));
	m_CalibUnit.reset(new OemCalib(center, this));
	m_DetectorCtrlUnit.reset(new OemDetectorCtrl(center, this));

	m_DetectorConfiguration.reset(new DetectorConfiguration(ConfigPath));
	m_WarnAndError.reset(new FPDErrorWarning(center, DetectorUnitType, m_strWorkPath));

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_INIT));
	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ERROR));
}

nsFPD::FPDDeviceXiuYuan::~FPDDeviceXiuYuan()
{
}

std::string nsFPD::FPDDeviceXiuYuan::GetGUID() const
{
	return DetectorUnitType;
}

bool nsFPD::FPDDeviceXiuYuan::Prepare()
{
	FINFO("--Func-- device prepare");
	EventCenter->OnMaxBlockSize("DrXiuYuan", 4000 * 4000 * 2, 3, 1500 * 1500 * 2, 1);
	Connect();
	return true;
}

bool nsFPD::FPDDeviceXiuYuan::CreateDevice()
{
	FINFO("CreateDevice start");
	if (!LoadConfig())
	{
		FINFO("Load configuration file failed!!!   ");
		return false;
	}

	if (nullptr == g_pXiuYuanCtrl)
	{
		g_pXiuYuanCtrl = new XiuYuanCtrl();
	}
	g_pXiuYuanCtrl->DriverEntry(this, m_DetectorConfiguration->m_Configurations);
	FINFO("CreateDevice end");
	return true;
}

void nsFPD::FPDDeviceXiuYuan::Register()
{
	auto Disp = &Dispatch;

	RegisterCtrl(Disp);
	RegisterAcq(Disp);
	RegisterSync(Disp);
	RegisterCalib(Disp);
	RegisterOthers(Disp);
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::Connect()
{
	FINFO("--Func-- device Connect");

	m_DetectorCtrlUnit->SetAttachStatus("1"); //没有attach功能，直接上发1，使客户端显示探测器状态

	RET_STATUS ret = RET_STATUS::RET_FAILED;
	if (g_pXiuYuanCtrl->Connect(this, m_strWorkPath))
	{
		ret = RET_STATUS::RET_SUCCEED;
		if (m_stDeviceConfig.bSupportDDR) //是否支持DDR采集功能
		{
			m_DetectorCtrlUnit->SetSupportDDR("YES");
		}
		else
		{
			m_DetectorCtrlUnit->SetSupportDDR("NO");
		}
	}
	return ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::EnterExam(int nExamStatus)
{
	FINFO("--Func-- EnterExam {$}", nExamStatus);

	switch (nExamStatus)
	{
	case APP_STATUS_WORK_BEGIN:
		FINFO("Enter into Exam Windows");
		m_eAppStatus = APP_STATUS_WORK_BEGIN;
		break;
	case APP_STATUS_WORK_END:
		FINFO("Quit Exam Windows");
		m_eAppStatus = APP_STATUS_WORK_END;
		break;
	case APP_STATUS_DETSHARE_BEGIN:
		FINFO("Enter into Detector Share Windows");
		m_eAppStatus = APP_STATUS_DETSHARE_BEGIN;
		break;
	case APP_STATUS_DETSHAR_END:
		FINFO("Quit Detector Share Windows");
		m_eAppStatus = APP_STATUS_DETSHAR_END;
		break;
	case APP_STATUS_CAL_BEGIN:
		FINFO("Enter into Calibration Windows");
		m_eAppStatus = APP_STATUS_CAL_BEGIN;
		break;
	case APP_STATUS_CAL_END:
		FINFO("Quit Calibration Windows");
		m_eAppStatus = APP_STATUS_CAL_END;
		break;
	case APP_STATUS_WORK_IN_SENSITIVITY:
		FINFO("Enter into sensitivity test interface");
		m_eAppStatus = APP_STATUS_WORK_IN_SENSITIVITY;
		break;
	default:
		FWARN("Undefined app status");
		break;
	}
	g_pXiuYuanCtrl->EnterExam(m_eAppStatus);

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::SetAcqMode(string strAcqMode)
{
	FINFO("--Func-- SetAcqMode({$})", strAcqMode);
	RET_STATUS ret = RET_STATUS::RET_FAILED;
	if (!m_bConnectStatus)
	{
		FERROR("m_bConnectStatus = false");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_WAKEUP));

	try
	{
		ResDataObject objModeConfig = m_DetectorConfiguration->m_Configurations;
		m_nFullImgWidth = (int)objModeConfig["ModeTable"][0]["ImageWidth"];
		m_nFullImgHeight = (int)objModeConfig["ModeTable"][0]["ImageHeight"];
		m_nImageBits = (int)objModeConfig["ModeTable"][0]["PhySizeInfoBit"];
		m_nAngle = (int)objModeConfig["ModeTable"][0]["RotateAngle"];
		m_nPixelSpacing = (int)objModeConfig["ModeTable"][0]["PixelPitch"];
		m_nSensitivity = (int)objModeConfig["ModeTable"][0]["Sensitivity"];
		m_nPreviewEnable = (int)objModeConfig["ModeTable"][0]["PreviewEnable"];
		m_nPreviewImageWidth = (int)objModeConfig["ModeTable"][0]["PreviewWidth"];
		m_nPreviewImageHeight = (int)objModeConfig["ModeTable"][0]["PreviewHeight"];

		if (m_nPreviewEnable)
		{
			m_AcqUnit->SetPrevImageInfo(true, m_nPreviewImageHeight, m_nPreviewImageWidth, 0);
			if (!m_pPreviewImgBuffer)
			{
				m_pPreviewImgBuffer = new WORD[m_nPreviewImageWidth * m_nPreviewImageHeight];
			}
		}

		if (nullptr != m_pFullImgBuffer)
		{
			delete[] m_pFullImgBuffer;
			m_pFullImgBuffer = nullptr;
		}

		m_pFullImgBuffer = new WORD[m_nFullImgWidth * m_nFullImgHeight];

		if (m_nAngle == 90 || m_nAngle == 270)
		{
			m_AcqUnit->SetFulImageInfo(m_nFullImgWidth, m_nFullImgHeight, m_nImageBits, false);
		}
		else
		{
			m_AcqUnit->SetFulImageInfo(m_nFullImgHeight, m_nFullImgWidth, m_nImageBits, false);
		}

		string strDoseOfExi = std::to_string(m_nSensitivity);
		m_fFactorEXI2UGY = 100.0f / stof(strDoseOfExi) * 1.0f;//统一使用IEC标准 呈现四角信息，无单位 ugy * 100 -ugy。所有Zskk探测器的FactorEXI2UGY均需*100
		FINFO("m_fFactorEXI2UGY = {$} ", m_fFactorEXI2UGY);
		m_DetectorCtrlUnit->SetFPDSensitivity(std::to_string(m_fFactorEXI2UGY));

		if (g_pXiuYuanCtrl->SetAcqMode(strAcqMode))
		{
			ret = RET_STATUS::RET_SUCCEED;
			m_AcqUnit->AcqModeNotify(strAcqMode);
		}
		else
		{
			ret = RET_STATUS::RET_FAILED;
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
	}

	return ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::GetSyncMode(SYNC_MODE& eSyncMode)
{
	FINFO("--Func-- GetSyncMode");
	eSyncMode = m_eSyncMode;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::PrepareAcquisition()
{
	FINFO("--Func-- PrepareAcquisition");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnectStatus)
	{
		FERROR("Detector not connected, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (g_pXiuYuanCtrl->PrepareAcquisition(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
	}

	FINFO("PrepareAcquisition over");
	return ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::StartAcquisition(string in)
{
	FINFO("--Func-- StartAcquisition");
	RET_STATUS Ret = RET_STATUS::RET_FAILED;

	if (!m_bConnectStatus)
	{
		FERROR("Detector not connected, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}
	
	if (g_pXiuYuanCtrl->StartAcquisition(this))
	{
		Ret = RET_STATUS::RET_SUCCEED;
		if (m_eSyncMode == SYNC_AED)
		{
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));//StartAcquisition
			m_SyncUnit->XWindowOnNotify();
		}
	}
	else
	{
		FERROR("StartAcquisition failed");
	}
	FINFO("StartAcquisition over");
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::StopAcquisition()
{
	FINFO("--Func-- StopAcquisition");
	RET_STATUS Ret = RET_STATUS::RET_FAILED;

	if (!m_bConnectStatus)
	{
		FERROR("Detector not connected, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (g_pXiuYuanCtrl->StopAcquisition(this))
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		Ret = RET_STATUS::RET_SUCCEED;
	}

	FINFO("StopAcquisition over");
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::ActiveCalibration(CCOS_CALIBRATION_TYPE Type)
{
	FINFO("--Func-- ActiveCalibration {$}", (int)Type);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnectStatus)
	{
		FERROR("Detector not connect, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (Type == CCOS_CALIBRATION_TYPE_NONE || Type == CCOS_CALIBRATION_TYPE_MAX)
	{
		FERROR("calibration type is invalid!");
		return RET_STATUS::RET_INVALID;
	}
	else
	{
		m_CalibType = Type;
	}

	m_eAppStatus = APP_STATUS_CAL_BEGIN;
	if (Type == CCOS_CALIBRATION_TYPE_XRAY)
	{
		FINFO("calibration type: XRAY");
		int nCalibrationRounds = (int)m_CalibDoseList.size();
		g_pXiuYuanCtrl->SetCalibRounds(nCalibrationRounds);
	}

	if (g_pXiuYuanCtrl->ActiveCalibration(this, Type))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ACTIVE));
		m_CalibUnit->SetCalibrationProgress("0");
	}
	else
	{
		FERROR("Active calibration failed");
		ret = RET_STATUS::RET_FAILED;
	}

	//重置校正流程参数
	m_nCalibCurrentCalibrationRound = 1;
	m_nCalibCurrentExposureIndex = 1;
	m_nCalibCurrentExposureNum = 0;

	FINFO("ActiveCalibration {$} over", (int)Type);

	return ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::PrepareCalibration()
{
	FINFO("--Func-- PrepareCalibration");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnectStatus)
	{
		FERROR("Detector not connect, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (g_pXiuYuanCtrl->PrepareCalibration(this))
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_PREPARE));
		CCOS_CALIBRATION_TYPE nCalibrationType = m_CalibUnit->GetCalibrationType();
		if (nCalibrationType == CCOS_CALIBRATION_TYPE_XRAY && m_eSyncMode == SYNC_AED)
		{
			FINFO("set m_bEnterAcqStatus true");
		}
		ret = RET_STATUS::RET_SUCCEED;
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	}
	else
	{
		FERROR("PrepareCalibration failed!");
		return ret;
	}

	FINFO("--Func-- PrepareCalibration over");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::GetRequestedDose(string& strDose)
{
	FINFO("--Func-- GetRequestedDose");
	RET_STATUS ret = RET_STATUS::RET_FAILED;
	ResDataObject out;

	if (!m_bConnectStatus)
	{
		FERROR("Detector not connect, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	CCOS_CALIBRATION_TYPE nCalibrationType = m_CalibUnit->GetCalibrationType();
	FINFO("GetRequestedDose calib type is {$}", (int)nCalibrationType);

	if (CCOS_CALIBRATION_TYPE_DARK == nCalibrationType)
	{
		out.add("Dose", 0.0f);
		out.add("kV", 0.0f);
		out.add("mA", 0.0f);
		out.add("ms", 0.0f);
		out.add("mAs", 0.0f);
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == nCalibrationType)
	{
		FINFO("calib dose list size is {$}", m_CalibDoseList.size());
		ResDataObject temp = m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1];
		int nTargetExi = (int)temp["TargetGainEXI"];
		m_DetectorCtrlUnit->SetTargetEXI(std::to_string(nTargetExi));
		FINFO("nTargetExi:{$}", nTargetExi);
		out.add("Dose", nTargetExi);
		out.add("kV", temp["KV"]);
		out.add("mA", temp["MA"]);
		out.add("ms", temp["MS"]);
		out.add("mAs", temp["MAS"]);
	}
	else
	{
		FERROR("Don't support CalibrationType($)", (int)nCalibrationType);
		return ret;
	}

	strDose = out.encode();
	FINFO("GetRequestedDose:{$}", strDose);
	ret = RET_STATUS::RET_SUCCEED;
	FINFO("GetRequestedDose Over");
	return ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::SetRequestedDose(std::string strDose)
{
	FINFO("--Func-- SetRequestedDose");
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	FINFO("SetRequestedDose Over");
	return ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::GetCalibrationStep(int nDetectorID, string& strCalibrationStepInfo)
{
	FINFO("--Func-- GetCalibrationStep DetectorID:{$}", nDetectorID);
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	ResDataObject out;

	int nCalibrationRounds = (int)m_CalibDoseList.size();
	int nExposureNumCurrentRound = (int)m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1]["ExpNum"];
	if (g_pXiuYuanCtrl->GetCalibrationStep(m_nCalibCurrentCalibrationRound, nCalibrationRounds, m_nCalibCurrentExposureIndex, nExposureNumCurrentRound))
	{
		FINFO("GetCalibrationStep success");
	}
	else
	{
		FERROR("GetCalibrationStep error");
		ret = RET_STATUS::RET_FAILED;
		return ret;
	}

	out.add("CalibrationRounds", (int)m_CalibDoseList.size());
	out.add("TotalExposureNum", m_nCalibTotalExposureNum);
	out.add("CurrentCalibrationRound", m_nCalibCurrentCalibrationRound);
	out.add("ExposureNumCurrentRound", (int)m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1]["ExpNum"]);
	out.add("CurrentExposureIndex", m_nCalibCurrentExposureIndex);
	out.add("CurrentExposureNum", m_nCalibCurrentExposureNum);

	strCalibrationStepInfo = out.encode();

	FINFO("strCalibrationStepInfo: {$}", strCalibrationStepInfo.c_str());
	FINFO("GetCalibrationStep Over");
	return ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::StartCalibration()
{
	FINFO("--Func-- StartCalibration");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnectStatus)
	{
		FERROR("Detector not connect, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (m_CalibUnit->GetCalibrationStatus() != CCOS_CALIBRATION_STATUS_PREPARE)
	{
		FERROR("Start calibration failed, in {$} status", (int)m_CalibUnit->GetCalibrationStatus());
		return ret;
	}

	if (g_pXiuYuanCtrl->StartCalibration(this))
	{
		FINFO("start calibration success set detector status");
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_RUNNING));
		ret = RET_STATUS::RET_SUCCEED;
		if (m_eSyncMode == SYNC_AED)
		{
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));//StartCalibration
		}
	}
	else
	{
		FERROR("StartCalibration failed");
		FERROR("StartCalibration Over");
		ret = RET_STATUS::RET_FAILED;
		return ret;
	}
	FINFO("StartCalibration Over");
	return ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::StopCalibration()
{
	FINFO("--Func-- StopCalibration");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnectStatus)
	{
		FERROR("m_bDeviceConnect is false, detector not connect, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	m_eAppStatus = APP_STATUS_CAL_END;

	if (g_pXiuYuanCtrl->StopCalibration(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_BESTOPPED));
	}
	else
	{
		FERROR("StopCalibration failed");
	}

	FINFO("StopCalibration over");
	return ret;
}

void nsFPD::FPDDeviceXiuYuan::AbortCalibration()
{
	FINFO("--Func-- AbortCalibration");

	m_eAppStatus = APP_STATUS_CAL_END;
	CCOS_CALIBRATION_TYPE nCalibrationType = m_CalibUnit->GetCalibrationType();

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ERROR));
	m_CalibUnit->SetCalibrationProgress("100");

	if (CCOS_CALIBRATION_TYPE_XRAY == nCalibrationType)
	{
		g_pXiuYuanCtrl->AbortCalibration(this);
		m_AcqUnit->SendNoNeedWaitImage(true);
	}
	//如果中止的时候探测器在采集状态需要停止采集

	FINFO("AbortCalibration Over");
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::AcceptCalibration()
{
	FINFO("--Func-- AcceptCalibration");
	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
	if (g_pXiuYuanCtrl->AcceptCalibration())
	{
		FINFO("AcceptCalibration Success");
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		FERROR("AcceptCalibration error");
		Ret = RET_STATUS::RET_FAILED;
	}
	int nExposureNumCurrentRound = (int)m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1]["ExpNum"];

	//完成校正条件：轮数够了，曝光次数够了
	if ((m_nCalibCurrentCalibrationRound == (int)m_CalibDoseList.size()) && (m_nCalibCurrentExposureIndex == nExposureNumCurrentRound))
	{
		FINFO("Calibration Round: {$}, Exposure Index: {$}, Finished", m_nCalibCurrentCalibrationRound, m_nCalibCurrentExposureIndex);
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress("100");
		return Ret;
	}

	if (m_nCalibCurrentExposureIndex >= nExposureNumCurrentRound) //跳到下一轮校正参数
	{
		m_nCalibCurrentCalibrationRound++;
		m_nCalibCurrentExposureIndex = 1;
	}
	else
	{
		m_nCalibCurrentExposureIndex++;
	}
	m_nCalibCurrentExposureNum++;

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	FINFO("AcceptCalibration Over");
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::RejectCalibration()
{
	FINFO("--Func-- RejectCalibration");
	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;

	if (g_pXiuYuanCtrl->RejectCalibration())
	{
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		FERROR("RejectCalibration error");
		Ret = RET_STATUS::RET_FAILED;
	}
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	FINFO("RejectCalibration Over");
	return Ret;
}

bool nsFPD::FPDDeviceXiuYuan::CompleteCalibration()
{
	FINFO("--Func-- CompleteCalibration");

	if (!g_pXiuYuanCtrl->CompleteCalibration(this))
	{
		FERROR("CompleteCalibration fail!");
		return false;
	}

	if (g_pXiuYuanCtrl->GetCalibType() == CCOS_CALIBRATION_TYPE_DARK)
	{
		FINFO("CompleteCalibration Calibration Type DARK");
	}
	else if (g_pXiuYuanCtrl->GetCalibType() == CCOS_CALIBRATION_TYPE_XRAY)
	{
		FINFO("CompleteCalibration Calibration Type XRAY");
		m_eAppStatus = APP_STATUS_CAL_END;
	}

	FINFO("CompleteCalibration set detector status standby");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
	m_CalibUnit->SetCalibrationProgress("100");
	FINFO("CompleteCalibration Over");
	return true;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::SaveCalibrationFile(bool bSaveFlag)
{
	FINFO("--Func-- SaveCalibrationFile");
	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
	FINFO("SaveCalibrationFile bSaveFlag: {$}", bSaveFlag);

	if (!bSaveFlag)
	{
		FERROR("Not save calibration file");
		return Ret;
	}

	//点击save按钮时先调用compelte再调用save
	CompleteCalibration();

	if (g_pXiuYuanCtrl->SaveCalibrationFile())
	{
		m_CalibUnit->SetSaveCalibrationFileFinish(true);
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		FERROR("SaveCalibrationFile error");
		m_CalibUnit->SetSaveCalibrationFileFinish(false);
		Ret = RET_STATUS::RET_FAILED;
	}
	FINFO("SaveCalibrationFile Over");
	return Ret;
}

bool nsFPD::FPDDeviceXiuYuan::Support_DarkCalib()
{
	return true;
}

bool nsFPD::FPDDeviceXiuYuan::Support_XrayCalib()
{
	return true;
}

void nsFPD::FPDDeviceXiuYuan::SendTemperatureValue(float fTemp)
{
	int nStatus = 0;
	m_Temperature->SetTemperature(fTemp, nStatus);
	FINFO("SendTemperatureValue: {$}, status {$} ", fTemp, nStatus);

	return;
}

void nsFPD::FPDDeviceXiuYuan::SendWifiValue(int nWifi)
{
	int nStatus = 0;
	m_Wifi->SetSignalValue(nWifi, nStatus);
	FINFO("SendWifiValue: {$}, status {$} ", nWifi, nStatus);

	return;
}

void nsFPD::FPDDeviceXiuYuan::SendBatteryValue(int nBattery)
{
	int nStatus = 0;
	m_Battery->SetRemainPowerValue(nBattery, nStatus);
	FINFO("SendBatteryValue: {$}, status {$} ", nBattery, nStatus);

	return;
}

bool nsFPD::FPDDeviceXiuYuan::LoadConfig()
{
	FINFO("--Func-- LoadConfig start");
	if (!m_DetectorConfiguration->LoadConfigurations(m_stDeviceConfig, m_CalibDoseList, m_nCalibTotalExposureNum))
	{
		FERROR("Load configuration file failed!!!");
		return false;
	}

	FINFO("m_CalibDoseList:{$}", m_CalibDoseList.encode());
	FINFO("m_nCalibTotalExposureNum:{$}", m_nCalibTotalExposureNum);
	m_SyncUnit->SetSupportSyncMode(m_stDeviceConfig.strSupportSyncMode);

	//把通知状态信息的时间间隔传给ctrl
	//g_pXiuYuanCtrl->SetNotifyStatusTimePeriod(m_stDeviceConfig.nNotifyStatusTimePeriod);

	//const char* strkey, int initialvalue, int min, int WarnMin, int WarnMax, int CalibWarnMin, int CalibWarnMax, int max, int accuracy, std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter
	m_Battery.reset(new DeviceBatteryMould("DetectorBattery", 0,
		m_stDeviceConfig.nBatteryLimit,
		m_stDeviceConfig.nBatteryWarning,
		90, 20, 90, 100, 0, EventCenter));

	//const char* strkey, float initialvalue, float min, float WarnMin, float WarnMax, float CalibWarnMin, float CalibWarnMax, float max, float accuracy,std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter
	m_Temperature.reset(new DeviceTemperatureMould("DetectorTemperature", 0.0f,
		m_stDeviceConfig.fTemperatureErrorMin,
		m_stDeviceConfig.fTemperatureWarnMin,
		m_stDeviceConfig.fTemperatureWarnMax,
		20.0f, 100.0f,
		m_stDeviceConfig.fTemperatureErrorMax,
		0.0f, EventCenter));

	//const char* strkey, int initialvalue, int min, int WarnMin, int WarnMax, int CalibWarnMin, int CalibWarnMax, int max, int accuracy, std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter
	m_Wifi.reset(new DeviceWifiMould("DetectorWifi", 0, m_stDeviceConfig.nWifiLimit,
		m_stDeviceConfig.nWifiWarning, 100, 10, 100, 100, 0, EventCenter));

	return true;
}

void nsFPD::FPDDeviceXiuYuan::RegisterCtrl(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::EnterExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSEnterExam);
	Dispatch->Action.Push(ActionKey::ExitExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSExitExam);
	Dispatch->Action.Push(ActionKey::SetExposureTimes, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetExposureTimes);
	Dispatch->Action.Push(ActionKey::SetXrayOnNum, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetXrayOnNum);
	Dispatch->Action.Push(ActionKey::CcosActiveDetector, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSActiveDetector);
	
	Dispatch->Get.Push(AttrKey::DetectorStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDStatus);
	Dispatch->Get.Push(AttrKey::DetectorType, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorType);
	Dispatch->Get.Push(AttrKey::Description, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDescription);
	Dispatch->Get.Push(AttrKey::DetectorID, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorID);
	Dispatch->Get.Push(AttrKey::FPDSensitivity, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDSensitivity);
	Dispatch->Get.Push(AttrKey::PixelData, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetPixelData);
	Dispatch->Get.Push(AttrKey::TargetEXI, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTargetEXI);
	Dispatch->Get.Push(CcosDetectorAttachedFlag, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachStatus);
	Dispatch->Get.Push(SupportDDR, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetSupportDDR);

	Dispatch->Set.Push(AttrKey::DetectorStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorStatus);
	Dispatch->Set.Push(AttrKey::DetectorType, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorType);
	Dispatch->Set.Push(AttrKey::Description, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDescription);
	Dispatch->Set.Push(AttrKey::DetectorID, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorID);
	Dispatch->Set.Push(AttrKey::PixelData, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetPixelData);
	Dispatch->Set.Push(AttrKey::TargetEXI, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetTargetEXI);
	Dispatch->Set.Push(CcosDetectorAttachedFlag, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetAttachStatus);
	Dispatch->Set.Push(SupportDDR, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetSupportDDR);

	Dispatch->Update.Push(AttrKey::NotifyStatusTimePeriod, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateNotifyStatusTimePeriod);
	Dispatch->Update.Push(AttrKey::ReconnectTimePeriod, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateReconnectTimePeriod);
}

void nsFPD::FPDDeviceXiuYuan::RegisterAcq(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::SetAcqMode, m_AcqUnit.get(), &AcqUnit::JSSetAcqMode);

	Dispatch->Get.Push(AttrKey::AcqMode, m_AcqUnit.get(), &AcqUnit::JSGetAcqMode);
	Dispatch->Get.Push(AttrKey::ZskkFPDState, m_AcqUnit.get(), &AcqUnit::JSGetZskkFPDState);
	Dispatch->Get.Push(AttrKey::NoNeedWaitImage, m_AcqUnit.get(), &AcqUnit::JSGetNoNeedWaitImage);
	Dispatch->Get.Push(AttrKey::ImgDataInfo, m_AcqUnit.get(), &AcqUnit::JSGetLastImage);

	Dispatch->Set.Push(AttrKey::ZskkFPDState, m_AcqUnit.get(), &AcqUnit::SetZskkFPDState);
	Dispatch->Set.Push(AttrKey::NoNeedWaitImage, m_AcqUnit.get(), &AcqUnit::JSSetNoNeedWaitImage);
}

void nsFPD::FPDDeviceXiuYuan::RegisterSync(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::SetSyncMode, m_SyncUnit.get(), &SyncUnit::JSSetSyncMode);
	Dispatch->Action.Push(ActionKey::SetXwindowSize, m_SyncUnit.get(), &SyncUnit::JSSetXwindowSize);
	Dispatch->Action.Push(ActionKey::PrepareAcquisition, m_SyncUnit.get(), &SyncUnit::JSPrepareAcquisition);
	Dispatch->Action.Push(ActionKey::StartAcquisition, m_SyncUnit.get(), &SyncUnit::JSStartAcquisition);
	Dispatch->Action.Push(ActionKey::StopAcquisition, m_SyncUnit.get(), &SyncUnit::JSStopAcquisition);
	Dispatch->Action.Push(ActionKey::ActiveSyncMode, m_SyncUnit.get(), &SyncUnit::JSActiveSyncMode);

	Dispatch->Get.Push(AttrKey::FPDReadyStatus, m_SyncUnit.get(), &SyncUnit::JSGetFPDReady);
	Dispatch->Get.Push(AttrKey::XwindowStatus, m_SyncUnit.get(), &SyncUnit::JSGetXWindowStatus);
	Dispatch->Get.Push(AttrKey::ImageReadingStatus, m_SyncUnit.get(), &SyncUnit::JSGetImageReadingStatus);
	Dispatch->Get.Push(AttrKey::FPDExpReady, m_SyncUnit.get(), &SyncUnit::JSGetExpReadyStatus);
	Dispatch->Get.Push(AttrKey::SyncMode, m_SyncUnit.get(), &SyncUnit::JSGetSyncMode);
	Dispatch->Get.Push(AttrKey::SupportSyncMode, m_SyncUnit.get(), &SyncUnit::JSGetSupportSyncMode);

	Dispatch->Set.Push(AttrKey::FPDReadyStatus, m_SyncUnit.get(), &SyncUnit::JSSetFPDReady);
	Dispatch->Set.Push(AttrKey::XwindowStatus, m_SyncUnit.get(), &SyncUnit::JSSetXWindowStatus);
	Dispatch->Set.Push(AttrKey::ImageReadingStatus, m_SyncUnit.get(), &SyncUnit::JSSetImageReadingStatus);
	Dispatch->Set.Push(AttrKey::SupportSyncMode, m_SyncUnit.get(), &SyncUnit::SetSupportSyncMode);
}

void nsFPD::FPDDeviceXiuYuan::RegisterCalib(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::ActiveCalibration, m_CalibUnit.get(), &CalibUnit::JSActiveCalibration);
	Dispatch->Action.Push(ActionKey::GetRequestedDose, m_CalibUnit.get(), &CalibUnit::JSGetRequestedDose);
	Dispatch->Action.Push(ActionKey::SetRequestedDose, m_CalibUnit.get(), &CalibUnit::JSSetRequestedDose);
	Dispatch->Action.Push(ActionKey::PrepareCalibration, m_CalibUnit.get(), &CalibUnit::JSPrepareCalibration);
	Dispatch->Action.Push(ActionKey::StartCalibration, m_CalibUnit.get(), &CalibUnit::JSStartCalibration);
	Dispatch->Action.Push(ActionKey::StopCalibration, m_CalibUnit.get(), &CalibUnit::JSStopCalibration);
	Dispatch->Action.Push(ActionKey::SetCorrectionType, m_CalibUnit.get(), &CalibUnit::JSSetCorrectionType);
	Dispatch->Action.Push(ActionKey::AcceptCalibration, m_CalibUnit.get(), &CalibUnit::JSAcceptCalibration);
	Dispatch->Action.Push(ActionKey::RejectCalibration, m_CalibUnit.get(), &CalibUnit::JSRejectCalibration);
	Dispatch->Action.Push(ActionKey::SaveCalibrationFile, m_CalibUnit.get(), &CalibUnit::JSSaveCalibrationFile);
	Dispatch->Action.Push(ActionKey::GetCalibrationStep, m_CalibUnit.get(), &CalibUnit::JSGetCalibrationStep);

	Dispatch->Get.Push(AttrKey::CalibrationStatus, m_CalibUnit.get(), &CalibUnit::JSGetCalibStatus);
	Dispatch->Get.Push(AttrKey::CalibrationProgress, m_CalibUnit.get(), &CalibUnit::JSGetCalibProgress);
	Dispatch->Get.Push(AttrKey::UploadCalibrationFilesResult, m_CalibUnit.get(), &CalibUnit::JSGetUploadCalibrationFilesResult);
	Dispatch->Get.Push(AttrKey::SupportCalibrationType, m_CalibUnit.get(), &CalibUnit::JSGetSupportCalibrationType);
	Dispatch->Get.Push(AttrKey::HaveImgCalibration, m_CalibUnit.get(), &CalibUnit::JSGetHaveImgCalibration);
	Dispatch->Get.Push(AttrKey::SaveCalibrationFileFinish, m_CalibUnit.get(), &CalibUnit::JSGetSaveCalibrationFileFinish);
	Dispatch->Get.Push(AttrKey::CalibMode, m_CalibUnit.get(), &CalibUnit::JSGetCalibMode);

	Dispatch->Set.Push(AttrKey::CalibrationStatus, m_CalibUnit.get(), &CalibUnit::SetCalibrationStatus);
	Dispatch->Set.Push(AttrKey::CalibrationProgress, m_CalibUnit.get(), &CalibUnit::SetCalibrationProgress);
	Dispatch->Set.Push(AttrKey::UploadCalibrationFilesResult, m_CalibUnit.get(), &CalibUnit::SetUploadCalibrationFilesResult);

	Dispatch->Update.Push(AttrKey::CalibMode, m_CalibUnit.get(), &CalibUnit::JSUpdateCalibMode);
}

void nsFPD::FPDDeviceXiuYuan::RegisterOthers(nDetail::Dispatch* Dispatch)
{
	Dispatch->Get.Push(AttrKey::Temperature_Value, m_Temperature.get(), &DeviceTemperatureMould::JSGetCurrentTemperatureValue);
	Dispatch->Get.Push(AttrKey::Remain_Power_Value, m_Battery.get(), &DeviceBatteryMould::JSGetCurrentBatteryValue);
	Dispatch->Get.Push(AttrKey::Wifi_Strength_Value, m_Wifi.get(), &DeviceWifiMould::JSGetCurrentSignalValue);
	Dispatch->Get.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureWarningMax);
	Dispatch->Get.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureWarningMin);
	Dispatch->Get.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureErrorMax);
	Dispatch->Get.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureErrorMin);
	Dispatch->Get.Push(TemperatureCalibUpWarn, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureCalibWarningMax);
	Dispatch->Get.Push(TemperatureCalibLowWarn, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureCalibWarningMin);
	Dispatch->Get.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::JSGetBatteryWarningMin);
	Dispatch->Get.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::JSGetBatteryErrorMin);
	Dispatch->Get.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::JSGetSignalWarningMin);
	Dispatch->Get.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::JSGetSignalErrorMin);

	Dispatch->Set.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureWarningMax);
	Dispatch->Set.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureWarningMin);
	Dispatch->Set.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureErrorMax);
	Dispatch->Set.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureErrorMin);
	Dispatch->Set.Push(TemperatureCalibUpWarn, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureCalibWarningMax);
	Dispatch->Set.Push(TemperatureCalibLowWarn, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureCalibWarningMin);
	Dispatch->Set.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::SetBatteryWarningMin);
	Dispatch->Set.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::SetBatteryErrorMin);
	Dispatch->Set.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::SetSignalWarningMin);
	Dispatch->Set.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::SetSignalErrorMin);

	Dispatch->Update.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureWarningMax);
	Dispatch->Update.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureWarningMin);
	Dispatch->Update.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureErrorMax);
	Dispatch->Update.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureErrorMin);
	Dispatch->Update.Push(TemperatureCalibUpWarn, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureCalibWarningMax);
	Dispatch->Update.Push(TemperatureCalibLowWarn, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureCalibWarningMin);
	Dispatch->Update.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::JSUpdateBatteryWarningMin);
	Dispatch->Update.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::JSUpdateBatteryErrorMin);
	Dispatch->Update.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::JSUpdateSignalWarningMin);
	Dispatch->Update.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::JSUpdateSignalErrorMin);
}

void nsFPD::FPDDeviceXiuYuan::OnFPDCallback(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventLevel)
	{
	case EVT_LEVEL_CONFIGURATION:
	{
		OnEventProcessConf(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_INFORMATOION:
	{
		OnEventProcessInfo(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_STATUS:
	{
		OnEventProcessStatus(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_DATA:
	{
		OnEventProcessData(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_WARNING:
	{
		break;
	}
	case EVT_LEVEL_ERROR:
	{
		OnEventProcessError(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	default:
		break;
	}
}

void nsFPD::FPDDeviceXiuYuan::OnEventProcessConf(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	FERROR("Not support this conf({$})", nEventID);
}

void nsFPD::FPDDeviceXiuYuan::OnEventProcessInfo(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	FERROR("Not support this info({$})", nEventID);
}

void nsFPD::FPDDeviceXiuYuan::OnEventProcessStatus(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	int nID = nDetectorID;
	string strWarnErrorCode = "";

	switch (nEventID)
	{
	case EVT_STATUS_INIT:
	{
		FINFO("EVT_STATUS_INIT nParam1:{$}", nParam1);
		break;
	}
	case EVT_STATUS_MOTION:
		break;
	case EVT_STATUS_UPDATE_FIRMWARE:
		break;
	case EVT_STATUS_DETECTORSHARE:
		break;
	case EVT_STATUS_SINGLEINIT:
		break;
	case EVT_STATUS_SELECTPANEL:
		break;
	case EVT_STATUS_PANEL:
	{
		PanelStatus m_ePanelStatus = (PanelStatus)nParam1;
		if (PANEL_CLOSE == nParam1)
		{
			FINFO("EVT_STATUS_PANEL PANEL_CLOSE");
			m_bConnectStatus = false;
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_SHUTDOWN));
		}
		else if (PANEL_CONNECT == nParam1)
		{
			FINFO("EVT_STATUS_PANEL PANEL_CONNECT");
			m_bConnectStatus = true;
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_WAKEUP));
		}
		else if (PANEL_STANDBY == nParam1)
		{
			FINFO("EVT_STATUS_PANEL PANEL_STANDBY");
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		}
		else if (PANEL_READY_EXP == nParam1)
		{
			FINFO("EVT_STATUS_PANEL PANEL_READY_EXP");
			m_AcqUnit->SetZskkFPDState(to_string(ZSKK_FPD_STATE_READY));
		}
		else if (PANEL_XWINDOW_ON == nParam1) //Xwindow On
		{
			m_stImgCreateTime = { 0 };
			GetLocalTime(&m_stImgCreateTime);
			FINFO("XWindowOn at {$:d04}-{$:d02}-{$:d02} {$:d02}:{$:d02}:{$:d02}:{$:d03}",
				m_stImgCreateTime.wYear, m_stImgCreateTime.wMonth, m_stImgCreateTime.wDay,
				m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);

			m_SyncUnit->XWindowOnNotify();
		}
		else if (PANEL_XWINDOW_OFF == nParam1) // Xwindow Off
		{
			m_stImgCreateTime = { 0 };
			GetLocalTime(&m_stImgCreateTime);
			FINFO("XWindowOff at {$:d04}-{$:d02}-{$:d02} {$:d02}:{$:d02}:{$:d02}:{$:d03}",
				m_stImgCreateTime.wYear, m_stImgCreateTime.wMonth, m_stImgCreateTime.wDay,
				m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);

			m_SyncUnit->XWindowOffNotify();
		}
		else if (PANEL_START_ACQ == nParam1)
		{
			FINFO("EVT_STATUS_PANEL PANEL_START_ACQ");
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));//PANEL_START_ACQ
		}
		else if (PANEL_XRAY_ON == nParam1)
		{
			FINFO("EVT_STATUS_PANEL PANEL_XRAY_ON");
			m_SyncUnit->XrayOnNotify();
		}
		else if (PANEL_XRAY_OFF == nParam1)
		{
			FINFO("EVT_STATUS_PANEL PANEL_XRAY_OFF");
			m_SyncUnit->XrayOffNotify();
		}
		break;
	}
	case EVT_STATUS_CALIBRATIOIN:
	{
		FINFO("EVT_STATUS_PANEL EVT_STATUS_CALIBRATIOIN");
		PanelEventState eStatus = (PanelEventState)nParam1;
		switch (eStatus)
		{
		case PANEL_EVENT_START:
			break;
		case PANEL_EVENT_END_OK:
		case PANEL_EVENT_END_ERROR:
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
			m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
			m_CalibUnit->SetCalibrationProgress("100");
			break;
		case PANEL_EVENT_TIMEOUT:
			break;
		default:
			break;
		}
		break;
	}
	case EVT_STATUS_SAVECALIB:
	{
		FINFO("EVT_STATUS_SAVECALIB");
		PanelEventState eStatus = (PanelEventState)nParam1;
		switch (eStatus)
		{
		case PANEL_EVENT_START:
		{
			FINFO("save calib file start");
			break;
		}
		case PANEL_EVENT_END:
		{
			FINFO("save calib file end");
			break;
		}
		default:
			break;
		}
		break;
	}
	case EVT_STATUS_SAVEDEFECT:
		break;
	case EVT_STATUS_ACQUISITION:
	{
		PanelEventState eStatus = (PanelEventState)nParam1;
		switch (eStatus)
		{
		case PANEL_EVENT_START:
			break;
		case PANEL_EVENT_END_OK:
			break;
		case PANEL_EVENT_END_ERROR: //由于断线造成指令执行失败
		{
			string strWarnErrorCode = ERR_FPD_ACQ_FAILED;//fixbug 12473 开窗失败不用ERR_FPD_RESTART上报
			break;
		}
		default:
			break;
		}
		break;
	}
	case EVT_STATUS_PREPARE_EDNCALIBRATION:
		break;
	case EVT_STATUS_SINGLEEXP:
	{
		FINFO("EVT_STATUS_PANEL EVT_STATUS_SINGLEEXP");
		if (DOSE_ACCEPT == nParam1)
		{
			FINFO("Calibration Result is acceptable");
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
			m_CalibUnit->PauseCalibration();
		}
		else
		{
			FERROR("Not support this param({$})", nParam1);
		}
		break;
	}
	case EVT_STATUS_IMAGEPENDING:
	{
		break;
	}
	case EVT_STATUS_IMAGERECOVERAUTO:
	{
		break;
	}
	case EVT_STATUS_TEMPERATURE:
	{
		FINFO("EVT_STATUS_PANEL EVT_STATUS_TEMPERATURE");
		float fTemperature = fParam2;
		SendTemperatureValue(fTemperature);
		break;
	}
	case EVT_STATUS_WIFI:
	{
		FINFO("EVT_STATUS_PANEL EVT_STATUS_WIFI");
		int nWifiLevel = nParam1;
		SendWifiValue(nWifiLevel);
		break;
	}
	case EVT_STATUS_BATTERY_VALUE:
	{
		FINFO("EVT_STATUS_PANEL EVT_STATUS_BATTERY_VALUE");
		int nBatteryValue = nParam1;
		SendBatteryValue(nBatteryValue);
		break;
	}
	case EVT_STATUS_BATTERY_CHARGING:
	{
		break;
	}
	case EVT_STATUS_SHOCK_SENSOR:
	{
		FINFO("Shock Seneor Number: {$}", nParam1);
		break;
	}
	case EVT_STATUS_HALL_SENSOR:
	{
		FINFO("Hall Sensor Status: {$}", nParam1);
		break;
	}
	case EVT_STATUS_PING:
	{
		break;
	}
	case EVT_STATUS_PMSNOTOPEN:
	{
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			FINFO("PMS isn't open");
		}
		break;
	}
	case EVT_STATUS_RESTOREFILES:
	{
		string strTemp = pszMsg;
		FINFO("Restore calibration files");
		break;
	}
	case EVT_STATUS_LASTERROR:
	{
		break;
	}
	case EVT_STATUS_RESET:
		break;
	default:
		break;
	}
}

string nsFPD::FPDDeviceXiuYuan::MakeImageHead(IMAGE_VIEW_TYPE Type)
{
	ResDataObject pFullImageHead;
	ResDataObject pPreviewImageHead;

	SYSTEMTIME SystemTime = { 0 };
	GetLocalTime(&SystemTime);

	if (Type == IMAGE_FULL)
	{
		ResDataObject json;
		json.add(SM_IMAGE_TYPE, (int)Type);
		json.add(SM_IMAGE_BIT, m_nImageBits);
		json.add(SM_IMAGE_TAG, 1);
		json.add(SM_IMAGE_INDEX, 1);
		json.add(SM_IMAGE_YEAR, SystemTime.wYear);
		json.add(SM_IMAGE_MONTH, SystemTime.wMonth);
		json.add(SM_IMAGE_DAY, SystemTime.wDay);
		json.add(SM_IMAGE_HOUR, SystemTime.wHour);
		json.add(SM_IMAGE_MINUTE, SystemTime.wMinute);
		json.add(SM_IMAGE_SEC, SystemTime.wSecond);
		json.add(SM_IMAGE_MILLSEC, SystemTime.wMilliseconds);
		json.add(SM_IMAGE_LSB, "5000");
		json.add(SM_IMAGE_DOSE, m_nSensitivity);
		json.add(SM_IMAGE_PIXELREPRESENTATION, "1");
		json.add(SM_IMAGE_PIXELSPACING, m_nPixelSpacing);
		json.add(SM_IMAGE_FLIP, "No");
		json.add(SM_IMAGE_ORIGINX, "0");
		json.add(SM_IMAGE_ORIGINY, "0");
		json.add(SM_IMAGE_EXI2UGY, m_fFactorEXI2UGY);
		json.add(SM_IMAGE_TEMP, 0.0f);
		if (90 == m_nAngle || 270 == m_nAngle)
		{
			json.add(SM_IMAGE_WIDTH, m_nFullImgHeight);
			json.add(SM_IMAGE_HEIGHT, m_nFullImgWidth);
			json.add(SM_IMAGE_ROTATION, "Yes");
		}
		else
		{
			json.add(SM_IMAGE_WIDTH, m_nFullImgWidth);
			json.add(SM_IMAGE_HEIGHT, m_nFullImgHeight);
			json.add(SM_IMAGE_ROTATION, "No");
		}

		pFullImageHead.add(SM_IMAGE_HEAD, json);
		return pFullImageHead.encode();
	}
	else
	{
		ResDataObject json;
		json.add(SM_IMAGE_TYPE, (int)Type);
		json.add(SM_IMAGE_WIDTH, m_nPreviewImageWidth);
		json.add(SM_IMAGE_HEIGHT, m_nPreviewImageHeight);
		json.add(SM_IMAGE_BIT, m_nImageBits);
		json.add(SM_IMAGE_TAG, 1);
		json.add(SM_IMAGE_INDEX, 1);
		json.add(SM_IMAGE_YEAR, SystemTime.wYear);
		json.add(SM_IMAGE_MONTH, SystemTime.wMonth);
		json.add(SM_IMAGE_DAY, SystemTime.wDay);
		json.add(SM_IMAGE_HOUR, SystemTime.wHour);
		json.add(SM_IMAGE_MINUTE, SystemTime.wMinute);
		json.add(SM_IMAGE_SEC, SystemTime.wSecond);
		json.add(SM_IMAGE_MILLSEC, SystemTime.wMilliseconds);
		json.add(SM_IMAGE_LSB, "5000");
		json.add(SM_IMAGE_DOSE, m_nSensitivity);
		json.add(SM_IMAGE_ROTATION, "No");
		json.add(SM_IMAGE_FLIP, "No");
		json.add(SM_IMAGE_ORIGINX, "0");
		json.add(SM_IMAGE_ORIGINY, "0");
		json.add(SM_IMAGE_PIXELSPACING, m_nPixelSpacing);
		json.add(SM_IMAGE_PIXELREPRESENTATION, "1");
		json.add(SM_IMAGE_TEMP, m_stDeviceConfig.fCurrentTemperValue);

		pPreviewImageHead.add(SM_IMAGE_HEAD, json);
		return pPreviewImageHead.encode();
	}
}

void nsFPD::FPDDeviceXiuYuan::OnEventProcessData(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
	case EVT_DATA_RAW_IMAGE:
	{
		FINFO("EVT_DATA_RAW_IMAGE");
		m_AcqUnit->ImagerPixelSpacingNotify(m_nPixelSpacing);
		memcpy(m_pFullImgBuffer, pParam, (size_t)m_nFullImgWidth * (size_t)m_nFullImgHeight * sizeof(WORD));

		string strImageHeader = MakeImageHead(IMAGE_FULL);
		FINFO("Full image head: {$}", strImageHeader);

		if (0 != m_nAngle)
		{
			m_AcqUnit->RotateImage(m_pFullImgBuffer, m_nFullImgHeight, m_nFullImgWidth, m_nAngle);
		}
		m_AcqUnit->AddFrameWithRawHead(IMAGE_FULL, strImageHeader, m_pFullImgBuffer, m_nFullImgWidth * m_nFullImgHeight);
		FINFO("Add image over");
		break;
	}
	case EVT_DATA_PREVIEW_IMAGE:
	{
		FINFO("EVT_DATA_PREVIEW_IMAGE");
		memcpy(m_pPreviewImgBuffer, pParam, (size_t)m_nPreviewImageWidth * (size_t)m_nPreviewImageHeight * sizeof(WORD));
		string strImageHeader = MakeImageHead(IMAGE_PREVIEW);
		FINFO("Preview image head: {$}", strImageHeader);
		m_AcqUnit->AddFrameWithRawHead(IMAGE_PREVIEW, strImageHeader, m_pPreviewImgBuffer, m_nPreviewImageWidth * m_nPreviewImageHeight);
		break;
	}
	case EVT_DATA_DOSEPARAM:
	{
		break;
	}
	default:
		FERROR("Not support this data({$})", nEventID);
		break;
	}
}

void nsFPD::FPDDeviceXiuYuan::OnEventProcessError(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
	case EVT_ERR_COMMUNICATE:
		break;
	case EVT_ERR_INIT_FAILED:
		break;
	default:
		FERROR("Not support this error({$})", nEventID);
		break;
	}
}

void nsFPD::FPDDeviceXiuYuan::OnEventProcessWarning(int nDetectorID, int nEventID, int nEventLevel,
	const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	FERROR("Not support this warn({$})", nEventID);
}

//设置同步模式
RET_STATUS nsFPD::FPDDeviceXiuYuan::ActiveSyncMode(int nSyncMode)
{
	FINFO("--Func-- ActiveSyncMode nSyncMode:{$}", nSyncMode);
	RET_STATUS Ret = RET_STATUS::RET_FAILED;

	m_eSyncMode = (SYNC_MODE)nSyncMode;
	if (g_pXiuYuanCtrl->SetSyncMode(nSyncMode))
	{
		Ret = RET_STATUS::RET_SUCCEED;
		FINFO("ActiveSyncMode Success");
	}
	else
	{
		FERROR("ActiveSyncMode Failed");
	}
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::ActiveDetector(bool bActive)
{
	FINFO("--Func-- ActiveDetector bActive:{$}", bActive);
	if (g_pXiuYuanCtrl->ActiveDetector(this, bActive))
	{
		if (bActive)
		{
			FINFO("ActiveDetector success!");
		}
		else
		{
			FINFO("InActiveDetector success!");
		}
		return RET_SUCCEED;
	}
	else
	{
		if (bActive)
		{
			FERROR("ActiveDetector fail!");
		}
		else
		{
			FERROR("InActiveDetector fail!");
		}
		return RET_FAILED;
	}
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::UpdateCalibMode(CCOS_CALIBRATION_MODE eCalibMode)
{
	FINFO("--Func-- UpdateCalibMode eCalibMode:{$}", (int)eCalibMode);
	m_stDeviceConfig.nCalibMode = (int)eCalibMode;
	if (g_pXiuYuanCtrl->UpdateCalibMode(eCalibMode))
	{
		FINFO("UpdateCalibMode success!");
		return RET_SUCCEED;
	}
	else
	{
		FERROR("UpdateCalibMode fail!");
		return RET_FAILED;
	}
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::UpdateNotifyStatusTimePeriod(int nTime)
{
	FINFO("--Func-- UpdateNotifyStatusTimePeriod nTime:{$}", nTime);
	m_stDeviceConfig.nNotifyStatusTimePeriod = nTime;
	g_pXiuYuanCtrl->SetNotifyStatusTimePeriod(nTime);
	return RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::UpdateReconnectTimePeriod(int nTime)
{
	FINFO("--Func-- UpdateReconnectTimePeriod nTime:{$}", nTime);
	m_stDeviceConfig.nReconnectTimePeriod = nTime;
	g_pXiuYuanCtrl->SetReconnectTimePeriod(nTime);
	return RET_SUCCEED;
}

string nsFPD::FPDDeviceXiuYuan::GetFileVersion(string strFilePathName)
{
	DWORD dwVerSize = GetFileVersionInfoSize(strFilePathName.c_str(), NULL);
	if (dwVerSize == 0)
	{
		return "";
	}

	LPVOID pVersionBuffer = malloc(dwVerSize);
	if (nullptr == pVersionBuffer)
	{
		return "";
	}
	GetFileVersionInfo(strFilePathName.c_str(), 0, dwVerSize, pVersionBuffer);

	VS_FIXEDFILEINFO* pInfo;
	UINT nInfoLen;
	char szValue[MAX_PATH] = { 0 };

	if (VerQueryValue(pVersionBuffer, ("\\"), (void**)&pInfo, &nInfoLen))
	{
		sprintf_s(szValue, ("%d.%d.%d.%d"),
			HIWORD(pInfo->dwFileVersionMS), LOWORD(pInfo->dwFileVersionMS),
			HIWORD(pInfo->dwFileVersionLS), LOWORD(pInfo->dwFileVersionLS));
	}

	string strVersion = szValue;

	return strVersion;
}

//保存RAW图数据
void nsFPD::FPDDeviceXiuYuan::SaveRawImage(const char* pImgName, const WORD* pRawImg, int nWidth, int nHeight)
{
	FINFO("Begin SaveRawImage: {$}, width: {$}, height: {$}", pImgName, nWidth, nHeight);
	if (pRawImg == nullptr || pImgName == nullptr)
	{
		FERROR("Undefined parameter");
		return;
	}
	string strImagePath = m_strWorkPath + "\\Image\\" + pImgName;

	FILE* fp;
	if ((fp = fopen(strImagePath.c_str(), "wb")) == nullptr)
	{
		DWORD dw = GetLastError();
		FERROR("fopen {$} failed, {$}", strImagePath.c_str(), dw);
		return;
	}
	fwrite(pRawImg, sizeof(WORD), nWidth * nHeight, fp);
	fclose(fp);
	FINFO("End SaveRawImage");
	return;
}

/***************************************************************
功能：将原始尺寸的图像裁剪为有效尺寸的图像
[IN][OUT]:pOutImg 有效尺寸图像信息
[IN]:pInImgData 原始尺寸图像数据
[IN]:nInWidth 原始尺寸图像的宽度
[IN]:nUpHeightOffset 要裁剪的上边高度
[IN]:nLeftWidthOffset要裁剪的左边宽度
************************************************************/
bool nsFPD::FPDDeviceXiuYuan::GetEffectiveImage(WORD* pwInImgData, int nRawImageWidth)
{
	if (pwInImgData == nullptr)
	{
		return false;
	}

	if (!m_pFullImgBuffer)
	{
		FINFO("Full ImgHeight:{$},Full ImgWidth:{$}", m_nFullImgWidth, m_nFullImgHeight);
		m_pFullImgBuffer = new WORD[m_nFullImgWidth * m_nFullImgHeight];
	}

	memcpy(m_pFullImgBuffer, pwInImgData, m_nFullImgWidth * m_nFullImgHeight * sizeof(WORD));
	return true;
}

bool nsFPD::FPDDeviceXiuYuan::SaveConfigFile(bool bSendNotify)
{
	m_DetectorConfiguration->SaveConfig();
	FINFO("SaveConfigFile over");
	return true;
}

RET_STATUS nsFPD::FPDDeviceXiuYuan::AddFrameWithRawHead(IMAGE_VIEW_TYPE Type, WORD* pFrameBuff, DWORD FrameSize)
{
	string strImageHead = MakeImageHead(Type);
	return m_AcqUnit->AddFrameWithRawHead(Type, strImageHead, pFrameBuff, FrameSize);
}