// CCOS.Dev.FPD.Yuying.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.Yuying.h"
#include "YuyingCtrl.h"


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

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

Log4CPP::Logger* gLogger = nullptr;

static nsFPD::YuyingDriver  gIODriver;

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

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

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

nsFPD::YuyingDriver::~YuyingDriver()
{
}

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

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

	FINFO("new FPDDeviceYuying over");
}

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

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

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

auto nsFPD::YuyingDriver::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::YuyingDriver::DriverProbe()
{
	FINFO("YuyingDriver::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", "Yuying");
		HardwareInfo.add("ProductID", "4343WA-AG");
		HardwareInfo.add("SerialID", "Driver");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

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

bool nsFPD::YuyingDriver::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::YuyingDriver::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::YuyingDriver::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::YuyingDriver::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::YuyingDriver::GetResource()
{
	FINFO("YuyingDriver 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("YuyingDriver module: get resource over");
	return res;
}

std::string nsFPD::YuyingDriver::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", "Yuying");
		HardwareInfo.add("ProductID", "4343WA-AG");
		HardwareInfo.add("SerialID", "1234");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

extern YuyingCtrl* g_pYuyingCtrl;
const float ABS_ZERO_TEMPERATURE = -273.15f; //绝对零度

nsFPD::FPDDeviceYuying::FPDDeviceYuying(std::shared_ptr <IOEventCenter> center, string ConfigPath)
	:m_nDeviceIndex{},
	m_nGridLicense{},
	m_strModuleIP{},
	m_strModuleSN{},
	m_strShockSensor{},
	m_strBatterySN{},
	m_strMotionStatus{},
	m_strSelfTest{},
	m_strLastError{},
	m_strCalibTime{},
	m_nBatteryCapacity{},
	m_nBatteryCharges{},
	m_nShockCounts{},
	m_nWorkStation{},
	m_fDoseParam{},
	m_nRawImgWidth{},
	m_nRawImgHeight{},
	m_nFullImgWidth{},
	m_nFullImgHeight{},
	m_nTopOffset{},
	m_nLeftOffset{},
	m_nImageBits{},
	m_fFactorEXI2UGY{},
	m_fBatteryTemperature{},
	m_nXrayCalibNum{},
	m_pwFullImageData{},
	m_pwRawImageData{},
	m_pwPreviewImg{},
	m_pPreviewImageHead{},
	m_pFullImageHead{},
	m_ExitEvt{},
	m_hNotifyThread{},
	m_CalTemperlowWarn{},
	m_CalTemperupWarn{},
	m_eAppStatus(APP_STATUS_WORK_END),
	m_nCalibrationType(CCOS_CALIBRATION_TYPE_MAX),
	m_bOpened(false),
	m_bBatteryCharging(false),
	m_bRecoveringImage(false),
	m_bAbortRecover(false),
	m_bUIReady(false),
	m_bImagePendingOrNot(false),
	m_bResetDetector(false),
	m_bPreviewEnable(false),
	m_bTestSensitivity(false),
	m_bDisConnected(false),
	m_bAttached(false),
	m_bRecoverImageStatusInit(false),
	m_bSaveRaw(false),
	m_bOffsetCalibRunning(false),
	m_bUIConfirmRecover(false),
	m_CalTemperWarnInitialed(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_Battery.reset(new DeviceBatteryMould("DetectorYuyingBattery", 0, 10, 20, 30, 40, 100, 100, 0, center));
	m_Temperature.reset(new DeviceTemperatureMould("DetectorYuyingTemperature", ABS_ZERO_TEMPERATURE, 0.0f, 10.0f, 60.0f, 20.0f, 40.0f, 70.0f, 0.0f, center));
	m_Wifi.reset(new DeviceWifiMould("DetectorYuyingWifi", 0, 20, 30, 40, 50, 100, 100, 0, center));

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

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

	m_WaitCalibDoseEvt = CreateEvent(0, 1, 0, 0);
	m_OffsetCalibrationEvt = CreateEvent(0, 0, 0, 0);
	m_PauseCalibrationEvt = CreateEvent(0, 1, 0, 0);
	m_CompleteCalibrationEvt = CreateEvent(0, 1, 0, 0);
	m_CrateCalibReportEvt = CreateEvent(0, 0, 0, 0);
	m_UploadCalibMapOver = CreateEvent(0, 1, 0, 0);
	m_ExitEvt = CreateEvent(0, 1, 0, 0);
	m_CalibGapEvt = CreateEvent(0, 1, 0, 0);
	m_WriteCumstomFileEvt = CreateEvent(0, 1, 0, 0);
}

nsFPD::FPDDeviceYuying::~FPDDeviceYuying()
{
	SetEvent(m_ExitEvt);

	CloseHandle(m_WaitCalibDoseEvt);
	CloseHandle(m_OffsetCalibrationEvt);
	CloseHandle(m_PauseCalibrationEvt);
	CloseHandle(m_CompleteCalibrationEvt);
	CloseHandle(m_CrateCalibReportEvt);
	CloseHandle(m_WriteCumstomFileEvt);
	CloseHandle(m_UploadCalibMapOver);
	CloseHandle(m_CalibGapEvt);
	if (m_hNotifyThread != nullptr)
	{
		CloseHandle(m_hNotifyThread);
	}
}

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

bool nsFPD::FPDDeviceYuying::Prepare()
{
	EventCenter->OnMaxBlockSize("DrYuying", m_nRawImgWidth * m_nRawImgHeight * 2, 3, 1500 * 1500 * 2, 1);
	Connect();
	return true;
}

void nsFPD::FPDDeviceYuying::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(SupportDDR, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetSupportDDR);
	Dispatch->Get.Push(CcosDetectorAttachedFlag, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachStatus);

	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);
}

void nsFPD::FPDDeviceYuying::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::FPDDeviceYuying::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::FPDDeviceYuying::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::FPDDeviceYuying::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(TemperatureCalibUpWarn, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureCalibWarningMax);
	Dispatch->Get.Push(TemperatureCalibLowWarn, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureCalibWarningMin);
	Dispatch->Get.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureErrorMax);
	Dispatch->Get.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureErrorMin);
	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->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::FPDDeviceYuying::Register()
{
	auto Disp = &Dispatch;

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

bool nsFPD::FPDDeviceYuying::LoadConfig()
{
	FINFO("LoadConfig start");
	if (!m_DetectorConfiguration->LoadConfigurations(m_stDeviceConfig))
	{
		FWARN("Load configuration file failed!!!  ");
		return false;
	}

	m_SyncUnit->SetSupportSyncMode(m_stDeviceConfig.strSupportSyncMode);

	//新增一个配置项代表当前系统中是否只有一个真是的平板探测器，其他设备没有或者是demo的
	size_t keyCount = m_DetectorConfiguration->m_Configurations.GetKeyCount(OnlyHaveFpd);
	FINFO("LoadConfig OnlyHaveFpd keyCount:{$}", keyCount);
	if (keyCount)
	{
		m_bOnlyHaveFpd = (bool)m_DetectorConfiguration->m_Configurations[OnlyHaveFpd];
		if (m_bOnlyHaveFpd)
			FINFO("current system only have FPD!");
	}

	//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));

	if (!m_DetectorConfiguration->LoadCalibrationDose(m_strWorkPath, m_CalibDoseList, m_nCalibTotalExposureNum))
	{
		FERROR("Load Calibration Dose failed!!!");
		return false;
	}
	FINFO("m_nCalibTotalExposureNum:{$}", m_nCalibTotalExposureNum);

	return true;
}

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

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

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

	//string strPath = m_strWorkPath + m_strSDKPath + "\\FpdSys.dll";
	//m_stDeviceConfig.strSoftware = GetFileVersion(strPath);
	//FINFO("Yuying SDK version: {$}", m_stDeviceConfig.strSoftware.c_str());

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

	RET_STATUS ret = RET_STATUS::RET_FAILED;
	if (g_pYuyingCtrl->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::FPDDeviceYuying::ActiveDetector(bool bActive)
{
	if (bActive)
	{
		FINFO("ActiveDetector");
		bool bRet = (g_pYuyingCtrl)->ActivePanel(this, bActive);
		if (!bRet)
		{
			return RET_STATUS::RET_FAILED;
		}
	}
	else
	{
		FINFO("UnActiveDetector");

		bool bRet = (g_pYuyingCtrl)->ActivePanel(this, bActive);
		if (!bRet)
		{
			return RET_STATUS::RET_FAILED;
		}
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::PrepareAcquisition()
{
	FINFO("==============================PrepareAcquisition  ");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	g_pYuyingCtrl->PrepareAcquisition(this);
	m_SyncUnit->FPDReadyNotify(true);
	FINFO("PrepareAcquisition over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::StartAcquisition(string in)
{
	FINFO("StartAcquisition  ");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	m_bAbortRecover = false;//能执行StartAcq，说明没有错误可以ready曝光。不再影响abort后再次recoverimage功能
	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	if (RET_STATUS::RET_SUCCEED == g_pYuyingCtrl->StartAcquisition(this))
	{
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		FERROR("StartAcquisition failed");
	}
	FINFO("StartAcquisition over");
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceYuying::StopAcquisition()
{
	FINFO("StopAcquisition");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	if (RET_STATUS::RET_SUCCEED == g_pYuyingCtrl->StopAcquisition(this))
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		Ret = RET_STATUS::RET_SUCCEED;
	}
	FINFO("StopAcquisition over  ");
	return Ret;
}

//设置同步模式
RET_STATUS nsFPD::FPDDeviceYuying::ActiveSyncMode(int nSyncMode)
{
	FINFO("=====ActiveSyncMode: {$}", nSyncMode);

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	if (g_pYuyingCtrl->ActiveSyncMode(this, nSyncMode))
	{
		Ret = RET_STATUS::RET_SUCCEED;
		FINFO("ActiveSyncMode success");
	}
	return Ret;
}

string nsFPD::FPDDeviceYuying::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;
}

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

	return;
}

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

	return;
}

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

	return;
}

RET_STATUS nsFPD::FPDDeviceYuying::ActiveCalibration(CCOS_CALIBRATION_TYPE Type)
{
	FINFO("ActiveCalibration is {$}", (int)Type);
	if (!m_stDeviceConfig.bConnectStatus)
	{
		FINFO("unconnected");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (Type == CCOS_CALIBRATION_TYPE_NONE || Type == CCOS_CALIBRATION_TYPE_MAX)
	{
		FINFO("type error {$}", (int)Type);
		return RET_STATUS::RET_INVALID;
	}

	m_eAppStatus = APP_STATUS_CAL_BEGIN;

	m_nCalibrationType = Type;

	OnErrorX(ERR_FPD_DOSE_LOW);
	OnErrorX(ERR_FPD_DOSE_HIGH);
	OnErrorX(ERR_FPD_DOSE_OBJ);//清除之前的错误，如果有的话

	RET_STATUS Ret = g_pYuyingCtrl->ActiveCalibration(Type, this);

	if (RET_STATUS::RET_SUCCEED == Ret)
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ACTIVE));
		m_CalibUnit->SetCalibrationProgress("0");
		if (Type == CCOS_CALIBRATION_TYPE_XRAY)
		{
			ResetEvent(m_WaitCalibDoseEvt);
		}

		m_nXrayCalibNum = 0;
	}

	ResetEvent(m_OffsetCalibrationEvt);
	ResetEvent(m_CompleteCalibrationEvt);

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

	return Ret;
}

RET_STATUS nsFPD::FPDDeviceYuying::GetRequestedDose(string& strDose)
{
	FINFO("GetRequestedDose");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	bool bGetDoseInfo = false;
	ResDataObject out;

	if (CCOS_CALIBRATION_TYPE_DARK == m_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);
		bGetDoseInfo = true;
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_nCalibrationType)
	{
		float fDose = (m_fDoseParam * 1.0f) / 1000.0f;
		FINFO("GetRequestedDose Xray {$} over {$}", fDose, m_fDoseParam);
		Ret = RET_STATUS::RET_SUCCEED;

		for (int i = 0; i < m_CalibDoseList.size(); i++)
		{
			ResDataObject temp = m_CalibDoseList[i];
			int nDose = temp["Dose"];
			if (m_fDoseParam == nDose)
			{
				out.add("Dose", nDose);
				out.add("kV", temp["kV"]);
				out.add("mA", temp["mA"]);
				out.add("ms", temp["ms"]);
				out.add("mAs", temp["mAs"]);
				bGetDoseInfo = true;
				break;
			}
		}
	}
	else
	{
		Ret = RET_STATUS::RET_FAILED;
	}

	if (bGetDoseInfo)
	{
		strDose = out.encode();
		FINFO("GetRequestedDose {$} over", strDose.c_str());
	}
	else
	{
		FERROR("GetRequestedDose failed");
	}
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceYuying::PrepareCalibration()
{
	FINFO("PrepareCalibration");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	m_SyncUnit->FPDReadyNotify(true);

	if (CCOS_CALIBRATION_TYPE_XRAY == m_nCalibrationType)
	{
		int nWaitTime = m_nConfXrayOnGap - m_nGenWaitGap;
		WaitForSingleObject(m_CalibGapEvt, nWaitTime);
	}

	FINFO("PrepareCalibration over");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::StartCalibration()
{
	FINFO("StartCalibration");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		m_bOffsetCalibRunning = true;
		SetEvent(m_OffsetCalibrationEvt);
	}

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	ResetEvent(m_PauseCalibrationEvt);
	if (RET_STATUS::RET_SUCCEED == g_pYuyingCtrl->StartCalibration(this))
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_RUNNING));
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		FERROR("StartCalibration failed");
		Ret = RET_STATUS::RET_FAILED;
	}

	FINFO("StartCalibration over");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::PauseCalibration()
{
	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
	m_nXrayCalibNum++;
	if (m_nXrayCalibNum != 20)
	{
		FINFO("start to waitting CalibDoseEvt");
		DWORD nRet = WaitForSingleObject(m_WaitCalibDoseEvt, INFINITE);
	}

	ResetEvent(m_PauseCalibrationEvt);
	ResetEvent(m_WaitCalibDoseEvt);
	m_AcqUnit->SendNoNeedWaitImage(true);
	if (m_nXrayCalibNum != 20)
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->PauseCalibration();
	}
	FINFO("Driver PauseCalibration over,m_nXrayCalibNum {$}", m_nXrayCalibNum);
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceYuying::StopCalibration()
{
	FINFO("StopCalibration");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_BESTOPPED));
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress("100");

		FINFO("StopDarkCalibration over");
		return RET_STATUS::RET_SUCCEED;
	}

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	m_eAppStatus = APP_STATUS_CAL_END;
	if (RET_STATUS::RET_SUCCEED == g_pYuyingCtrl->AbortCalibration(this))
	{
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		Ret = RET_STATUS::RET_FAILED;
	}

	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_BESTOPPED));
	m_CalibUnit->SetCalibrationProgress("100");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_AcqUnit->SendNoNeedWaitImage(true);

	FINFO("StopCalibration over");

	return RET_STATUS::RET_SUCCEED;
}

void nsFPD::FPDDeviceYuying::AbortCalibration()
{
	FINFO("AbortCalibration");

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ERROR));
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress("100");

		FINFO("AbortDarkCalibration over");
		return;
	}

	m_eAppStatus = APP_STATUS_CAL_END;
	g_pYuyingCtrl->AbortCalibration(this);

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

	FINFO("AbortXrayCalibration over");

	return;
}

void nsFPD::FPDDeviceYuying::StopCalibrationInside()
{
	FINFO("StopCalibrationInside");

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress("100");

		FINFO("StopCalibrationInside dark over");
		return;
	}

	m_eAppStatus = APP_STATUS_CAL_END;
	g_pYuyingCtrl->AbortCalibration(this);

	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
	m_CalibUnit->SetCalibrationProgress("100");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_AcqUnit->SendNoNeedWaitImage(true);

	FINFO("StopCalibrationInside xray over");

	return;
}

bool nsFPD::FPDDeviceYuying::CompleteCalibration()
{
	m_stDeviceConfig.fCalibTemperature = m_stDeviceConfig.fCurrentTemperValue;

	ResetEvent(m_UploadCalibMapOver);

	g_pYuyingCtrl->CompleteCalibration(this);

	DWORD nRet = WaitForSingleObject(m_UploadCalibMapOver, 60000);
	if (WAIT_OBJECT_0 == nRet)
	{
		FINFO("got event m_UploadCalibMapOver");
	}
	else if (WAIT_TIMEOUT == nRet)
	{
		FINFO("wait event m_UploadCalibMapOver timeout");
	}
	else
	{
		FINFO("wait event m_UploadCalibMapOver error");
	}

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

	CheckCalibartionDue();

	return true;
}

RET_STATUS nsFPD::FPDDeviceYuying::ResetConnect()
{
	FINFO("Reset Connect");
	g_pYuyingCtrl->ResetFPD(this);
	FINFO("FPDDeviceYuying::ResetConnect over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::DisConnectFPD()
{
	FINFO("DisConnectFPD");

	if (!g_pYuyingCtrl->DisConnect(this))
	{
		FERROR("DisConnectFPD failed");
		return RET_STATUS::RET_FAILED;
	}

	SendWifiValue(0);
	SendBatteryValue(0);
	SendTemperatureValue(ABS_ZERO_TEMPERATURE);

	m_bDisConnected = true;
	ResetAllError();

	FINFO("DisConnectFPD over");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::AttachConnect()
{
	m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_ATTACH_START));
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::CancelAttach()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::SetAttachStatus(int nStatus)
{
	return m_DetectorCtrlUnit->SetAttachStatus(to_string(nStatus));
}

void nsFPD::FPDDeviceYuying::FullImageDateArrived(WORD* pImg)
{
	AddFrameWithRawHead(IMAGE_FULL, pImg, m_stDeviceConfig.nFullImageWidth * m_stDeviceConfig.nFullImageHeight);
}

void nsFPD::FPDDeviceYuying::PrevImageDateArrived(WORD* pImg)
{
	AddFrameWithRawHead(IMAGE_PREVIEW, pImg, m_stDeviceConfig.nPreviewWidth * m_stDeviceConfig.nPreviewHeight);
}

RET_STATUS nsFPD::FPDDeviceYuying::SetXwindow(float XwindowSize)
{
	FINFO("SetXwindowSize {$}", XwindowSize);
	FINFO("SetXwindowSize DoNothing");
	FINFO("SetXwindowSize over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::EnterExam(int nExamStatus)
{
	FINFO("EnterExam");

	switch (nExamStatus)
	{
	case APP_STATUS_WORK_BEGIN:
		FINFO("Enter into Exam Windows");
		OnErrorX(ERR_FPD_DOSE_LOW);
		OnErrorX(ERR_FPD_DOSE_HIGH);
		OnErrorX(ERR_FPD_DOSE_OBJ);//清除之前校正的错误，如果有的话
		break;
	case APP_STATUS_WORK_END:
		FINFO("Quit Exam Windows");
		m_bTestSensitivity = false;
		break;
	case APP_STATUS_DETSHARE_BEGIN:
		FINFO("Enter into Detector Share Windows");
		break;
	case APP_STATUS_DETSHAR_END:
		FINFO("Quit Detector Share Windows");
		break;
	case APP_STATUS_CAL_BEGIN:
		FINFO("Enter into Calibration Windows");
		break;
	case APP_STATUS_CAL_END:
		FINFO("Quit Calibration Windows");
		break;
	case APP_STATUS_WORK_IN_SENSITIVITY:
		FINFO("Enter into sensitivity test interface");
		m_bTestSensitivity = true;
		break;
	default:
		FWARN("Undefined app status");
		break;
	}
	m_eAppStatus = (APP_STATUS)nExamStatus;
	g_pYuyingCtrl->EnterExam(m_eAppStatus);

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::SetAcqMode(string mode)
{
	if (!m_stDeviceConfig.bConnectStatus)
	{
		FERROR("m_stDeviceConfig.bConnectStatus = false");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	m_AcqUnit->SetFulImageInfo(m_nFullImgWidth, m_nFullImgHeight, m_nImageBits, false);
	m_AcqUnit->SetPrevImageInfo(m_stDeviceConfig.bPreviewEnable, m_stDeviceConfig.nPreviewHeight, m_stDeviceConfig.nPreviewWidth, false);

	if (!g_pYuyingCtrl->SelectExamMode(1, this))
	{
		FERROR("Set acqmode failed");
		return RET_STATUS::RET_FAILED;
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS CCOS::Dev::Detail::Detector::FPDDeviceYuying::SetSyncMode(SYNC_MODE nSyncMode, HARDWARE_TRIGGER_MODE TriggerMode)
{
	return RET_STATUS::RET_SUCCEED;
}

void nsFPD::FPDDeviceYuying::OnFPDCallback(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	m_nDeviceIndex = nDetectorID;

	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::FPDDeviceYuying::OnEventProcessConf(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{

	switch (nEventID)
	{
		case EVT_CONF_PANEL_SERIAL:
		{
			m_stDeviceConfig.strPanelSerial = pszMsg;
			FINFO("Receive Panel {$} SN {$}", nDetectorID, pszMsg);
			char cDetectorID[17] = { 0 };
			memcpy(cDetectorID, m_stDeviceConfig.strPanelSerial.c_str(), 16);
			string strDetectorID = cDetectorID;
			m_DetectorCtrlUnit->SetDetectorID(strDetectorID);
			FINFO("SedDetectorID {$}", strDetectorID.c_str());

			if (!m_bRecoverImageStatusInit)
			{
				m_RecoverImageStatus.add("DetectorName", m_stDeviceConfig.strDeviceName.c_str());
				m_RecoverImageStatus.add("DetectorSN", m_stDeviceConfig.strPanelSerial.c_str());
				m_RecoverImageStatus.add("DetectorWifiSignal", "1");
				m_RecoverImageStatus.add("Result", "-1");
				m_bRecoverImageStatusInit = true;
			}

			break;
		}
		case EVT_CONF_RAW_WIDTH:
		{
			if (m_stDeviceConfig.nFullImageWidth != nParam1)
			{
				m_stDeviceConfig.nFullImageWidth = nParam1;
			}
			FINFO("Panel {$} nRawWidth:{$}", nDetectorID, m_stDeviceConfig.nRawWidth);
			break;
		}
		case EVT_CONF_RAW_HIGHT:
		{
			if (m_stDeviceConfig.nFullImageHeight != nParam1)
			{
				m_stDeviceConfig.nFullImageHeight = nParam1;
			}
			FINFO("Panel {$} nRawHeight:{$}", nDetectorID, m_stDeviceConfig.nRawHeight);
			break;
		}
		case EVT_CONF_RAW_BITS:
		{
			if (m_stDeviceConfig.nImageBits != nParam1)
			{
				m_stDeviceConfig.nImageBits = nParam1;
			}
			m_stDeviceConfig.nImageBits = nParam1;
			FINFO("Panel {$} nImageBits:{$}", nDetectorID, m_stDeviceConfig.nImageBits);
			break;
		}
		case EVT_CONF_PIXELSPACE:
		{
			m_stDeviceConfig.nPixelSpace = nParam1;
			FINFO("Panel {$} nPixelSpace:{$}", nDetectorID, m_stDeviceConfig.nPixelSpace);
			break;
		}
		case EVT_CONF_PREVIEW_WIDTH:
		{
			if (m_stDeviceConfig.nPreviewWidth != nParam1)
			{
				m_stDeviceConfig.nPreviewWidth = nParam1;
			}
			FINFO("Panel {$} nPreviewWidth:{$}", nDetectorID, m_stDeviceConfig.nPreviewWidth);
			break;
		}
		case EVT_CONF_PREVIEW_HIGHT:
		{
			if (m_stDeviceConfig.nPreviewHeight != nParam1)
			{
				m_stDeviceConfig.nPreviewHeight = nParam1;
			}
			FINFO("Panel {$} nPreviewHeight:{$}", nDetectorID, m_stDeviceConfig.nPreviewHeight);
			break;
		}
		case EVT_CONF_MODULE_TYPE:
		{
			FINFO("Receive Panel {$} ModuleType {$}", nDetectorID, pszMsg);
			break;
		}
		case EVT_CONF_MODULE_IP:
		{
			m_strModuleIP = pszMsg;
			FINFO("Receive Panel {$} ModuleIP {$}", nDetectorID, pszMsg);
			break;
		}
		case EVT_CONF_MODULE_SN:
		{
			m_strModuleSN = pszMsg;
			FINFO("Receive Panel {$} ModuleSN {$}", nDetectorID, pszMsg);
			break;
		}
		case EVT_CONF_FIRWARE_UPDATE:
		{
			m_stDeviceConfig.nFirmwareStatus = nParam1;
			m_DetectorCtrlUnit->SetFirmwareStatus(to_string(nParam1));
			FINFO("Panel {$} FirmwareUpdate:{$}", nDetectorID, m_stDeviceConfig.nFirmwareStatus);
			break;
		}
		case EVT_CONF_PART_NUMBER:
		{
			break;
		}
		case EVT_CONF_BATTERY_SN:
		{
			m_strBatterySN = pszMsg;
			FINFO("Panel {$} Battery SN:{$}", nDetectorID, pszMsg);
			break;
		}
		case EVT_CONF_WIFI_SSID:
		{
			m_stDeviceConfig.strWifiSSID = pszMsg;
			FINFO("Panel {$} WifiSSID:{$}", nDetectorID, pszMsg);
			break;
		}
		case EVT_CONF_IFBOARD:
		{
			FINFO("Panel {$} InterfaceBoard:{$}", nDetectorID, pszMsg);
			break;
		}
		default:
		{
			break;
		}
	}
}

void nsFPD::FPDDeviceYuying::OnEventProcessInfo(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	int nID = nDetectorID;
	switch (nEventID)
	{
		case EVT_INFO_BATTERY_CAPACITY:
		{
			int nBatteryCapacity = nParam1;
			if ((nBatteryCapacity != m_nBatteryCapacity) && (m_strBatterySN != ""))
			{
				FINFO("{$},SN:{$}", nBatteryCapacity, m_strBatterySN);
				m_nBatteryCapacity = nBatteryCapacity;
			}
			break;
		}
		case EVT_INFO_BATTERY_TEMPERATURE:
		{
			float fBatteryTemper = fParam2;
			if (((fBatteryTemper - m_fBatteryTemperature) >= 0.1f) && (m_strBatterySN != ""))
			{
				FINFO("SN:{$} ,temperature:{$}", m_strBatterySN, fBatteryTemper);
				m_fBatteryTemperature = fBatteryTemper;
			}
			break;
		}
		case EVT_INFO_BATTERY_CHARGES:
		{
			int nBatteryCharges = nParam1;
			if ((nBatteryCharges != m_nBatteryCharges) && (m_strBatterySN != ""))
			{
				FINFO("SN:{$},Charge number:{$}", m_strBatterySN, nBatteryCharges);
				m_nBatteryCharges = nBatteryCharges;
			}
			break;
		}
		case EVT_INFO_WIFI_DATARATE:
		{
			m_stDeviceConfig.nWifiDataRate = nParam1;
			FINFO("Detector {$} WifiDataRate:{$}", nID, m_stDeviceConfig.nWifiDataRate);
			break;
		}
		case EVT_INFO_WIFI_CHANNEL:
		{
			m_stDeviceConfig.nWifiChannel = nParam1;
			FINFO("Panel {$} WifiChannel:{$}", nID, m_stDeviceConfig.nWifiChannel);
			break;
		}
		case EVT_INFO_WIFI_SIGNALPOWER:
		{
			m_stDeviceConfig.nWifiSignalPower = nParam1;
			break;
		}
		case EVT_INFO_WIFI_NOISEPOWER:
		{
			m_stDeviceConfig.nWifiNoisePower = nParam1;
			FINFO("Panel {$} WifiNoisePower:{$}", nID, m_stDeviceConfig.nWifiNoisePower);
			break;
		}
		case EVT_INFO_SHOCKSENSOR_INFO:
		{
			FINFO("Receive ShockSensor FINFO");
			m_strShockSensor = pszMsg;
			m_DetectorCtrlUnit->SetShockSensorInfo(m_strShockSensor);
			break;
		}
		case EVT_INFO_CALIBRATIOIN_DATE:
		{
			FINFO("Panel {$} STE Calibration Date:{$}", nID, pszMsg);
			break;
		}
		case EVT_INFO_CALIBRATIOIN_TIME:
		{
			FINFO("Panel {$} STE Calibration Time:{$}", nID, pszMsg);
			m_stDeviceConfig.strCalibrationTime = pszMsg;
			m_DetectorCtrlUnit->SetTimeofLastDetectorCalibration(m_stDeviceConfig.strCalibrationTime);
			break;
		}
		default:
		{
			break;
		}
	}
}

void nsFPD::FPDDeviceYuying::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:
		{
			if (PANEL_EVENT_END_OK == nParam1)
			{
				OnInitResult(true);
				m_DetectorCtrlUnit->SetInitialStatus(to_string(DETECTOR_INI_SUCCESS));
				FINFO("connect FPD ok. Start Status Polling");
			}
			else if (PANEL_EVENT_END_ERROR == nParam1)
			{
				OnInitResult(false);
				m_DetectorCtrlUnit->SetInitialStatus(to_string(DETECTOR_INI_FAILED));
			}
			else if (PANEL_EVENT_END == nParam1) //未连接探测器
			{
				m_DetectorCtrlUnit->SetInitialStatus(to_string(DETECTOR_INI_SUCCESS));
			}
			else if (PANEL_EVENT_START == nParam1)
			{
				m_DetectorCtrlUnit->SetInitialStatus(to_string(DETECTOR_INI_START));
			}
			break;
		}
		case EVT_STATUS_MOTION:
		{
			m_strMotionStatus = pszMsg;
			break;
		}
		case EVT_STATUS_UPDATE_FIRMWARE:
		{
			if (PANEL_EVENT_START == nParam1)
			{
				FINFO("Start update firmware");
				m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_START));
			}
			else if (PANEL_EVENT_BEGIN == nParam1)
			{
				FINFO("Update firmware begin");
				m_stDeviceConfig.bConnectStatus = false;
			}
			else if (PANEL_EVENT_END_ERROR == nParam1)
			{
				FINFO("Update firmware failed");
				m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_ERROR));
			}
			else if (PANEL_EVENT_SUCCESS == nParam1)
			{
				FINFO("update firmware success");
				m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_SUCCESS));
			}
			else if (PANEL_EVENT_FWU_ERROR_BATTERY == nParam1)
			{
				FINFO("update firmware failed, battery < 50");
				m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_ERROR_BATTERY));
			}
			else if (PANEL_EVENT_FWU_ERROR_OMIT == nParam1)
			{
				FINFO("update firmware failed, Omit");
				m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_ERROR_OMIT));
			}
			break;
		}
		case EVT_STATUS_DETECTORSHARE:
		{
			ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
			switch (eStatus)
			{
				case PANEL_CONNECT_OK:
				{
					string strError = ERR_FPD_NOFPD;
					OnErrorX(strError); //之前可能会提示NO DETECTOR
					FINFO("SetConnectStatus(PANEL_CONNECT_OK)");
					m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_CONNECT_OK));
					m_stDeviceConfig.bConnectStatus = true;
					SetAttachStatus(1);
					m_bAttached = true;
					break;
				}
				case PANEL_CONNECT_ERROR:
				{
					FINFO("SetConnectStatus(PANEL_CONNECT_ERROR)");
					m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_CONNECT_ERROR));
					break;
				}
				case PANEL_DISCONNECT_SUCCESS:
				{
					m_nBatteryCapacity = 0;
					m_strBatterySN = "";
					m_stDeviceConfig.bExisted = false;
					m_stDeviceConfig.bConnectStatus = false;
					FINFO("SetConnectStatus(PANEL_DISCONNECT_SUCCESS)");
					m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_DISCONNECT_SUCCESS));
					break;
				}
				case PANEL_DISCONNECT_ERROR:
				{
					FINFO("SetConnectStatus(PANEL_DISCONNECT_ERROR)");
					m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_DISCONNECT_ERROR));
					break;
				}
				default:
					break;
			}
			break;
		}
		case EVT_STATUS_SINGLEINIT:
			break;
		case EVT_STATUS_SELECTPANEL:
			break;
		case EVT_STATUS_PANEL:
		{
			ENUM_PANEL_STATUS m_ePanelStatus = (ENUM_PANEL_STATUS)nParam1;
			if (PANEL_STANDBY == nParam1)
			{
				FINFO("Panel Status:PREPARE");
			}
			else if (PANEL_START_ACQ == nParam1)
			{
				FINFO("Panel Status:ACQ");
				m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));
			}
			else if (PANEL_READY_EXP == nParam1)
			{
				FINFO("Panel Status:READY");
				Action_ExpReady();
			}
			else if (PANEL_OFFSET_CAL == nParam1)
			{
				FINFO("Panel Status:PANEL_OFFSET_CAL");
			}
			else if (PANEL_OFFSET_FINISH == nParam1)
			{
				FINFO("Panel Status:PANEL_OFFSET_FINISH");
				m_bOffsetCalibRunning = false;
				StopCalibrationInside();
			}
			else if (PANEL_OFFSET_FAILED == nParam1)
			{
				FINFO("Panel Status:PANEL_OFFSET_FAILED");
				m_bOffsetCalibRunning = false;
				AbortCalibration();
			}
			else if (PANEL_XWINDOW_ON == nParam1) //Xwindow On
			{
				FINFO("Panel Status: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
			{
				FINFO("Panel Status: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_GAIN_FINISH == nParam1)
			{
				FINFO("Panel Status:CALIBRATION_FINISH");
			}
			else if (PANEL_GAIN_PREPARE == nParam1)
			{
				FINFO("Detector Notify Xray Prepare");
			}
			else if (PANEL_GAIN_READY_EXP == nParam1)
			{
				Action_ExpReady();
			}
			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();
			}
			else
			{
				FINFO("Panel {$} Status is :{$}", nID, (int)m_ePanelStatus);
			}
			break;
		}
		case EVT_STATUS_CALIBRATIOIN:
		{
			ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
			switch (eStatus)
			{
				case PANEL_EVENT_START:
					break;
				case PANEL_EVENT_END_OK:
					FINFO("Calibration process is success");
					SetEvent(m_CompleteCalibrationEvt);
					break;
				case PANEL_EVENT_END_ERROR:
					FINFO("Calibration process is failed");
					break;
				case PANEL_EVENT_TIMEOUT:
					FINFO("Calibration timeout");
					FINFO("Calibration process is failed");
					break;
				case PANEL_EVENT_CALIB_REPORT:
					FINFO("Create Calibration Report failed");
					SetEvent(m_CrateCalibReportEvt);
					break;
				default:
					break;
			}
			break;
		}
		case EVT_STATUS_SAVECALIB:
		{
			if (PANEL_EVENT_START == nParam1)
			{
				FINFO("Begin to Save Calibration Files");

			}
			else if (PANEL_EVENT_END_ERROR == nParam1)
			{
				SetEvent(m_UploadCalibMapOver);
				FINFO("Save Calibration Files failed");
			}
			else if (PANEL_EVENT_END == nParam1)
			{
				SetEvent(m_UploadCalibMapOver);
				FINFO("Save Calibration Files Success");
			}
			break;
		}
		case EVT_STATUS_SAVEDEFECT:
		{
			if (PANEL_EVENT_START == nParam1)
			{
				FINFO("Begin to Save Defect Files");
			}
			else if (PANEL_EVENT_END_ERROR == nParam1)
			{
				SetEvent(m_UploadCalibMapOver);
				FINFO("Save Defect Files failed");
			}
			else if (PANEL_EVENT_END == nParam1)
			{
				FINFO("Save Defect Files Success");
				SetEvent(m_UploadCalibMapOver);
			}
			break;
		}
		case EVT_STATUS_ACQUISITION:
		{
			ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)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上报
					OnError(strWarnErrorCode);
					break;
				}
				default:
					break;
			}
			break;
		}
		case EVT_STATUS_PREPARE_EDNCALIBRATION:
			break;
		case EVT_STATUS_SINGLEEXP:
		{
			if (DOSE_TOO_HIGH == nParam1)
			{
				FINFO("Dose too high");
				m_strLastError = "Current dose level is too high and beyond the tolerance interval";
				OnError(ERR_FPD_DOSE_HIGH, m_strLastError);
				AbortCalibration();
			}
			else if (DOSE_TOO_LOW == nParam1)
			{
				FINFO("Dose too low");
				m_strLastError = "Current dose level is too low and beyond the tolerance interval";
				OnError(ERR_FPD_DOSE_LOW, m_strLastError);
				AbortCalibration();
			}
			else if (DOSE_OBJECT == nParam1)
			{
				FINFO("Dose object");
				m_strLastError = "Calibration has failed. Please check emergency stop button or calibration switch, otherwise call service.";
				OnError(ERR_FPD_DOSE_OBJ, m_strLastError);
				AbortCalibration();
			}
			else if (DOSE_ACCEPT == nParam1)
			{
				FINFO("Calibration Result is acceptable");
				m_strLastError = "";
				OnErrorX(ERR_FPD_DOSE_LOW);
				OnErrorX(ERR_FPD_DOSE_HIGH);
				OnErrorX(ERR_FPD_DOSE_OBJ);
				SetEvent(m_PauseCalibrationEvt);
			}
			else if (PANEL_EVENT_END_ERROR == nParam1)
			{
				AbortCalibration();
			}
			break;
		}
		case EVT_STATUS_IMAGEPENDING:
		{
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				m_bImagePendingOrNot = true;
			}
			else
			{
				m_bImagePendingOrNot = false;
			}

			if (m_bImagePendingOrNot)  // && !m_bResetDetector
			{
				OnError(ERR_FPD_IMAGE_PENDING);
			}
			else
			{
				m_bResetDetector = false;//可以再次reset
				OnErrorX(ERR_FPD_IMAGE_PENDING);
			}
			break;
		}
		case EVT_STATUS_IMAGERECOVERAUTO:
		{
			OnErrorX(ERR_FPD_IMAGE_PENDING);
			m_RecoverImageStatus["Result"] = "0";
			FINFO("m_RecoverImageStatus[Result] = 0 by auto");
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());
			m_bAbortRecover = false; //终止恢复图像的变量也要重置
			m_bRecoveringImage = false; //不再恢复图像过程中
			m_nRecoverImageTimes = 0; //下次恢复图像，重置
			m_bSendRecoverMessage = false; //下次恢复图像仍需判断；
			break;
		}
		case EVT_STATUS_TEMPERATURE:
		{
			float fTemperature = fParam2;
			OnProcessTemperature(nID, fTemperature);
			m_stDeviceConfig.fCurrentTemperValue = fTemperature;
			FINFO("Detector {$} Temperature Value:{$}", nID, fTemperature);
			SendTemperatureValue(fTemperature);
			break;
		}
		case EVT_STATUS_WIFI:
		{
			int nWifiLevel = nParam1;

			FINFO("Detector {$} Wifi Value:{$}", nID, nWifiLevel);
			strWarnErrorCode = ERR_FPD_WIFI_LOW;
			if (nWifiLevel == 0) //WIFI值为0 表明是有线连接，不报错
			{
				OnErrorX(strWarnErrorCode);
			}
			else if (nWifiLevel < m_stDeviceConfig.nWifiLimit)
			{
				//wifi error
				OnWarnX(WAR_FPD_WIFI_LOW);
				OnError(strWarnErrorCode);
			}
			else if (nWifiLevel <= m_stDeviceConfig.nWifiWarning)
			{
				//wifi error
				OnErrorX(strWarnErrorCode);
				strWarnErrorCode = WAR_FPD_WIFI_LOW;
				OnWarn(nID, strWarnErrorCode);
			}
			else
			{
				OnErrorX(strWarnErrorCode);
				strWarnErrorCode = WAR_FPD_WIFI_LOW;
				OnWarnX(strWarnErrorCode);
			}
			if (nWifiLevel != m_stDeviceConfig.nCurrentWifiValue)
			{
				FINFO("Channel:{$},SignalPower:{$},NoisePower:{$},DataRate:{$}",
				m_stDeviceConfig.nWifiChannel, m_stDeviceConfig.nWifiSignalPower, m_stDeviceConfig.nWifiNoisePower, m_stDeviceConfig.nWifiDataRate);
			}
			m_stDeviceConfig.nCurrentWifiValue = nWifiLevel;
			SendWifiValue(nWifiLevel);
			break;
		}
		case EVT_STATUS_BATTERY_VALUE:
		{
			int nBatteryValue = nParam1;

			FINFO("Detector {$} Battery:{$}", nID, nParam1);

			if (nBatteryValue < m_stDeviceConfig.nBatteryLimit)
			{
				if (!m_bBatteryCharging) //如果没有充电；
				{
					strWarnErrorCode = ERR_FPD_BATTERY_LOW;
					OnError(strWarnErrorCode);
					strWarnErrorCode = WAR_FPD_BATTERY_LOW;
					OnWarnX(strWarnErrorCode);
				}

			}
			else if (nBatteryValue < m_stDeviceConfig.nBatteryWarning)
			{
				//battery error
				strWarnErrorCode = ERR_FPD_BATTERY_LOW;
				OnErrorX(strWarnErrorCode);
				strWarnErrorCode = WAR_FPD_BATTERY_LOW;
				//这里需要滤波，如果2次以上都检测到低于告警值才上报该警告
				OnWarn(nID, strWarnErrorCode);
			}
			else
			{
				strWarnErrorCode = ERR_FPD_BATTERY_LOW;
				OnErrorX(strWarnErrorCode);
				strWarnErrorCode = WAR_FPD_BATTERY_LOW;
				OnWarnX(strWarnErrorCode);
			}

			m_stDeviceConfig.nCurrentBatteryValue = nBatteryValue;
			FINFO("Detector {$} Battery Value:{$}", nID, nBatteryValue);

			if (nBatteryValue < m_stDeviceConfig.nBatteryWarning)
			{
				//防止探测器电池电量状态异常跳变
				SendBatteryValue(nBatteryValue);
			}
			else
			{
				SendBatteryValue(nBatteryValue);
			}
			break;
		}
		case EVT_STATUS_BATTERY_CHARGING:
		{
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				m_bBatteryCharging = true;
			}
			else
			{
				m_bBatteryCharging = false;
			}
			break;
		}
		case EVT_STATUS_SHOCK_SENSOR:
		{
			m_nShockCounts = nParam1;
			string strWarn = WAR_FPD_MAX_SHOCK_NUM;
			FINFO("Panel {$} Shock Sensor Number:{$}", nID, m_nShockCounts);

			if ((m_nShockCounts >= m_stDeviceConfig.nMaxShockNumber) && (m_stDeviceConfig.nShockTimes != m_nShockCounts))//避免频繁发送
			{
				FINFO("Reach Max Shock Sensor Number");
				OnWarn(nID, strWarn);
			}
			else
			{
				OnWarnX(strWarn);
			}
			m_stDeviceConfig.nShockTimes = m_nShockCounts;
			break;
		}
		case EVT_STATUS_HALL_SENSOR:
		{
			int nWorkstaion = nParam1;
			FINFO("Update Hall Status : {$} ", nWorkstaion);
			FINFO("Panel {$} WS:{$},Current OGP WS:{$} ", nID, nWorkstaion, m_nWorkStation);

			m_stDeviceConfig.nWorkstation = nWorkstaion;
			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:
		{
			m_strLastError = pszMsg;
			FINFO("Panel {$} LastError {$}", nID, pszMsg);
			break;
		}
		case EVT_STATUS_RESET:
			break;
		default:
			break;
	}
}

//保存RAW图数据
void nsFPD::FPDDeviceYuying::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;
}

void nsFPD::FPDDeviceYuying::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("Image Arrved");
			if (APP_STATUS_IDLE == m_eAppStatus)
			{
				FERROR("Omit Image in Idle Status");
				return;
			}

			FINFO("Currenct FPD RawImage Width: {$}, FullImage Height: {$}", m_nRawImgWidth, m_nRawImgHeight);
			float fImageReferUGY = 2.5;
			if (nullptr == m_pwRawImageData)
			{
				m_pwRawImageData = new WORD[m_nRawImgWidth * m_nRawImgHeight];
			}

			memcpy(m_pwRawImageData, pParam, m_nRawImgWidth * m_nRawImgHeight * sizeof(WORD));
			if (m_bSaveRaw)
			{
				SaveRawImage("YuyingSDK.raw", m_pwRawImageData, m_nRawImgWidth, m_nRawImgHeight);
			}
			OnProcessImage(m_pwRawImageData, m_stDeviceConfig.nFullImageWidth, m_stDeviceConfig.nFullImageHeight, fImageReferUGY);
			break;
		}
		case EVT_DATA_PREVIEW_IMAGE:
		{
			FINFO("Preview Image Arrved");

			m_SyncUnit->ImageReadingNotify();

			if (nullptr == m_pwPreviewImg)
			{
				m_pwPreviewImg = new WORD[m_stDeviceConfig.nPreviewWidth * m_stDeviceConfig.nPreviewHeight];
			}

			memcpy(m_pwPreviewImg, pParam, m_stDeviceConfig.nPreviewWidth * m_stDeviceConfig.nPreviewHeight * sizeof(WORD));
			OnProcessPreviewImage(m_pwPreviewImg, m_stDeviceConfig.nPreviewWidth, m_stDeviceConfig.nPreviewHeight);

			break;
		}
		case EVT_DATA_DOSEPARAM:
		{
			m_fDoseParam = nParam1;// static_cast<int>(fParam2 * 1000);
			FINFO("calibration dose {$}, Param1 {$}", m_fDoseParam, nParam1);
			SetEvent(m_WaitCalibDoseEvt);
			break;
		}
		default:
			break;
	}
}

void nsFPD::FPDDeviceYuying::OnEventProcessError(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	string strErrorName = "";

	switch (nEventID)
	{
		case EVT_ERR_COMMUNICATE:
		{
			strErrorName = ERR_FPD_DISCONNECT;
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				m_stDeviceConfig.nWorkstation = -1;
				m_stDeviceConfig.bConnectStatus = false;
				m_nBatteryCapacity = 0;
				m_stDeviceConfig.nCurrentWifiValue = 0;
				m_stDeviceConfig.nCurrentBatteryValue = 0;

				SendWifiValue(0);
				SendBatteryValue(0);

				//fix 断开连接时温度保留当前值，清除温度相关告警信息
				ProcessTempreatureOnLostCommunicate();

				OnError(strErrorName);
			}
			else if (strTemp.find("false") != std::string::npos)//成功时交给WIFI发送SendDetectorInfo
			{
				if (m_stDeviceConfig.nCurrentWifiValue != -1)
				{
					SendWifiValue(m_stDeviceConfig.nCurrentWifiValue);
					SendBatteryValue(m_stDeviceConfig.nCurrentBatteryValue);
					SendTemperatureValue(m_stDeviceConfig.fCurrentTemperValue);
				}
				m_stDeviceConfig.bConnectStatus = true;
				OnErrorX(strErrorName);
				OnErrorX(ERR_FPD_ACQ_FAILED);//fixbug 12473 开窗失败不用ERR_FPD_RESTART上报
			}
			break;
		}
		case EVT_ERR_EXP_REQUEST:
		{
			string strTemp = pszMsg;
			if (strTemp.find("true") == std::string::npos)
			{
				return;
			}
			strErrorName = ERR_FPD_ACQ_FAILED;
			break;
		}
		case EVT_ERR_GET_IMAGE:
		{
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				if (APP_STATUS_WORK_BEGIN != m_eAppStatus) //如果不在检查界面;
				{
					FWARN("there are image exist in current detector,do you want to continue");
				}
				else
				{
					FWARN("FPD has exposed Image!");
					CallSiemensRecoverAction(true);
				}
			}
			else if (strTemp.find("false") != std::string::npos)
			{
				if (m_bRecoveringImage)
				{
					CallSiemensRecoverAction(false);
				}
				else
				{
					m_bAbortRecover = false; //终止恢复图像的变量也要重置
					m_bRecoveringImage = false; //不再恢复图像过程中
					m_nRecoverImageTimes = 0; //下次恢复图像，重置
					m_bSendRecoverMessage = false; //下次恢复图像仍需判断；
				}
			}
			break;
		}
		case EVT_ERR_MAX_NUMBER:
		{
			strErrorName = ERR_FPD_MAX_NUMBER;
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				FERROR("Exceed max number");
				OnError(strErrorName);
			}
			break;
		}
		case EVT_ERR_SN_NOTINLIST:
		{
			strErrorName = ERR_FPD_SN_NOT_LIST;
			FERROR("Not in List");
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				OnError(strErrorName);
			}
			break;
		}
		case EVT_ERR_POWER_OFF:
		{
			strErrorName = ERR_FPD_POWEROFF;
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				ProcessTempreatureOnLostCommunicate();
				OnError(strErrorName);
				m_stDeviceConfig.bConnectStatus = false;
			}
			else if (strTemp.find("false") != std::string::npos)
			{
				OnErrorX(strErrorName);
			}
			break;
		}
		case EVT_ERR_INIT_FAILED:
		{
			strErrorName = ERR_FPD_FATAL_ERROR;
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				OnError(strErrorName);
				m_stDeviceConfig.bConnectStatus = false;
			}
			else if (strTemp.find("false") != std::string::npos)
			{
				OnErrorX(strErrorName);
			}
			break;
		}
		default:
			break;
	}
}

bool nsFPD::FPDDeviceYuying::OnInitResult(bool bSuccess)
{
	if (bSuccess)
	{
		m_stDeviceConfig.bConnectStatus = true;
		m_stDeviceConfig.bInitOK = true;
	}
	else
	{
		m_stDeviceConfig.bConnectStatus = false;
	}
	m_stDeviceConfig.bExisted = true;
	auto temperuperror = m_stDeviceConfig.fTemperMaxLimit;
	auto temperlowerror = m_stDeviceConfig.fTemperMinLimit;
	auto temperupwarn = m_stDeviceConfig.fTemperUpLimit;
	auto temperlowwarn = m_stDeviceConfig.fTemperLowLimit;
	if (m_Temperature)
	{
		m_Temperature->SetTemperatureErrorMax(to_string(temperuperror));
		m_Temperature->SetTemperatureWarningMax(to_string(temperupwarn));
		m_Temperature->SetTemperatureCalibWarningMax(to_string(m_CalTemperupWarn));
		m_Temperature->SetTemperatureCalibWarningMin(to_string(m_CalTemperlowWarn));
		m_Temperature->SetTemperatureWarningMin(to_string(temperlowwarn));
		m_Temperature->SetTemperatureErrorMin(to_string(temperlowerror));
	}

	auto wifiWarning = m_stDeviceConfig.nWifiWarning;
	auto wifiError = m_stDeviceConfig.nWifiLimit;
	if (m_Wifi)
	{
		m_Wifi->SetSignalWarningMin(to_string(wifiWarning));
		m_Wifi->SetSignalErrorMin(to_string(wifiError));
	}

	return true;
}

//-----------------------------------------------------------------------------
//
// 函数名称	: CheckCalibartionDue
// 函数描述	: 检查校正文件是否过期
// 返回类型	: 过期true or false
// 接口参数	: 
//
//-----------------------------------------------------------------------------
bool nsFPD::FPDDeviceYuying::CheckCalibartionDue()
{
	FINFO("[Checking Calibration Date]");
	string strWarn = WAR_FPD_LOAD_CORRECT_FILE;
	if (!m_CalibProcess->CheckCalibartionDue(m_stDeviceConfig))
	{
		OnWarn(m_nDeviceIndex, strWarn);
		return false;
	}
	OnWarnX(strWarn);
	FINFO("[Calibration File is Normal]");
	return true;
}

bool nsFPD::FPDDeviceYuying::LoadSensitivity()
{
	FINFO("Load Sensitivity.txt");
	string strTemp = m_stDeviceConfig.strPanelSerial + "_Sensitivity.txt";
	string strPath = m_strWorkPath + "\\references\\" + strTemp;

	char* pszSensitivity = nullptr;
	FILE* pFile;
	if ((pFile = fopen(strPath.c_str(), "rb")) == nullptr)
	{
		FINFO("Read {$} File FERROR", strPath.c_str());
		return false;
	}
	FINFO("Open {$} over", strPath.c_str());

	fseek(pFile, 0, SEEK_END);   ///将文件指针移动文件结尾
	long nLen = ftell(pFile); ///求出当前文件指针距离文件开始的字节数

	FINFO("Length is :{$}", nLen);

	pszSensitivity = new char[nLen + 1];
	memset(pszSensitivity, 0, nLen + 1);
	fseek(pFile, 0, SEEK_SET);   ///将文件指针移动文件头

	size_t rLen = fread(pszSensitivity, (size_t)1, nLen, pFile);
	FINFO("read Length is :{$} {$}", rLen, pszSensitivity);

	if (rLen != nLen)
	{
		delete[] pszSensitivity;
		fclose(pFile);
		FINFO("Read Sensitivity info FERROR");
		return false;
	}
	fclose(pFile);

	m_fFactorEXI2UGY = (float)atof(pszSensitivity);
	auto strSensitivity = std::to_string(m_fFactorEXI2UGY);
	m_DetectorCtrlUnit->SetFPDSensitivity(strSensitivity);
	FINFO("Sensitivity is :{$}", m_fFactorEXI2UGY);

	if (pszSensitivity)
	{
		delete[] pszSensitivity;
		pszSensitivity = nullptr;
	}

	FINFO("Read Sensitivity Over");
	return true;
}

RET_STATUS nsFPD::FPDDeviceYuying::SaveSensitivity()
{
	FINFO("Save Sensitivity");
	FINFO("SaveSensitivity DoNothing");
	return RET_STATUS::RET_SUCCEED;
}

//预览图
bool nsFPD::FPDDeviceYuying::OnProcessPreviewImage(WORD* pwRawImage, int nWidth, int nHeight)
{
	FINFO("Currenct PreviewImage Width: {$}, Height: {$}", nWidth, nHeight);

	if (m_stDeviceConfig.nSaveRaw > 1)
	{
		SaveRawImage("PreviewImage.raw", pwRawImage, nWidth, nHeight);
	}
	PrevImageDateArrived(pwRawImage);
	FINFO("Write PreviewImage Over");
	return true;
}

//大图
bool nsFPD::FPDDeviceYuying::OnProcessImage(WORD* pwRawImage, int nImageWidth, int nImageHeight, float fImageReferUGY)
{
	FINFO("Process Full Image");
	FINFO("Image EXI2UGY factor:{$},Image Refer UGY: {$}", m_fFactorEXI2UGY, fImageReferUGY);
	pwRawImage[0] = 65535;
	//图像预处理完成
	FullImageDateArrived(pwRawImage);
	FINFO("Write Frame Over");

	return true;
}

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

	if (!m_pwFullImageData)
	{
		FINFO("Full ImgHeight:{$},Full ImgWidth:{$}", m_stDeviceConfig.nFullImageWidth, m_stDeviceConfig.nFullImageHeight);
		m_pwFullImageData = new WORD[m_stDeviceConfig.nFullImageWidth * m_stDeviceConfig.nFullImageHeight];
	}

	memcpy(m_pwFullImageData, pwInImgData, m_stDeviceConfig.nFullImageWidth * m_stDeviceConfig.nFullImageHeight * sizeof(WORD));
	return true;
}

void nsFPD::FPDDeviceYuying::OnProcessTemperature(int nID, float fTemperature)
{
	string strWarnErrorCode = "";

	auto lowerror = m_stDeviceConfig.fTemperMinLimit;
	auto uperror = m_stDeviceConfig.fTemperMaxLimit;
	auto lowwarn = m_stDeviceConfig.fTemperLowLimit;
	auto upwarn = m_stDeviceConfig.fTemperUpLimit;
	auto calupwarn = m_CalTemperupWarn;
	auto callowwarn = m_CalTemperlowWarn;

	//should be lowerror < lowwarn < callowwarn < calupwarn < upwarn < uperror

	m_stDeviceConfig.nTemperatureStatus = TEMP_NORMAL;

	if (fTemperature > callowwarn && fTemperature < calupwarn)
	{
		//normal,clear all warns&errors
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		OnWarnX(WAR_FPD_TEMPERTURE_LOW);
		OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);
	}
	else if ((fTemperature <= callowwarn && fTemperature > lowwarn)
		|| (fTemperature >= calupwarn && fTemperature < upwarn)
		)
	{
		//out of cal range
		FINFO("Exceed Calibration Temperature");
		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;
		OnWarnX(WAR_FPD_TEMPERTURE_LOW);
		OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

		strWarnErrorCode = WAR_FPD_EXCEED_CALB_TEMPER_HIGH;
		if (fTemperature <= callowwarn && fTemperature > lowwarn)
		{
			OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
			strWarnErrorCode = WAR_FPD_EXCEED_CALB_TEMPER_LOW;
		}
		else
		{
			OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		}

		OnWarn(nID, strWarnErrorCode);
	}
	else if (fTemperature > lowerror && fTemperature <= lowwarn)
	{
		//low warn
		FINFO("Exceed Temperature Low Warning");
		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

		strWarnErrorCode = WAR_FPD_TEMPERTURE_LOW;
		OnWarn(nID, strWarnErrorCode);
	}
	else if (fTemperature <= lowerror)
	{
		//low error
		FINFO("Exceed Min Temperature");
		m_stDeviceConfig.nTemperatureStatus = TEMP_TOO_LOW;
		if (m_stDeviceConfig.bActived)
		{
			OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
			OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
			OnWarnX(WAR_FPD_TEMPERTURE_LOW);
			OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
			OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);

			strWarnErrorCode = ERR_FPD_TEMPLOW_NOT_ACQ;
			OnError(strWarnErrorCode);
		}
	}
	else if (fTemperature >= upwarn && fTemperature < uperror)
	{
		//up warn
		FINFO("Exceed Temperature High Warning");
		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		OnWarnX(WAR_FPD_TEMPERTURE_LOW);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

		strWarnErrorCode = WAR_FPD_TEMPERATURE_HIGH;
		OnWarn(nID, strWarnErrorCode);
	}
	else if (fTemperature >= uperror)
	{
		//up error
		FINFO("Exceed Max Temperature");
		m_stDeviceConfig.nTemperatureStatus = TEMP_TOO_HIGH;
		if (m_stDeviceConfig.bActived)
		{
			OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
			OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
			OnWarnX(WAR_FPD_TEMPERTURE_LOW);
			OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
			OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

			strWarnErrorCode = ERR_FPD_TEMPHIGH_NOT_ACQ;
			OnError(strWarnErrorCode);
		}
	}
}

void nsFPD::FPDDeviceYuying::Action_ExpReady()
{
	m_SyncUnit->FPDReadyNotify(true);
}

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

RET_STATUS nsFPD::FPDDeviceYuying::SetSID(int nSID)
{
	if (nSID < 0 || nSID>200)
	{
		return RET_STATUS::RET_INVALID;
	}
	m_stDeviceConfig.nSID = nSID;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsFPD::FPDDeviceYuying::GetRecoverImageState(string& RCI)
{
	FINFO("GetRecoverImageState");
	m_bSendRecoverMessage = true;
	RCI = m_RecoverImageStatus.encode();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceYuying::RecoverImage(bool bRecoverIt)
{
	FINFO("Recover Image {$}", bRecoverIt);
	m_bUIConfirmRecover = true;
	int nRecoverOrNot = 0;
	if (bRecoverIt)
	{
		nRecoverOrNot = 1;
	}
	if (nRecoverOrNot != 0)
	{
		string strResult = (string)m_RecoverImageStatus["Result"];
		if (strResult == "0")
		{
			FINFO("already recover success,just return");
			return RET_STATUS::RET_SUCCEED;
		}

		m_RecoverImageStatus["Result"] = "1";
		m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());

		if (!(g_pYuyingCtrl)->RecoverLastImage())
		{
			m_RecoverImageStatus["Result"] = "2";
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());
			m_bUIConfirmRecover = false;
		}
		m_nRecoverImageTimes++;
	}
	else
	{
		FINFO("Abort Recovering Image");
		m_bAbortRecover = true; //终止恢复图像的变量也要重置
		m_bRecoveringImage = false; //不再恢复图像过程中
		m_nRecoverImageTimes = 0; //下次恢复图像，重置
		m_bSendRecoverMessage = false; //下次恢复图像仍需判断；
		if (m_stDeviceConfig.bConnectStatus)
		{
			if (m_bImagePendingOrNot)
			{
				OnError(ERR_FPD_IMAGE_PENDING);
			}
			else
			{
				OnErrorX(ERR_FPD_IMAGE_PENDING);
			}
		}
		else
		{
			OnError(ERR_FPD_IMAGE_PENDING);
			OnError(ERR_FPD_DISCONNECT);
		}
	}
	return RET_STATUS::RET_SUCCEED;
}

bool nsFPD::FPDDeviceYuying::CallSiemensRecoverAction(bool bErrorResult)
{
	string strRecoverInfo = "";
	if (bErrorResult)
	{
		if (m_bAbortRecover)
		{
			FINFO("Recover Image is Cancelled");
			return true;
		}

		SendWifiValue(0);
		SendBatteryValue(0);
		SendTemperatureValue(ABS_ZERO_TEMPERATURE);

		if (!m_bRecoveringImage)
		{
			m_RecoverImageStatus["Result"] = "-1";//新的imagerecover流程开始，防止之前成功recover过，上层查询状态引发误解
			m_DetectorCtrlUnit->SetRecoverImageEvent("0");
			OnError(ERR_FPD_IMAGE_PENDING);
			m_bRecoveringImage = true;
			m_bUIConfirmRecover = false;

			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());

			FINFO("SetRecoverImageEvent");

			return true;
		}
		m_RecoverImageStatus["Result"] = "2";
	}
	else
	{
		m_bAbortRecover = false; //终止恢复图像的变量也要重置
		m_bRecoveringImage = false; //不再恢复图像过程中
		m_nRecoverImageTimes = 0; //下次恢复图像，重置
		m_bSendRecoverMessage = false; //下次恢复图像仍需判断；
		if (m_bUIConfirmRecover)
		{
			FINFO("Recover Image Success");
			m_RecoverImageStatus["Result"] = "0";
			FINFO("m_RecoverImageStatus[Result] = 0");
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());
			m_bUIConfirmRecover = false;
			FINFO("send RecoverImageState over");
		}
		else
		{
			m_RecoverImageStatus["Result"] = "3";
			FINFO("m_RecoverImageStatus[Result] = 3");
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());
			FWARN("UI do not confirm, image have been abandoned");
			m_RecoverImageStatus["Result"] = "0";
			m_AcqUnit->SendNoNeedWaitImage(true);
		}
		return true;
	}

	FINFO("CallSiemensRecoverAction {$}", m_RecoverImageStatus.encode());
	if (m_bSendRecoverMessage)
	{
		if (m_bUIConfirmRecover)
		{
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());
			m_bUIConfirmRecover = false;
			FINFO("send RecoverImageState over");
		}
		else
		{
			FWARN("UI do not confirm omit send result");
		}
	}

	return true;
}

string nsFPD::FPDDeviceYuying::MakeImageHead(IMAGE_VIEW_TYPE Type)
{
	if (Type == IMAGE_FULL)
	{
		if (m_pFullImageHead == nullptr)
		{
			m_pFullImageHead = new ResDataObject;
			ResDataObject json;
			json.add(SM_IMAGE_TYPE, (int)Type);
			json.add(SM_IMAGE_WIDTH, m_stDeviceConfig.nFullImageWidth);
			json.add(SM_IMAGE_HEIGHT, m_stDeviceConfig.nFullImageHeight);
			json.add(SM_IMAGE_BIT, 16);
			json.add(SM_IMAGE_TAG, 1);
			json.add(SM_IMAGE_INDEX, 1);
			json.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
			json.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
			json.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
			json.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
			json.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
			json.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
			json.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
			json.add(SM_IMAGE_LSB, "5000");
			json.add(SM_IMAGE_DOSE, m_stDeviceConfig.nDoseOfEXI);
			json.add(SM_IMAGE_PIXELREPRESENTATION, "0");
			json.add(SM_IMAGE_PIXELSPACING, m_stDeviceConfig.nPixelSpace);
			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_EXI2UGY, m_fFactorEXI2UGY);
			json.add(SM_IMAGE_TEMP, m_stDeviceConfig.fCurrentTemperValue);
			m_pFullImageHead->add(SM_IMAGE_HEAD, json);
		}
		else
		{
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_YEAR] = m_stImgCreateTime.wYear;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MONTH] = m_stImgCreateTime.wMonth;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_DAY] = m_stImgCreateTime.wDay;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_HOUR] = m_stImgCreateTime.wHour;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MINUTE] = m_stImgCreateTime.wMinute;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_SEC] = m_stImgCreateTime.wSecond;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MILLSEC] = m_stImgCreateTime.wMilliseconds;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_TEMP] = m_stDeviceConfig.fCurrentTemperValue;
		}
		return (*m_pFullImageHead).encode();
	}
	else
	{
		if (m_pPreviewImageHead == nullptr)
		{
			m_pPreviewImageHead = new ResDataObject;
			ResDataObject json;
			json.add(SM_IMAGE_TYPE, (int)Type);
			json.add(SM_IMAGE_WIDTH, m_stDeviceConfig.nPreviewWidth);
			json.add(SM_IMAGE_HEIGHT, m_stDeviceConfig.nPreviewHeight);
			json.add(SM_IMAGE_BIT, 16);
			json.add(SM_IMAGE_TAG, 1);
			json.add(SM_IMAGE_INDEX, 1);
			json.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
			json.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
			json.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
			json.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
			json.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
			json.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
			json.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
			json.add(SM_IMAGE_LSB, "5000");
			json.add(SM_IMAGE_DOSE, m_stDeviceConfig.nDoseOfEXI);
			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_stDeviceConfig.nPixelSpace);
			json.add(SM_IMAGE_PIXELREPRESENTATION, "0");
			json.add(SM_IMAGE_TEMP, m_stDeviceConfig.fCurrentTemperValue);
			m_pPreviewImageHead->add(SM_IMAGE_HEAD, json);
		}
		else
		{
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_YEAR] = m_stImgCreateTime.wYear;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MONTH] = m_stImgCreateTime.wMonth;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_DAY] = m_stImgCreateTime.wDay;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_HOUR] = m_stImgCreateTime.wHour;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MINUTE] = m_stImgCreateTime.wMinute;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_SEC] = m_stImgCreateTime.wSecond;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MILLSEC] = m_stImgCreateTime.wMilliseconds;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_TEMP] = m_stDeviceConfig.fCurrentTemperValue;
		}
		return (*m_pPreviewImageHead).encode();
	}
	return "";
}

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

void nsFPD::FPDDeviceYuying::ClearAllError()
{
	m_WarnAndError->ClearAllError();
}

void nsFPD::FPDDeviceYuying::SyncErrorList()
{
	if (m_WarnAndError)
	{
		m_WarnAndError->SyncErrorList();
	}
}

void nsFPD::FPDDeviceYuying::OnErrorX(string strErrCode)
{
	bool bExit = false;
	if (m_WarnAndError->IsErrorExist(strErrCode))
	{
		bExit = true;
	}

	m_WarnAndError->OnErrorX(strErrCode);
}

void nsFPD::FPDDeviceYuying::OnError(string strErrCode, string strErr)
{
	string strBackCom = "";
	m_WarnAndError->OnError(strErrCode, strErr);
}

void nsFPD::FPDDeviceYuying::OnWarn(int nIndex, string strWarnCode, string strWarn)
{
	m_WarnAndError->OnWarn(strWarnCode, strWarn);
}

void nsFPD::FPDDeviceYuying::OnWarnX(string strWarnCode)
{
	m_WarnAndError->OnWarnX(strWarnCode);
}

RET_STATUS  nsFPD::FPDDeviceYuying::ResetError()
{
	FINFO("ResetError");
	OnErrorX(ERR_FPD_DOSE_LOW);
	OnErrorX(ERR_FPD_DOSE_HIGH);
	OnErrorX(ERR_FPD_DOSE_OBJ); //清除之前的错误，如果有的话

	return RET_STATUS::RET_SUCCEED;
}

void nsFPD::FPDDeviceYuying::SendAllError()
{
	m_WarnAndError->SendAllError();
}

void nsFPD::FPDDeviceYuying::ProcessTempreatureOnLostCommunicate()
{
	SendTemperatureValue(ABS_ZERO_TEMPERATURE);

	OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
	OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
	OnWarnX(WAR_FPD_TEMPERTURE_LOW);
	OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
	OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
	OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);
	OnWarnX(WAR_FPD_WIFI_LOW);
	OnWarnX(WAR_FPD_BATTERY_LOW);
	OnErrorX(ERR_FPD_WIFI_LOW);
	OnErrorX(ERR_FPD_BATTERY_LOW);
}

void nsFPD::FPDDeviceYuying::ResetAllError()
{
	OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
	OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
	OnWarnX(WAR_FPD_TEMPERTURE_LOW);
	OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
	OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
	OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);
	OnWarnX(WAR_FPD_LOAD_CORRECT_FILE);
	OnWarnX(WAR_FPD_WIFI_LOW);
	OnWarnX(WAR_FPD_MAX_SHOCK_NUM);
	OnWarnX(WAR_FPD_IN_INITIAL);
	OnWarnX(WAR_FPD_ATTACH_PMS_LOGOUT);
	OnWarnX(WAR_FPD_BATTERY_LOW);
	OnErrorX(ERR_FPD_WIFI_LOW);
	OnErrorX(ERR_FPD_BATTERY_LOW);
	OnErrorX(ERR_FPD_DISCONNECT);
	OnErrorX(ERR_FPD_POWEROFF);
	OnErrorX(ERR_FPD_ACQ_FAILED);
	OnErrorX(ERR_FPD_DOSE_LOW);
	OnErrorX(ERR_FPD_DOSE_HIGH);
	OnErrorX(ERR_FPD_DOSE_OBJ);
	OnErrorX(ERR_FPD_IMAGE_PENDING);
	OnErrorX(ERR_FPD_FATAL_ERROR);
	OnErrorX(LASTERR_ATTACH_FAIL_WITHIMG);
	OnErrorX(LASTERR_ATTACH_FAIL_BATTERYLOW);
}

RET_STATUS nsFPD::FPDDeviceYuying::SetCorrectionType(CCOS_CORRECTION_TYPE in)
{
	return RET_STATUS::RET_SUCCEED;
}