PhysicalDevice/Detector/RunZe/DIOS.Dev.UltrasonicProbe/DIOS.Dev.FPD.UltrasonicProbeDR.cpp

#include "stdafx.h"
#include "CCOS.Dev.FPD.UltrasonicProbeDR.h"
#include "common_api.h"
#include "DICOMImageHeadKey.h"
#include "UltrasonicProbeCtrl.h"
#include <sys/stat.h>


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

//-----------------------------------------------------------------------------
//		FPDDeviceUltrasonicProbe
//-----------------------------------------------------------------------------
extern UltrasonicProbe* g_pDetector;


//-----------------------------------------------------------------------------
//		GetIODriver & CreateIODriver
//-----------------------------------------------------------------------------
static nsFPD::UltrasonicProbeDriver  gIODriver;

Log4CPP::Logger* gLogger = nullptr;

/// <summary>
///  [DONE.CHECKED.]
/// </summary>
/// <returns></returns>
extern "C"  CCOS::Dev::IODriver * __cdecl GetIODriver()		// 返回静态对象的引用, 调用者不能删除 !
{
	return &gIODriver;
}

/// <summary>
/// [DONE.TO BE TESTED.]
/// </summary>
/// <returns></returns>
extern "C"  CCOS::Dev::IODriver * __cdecl CreateIODriver()  // 返回新对象, 调用者必须自行删除此对象 !
{
	return new nsFPD::UltrasonicProbeDriver();
}

/// <summary>
/// 驱动构造函数
///  [DONE.CHECKED.]
/// </summary>
nsFPD::UltrasonicProbeDriver::UltrasonicProbeDriver()
{
	m_pObjDev = nullptr;
	m_bDriverConnect = false; //缺省为false
	m_pAttribute.reset(new ResDataObject());
	m_pDescription.reset(new ResDataObject());
}

/// <summary>
/// 析构函数
/// </summary>
nsFPD::UltrasonicProbeDriver::~UltrasonicProbeDriver()
{
	if (m_pObjDev != nullptr)
	{
		delete m_pObjDev;
		m_pObjDev = nullptr;
	}
}

/// <summary>
/// 驱动的准备，可以做一些特殊的操作
/// [DONE.CHECKED.] TBD.
/// </summary>
void nsFPD::UltrasonicProbeDriver::Prepare()
{
	printf("UltrasonicProbeDriver prepare \r\n");
	string strLogPath = GetProcessDirectory() + R"(\OEMDrivers\Detector\Conf\Log4CPP.Config.FPD.xml)";

	Log4CPP::GlobalContext::Map::Set(ZSKK::Utility::Hash("LogFileName"), "FPD.UltrasonicProbeDR");

	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
	gLogger = Log4CPP::LogManager::GetLogger("FPD.UltrasonicProbeDR");

	Info("------------------------UltrasonicProbeDriver Prepare ------------------------");
}

/// <summary>
/// 驱动的连接，创建设备对象
/// [DONE.CHECKED.] TBD. 重复执行？
/// </summary>
/// <returns></returns>
bool nsFPD::UltrasonicProbeDriver::Connect()
{
	printf("UltrasonicProbe driver module: Connect \r\n");
	Info("--Func-- driver connect \n");

	m_pObjDev = new FPDDeviceUltrasonicProbe(EventCenter, m_ConfigFileName);
	m_bDriverConnect = true; //connect执行完毕，置为true
	printf("UltrasonicProbe driver module: Connect over\r\n");
	return true;
}

/// <summary>
///  驱动断开连接，释放设备对象
/// </summary>
void nsFPD::UltrasonicProbeDriver::Disconnect()
{
	printf("UltrasonicProbe driver module: Disconnect \r\n");
	Info("--Func-- driver disconnect \n");
	if (m_pObjDev != nullptr)
	{
		delete m_pObjDev;
		m_pObjDev = nullptr;
	}

	m_bDriverConnect = false; //disconnect置为false
}


bool nsFPD::UltrasonicProbeDriver::isConnected() const
{
	printf("UltrasonicProbe driver module: isConnected \r\n");
	return m_bDriverConnect;
}

/// <summary>
/// 驱动创建设备丢下，然后 给 上层返回 IODevice 对象指针
/// [DONE.CHECKED.]
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
auto nsFPD::UltrasonicProbeDriver::CreateDevice(int index)->std::unique_ptr <IODevice>
{
	printf("UltrasonicProbe driver module: CreateDevice \r\n");
	Info("--Func-- driver createdevice \n");
	auto Device = std::unique_ptr<IODevice>(new IODevice(m_pObjDev));
	m_pObjDev->CreateDevice();
	m_pObjDev->Register();
	return Device;
}

/// <summary>
///  驱动信息检索 TODO ： 需要重新定义
/// </summary>
/// <returns></returns>
std::string nsFPD::UltrasonicProbeDriver::DriverProbe()
{
	printf("UltrasonicProbe driver module: Driver Probe \r\n");
	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", "Detector");
		HardwareInfo.add("MinorID", "DM");
		HardwareInfo.add("VendorID", "UltrasonicProbe");
		HardwareInfo.add("ProductID", "UltrasonicProbe");
		HardwareInfo.add("SerialID", "Driver");
	}
	string str = HardwareInfo.encode();
	Info("DriverProbe HardwareInfo:{$}", str);
	return str;
}


/***
** 获取ID和配置
***/

/// <summary>
/// 从配置文件中返回给上层 配置对象
/// 标准代码
/// [DONE.CHECKED.]
/// </summary>
/// <returns></returns>
std::string nsFPD::UltrasonicProbeDriver::GetResource()
{
	printf("UltrasonicProbeDriver GetResource,m_ConfigFileName:%s\r\n", m_ConfigFileName.c_str());
	Info("UltrasonicProbeDriver GetResource,m_ConfigFileName:{$}", m_ConfigFileName);
	ResDataObject r_config, temp;
	if (!temp.loadFile(m_ConfigFileName.c_str()))
	{
		Error("GetResource loadfile error!");
		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");
		//Info(g_pFPDCtrlLog, "ConfigInfo Count: {$}", nConfigInfoCount);
		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());
			//Info("DescriptionTemp--> {$}: {$}", 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];
					//sprintf_s(sstream, "{$}", 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)
	{
		Error("Get config error: {$}", 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 str_DeviceConfig = DescriptionTempEx.encode();

	//Info("GetResource over,str_DeviceConfig:{$}", str_DeviceConfig);
	printf("UltrasonicProbe driver module: get resource over \r\n");
	return str_DeviceConfig;
}

/// <summary>
/// 设备信息检索 TODO ： 需要重新定义，TBD.
/// </summary>
/// <returns></returns>
std::string nsFPD::UltrasonicProbeDriver::DeviceProbe()
{
	printf("UltrasonicProbe driver module: Device Probe \r\n");
	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", "UltrasonicProbe");
		HardwareInfo.add("ProductID", "UltrasonicProbe");
		HardwareInfo.add("SerialID", "1234");
	}
	string str = HardwareInfo.encode();
	Info("DeviceProbe HardwareInfo:{$}", str);
	return str;
}

/// <summary>
/// 设备配置读取接口
/// [DONE.CHECKED.]
/// </summary>
/// <param name="Cfg"></param>
/// <returns></returns>
bool nsFPD::UltrasonicProbeDriver::GetDeviceConfig(std::string& Cfg)
{
	Cfg = m_DeviceConfig.encode();
	Info("GetDeviceConfig over");
	return true;
}

/// <summary>
/// 提供给web配置中心的 配置写入接口
/// [DONE.CHECKED.]
/// </summary>
/// <param name="Cfg"></param>
/// <returns></returns>
bool nsFPD::UltrasonicProbeDriver::SetDeviceConfig(std::string Cfg)
{
	Info("--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];
		Info("{$}", temp.encode());
		for (int j = 0; j < temp.size(); j++)
		{
			string strKey = temp.GetKey(j);
			Info("strKey:{$}", 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");
						Info("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
					{
						Info("{$} is not a RW configuration item", strKey.c_str());
					}
				}
			}
			catch (ResDataObjectExption& e)
			{
				Error("SetDriverConfig crashed: {$}", e.what());
				return false;
			}
		}
	}

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

/// <summary>
/// 保存配置到文件
/// [DONE.TO BE TESTED.]
/// </summary>
/// <param name="bSendNotify"></param>
/// <returns></returns>
bool nsFPD::UltrasonicProbeDriver::SaveConfigFile(bool bSendNotify)
{
	m_ConfigAll["CONFIGURATION"] = m_Configurations;
	m_ConfigAll.SaveFile(m_ConfigFileName.c_str());
	Info("SaveConfigFile over,m_ConfigAll:{$}", m_ConfigAll.encode());
	return true;
}

/// <summary>
///  读取当前配置项
///  TBD. 审视参数列表
/// </summary>
/// <param name="config"></param>
/// <param name="pInnerKey"></param>
/// <param name="nPathID"></param>
/// <param name="strValue"></param>
/// <returns></returns>
bool nsFPD::UltrasonicProbeDriver::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 || RawImgWidth == strTemp || RawImgHeight == strTemp)
		{
			strValue = (string)config["ModeTable"]["DetectorMode"][pInnerKey];
		}
		else if (TempMaxLimit == strTemp || TempMinLimit == strTemp || TempUpperLimit == strTemp 
			|| TempLowerLimit == strTemp || ReConnect == 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 || OnlyHaveFpd == strTemp)
		{
			strValue = (string)config[pInnerKey];
		}
		else
		{
			strValue = "";
			Warn("Error Configuration item: {$}", pInnerKey);
		}
	}
	return true;
}

/// <summary>
/// 设置写入设备参数实现，这里过滤需要设置本探测器接受的参数
/// 参数项和内容来源于 探测器配置文件 <ConfigToolInfo> <AttributeInfo>
/// TBD. 具体内容
/// comment by chenggw 2023.2.7
/// </summary>
/// <param name="config"></param>
/// <param name="pInnerKey"></param>
/// <param name="nPathID"></param>
/// <param name="szValue"></param>
/// <returns></returns>
bool nsFPD::UltrasonicProbeDriver::SetDeviceConfigValue(ResDataObject& config, const char* pInnerKey,
	int nPathID, const char* szValue)
{
	string strTemp = pInnerKey;
	Info("Begin to change {$} item value to {$}", pInnerKey, szValue);
	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 || RawImgWidth == strTemp || RawImgHeight == strTemp)
		{
			config["ModeTable"]["DetectorMode"][pInnerKey] = szValue;
		}
		else if (TempMaxLimit == strTemp || TempMinLimit == strTemp || TempUpperLimit == strTemp
			|| TempLowerLimit == strTemp || ReConnect == 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 || OnlyHaveFpd == strTemp)
		{
			config[pInnerKey] = szValue;
		}
		else
		{
			Warn("Error Configuration item: {$}", pInnerKey);
			return false;
		}
	}
	return true;
}


nsFPD::FPDDeviceUltrasonicProbe::FPDDeviceUltrasonicProbe(std::shared_ptr<IOEventCenter> center, std::string strConfigPath) 
{
	m_DetectorCtrlUnit.reset(new UltrasonicProbeCtrlUnit(center, this));
	m_AcqUnit.reset(new UltrasonicProbeAcq(center, this));
	m_SyncUnit.reset(new UltrasonicProbeSync(center, this));
	m_CalibUnit.reset(new UltrasonicProbeCalib(center, this));
	m_DetectorConfiguration.reset(new DetectorConfiguration(strConfigPath));

	m_pDetectors = nullptr;
	m_strWorkPath = GetProcessDirectory();
	m_nHavePreview = 0;
	m_nPreImgWidth = 0; 
	m_nPreImgHeight = 0; 
	m_nPreImageBits = 0;
	m_nImageWidth = 0;
	m_nImageHeight = 0;
	m_nImageBits = 0; 
	m_nPixelSpacing = 0;
	m_nSensitivity = 0;
	m_eAppStatus = APP_STATUS_IDLE;
	m_bConnect = false;
	m_pwRawImageData = nullptr;
	m_pwPreviewImg = nullptr;
	m_eSyncMode = SYNC_AED;
	m_pFullImageHead = nullptr;
	m_pPreviewImageHead = nullptr;
	m_fFactorEXI2UGY = 0.0f;
	m_bForceGridSuppress = false;
	m_bAttached = false;
	m_nBatteryCapacity = 0;
	m_nBatteryCharges = 0;
	m_fBatteryTemperature = 0.0f;
	m_bResetDetector = false;
	m_nShockCounts = 0;
	m_bOnlyHaveFpd = false;
	
	m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_INIT);
	m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_STANDBY);
	//m_WaitCalibDoseEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
	//m_PauseCalibrationEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
	//m_UploadCalibMapOver = CreateEvent(NULL, FALSE, FALSE, NULL);
	EventCenter = center;
}


nsFPD::FPDDeviceUltrasonicProbe::~FPDDeviceUltrasonicProbe()
{
	if (m_pwRawImageData)
	{
		delete m_pwRawImageData;
		m_pwRawImageData = nullptr;
	}
	if (m_pwPreviewImg)
	{
		delete m_pwPreviewImg;
		m_pwPreviewImg = nullptr;
	}
	//if (m_WaitCalibDoseEvt)
	//{
	//	CloseHandle(m_WaitCalibDoseEvt);
	//	m_WaitCalibDoseEvt = nullptr;
	//}
	//if (m_PauseCalibrationEvt)
	//{
	//	CloseHandle(m_PauseCalibrationEvt);
	//	m_PauseCalibrationEvt = nullptr;
	//}
	//if (m_UploadCalibMapOver)
	//{
	//	CloseHandle(m_UploadCalibMapOver);
	//	m_UploadCalibMapOver = nullptr;
	//}
}


std::string nsFPD::FPDDeviceUltrasonicProbe::GetGUID() const
{
	printf("UltrasonicProbe device module: GetGUID \r\n");
	Info("================Device GetGUID");
	return UltrasonicUnitType;
}


bool nsFPD::FPDDeviceUltrasonicProbe::Prepare()
{
	printf("UltrasonicProbe device module: Prepare \r\n");
	Info("================ device prepare");
	//const char *pQueName, DWORD BlockSize, DWORD FulBlockCount, DWORD PrevBlockSize, DWORD PrevBlockCount
	EventCenter->OnMaxBlockSize("UsQue", m_stDeviceConfig.nRawWidth * m_stDeviceConfig.nRawHeight * 4, 50, 1500 * 1500 * 2, 1);
	Connect();
	return true;
}


bool nsFPD::FPDDeviceUltrasonicProbe::CreateDevice()
{
	printf("--Func-- CreateDevice \r\n");
	Info("================ CreateDevice");
	if (!LoadConfig())
	{
		return false;
	}

	if (nullptr == g_pDetector)
	{
		if (nullptr == m_pDetectors)
		{
			m_pDetectors = new UltrasonicProbe();
			Info("Create SDK ctrl ok\n");
			g_pDetector = (UltrasonicProbe*)m_pDetectors;
		}
	}
	else
	{
		m_pDetectors = g_pDetector;
		Error("SDK ctrl Already exit\n");
	}
	g_pDetector->DriverEntry(this, m_DetectorConfiguration->m_Configurations);
	return true;
}


void nsFPD::FPDDeviceUltrasonicProbe::Register()
{
	Info("================ Register");
	auto Disp = &Dispatch;

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


RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::Connect()
{
	printf("==========Fun Connect ========== \r\n");
	Info("================ Connect");
	RET_STATUS ret = RET_STATUS::RET_FAILED;
	Info("Connect m_strWorkPath:{$}", m_strWorkPath.c_str());
	if (g_pDetector->Connect(this, m_strWorkPath.c_str()))
	{
		m_bConnect = true;
		ret = RET_STATUS::RET_SUCCEED;
	}
	return ret;
}


RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::EnterExam(int nExamMode)
{
	Info("--Func-- EnterExam {$}", nExamMode);
	switch (nExamMode)
	{
	case APP_STATUS_WORK_BEGIN:
		Info("Enter into Exam Windows");
		m_eAppStatus = APP_STATUS_WORK_BEGIN;
		break;
	case APP_STATUS_WORK_END:
		Info("Quit Exam Windows");
		m_eAppStatus = APP_STATUS_WORK_END;
		break;
	case APP_STATUS_DETSHARE_BEGIN:
		Info("Enter into Detector Share Windows");
		m_eAppStatus = APP_STATUS_DETSHARE_BEGIN;
		break;
	case APP_STATUS_DETSHAR_END:
		m_eAppStatus = APP_STATUS_IDLE;
		Info("Quit Detector Share Windows");
		m_eAppStatus = APP_STATUS_DETSHAR_END;
		break;
	case APP_STATUS_CAL_BEGIN:
		Info("Enter into Calibration Windows");
		m_eAppStatus = APP_STATUS_CAL_BEGIN;
		break;
	case APP_STATUS_CAL_END:
		Info("Quit Calibration Windows");
		m_eAppStatus = APP_STATUS_CAL_END;
		break;
	case APP_STATUS_WORK_IN_SENSITIVITY:
		Info("Enter into sensitivity test interface");
		m_eAppStatus = APP_STATUS_WORK_IN_SENSITIVITY;
		break;
	default:
		break;
	}

	return RET_STATUS::RET_SUCCEED;
}


/***
* 这是切换探测器的接口
***/
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::ActiveDetector(int nDetectorIndex, bool bActive)
{
	printf("--Func-- ActiveDetector(%d) to (%d) \r\n", nDetectorIndex, bActive);
	Info("--Func-- ActiveDetector nDetectorIndex:{$} to bActive:{$}", nDetectorIndex, bActive);
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;

	if (g_pDetector == nullptr)
	{
		printf("UltrasonicProbe object is not exist, return RET_FAILED\n");
		Info("UltrasonicProbe object is not exist, return RET_FAILED");
		return RET_STATUS::RET_FAILED;
	}
	
	return ret;
}

//设置采集模式 1-RAD点片 3-动态点片(DROC中是DDR DFOC中就是CF PF)
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetAcqMode(int nMode)
{
	printf("--Func-- SetAcqMode %d \n", nMode);
	Info("--Func-- SetAcqMode {$}", nMode);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//如果没连接则返回
	if (!m_bConnect)
	{
		Error("Detector not connected, return");
		return ret;
	}

	try
	{
		ResDataObject objModeConfig = m_DetectorConfiguration->m_Configurations;
		int nModeCount = (int)objModeConfig["ModeTable"].GetKeyCount("DetectorMode");
		for (int i = 0; i < nModeCount; i++)
		{
			int nLogicMode = (int)objModeConfig["ModeTable"][i]["LogicMode"];
			if (nLogicMode == nMode)
			{
				printf("find LogicMode == AcqMode\n");
				Info("find LogicMode == AcqMode == {$}", nLogicMode);
				m_nHavePreview = (int)objModeConfig["ModeTable"][i]["HavePreview"];
				m_nPreImgWidth = (int)objModeConfig["ModeTable"][i]["PreviewImageWidth"];
				m_nPreImgHeight = (int)objModeConfig["ModeTable"][i]["PreviewImageHeight"];
				m_nPreImageBits = (int)objModeConfig["ModeTable"][i]["PreviewImageBit"];
				m_nImageWidth = (int)objModeConfig["ModeTable"][i]["RawImgWidth"];
				m_nImageHeight = (int)objModeConfig["ModeTable"][i]["RawImgHeight"];
				m_nImageBits = (int)objModeConfig["ModeTable"][i]["PhySizeInfoBit"];
				m_nPixelSpacing = (int)objModeConfig["ModeTable"][i]["PixelPitch"];
				m_eSyncMode = (SYNC_MODE)(int)objModeConfig["ModeTable"][i]["SyncType"];

				Info("config file SyncType:{$}", (int)m_eSyncMode);
				m_AcqUnit->SetFulImageInfo(m_nImageHeight, m_nImageWidth, m_nImageBits, false);
				if (m_nHavePreview)
				{
					Info("SetAcqMode get preview image width:{$} Height:{$}", m_nPreImgWidth, m_nPreImgHeight);
					m_AcqUnit->SetPrevImageInfo(true, m_nPreImgHeight, m_nPreImgWidth, false);
					if (m_pwPreviewImg)
					{
						delete m_pwPreviewImg;
						m_pwPreviewImg = NULL;
					}
					int severalTimes = m_nPreImageBits / 8;
					m_pwPreviewImg = new unsigned char[m_nPreImgWidth * m_nPreImgHeight * severalTimes];
				}
				else 
				{
					m_AcqUnit->SetPrevImageInfo(false, 0, 0, false);
				}
				Info("SetAcqMode get full image width:{$} Height:{$}", m_nImageWidth, m_nImageHeight);
				if (m_pwRawImageData)
				{
					delete m_pwRawImageData;
					m_pwRawImageData = NULL;
				}
				m_pwRawImageData = new unsigned char[m_nImageWidth * m_nImageHeight * 3];//Ctrl回调回来时肯定是24位的
				
				if (((UltrasonicProbe*)m_pDetectors)->SelectExamMode(nLogicMode, this))
				{
					ret = RET_STATUS::RET_SUCCEED;
				}
				else 
				{
					Error("SetAcqMode SelectExamMode fail!!");
				}
				break;
			}
		}
	}
	catch (ResDataObjectExption& e)
	{
		Error("Read configuration failed, Error code: {$}", e.what());
	}

	return ret;
}

RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::PrepareAcquisition()
{
	printf("--Func-- PrepareAcquisition \n");
	Info("================ PrepareAcquisition");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		Error("Detector not connected, return");
		return ret;
	}

	if (DETECTOR_STATUS_STANDBY == m_DetectorCtrlUnit->GetDetectorStatus())
	{
		printf("Detector already at standby status.\n");
		Error("Detector already at standby status");
		ret = RET_STATUS::RET_SUCCEED; 
	}
	else
	{
		Info("FPDReadyNotify(false)");
		m_SyncUnit->FPDReadyNotify(false); //prepare前置为初值
		if (g_pDetector->PrepareAcquisition(this))
		{
			ret = RET_STATUS::RET_SUCCEED;
			Info("FPDReadyNotify(true)");
			m_SyncUnit->FPDReadyNotify(true); //prepare succeed
		}
	}
	//m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
	Info("================ PrepareAcquisition over");
	return ret;
}


RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::StartAcquisition(string in)
{
	printf("--Func-- StartAcquisition \n");
	Info("================ StartAcquisition");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		Error("Detector not connected, return");
		return ret;
	}

	if (g_pDetector->StartAcquisition(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_ACQ);
	}
	else
	{
		printf("StartAcquisition fail!\n");
		Info("StartAcquisition fail!");
		m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
	}
	Info("================ StartAcquisition over");
	return ret;
}


RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::StopAcquisition()
{
	printf("--Func-- StopAcquisition \n");
	Info("================ StopAcquisition");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		Error("Detector not connected, return");
		return ret;
	}

	if (DETECTOR_STATUS_STANDBY == m_DetectorCtrlUnit->GetDetectorStatus())
	{
		printf("Detector status already is standby\n");
		Info("Detector status already is standby");
		ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		printf("StopAcquisition 111\n");
		Info("StopAcquisition 111");
		if (g_pDetector->StopAcquisition(this))
		{
			ret = RET_STATUS::RET_SUCCEED;
			m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
		}
	}
	Info("================ StopAcquisition over");
	return ret;
}


//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::ActiveCalibration(CCOS_CALIBRATION_TYPE eType)
//{
//	printf("--Func-- ActiveCalibration %d \n", eType);
//	Info("==============================ActiveCalibration type {$}", (int)eType);
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	if (!m_bConnect)
//	{
//		printf("Detector not connected, return\n");
//		Error("Detector not connected, return");
//		return ret;
//	}
//
//	if (eType == CCOS_CALIBRATION_TYPE_NONE || eType == CCOS_CALIBRATION_TYPE_MAX)
//	{
//		return RET_STATUS::RET_INVALID;
//	}
//
//	if (DETECTOR_STATUS_STANDBY != m_DetectorCtrlUnit->GetDetectorStatus())
//	{
//		printf("detector status is not standby!\n");
//		Error("detector status is not standby!");
//		if (DETECTOR_STATUS_ACQ == m_DetectorCtrlUnit->GetDetectorStatus())
//		{
//			printf("ActiveCalibration->Detector at Acq status need stop acquisition\n");
//			Error("ActiveCalibration->Detector at Acq status need stop acquisition");
//			printf("ActiveCalibration stop acquisition\n");
//			Error("ActiveCalibration stop acquisition");
//			ret = StopAcquisition();
//			if (ret != RET_STATUS::RET_SUCCEED)
//			{
//				printf("stop acquisition error\n");
//				Error("stop acquisition error");
//				return ret;
//			}
//		}
//	}
//
//	m_eAppStatus = APP_STATUS_CAL_BEGIN;
//
//	if (eType == CCOS_CALIBRATION_TYPE_XRAY)
//	{
//		printf("calibration type: CCOS_CALIBRATION_TYPE_XRAY\n");
//		Info("calibration type: CCOS_CALIBRATION_TYPE_XRAY");
//		int nCalibrationRounds = (int)m_CalibDoseList.size();
//		g_pDetector->SetReferenceNum(nCalibrationRounds);
//	}
//
//	if (g_pDetector->ActiveCalibration(this, eType))
//	{
//		m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_ACTIVE);
//		m_CalibUnit->SetCalibrationProgress(0);
//		if (eType == CCOS_CALIBRATION_TYPE_XRAY)
//		{
//			Info("start to waitting CalibDoseEvt");
//			printf("start to waitting CalibDoseEvt\n");
//			DWORD nRet = WaitForSingleObject(m_WaitCalibDoseEvt, INFINITE);
//		}
//		m_nXrayCalibNum = 0;
//	}
//	else
//	{
//		printf("Active calibration failed!\n");
//		Error("Active calibration failed!");
//	}
//
//	//重置校正流程参数
//	m_nCalibCurrentCalibrationRound = 1;
//	m_nCalibCurrentExposureIndex = 1;
//	m_nCalibCurrentExposureNum = 0;
//
//	ret = RET_STATUS::RET_SUCCEED;
//	printf("ActiveCalibration over\n");
//	Info("==============================ActiveCalibration over");
//	return ret;
//}
//
//
//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::PrepareCalibration()
//{
//	printf("--Func-- PrepareCalibration------ \n");
//	Info("==============================PrepareCalibration");
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	if (!m_bConnect)
//	{
//		printf("Detector not connected, return\n");
//		Error("Detector not connected, return");
//		return ret;
//	}
//
//	m_SyncUnit->FPDReadyNotify(false); //prepare前置为初值
//	if (g_pDetector->PrepareCalibration(this))
//	{
//		printf("FPD ready notify------------\n");
//		ret = RET_STATUS::RET_SUCCEED;
//		m_SyncUnit->FPDReadyNotify(true); //prepare succeed
//	}
//	else
//	{
//		printf("Prepare calibration failed\n");
//		Error("Prepare calibration failed");
//	}
//	m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//	printf("PrepareCalibration over\n");
//	Info("==============================PrepareCalibration over");
//	return ret;
//}
//
//
//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetRequestedDose(std::string& strDose)
//{
//	Info("==============================GetRequestedDose");
//	printf("--Func-- GetRequestedDose------ \n");
//	if (!m_stDeviceConfig.bConnectStatus)
//	{
//		return RET_STATUS::RET_THREAD_INVALID;
//	}
//
//	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
//	bool bGetDoseInfo = false;
//	ResDataObject out;
//
//	CCOS_CALIBRATION_TYPE nCalibrationType = m_CalibUnit->GetCalibrationType();
//	Info("GetRequestedDose calib type is {$}",(int)nCalibrationType);
//	printf("GetRequestedDose calib type is %d\n",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);
//		bGetDoseInfo = true;
//	}
//	else if (CCOS_CALIBRATION_TYPE_XRAY == nCalibrationType)
//	{
//		Info("calib dose list size is {$}",m_CalibDoseList.size());
//		printf("calib dose list size is %d\n",(int)m_CalibDoseList.size());
//		for (int i = 0; i < m_CalibDoseList.size(); i++)
//		{
//			ResDataObject temp = m_CalibDoseList[i];
//			int nDose = temp["Dose"];
//			int nDoseParem = (int)(m_fDoseParam * 1000);
//			if (nDoseParem == nDose)
//			{
//				out.add("Dose", nDoseParem);
//				out.add("kV", temp["kV"]);
//				out.add("mA", temp["mA"]);
//				out.add("ms", temp["ms"]);
//				out.add("mAs", temp["mAs"]);
//				bGetDoseInfo = true;
//				Info("Find target dose parameter");
//				break;
//			}
//		}
//	}
//	else
//	{
//		Warn("Can not support CalibrationType($)", (int)nCalibrationType);
//		Ret = RET_STATUS::RET_FAILED;
//	}
//
//	if (bGetDoseInfo)
//	{
//		strDose = out.encode();
//		Info("GetRequestedDose:{$}", strDose.c_str());
//	}
//	else
//	{
//		Error("GetRequestedDose failed");
//	}
//	Info("==============================GetRequestedDose over");
//	return Ret;
//}
//
//
//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::StartCalibration()
//{
//	Info("==============================StartCalibration");
//	printf("--Func-- StartCalibration------ \n");
//	RET_STATUS Ret = RET_STATUS::RET_FAILED;
//	if (!m_stDeviceConfig.bConnectStatus)
//	{
//		Ret = RET_STATUS::RET_THREAD_INVALID;
//		Error("detector is not connected");
//		return Ret;
//	}
//
//	if (DETECTOR_STATUS_STANDBY != m_DetectorCtrlUnit->GetDetectorStatus())
//	{
//		if (DETECTOR_STATUS_ACQ == m_DetectorCtrlUnit->GetDetectorStatus())
//		{
//			Error("ActiveCalibration failed. Detector at Acq status");
//		}
//		Ret = RET_STATUS::RET_FAILED;
//		return Ret;
//	}
//
//	if (((UltrasonicProbe*)m_pDetectors)->StartCalibration(this))
//	{
//		printf("start calibration success set detector status\n");
//		Info("start calibration success set detector status");
//		m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_ACQ);
//		m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_RUNNING);
//		Ret = RET_STATUS::RET_SUCCEED;
//	}
//	else
//	{
//		Ret = RET_STATUS::RET_FAILED;
//	}
//	printf("StartCalibration over\n");
//	Info("==============================StartCalibration over");
//	return Ret;
//}
//
//
//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::StopCalibration()
//{
//	Info("==============================StopCalibration");
//	printf("--Func-- StopCalibration------ \n");
//	RET_STATUS Ret = RET_STATUS::RET_FAILED;
//	if (!m_bConnect)
//	{
//		Error("Detector not connected, return");
//		return Ret;
//	}
//
//	m_eAppStatus = APP_STATUS_CAL_END;
//	if (RET_STATUS::RET_SUCCEED == ((UltrasonicProbe*)m_pDetectors)->AbortCalibration(this))
//	{
//		m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_STANDBY);
//		Ret = RET_STATUS::RET_SUCCEED;
//	}
//	else
//	{
//		Ret = RET_STATUS::RET_FAILED;
//	}
//	m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//	Info("==============================StopCalibration over");
//	return Ret;
//}

//create device 时调用
bool nsFPD::FPDDeviceUltrasonicProbe::LoadConfig()
{
	printf("--Func-- LoadConfig \r\n");
	Info("============ LoadConfig config");
	if (!m_DetectorConfiguration->LoadConfigurations(m_stDeviceConfig))
	{
		Error("LoadConfig LoadConfigurations failed!!!");
		return false;
	}

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

	if (m_stDeviceConfig.nForceGridSuppress > 0)
	{
		m_bForceGridSuppress = true;
	}
	else
	{
		m_bForceGridSuppress = false;
	}

	try
	{
		int nAttached = (int)m_DetectorConfiguration->m_Configurations[CcosDetectorAttachedFlag];
		if (nAttached == 1)
		{
			m_bAttached = true;
			m_DetectorCtrlUnit->SetAttachStatus(1);
		}
		else
		{
			m_bAttached = false;
			m_stDeviceConfig.bConnectStatus = false;
		}

		m_DetectorCtrlUnit->SetDetectorType((string)m_DetectorConfiguration->m_Configurations[DetectorModel]);
		m_DetectorCtrlUnit->SetDescription((string)m_DetectorConfiguration->m_Configurations[DetectorDescription]);
	}
	catch (ResDataObjectExption& e)
	{
		printf("LoadConfig error: %s \r\n", e.what());
		Error("LoadConfig error!! reason:{$}", e.what());
	}
	
	m_DetectorCtrlUnit->SetDetectorConditionsNominalFlag("YES");

	auto strFinfo = std::to_string(m_stDeviceConfig.nDoseOfEXI);
	m_DetectorCtrlUnit->SetFPDSensitivity(strFinfo);

	m_fFactorEXI2UGY = 100.0f / (float)atof(strFinfo.c_str()) * 1.0f;//子系统将UI的TargetEXI 乘以 FPDSensitivity再传给imagesave，用作计算EXI和DI并填写ecm头
	Info("m_fFactorEXI2UGY = {$}", m_fFactorEXI2UGY);

	m_DetectorCtrlUnit->SetPixelData("");
	m_DetectorCtrlUnit->SetTargetEXI("5000");

	m_Battery.reset(new DeviceBatteryMould("GetRemainPowerValue", 0, 
		m_stDeviceConfig.nBatteryLimit, 
		m_stDeviceConfig.nBatteryWarning, 
		100, 0, 100, 100, 
		0, EventCenter));

	m_Temperature.reset(new DeviceTemperatureMould("GetTemperatureValue", 0.0f, 
		m_stDeviceConfig.fTemperatureMin, 
		m_stDeviceConfig.fTemperLowLimit, 
		m_stDeviceConfig.fTemperatureMax, 
		m_stDeviceConfig.fTemperMaxLimit, 
		0.0f, 0.0f, 0.0f, EventCenter));

	m_Wifi.reset(new DeviceWifiMould("GetWifiStrengthValue", 0, 
		m_stDeviceConfig.nWifiLimit,
		m_stDeviceConfig.nWifiWarning,
		100, 0, 100, 100, 
		0, EventCenter));

	//ResDataObject CalibDoseList;
	//string strCalibDose = m_strWorkPath + R"(\OEMDrivers\Detector\UltrasonicProbe\UltrasonicProbeDMDetector\CalibrationDose_UltrasonicProbe.xml)";
	//Info("start load calibDose file: {$}", strCalibDose.c_str());
	//struct stat buffer;
	//if (stat(strCalibDose.c_str(), &buffer) == 0)
	//{
	//	try
	//	{
	//		CalibDoseList.loadFile(strCalibDose.c_str());
	//		m_CalibDoseList = CalibDoseList["List"];

	//		Info("m_CalibDoseList: {$} ", m_CalibDoseList.encode());

	//		for (int i = 0; i < m_CalibDoseList.size(); i++)
	//		{
	//			ResDataObject temp = m_CalibDoseList[i];
	//			int nExpNum = temp["ExpNum"];
	//			m_nCalibTotalExposureNum += nExpNum;
	//			//Info("temp: {$} ", temp.encode());
	//		}

	//		Info("CalibTotalExposureNum: {$}", m_nCalibTotalExposureNum);
	//	}
	//	catch (exception e)
	//	{
	//		Error("Get calibDose error: {$}", e.what());
	//	}
	//}
	//else 
	//{
	//	Error("{$} file not exist!");
	//}
	
	return true;
}


void nsFPD::FPDDeviceUltrasonicProbe::RegisterCtrl(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("ActiveDetector", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSActiveDetector);
	Dispatch->Action.Push("AttachConnect", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSAttachConnect);
	Dispatch->Action.Push("CancelAttach", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSCancelAttach);
	Dispatch->Action.Push("ResetConnect", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSResetConnect);
	Dispatch->Action.Push("DisConnectFPD", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSDisConnectFPD);
	Dispatch->Action.Push("UpdateFirmware", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateFirmware);
	Dispatch->Action.Push(ActionKey::GetDetectorInfo, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorInfo);
	Dispatch->Action.Push("EnterExam", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSEnterExam);
	Dispatch->Action.Push("RecoverImage", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRecoverImage);
	Dispatch->Action.Push("GetRecoverImageState", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetRecoverImageState);
	Dispatch->Action.Push("SaveSensitivity", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSaveSensitivity);
	Dispatch->Action.Push("RESET", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRESET);
	Dispatch->Action.Push("SaveRawDataMode", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSaveRawDataMode);

	Dispatch->Get.Push(CcosDetectorConnectStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetConnectStatus);
	Dispatch->Get.Push(CcosDetectorInitialStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetInitialStatus);
	Dispatch->Get.Push(CcosDetectorUpdateFWStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetUpdateFWStatus);
	Dispatch->Get.Push("FPDShockSensorInfo", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetShockSensorInfo);
	Dispatch->Get.Push(CcosDetectorStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDStatus);
	Dispatch->Get.Push(CcosDetectorAttachedFlag, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachStatus);
	Dispatch->Get.Push(CcosDetectorAttach, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachResult);//event
	Dispatch->Get.Push("RecoverImageState", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetRecoverImageState);//event
	Dispatch->Get.Push("RecoverImageEvent", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetRecoverImageEvent);//event
	Dispatch->Get.Push("FieldofViewShape", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewShape);
	Dispatch->Get.Push("FieldofViewDimension", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewDimension);
	Dispatch->Get.Push("DetectorType", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorType);
	Dispatch->Get.Push("Description", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDescription);
	Dispatch->Get.Push("DetectorID", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorID);
	Dispatch->Get.Push("DateofLastDetectorCalibration", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDateofLastDetectorCalibration);
	Dispatch->Get.Push("TimeofLastDetectorCalibration", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTimeofLastDetectorCalibration);
	Dispatch->Get.Push("DetectorConditionsNominalFlag", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorConditionsNominalFlag);
	Dispatch->Get.Push("FPDSensitivity", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDSensitivity);
	Dispatch->Get.Push("PixelData", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetPixelData);
	Dispatch->Get.Push("TargetEXI", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTargetEXI);
}


void nsFPD::FPDDeviceUltrasonicProbe::RegisterAcq(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("SetAcqMode", m_AcqUnit.get(), &AcqUnit::JSSetAcqMode);
	//超声相关
	Dispatch->Action.Push("SetFreeze", m_AcqUnit.get(), &AcqUnit::JSSetFreeze);
	Dispatch->Action.Push("SwitchProbe", m_AcqUnit.get(), &AcqUnit::JSSwitchProbe);
	Dispatch->Action.Push("SwitchProbeMode", m_AcqUnit.get(), &AcqUnit::JSSwitchProbeMode);
	Dispatch->Action.Push("SetBGain", m_AcqUnit.get(), &AcqUnit::JSSetBGain);
	Dispatch->Action.Push("SetBDepth", m_AcqUnit.get(), &AcqUnit::JSSetBDepth);
	Dispatch->Action.Push("SetBFrequency", m_AcqUnit.get(), &AcqUnit::JSSetBFrequency);
	Dispatch->Action.Push("SetBFocus", m_AcqUnit.get(), &AcqUnit::JSSetBFocus);
	Dispatch->Action.Push("SetBHarmonic", m_AcqUnit.get(), &AcqUnit::JSSetBHarmonic);
	Dispatch->Action.Push("SetBPower", m_AcqUnit.get(), &AcqUnit::JSSetBPower);
	Dispatch->Action.Push("SetBDynamicRange", m_AcqUnit.get(), &AcqUnit::JSSetBDynamicRange);
	Dispatch->Action.Push("GetBDepth", m_AcqUnit.get(), &AcqUnit::JSGetBDepth);
	Dispatch->Action.Push("GetBFrequency", m_AcqUnit.get(), &AcqUnit::JSGetBFrequency);
	Dispatch->Action.Push("GetBGain", m_AcqUnit.get(), &AcqUnit::JSGetBGain);
	Dispatch->Action.Push("GetBFocus", m_AcqUnit.get(), &AcqUnit::JSGetBFocus);
	Dispatch->Action.Push("GetBDynamicRange", m_AcqUnit.get(), &AcqUnit::JSGetBDynamicRange);
	Dispatch->Action.Push("SetCRoi", m_AcqUnit.get(), &AcqUnit::JSSetCRoi);
	Dispatch->Action.Push("SetCGain", m_AcqUnit.get(), &AcqUnit::JSSetCGain);
	Dispatch->Action.Push("SetPostLevel", m_AcqUnit.get(), &AcqUnit::JSSetPostLevel);
	Dispatch->Action.Push("SetMirror", m_AcqUnit.get(), &AcqUnit::JSSetMirror);
	Dispatch->Action.Push("SetCFrequency", m_AcqUnit.get(), &AcqUnit::JSSetCFrequency);
	Dispatch->Action.Push("SetCSpeedWallFilter", m_AcqUnit.get(), &AcqUnit::JSSetCSpeedWallFilter);
	Dispatch->Action.Push("SetCRangeWallFilter", m_AcqUnit.get(), &AcqUnit::JSSetCRangeWallFilter);
	Dispatch->Action.Push("SetCPersistence", m_AcqUnit.get(), &AcqUnit::JSSetCPersistence);
	Dispatch->Action.Push("SetCLinearAngle", m_AcqUnit.get(), &AcqUnit::JSSetCLinearAngle);
	Dispatch->Action.Push("SetCPrf", m_AcqUnit.get(), &AcqUnit::JSSetCPrf);
	Dispatch->Action.Push("GetCFrequency", m_AcqUnit.get(), &AcqUnit::JSGetCFrequency);
	Dispatch->Action.Push("GetCGain", m_AcqUnit.get(), &AcqUnit::JSGetCGain);
	Dispatch->Action.Push("GetCPrf", m_AcqUnit.get(), &AcqUnit::JSGetCPrf);
	//
	Dispatch->Get.Push(CcosZskkFPDState, m_AcqUnit.get(), &AcqUnit::JSGetZskkFPDState);
	Dispatch->Get.Push("NoNeedWaitImage", m_AcqUnit.get(), &AcqUnit::JSGetNoNeedWaitImage);
	Dispatch->Get.Push("ImgDataInfo", m_AcqUnit.get(), &AcqUnit::JSGetLastImage);
	Dispatch->Get.Push("AutonumousMapFinish", m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	//超声相关
	Dispatch->Get.Push(AttrKey::ProbeType, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::ProbeMode, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BGain, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BDepth, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BDepthCm, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BFrequency, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BFocus, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BFocusCm, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BDynamicRange, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BHarmonic, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::BPower, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CxLeft, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CxRight, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CyTop, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CyBottom, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CGain, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CFrequency, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CSpeedWallFilter, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CRangeWallFilter, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CPersistence, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CLinearAngle, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::CPrf, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::PostLevel, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);
	Dispatch->Get.Push(AttrKey::Mirror, m_AcqUnit.get(), &AcqUnit::JSAutonumousMapFinish);

}


void nsFPD::FPDDeviceUltrasonicProbe::RegisterSync(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("SetSyncMode", m_SyncUnit.get(), &SyncUnit::JSSetSyncMode);
	Dispatch->Action.Push("SetXwindowSize", m_SyncUnit.get(), &SyncUnit::JSSetXwindowSize);
	Dispatch->Action.Push("PrepareAcquisition", m_SyncUnit.get(), &SyncUnit::JSPrepareAcquisition);
	Dispatch->Action.Push("StartAcquisition", m_SyncUnit.get(), &SyncUnit::JSStartAcquisition);
	Dispatch->Action.Push("StopAcquisition", m_SyncUnit.get(), &SyncUnit::JSStopAcquisition);
	Dispatch->Get.Push(CcosFPDReadyStatus, m_SyncUnit.get(), &SyncUnit::JSGetFPDReady);
	Dispatch->Get.Push(CcosXwindowStatus, m_SyncUnit.get(), &SyncUnit::JSGetXWindowStatus);
	Dispatch->Get.Push(CcosImageReadingStatus, m_SyncUnit.get(), &SyncUnit::JSGetImageReadingStatus);
	Dispatch->Get.Push("XrayON", m_SyncUnit.get(), &SyncUnit::JSGetXrayON);
	Dispatch->Get.Push(CcosSyncMode, m_SyncUnit.get(), &SyncUnit::JSGetSyncMode);
}


void nsFPD::FPDDeviceUltrasonicProbe::RegisterCalib(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("ActiveCalibration", m_CalibUnit.get(), &CalibUnit::JSActiveCalibration);
	Dispatch->Action.Push("GetRequestedDose", m_CalibUnit.get(), &CalibUnit::JSGetRequestedDose);
	Dispatch->Action.Push("SetRequestedDose", m_CalibUnit.get(), &CalibUnit::JSSetRequestedDose);
	Dispatch->Action.Push("PrepareCalibration", m_CalibUnit.get(), &CalibUnit::JSPrepareCalibration);
	Dispatch->Action.Push("StartCalibration", m_CalibUnit.get(), &CalibUnit::JSStartCalibration);
	Dispatch->Action.Push("StopCalibration", m_CalibUnit.get(), &CalibUnit::JSStopCalibration);
	Dispatch->Action.Push("SetCorrectionType", m_CalibUnit.get(), &CalibUnit::JSSetCorrectionType);
	Dispatch->Action.Push("AcceptCalibration", m_CalibUnit.get(), &CalibUnit::JSAcceptCalibration);
	Dispatch->Action.Push("RejectCalibration", m_CalibUnit.get(), &CalibUnit::JSRejectCalibration);
	Dispatch->Action.Push("SaveCalibrationFile", m_CalibUnit.get(), &CalibUnit::JSSaveCalibrationFile);
	Dispatch->Action.Push("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("HaveImgCalibration", m_CalibUnit.get(), &CalibUnit::JSGetHaveImgCalibration);
	Dispatch->Get.Push("UploadCalibrationFilesResult", m_CalibUnit.get(), &CalibUnit::JSGetUploadCalibrationFilesResult);
	Dispatch->Get.Push("SaveCalibrationFileFinish", m_CalibUnit.get(), &CalibUnit::JSGetSaveCalibrationFileFinish);
}


void nsFPD::FPDDeviceUltrasonicProbe::RegisterOthers(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Get.Push("Temperature_Value", m_Temperature.get(), &DeviceTemperatureMould::JSGetCurrentTemperatureValue);
	Dispatch->Get.Push("Remain_Power_Value", m_Battery.get(), &DeviceBatteryMould::JSGetCurrentBatteryValue);
	Dispatch->Get.Push("Wifi_Strength_Value", m_Wifi.get(), &DeviceWifiMould::JSGetCurrentSignalValue);
}

void nsFPD::FPDDeviceUltrasonicProbe::RegisterAutonumous(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("OfflineFPD", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSOfflineFPD);
	Dispatch->Action.Push("OnlineFPD", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSOnlineFPD);
	Dispatch->Action.Push("GetAutonumousImageList", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAutonumousImageList);
	Dispatch->Action.Push("RemoveAutonumousImageList", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRemoveAutonumousImageList);
	Dispatch->Action.Push("RemoveAutonumousAll", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRemoveAutonumousAll);
	Dispatch->Action.Push("GetImageMetaData", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetImageMetaData);
	Dispatch->Action.Push("ExportAutonumousAll", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSExportAutonumousAll);
}


void nsFPD::FPDDeviceUltrasonicProbe::SendTemperatureValue(float fValue)
{
	int nStatus = 0;
	m_Temperature->SetTemperature(fValue, nStatus);
	Info("SendTemperatureValue: {$}, status {$}", fValue, nStatus);
}


void nsFPD::FPDDeviceUltrasonicProbe::SendWifiValue(int nValue)
{
	int nStatus = 0;
	m_Wifi->SetSignalValue(nValue, nStatus);
	Info("SendWifiValue: {$}, status {$}", nValue, nStatus);
}


void nsFPD::FPDDeviceUltrasonicProbe::SendBatteryValue(int nValue)
{
	int nStatus = 0;
	m_Battery->SetRemainPowerValue(nValue, nStatus);
	Info("SendBatteryValue: {$}, status {$}", nValue, nStatus);
}


/// <summary>
/// 探测器设备 所有 事件处理入口 @PZ_FPD
/// conf/info/status/data/warning/error
/// </summary>
/// <param name="nDetectorID"></param>
/// <param name="nEventID"></param>
/// <param name="nEventLevel"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void nsFPD::FPDDeviceUltrasonicProbe::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:
	{
		OnEventProcessWarning(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_ERROR:
	{
		OnEventProcessError(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	default:
		break;
	}
}

// 通知子系统开窗
void nsFPD::FPDDeviceUltrasonicProbe::NotifyXWindowOn() {
	m_SyncUnit->XWindowOnNotify();
}

// 通知子系统关窗
void nsFPD::FPDDeviceUltrasonicProbe::NotifyXWindowOff() {
	m_SyncUnit->XWindowOffNotify();
}

bool nsFPD::FPDDeviceUltrasonicProbe::GetOnlyHaveFpd()
{
	return m_bOnlyHaveFpd;
}

//int nsFPD::FPDDeviceUltrasonicProbe::GetGainExposureNum()
//{
//	return m_nCalibTotalExposureNum;
//}


/// <summary>
/// 探测器设备 配置 事件处理 @PZ_FPD
/// 暂不支持 配置
/// </summary>
/// <param name="nDetectorID"></param>
/// <param name="nEventID"></param>
/// <param name="nEventLevel"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void nsFPD::FPDDeviceUltrasonicProbe::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;
		Info("Receive Panel {$} SN {$}", nDetectorID, pszMsg);
		m_DetectorCtrlUnit->SetDetectorID(m_stDeviceConfig.strPanelSerial);
		break;
	}
	case EVT_CONF_RAW_WIDTH:
	{
		if (m_stDeviceConfig.nFullImageWidth != nParam1)
		{
			m_stDeviceConfig.nFullImageWidth = nParam1;
		}
		m_nImageWidth = nParam1;
		Info("Panel {$} nFullImageWidth:{$}", nDetectorID, m_stDeviceConfig.nFullImageWidth);
		break;
	}
	case EVT_CONF_RAW_HIGHT:
	{
		if (m_stDeviceConfig.nFullImageHeight != nParam1)
		{
			m_stDeviceConfig.nFullImageHeight = nParam1;
		}
		m_nImageHeight = nParam1;
		Info("Panel {$} nFullImageHeight:{$}", nDetectorID, m_stDeviceConfig.nFullImageHeight);
		break;
	}
	case EVT_CONF_RAW_BITS:
	{
		m_stDeviceConfig.nImageBits = nParam1;
		m_nImageBits = nParam1;
		//把image bits 设置到AcqUnit中
		m_AcqUnit->SetFulImageInfo(m_nImageHeight, m_nImageWidth, m_nImageBits, false);
		Info("Panel {$} nImageBits:{$}", nDetectorID, m_stDeviceConfig.nImageBits);
		break;
	}
	case EVT_CONF_PIXELSPACE:
	{
		m_stDeviceConfig.nPixelSpace = (int)fParam2;
		Info("Panel {$} nPixelSpace:{$}", nDetectorID, m_stDeviceConfig.nPixelSpace);
		break;
	}
	case EVT_CONF_PREVIEW_WIDTH:
	{
		if (m_stDeviceConfig.nPreviewWidth != nParam1)
		{
			m_stDeviceConfig.nPreviewWidth = nParam1;
		}
		m_nPreImgWidth = nParam1;
		Info("Panel {$} nPreviewWidth:{$}", nDetectorID, m_stDeviceConfig.nPreviewWidth);
		break;
	}
	case EVT_CONF_PREVIEW_HIGHT:
	{
		if (m_stDeviceConfig.nPreviewHeight != nParam1)
		{
			m_stDeviceConfig.nPreviewHeight = nParam1;
		}
		m_nPreImgHeight = nParam1;
		Info("Panel {$} nPreviewHeight:{$}", nDetectorID, m_stDeviceConfig.nPreviewHeight);
		break;
	}
	case EVT_CONF_MODULE_TYPE:
	{
		//m_strModuleType = pszMsg;
		Info("Receive Panel {$} ModuleType {$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_MODULE_IP:
	{
		//m_strModuleIP = pszMsg;
		Info("Receive Panel {$} ModuleIP {$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_MODULE_SN:
	{
		//m_strModuleSN = pszMsg;
		Info("Receive Panel {$} ModuleSN {$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_FIRWARE_UPDATE:
	{
		m_stDeviceConfig.nFirmwareStatus = nParam1;
		Info("Panel {$} FirmwareUpdate:{$}", nDetectorID, m_stDeviceConfig.nFirmwareStatus);
		break;
	}
	case EVT_CONF_PART_NUMBER:
	{
		m_stDeviceConfig.strPartNumber = pszMsg;
		Info("Panel {$} PartNumber:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_BATTERY_SN:
	{
		//m_strBatterySN = pszMsg;
		Info("Panel {$} Battery SN:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_WIFI_SSID:
	{
		m_stDeviceConfig.strWifiSSID = pszMsg;
		Info("Panel {$} WifiSSID:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_IFBOARD:
	{
		m_stDeviceConfig.strInterfaceBoard = pszMsg;
		Info("Panel {$} InterfaceBoard:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_DATECODE:
	{
		m_stDeviceConfig.strDateCode = pszMsg;
		Info("Panel {$} DateCode:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_LIFETIME:
	{
		int nLifeTime = nParam1;
		if ((nLifeTime != m_stDeviceConfig.nLifeTime) /*&& (m_strBatterySN != "")*/)
		{
			Info("LifeTime:{$}", nLifeTime);
			m_stDeviceConfig.nLifeTime = nLifeTime;
		}
		break;
	}
	default:
		break;
	}
}

/// <summary>
/// 探测器设备 Info 事件处理 @PZ_FPD
/// 暂不支持 Info
/// </summary>
/// <param name="nDetectorID"></param>
/// <param name="nEventID"></param>
/// <param name="nEventLevel"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void nsFPD::FPDDeviceUltrasonicProbe::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_POWER_ON:
	{
		int nPowerOn = nParam1;
		Info("Detector {$} PowerOn:{$}", nID, nPowerOn);
		if ((nPowerOn != m_stDeviceConfig.nPowerOn) /*&& (m_strBatterySN != "")*/)
		{
			m_stDeviceConfig.nPowerOn = nPowerOn;
		}
		break;
	}
	case EVT_INFO_BATTERY_CAPACITY:
	{
		int nBatteryCapacity = nParam1;
		if ((nBatteryCapacity != m_nBatteryCapacity) /*&& (m_strBatterySN != "")*/)
		{
			Info("nBatteryCapacity:{$}", nBatteryCapacity);
			m_nBatteryCapacity = nBatteryCapacity;
		}
		break;
	}
	case EVT_INFO_BATTERY_TEMPERATURE:
	{
		float fBatteryTemper = fParam2;

		if (((fBatteryTemper - m_fBatteryTemperature) >= 0.1f) /*&& (m_strBatterySN != "")*/)
		{
			Info("temperature:%.2f", fBatteryTemper);
			m_fBatteryTemperature = fBatteryTemper;
		}
		break;
	}
	case EVT_INFO_BATTERY_CHARGES:
	{
		int nBatteryCharges = nParam1;

		if ((nBatteryCharges != m_nBatteryCharges)/* && (m_strBatterySN != "")*/)
		{
			Info("nBatteryCharges:{$}", nBatteryCharges);
			m_nBatteryCharges = nBatteryCharges;
		}
		break;
	}
	case EVT_INFO_WIFI_DATARATE:
	{
		m_stDeviceConfig.nWifiDataRate = nParam1;
		Info("Detector {$} WifiDataRate:{$}", nID, m_stDeviceConfig.nWifiDataRate);
		break;
	}
	case EVT_INFO_WIFI_CHANNEL:
	{
		m_stDeviceConfig.nWifiChannel = nParam1;
		Info("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;
		Info("Panel {$} WifiNoisePower:{$}", nID, m_stDeviceConfig.nWifiNoisePower);
		break;
	}
	case EVT_INFO_FIRMWARE:
	{
		m_stDeviceConfig.strFirmware = pszMsg;
		Info("Panel {$} Firmware:{$}", nID, pszMsg);
		break;
	}
	case EVT_INFO_SHOCKSENSOR_INFO:
	{
		Info("Receive ShockSensor Info");
		//m_strShockSensor = pszMsg;
		//m_DetectorCtrlUnit->SetShockSensorInfo(m_strShockSensor);
		break;
	}
	case EVT_INFO_CALIBRATIOIN_TIME:
	{
		m_stDeviceConfig.strCalibrationDate = pszMsg;
		Info("Panel {$} Calibration Time:{$}", nID, pszMsg);
		m_DetectorCtrlUnit->SetDateofLastDetectorCalibration(m_stDeviceConfig.strCalibrationDate);
		m_DetectorCtrlUnit->SetTimeofLastDetectorCalibration("");
		//m_stDeviceConfig.strCalibrationDue = m_CalibProcess->GetCalibDueDate(m_stDeviceConfig, m_stDeviceConfig.strCalibrationDate);
		break;
	}
	case EVT_INFO_CALIBRATIOIN_TIMEL:
	{
		m_stDeviceConfig.strCalibrationLTEDate = pszMsg;
		Info("Panel {$} Calibration LTE Time:{$}", nID, pszMsg);
		//m_stDeviceConfig.strCalibrationLTEDue = m_CalibProcess->GetCalibDueDate(m_stDeviceConfig, m_stDeviceConfig.strCalibrationLTEDate);
		break;
	}
	case EVT_INFO_FPVOLTAGE:
	{
		//m_strVoltage = pszMsg;
		break;
	}
	default:
		break;
	}
}


/// <summary>
/// 探测器设备状态事件 处理@PZ_FPD
/// </summary>
/// <param name="nDetectorID"></param>
/// <param name="nEventID"></param>
/// <param name="nEventLevel"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void nsFPD::FPDDeviceUltrasonicProbe::OnEventProcessStatus(int nDetectorID, int nEventID, int nEventLevel,
	const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
	case EVT_STATUS_INIT:
	{
		if (PANEL_EVENT_END_OK == nParam1)
		{
			Info("Detector init success set connect status is true");
			m_DetectorCtrlUnit->SetInitialStatus(DETECTOR_INI_SUCCESS);
		}
		else if (PANEL_EVENT_END_ERROR == nParam1)
		{
			m_DetectorCtrlUnit->SetInitialStatus(DETECTOR_INI_FAILED);
		}
		else if (PANEL_EVENT_END == nParam1) //未连接探测器
		{
			m_DetectorCtrlUnit->SetInitialStatus(DETECTOR_INI_SUCCESS);
		}
		else if (PANEL_EVENT_START == nParam1)
		{
			m_DetectorCtrlUnit->SetInitialStatus(DETECTOR_INI_START);
		}
		break;
	}
	case EVT_STATUS_MOTION:
	{
		//m_strMotionStatus = pszMsg;
		break;
	}
	case EVT_STATUS_UPDATE_FIRMWARE:
	{
		if (PANEL_EVENT_START == nParam1)
		{
			Info("Start update firmware");
			m_DetectorCtrlUnit->SetUpdateFWStatus(DETECTOR_UFW_START);
		}
		else if (PANEL_EVENT_BEGIN == nParam1)
		{
			Info("Update firmware begin");
			m_stDeviceConfig.bConnectStatus = false;
		}
		else if (PANEL_EVENT_END_ERROR == nParam1)
		{
			Info("Update firmware failed");
			//SendDetectorInfo(); //更新探测器状态图标
			m_DetectorCtrlUnit->SetUpdateFWStatus(DETECTOR_UFW_ERROR);
		}
		else if (PANEL_EVENT_SUCCESS == nParam1) //
		{
			Info("update firmware success");
			//SendDetectorInfo();
			m_DetectorCtrlUnit->SetUpdateFWStatus(DETECTOR_UFW_SUCCESS);
		}
		break;
	}
	case EVT_STATUS_SELFTEST:
	{
		break;
	}
	case EVT_STATUS_DETECTORSHARE:
	{
		ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
		switch (eStatus)
		{
		case PANEL_ATTACH_START:
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_ATTACH_START); //重置status，避免服务判重，两次attach失败时，不将第二次的失败信息发送给客户端
			Info("New Detector Attach start\n");
			break;
		case PANEL_ATTACH_OVER:
		{
			Info("New Detector Attach Over,Prepare to Connecting");
			//m_DetectorCtrlUnit->SetAttachResult(true, m_stDeviceConfig.strDeviceName.c_str(), m_strModuleSN.c_str());
		}
		break;
		case PANEL_ATTACH_FAILED: //UI显示Failed
			Error("New Detector Attach failed\n");
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_ATTACH_FAILED);
			break;
		case PANEL_CONNECT_OK:
		{
			Info("OnEventProcessStatus panel connect ok set connect status is true");
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_CONNECT_OK);
			m_stDeviceConfig.bConnectStatus = true;
			break;
		}
		case PANEL_CONNECT_ERROR:
		{
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_CONNECT_ERROR);
		}
		break;
		case PANEL_DISCONNECT_SUCCESS:
		{
			m_nBatteryCapacity = 0;
			//m_strBatterySN = "";
			m_stDeviceConfig.bExisted = false;
			m_stDeviceConfig.bConnectStatus = false;
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_DISCONNECT_SUCCESS);
			break;
		}
		case PANEL_DISCONNECT_ERROR:
			m_DetectorCtrlUnit->SetConnectStatus(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_XWINDOW_ON == nParam1) //Xwindow On
		{
			m_stImgCreateTime = { 0 };
			GetLocalTime(&m_stImgCreateTime);
			Info("XWindow on time {$}:{$}:{$}:{$}", 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);
			Info("XWindow off time {$}:{$}:{$}:{$}", m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);
			m_SyncUnit->XWindowOffNotify();
		}
		else if (PANEL_READY_EXP == nParam1)
		{
			Info("FPDReadyNotify(true)");
			m_SyncUnit->FPDReadyNotify(true);
		}
		else if (PANEL_GAIN_READY_EXP == nParam1)
		{
			Info("FPDReadyNotify(true)");
			m_SyncUnit->FPDReadyNotify(true);
		}
		else if (PANEL_XRAY_ON == nParam1)
		{
			m_SyncUnit->XrayONNotify();
		}
		else if (PANEL_XRAY_OFF == nParam1)
		{
			m_SyncUnit->XrayOffNNotify();
		}
		break;
	}
	case EVT_STATUS_CALIBRATIOIN:
	{
		ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
		switch (eStatus)
		{
		case PANEL_EVENT_END_OK:
			Info("Calibration process end ok");
			//CompleteCalibration();
			break;
		case PANEL_EVENT_END_ERROR:
			Info("Calibration process end error");
			break;
		case PANEL_EVENT_START:
			Info("Calibration process start");
			break;
		case PANEL_EVENT_SUCCESS:
			Info("Calibration process success");
			break;
		case PANEL_EVENT_END:
			Info("Calibration process end");
			break;
		case PANEL_EVENT_BEGIN:
			Info("Calibration process begin");
			break;
		case PANEL_EVENT_TIMEOUT:
			Info("Calibration timeout");
			break;
		default:
			break;
		}
		break;
	}
	case EVT_STATUS_SAVECALIB:
	{
		if (PANEL_EVENT_START == nParam1)
		{
			Info("Begin to Save Calibration Files");
		}
		else if (PANEL_EVENT_END_ERROR == nParam1)
		{
			Info("Save Calibration Files failed");
			//SetEvent(m_UploadCalibMapOver);
		}
		else if (PANEL_EVENT_END == nParam1)
		{
			Info("Save Calibration Files Success");
			//SetEvent(m_UploadCalibMapOver);
		}
		break;
	}
	case EVT_STATUS_SAVEDEFECT:
	{
		if (PANEL_EVENT_START == nParam1)
		{
			Info("Begin to Save Defect Files");
		}
		else if (PANEL_EVENT_END_ERROR == nParam1)
		{
			Info("Save Defect Files failed");
			//SetEvent(m_UploadCalibMapOver);
		}
		else if (PANEL_EVENT_END == nParam1)
		{
			Info("Save Defect Files Success");
			m_stDeviceConfig.bTaskEnd = true;
			//SetEvent(m_UploadCalibMapOver);
		}
		break;
	}
	case EVT_STATUS_ACQUISITION:
	{
		ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
		switch (eStatus)
		{
		case PANEL_EVENT_START:
			Info("Acquisition start");
			break;
		case PANEL_EVENT_END_OK:
			Info("Acquisition end");
			break;
		case PANEL_EVENT_END_ERROR: //目前不会报错，不会走到这里
			break;
		default:
			break;
		}
		break;
	}
	case EVT_STATUS_SINGLEEXP:
	{
		if (DOSE_TOO_HIGH == nParam1)
		{
			Info("Dose too high");
			//StopCalibration();
			m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_STANDBY);
			m_CalibUnit->SetCalibrationProgress(100);//make progress
			m_AcqUnit->SendNoNeedWaitImage(true);
		}
		else if (DOSE_TOO_LOW == nParam1)
		{
			Info("Dose too low");
			//StopCalibration();
			m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_STANDBY);
			m_CalibUnit->SetCalibrationProgress(100);//make progress
			m_AcqUnit->SendNoNeedWaitImage(true);
		}
		else if (DOSE_OBJECT == nParam1)
		{
			Info("Dose object");
			//StopCalibration();
			m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_STANDBY);
			//m_CalibUnit->SetCalibrationProgress(100);//make progress
			m_AcqUnit->SendNoNeedWaitImage(true);
		}
		else if (DOSE_ACCEPT == nParam1)
		{
			Info("Calibration Result is acceptable");
			//m_WarnAndError->OnErrorX("ERR_FPD_DOSE_INVALID");
			//SetEvent(m_PauseCalibrationEvt);
		}
		else if (EVT_STATUS_LASTERROR == nParam1)
		{
			//m_strLastError = pszMsg;
			//Info("Panel {$} LastError {{$}}", nID, pszMsg);
		}
		break;
	}
	case EVT_STATUS_IMAGEPENDING:
	{
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			
		}
		else
		{
			
		}

		break;
	}
	case EVT_STATUS_TEMPERATURE:
	{
		float fTemperature = fParam2;

		OnProcessTemperature(nDetectorID, fTemperature);
		m_stDeviceConfig.fCurrentTemperValue = fTemperature;
		Info("Detector {$} Temperature Value:{$}", nDetectorID, fTemperature);

		SendTemperatureValue(m_stDeviceConfig.fCurrentTemperValue);
		break;
	}
	case EVT_STATUS_WIFI:
	{
		int nWifiLevel = nParam1;
		if (m_stDeviceConfig.strDeviceName.find("UltrasonicProbe") >= 0)
		{
			nWifiLevel = int(nWifiLevel / 0.75);
			if (nWifiLevel > 100)
			{
				nWifiLevel = 100;
			}
		}
		Info("Detector {$} Wifi Value:{$}", nDetectorID, nWifiLevel);
		//strWarnErrorCode = "ERR_FPD_WIFI_LOW";
		if (nWifiLevel == 0) //WIFI值为0 表明是有线连接，不报错
		{
			//m_WarnAndError->OnErrorX(strWarnErrorCode);
		}
		else if (nWifiLevel < m_stDeviceConfig.nWifiLimit)
		{
			//wifi error
		}
		else if (nWifiLevel <= m_stDeviceConfig.nWifiWarning)
		{
			//wifi error
			//m_WarnAndError->OnErrorX(strWarnErrorCode);
			//strWarnErrorCode = "WAR_FPD_WIFI_LOW";
		}
		else
		{
			//m_WarnAndError->OnErrorX(strWarnErrorCode);
		}
		Info("detector wifi level:%d", nWifiLevel);
		if (nWifiLevel != m_stDeviceConfig.nCurrentWifiValue)
		{
			Info("Channel:{$},SignalPower:{$},NoisePower:{$},DataRate:{$}", m_stDeviceConfig.nWifiChannel, m_stDeviceConfig.nWifiSignalPower, m_stDeviceConfig.nWifiNoisePower, m_stDeviceConfig.nWifiDataRate);
		}
		//endif
		m_stDeviceConfig.nCurrentWifiValue = nWifiLevel;
		SendWifiValue(m_stDeviceConfig.nCurrentWifiValue);
		break;
	}
	case EVT_STATUS_BATTERY_VALUE:
	{
		int nBatteryValue = nParam1;
		Info("Detector {$} Battery:{$}", nDetectorID, nParam1);

		if (nBatteryValue < m_stDeviceConfig.nBatteryLimit)
		{
			//battery error	
			//if (!m_bBatteryCharging) //如果没有充电；
			//{
			//	strWarnErrorCode = "ERR_FPD_BATTERY_LOW";
			//}
		}
		else if (nBatteryValue < m_stDeviceConfig.nBatteryWarning)
		{
			//battery error
			//strWarnErrorCode = "ERR_FPD_BATTERY_LOW";
			//m_WarnAndError->OnErrorX(strWarnErrorCode);
			//strWarnErrorCode = "WAR_FPD_BATTERY_LOW";
		}
		else
		{
			//strWarnErrorCode = "ERR_FPD_BATTERY_LOW";
			//m_WarnAndError->OnErrorX(strWarnErrorCode);
		}
		m_stDeviceConfig.nCurrentBatteryValue = nBatteryValue;
		Info("Detector {$} Battery Value:{$}", nDetectorID, nBatteryValue);
		SendBatteryValue(m_stDeviceConfig.nCurrentBatteryValue);
		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 strLog;
		//PRINTA_INFO("Panel %d Shock Sensor Number:%d", nID, m_nShockCounts);

		//if ((m_nShockCounts >= m_stDeviceConfig.nMaxShockNumber) && (m_stDeviceConfig.nShockTimes != m_nShockCounts))//避免频繁发送
		//{
		//	PRINTA_INFO("Reach Max Shock Sensor Number");
		//	SendInfoLog("DEV_LOG_FPD_SHOCKSENSOR", m_strShockSensor);
		//}
		//m_stDeviceConfig.nShockTimes = m_nShockCounts;
		break;
	}
	case EVT_STATUS_HALL_SENSOR:
	{
		//int nWorkstaion = nParam1;
		//PRINTA_INFO("Update Hall Status : %d ", nWorkstaion);

		//PRINTA_INFO("Panel %d WS:%d,Current OGP WS:%d ", 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)
		{
			Info("PMS isn't open");
		}
		break;
	}
	case EVT_STATUS_RESTOREFILES:
	{
		//string strTemp = pszMsg;
		//if (strTemp.find("true") != std::string::npos)
		//{
		//	PRINTA_INFO("Restore calibration files");
		//	string wcsPanelType = "3543dr";
		//	if (m_stDeviceConfig.strDeviceName.find("3543EZ") >= 0)
		//	{
		//		wcsPanelType = "3543ezh";
		//	}
		//	else if (m_stDeviceConfig.strDeviceName.find("2430EZ") != std::string::npos)
		//	{
		//		wcsPanelType = "2430ez";
		//	}
		//	m_CalibProcess->UpdateFDCalibList(m_nLTEenable, m_stDeviceConfig.strPanelSerial, wcsPanelType.c_str());
		//}
		break;
	}
	case EVT_STATUS_LASTERROR:
	{
		//m_strLastError = pszMsg;
		//PRINTA_INFO("Panel {$} LastError {$}", nID, pszMsg);
		break;
	}
	case EVT_STATUS_RESET:
	{
		int nStatus = nParam1;
		if (PANEL_RESET_BEGIN == nStatus)
		{
			m_bResetDetector = false;
		}
		else if (PANEL_RESET_OK == nStatus)
		{
			m_bResetDetector = true;
		}
		else if (PANEL_RESET_ERROR == nStatus)
		{
			m_bResetDetector = false;
		}
		break;
	}
	case EVT_AUTONUMOUS_STATUS:
	{
		ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
		switch (eStatus)
		{
		case PANEL_CONNECT_ERROR:
		{
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_CONNECT_ERROR);
			break;
		}
		case PANEL_CONNECT_OK:
		{
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_CONNECT_OK);
			m_stDeviceConfig.bConnectStatus = true;
			break;
		}
		case PANEL_DISCONNECT_SUCCESS:
		{
			m_nBatteryCapacity = 0;
			m_stDeviceConfig.bExisted = false;
			m_stDeviceConfig.bConnectStatus = false;
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_DISCONNECT_SUCCESS);
			break;
		}
		case PANEL_DISCONNECT_ERROR:
		{
			m_DetectorCtrlUnit->SetConnectStatus(PANEL_DISCONNECT_ERROR);
			break;
		}
		case PANEL_START_STOREDIMAGE:
		{
			Info("Send start autonumous to server");
			m_AcqUnit->SendAutonumousMapFinish(0);
			break;
		}
		case PANEL_END_STOREDIMAGE:
		{
			Info("Send finish autonumous to server");
			m_AcqUnit->SendAutonumousMapFinish(1);
			break;
		}
		case PANEL_EXPORT_AUTONUMOUS_FINISH:
		{
			Info("Send finish export local autonumous to server");
			m_AcqUnit->SendAutonumousMapFinish(2);
			break;
		}
		default:
			break;
		}
		break;
	}
	case EVT_PROBE_TYPE:
	{
		int probeType = nParam1;
		Info("EVT_PROBE_TYPE probeType:{$}", probeType);
		m_AcqUnit->NotifyProbeType(probeType);
		break;
	}
	default:
		break;
	}
}

/// <summary>
/// 探测器设备图像数据事件 处理 @PZ_FPD
/// </summary>
/// <param name="nDetectorID"></param>
/// <param name="nEventID"></param>
/// <param name="nEventLevel"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void nsFPD::FPDDeviceUltrasonicProbe::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:
	{
		Info("EVT_DATA_RAW_IMAGE");
		Info("RawImage Width:{$}, Height:{$},ImageBits:{$}", m_nImageWidth, m_nImageHeight, m_nImageBits);

		/*if (APP_STATUS_IDLE == m_eAppStatus)
		{
			Error("Omit Image in Idle Status");
			return;
		}*/
		//Ctrl回调上来肯定是24位图
		if (NULL == m_pwRawImageData)
		{
			Error("m_pwRawImageData has no memory!!!");
			m_pwRawImageData = new unsigned char[m_nImageWidth * m_nImageHeight * 3];
		}
		memcpy(m_pwRawImageData, pParam, m_nImageWidth * m_nImageHeight * 3);
		OnProcessImage(m_pwRawImageData, m_nImageWidth * m_nImageHeight * 3);
		break;
	}
	case EVT_DATA_PREVIEW_IMAGE:
	{
		Info("EVT_DATA_PREVIEW_IMAGE");
		Info("preview image width: {$}, height: {$}", m_nPreImgWidth, m_nPreImgHeight);
		m_SyncUnit->ImageReadingNotify();
		int severalTimes = m_nPreImageBits / 8;
		if (NULL == m_pwPreviewImg)
		{
			Error("m_pwPreviewImg has no memory!!! now to new");
			m_pwPreviewImg = new unsigned char[m_nPreImgWidth * m_nPreImgHeight * severalTimes];
		}
		memcpy(m_pwPreviewImg, pParam, m_nPreImgWidth * m_nPreImgHeight * severalTimes);
		OnProcessPreviewImage(m_pwPreviewImg, m_nPreImgWidth * m_nPreImgHeight * severalTimes);
		break;
	}
	case EVT_DATA_DOSEPARAM:
	{
		//m_fDoseParam = fParam2;
		//SetEvent(m_WaitCalibDoseEvt);
		break;
	}
	default:
		Warn("Not support this eventID (%d)", nEventID);
		break;
	}
}

/// <summary>
/// 探测器设备 ERROR 事件处理 @PZ_FPD
/// </summary>
/// <param name="nDetectorID"></param>
/// <param name="nEventID"></param>
/// <param name="nEventLevel"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void nsFPD::FPDDeviceUltrasonicProbe::OnEventProcessError(int nDetectorID, int nEventID, int nEventLevel,
	const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
		case EVT_ERR_COMMUNICATE:
		{
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				m_stDeviceConfig.nWorkstation = -1;
				m_stDeviceConfig.bConnectStatus = false;
				m_nBatteryCapacity = 0;
				m_stDeviceConfig.fCurrentTemperValue = 0.0f;
				m_stDeviceConfig.nCurrentWifiValue = 0;
				m_stDeviceConfig.nCurrentBatteryValue = 0;
				SendWifiValue(m_stDeviceConfig.nCurrentWifiValue);
				SendBatteryValue(m_stDeviceConfig.nCurrentBatteryValue);
				SendTemperatureValue(m_stDeviceConfig.fCurrentTemperValue);
			}
			else if (strTemp.find("false") != std::string::npos)//成功时交给WIFI发送SendDetectorInfo
			{
				m_stDeviceConfig.bConnectStatus = true;
			}
			break;
		}
		case EVT_ERR_EXP_REQUEST:
			Error("OnEventProcessError EVT_ERR_EXP_REQUEST");
			break;
		case EVT_ERR_GET_IMAGE:
			Error("OnEventProcessError EVT_ERR_GET_IMAGE");
			break;
		case EVT_ERR_MAX_NUMBER:
			Error("OnEventProcessError EVT_ERR_MAX_NUMBER");
			break;
		case EVT_ERR_SN_NOTINLIST:
			Error("OnEventProcessError EVT_ERR_SN_NOTINLIST");
			break;
		case EVT_ERR_POWER_OFF:
			Error("OnEventProcessError EVT_ERR_POWER_OFF");
			break;
		case EVT_ERR_INIT_FAILED:
		{
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				//AddErrMsg("6", "initialize error");
			}
			else if (strTemp.find("false") != std::string::npos)
			{
				//一般不可恢复
			}
			break;
		}
	default:
		Warn("Not support this error(%d)", nEventID);
		break;
	}
}

/// <summary>
/// 探测器设备 WARNING 事件 处理 @PZ_FPD
/// 当前版本不支持，TBD.
/// </summary>
/// <param name="nDetectorID"></param>
/// <param name="nEventID"></param>
/// <param name="nEventLevel"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void nsFPD::FPDDeviceUltrasonicProbe::OnEventProcessWarning(int nDetectorID, int nEventID, int nEventLevel,
	const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	Warn("Not support this warn(%d)", nEventID);
}


bool nsFPD::FPDDeviceUltrasonicProbe::OnProcessPreviewImage(unsigned char* pwRawImage, DWORD FrameSize)
{
	AddFrameWithRawHead(IMAGE_PREVIEW, pwRawImage, FrameSize);
	Info("Write PreviewImage Over");
	return true;
}

RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::AddFrameWithRawHead(IMAGE_VIEW_TYPE Type, unsigned char* pFrameBuff, DWORD FrameSize)
{
	string strImageHead = MakeImageHead(Type);
	Info("str image head:{$}",strImageHead.c_str());
	printf("str image head:%s", strImageHead.c_str());
	return m_AcqUnit->AddFrameWithRawHead(Type, strImageHead, pFrameBuff, FrameSize);
}

string nsFPD::FPDDeviceUltrasonicProbe::MakeImageHead(IMAGE_VIEW_TYPE Type)
{
	if (m_pFullImageHead != NULL)
	{
		delete m_pFullImageHead;
		m_pFullImageHead = nullptr;
	}
	if (Type == IMAGE_FULL)
	{
		if (m_pFullImageHead == NULL)
		{
			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, m_nImageBits);
			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, "1");
			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, 0.0f);
			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 == NULL)
		{
			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, m_nPreImageBits);
			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, "1");
			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();
	}
}


bool nsFPD::FPDDeviceUltrasonicProbe::OnProcessImage(unsigned char* pwRawImage, DWORD FrameSize)
{
	Info("FPDDeviceUltrasonicProbe OnProcessImage");
	if (pwRawImage == NULL) 
	{
		Error("OnProcessImage pwRawImage is null!");
		return false;
	}

	//如果环境中只有探测器，那么这里增加一个推送状态
	if (m_bOnlyHaveFpd) 
	{
		Info("OnProcessImage OnlyHaveFpd Sleep 1s then set fpd standby(4)");
		Sleep(1000);
		m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
	}

	AddFrameWithRawHead(IMAGE_FULL, pwRawImage, FrameSize);

	Info("OnProcessImage Write Frame Over");
	return true;
}

//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::AcceptCalibration()
//{
//	Info("==============================AcceptCalibration");
//	printf("--func-- AcceptCalibration\n");
//	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
//	if (((UltrasonicProbe*)m_pDetectors)->AcceptCalibration())
//	{
//		Info("AcceptCalibration over");
//		Ret = RET_STATUS::RET_SUCCEED;
//	}
//	else
//	{
//		Error("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))
//	{
//		Info("Calibration Round: {$}, Exposure Index: {$}, Finished", m_nCalibCurrentCalibrationRound, m_nCalibCurrentExposureIndex);
//		m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//		m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_STANDBY);
//		m_CalibUnit->SetCalibrationProgress(100);
//		return Ret;
//	}
//
//	if (m_nCalibCurrentExposureIndex >= nExposureNumCurrentRound) //跳到下一轮校正参数
//	{
//		m_nCalibCurrentCalibrationRound++;
//		m_nCalibCurrentExposureIndex = 1;
//		ResDataObject temp = m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1];
//		int nDose = temp["Dose"];
//		m_fDoseParam = nDose / 1000.0f;
//	}
//	else
//	{
//		m_nCalibCurrentExposureIndex++;
//	}
//	m_nCalibCurrentExposureNum++;
//
//	m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//	Info("==============================AcceptCalibration over");
//	return Ret;
//}
//
//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::RejectCalibration()
//{
//	printf("--Func-- RejectCalibration \n");
//	Info("==============================RejectCalibration");
//	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
//	if (((UltrasonicProbe*)m_pDetectors)->RejectCalibration())
//	{
//		Ret = RET_STATUS::RET_SUCCEED;
//	}
//	else
//	{
//		Error("RejectCalibration error");
//		Ret = RET_STATUS::RET_FAILED;
//	}
//
//	m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//	Info("==============================RejectCalibration over");
//	return Ret;
//}
//
//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SaveCalibrationFile(bool bSaveFlag)
//{
//	printf("--Func-- SaveCalibrationFile \n");
//	Info("==============================SaveCalibrationFile");
//	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
//	Info("SaveCalibrationFile by user: {$}", bSaveFlag);
//
//	if (!bSaveFlag)
//	{
//		Warn("Not save calibration file");
//		return Ret;
//	}
//
//	if (((UltrasonicProbe*)m_pDetectors)->SaveCalibrationFile())
//	{
//		Info("SaveCalibrationFile over");
//		m_CalibUnit->SetSaveCalibrationFileFinish(true);
//		Ret = RET_STATUS::RET_SUCCEED;
//	}
//	else
//	{
//		Error("SaveCalibrationFile error");
//		m_CalibUnit->SetSaveCalibrationFileFinish(false);
//		Ret = RET_STATUS::RET_FAILED;
//	}
//	Info("==============================SaveCalibrationFile over");
//	return Ret;
//}

//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetRequestedDose(std::string strDose)
//{
//	Info("==============================SetRequestedDose");
//	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
//
//	return Ret;
//}
//
//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetCalibrationStep(int nDetectorID, string& strCalibrationStepInfo)
//{
//	Info("==============================GetCalibrationStep");
//	printf("--func-- GetCalibrationStep\n");
//	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
//	Info("Calibration DetectorID: {$}", nDetectorID);
//	ResDataObject out;
//	int nCalibrationRounds = (int)m_CalibDoseList.size();
//	int nExposureNumCurrentRound = (int)m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1]["ExpNum"];
//
//	if (((UltrasonicProbe*)m_pDetectors)->GetCalibrationStep(m_nCalibCurrentCalibrationRound, nCalibrationRounds, m_nCalibCurrentExposureIndex, nExposureNumCurrentRound))
//	{
//		Info("UltrasonicProbe GetCalibrationStep success");
//		Ret = RET_STATUS::RET_SUCCEED;
//	}
//	else
//	{
//		Error("GetCalibrationStep error");
//		Ret = RET_STATUS::RET_FAILED;
//	}
//
//	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();
//
//	Info("GetCalibrationStep over,strCalibrationStepInfo: {$}", strCalibrationStepInfo.c_str());
//	return Ret;
//}
//
//RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::PauseCalibration()
//{
//	printf("--Func-- PauseCalibration\n");
//	Info("==============================PauseCalibration");
//	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
//	m_nXrayCalibNum++;
//	int nDose = (int)m_fDoseParam;
//	if (nDose == 25 && m_nXrayCalibNum == 10)
//	{
//		Info("start to waitting CalibDoseEvt");
//		DWORD nRet = WaitForSingleObject(m_WaitCalibDoseEvt, INFINITE);
//		//m_nXrayCalibNum = 0;
//	}
//	else if (nDose != 25)
//	{
//		if (m_nXrayCalibNum != 13)
//		{
//			Info("start to waitting CalibDoseEvt");
//			DWORD nRet = WaitForSingleObject(m_WaitCalibDoseEvt, INFINITE);
//		}
//	}
//	m_AcqUnit->SendNoNeedWaitImage(true);
//	if (m_nXrayCalibNum != 13)
//	{
//		m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//		m_CalibUnit->PauseCalibration();
//	}
//
//	Info("Driver PauseCalibration over,m_nXrayCalibNum {$}", m_nXrayCalibNum);
//	Info("==============================PauseCalibration over");
//	return Ret;
//}
//
//bool nsFPD::FPDDeviceUltrasonicProbe::CompleteCalibration()
//{
//	Info("==============================CompleteCalibration");
//	printf("--func-- CompleteCalibration \n");
//	m_stDeviceConfig.fCalibTemperature2 = m_stDeviceConfig.fCurrentTemperValue;
//	m_stDeviceConfig.fCalibTemperature = (m_stDeviceConfig.fCalibTemperature1 + m_stDeviceConfig.fCalibTemperature2) / 2;
//
//	((UltrasonicProbe*)m_pDetectors)->CompleteCalibration(this);
//	
//	if (((UltrasonicProbe*)m_pDetectors)->GetUltrasonicProbeCalibType() == CCOS_CALIBRATION_TYPE_DARK)
//	{
//		Info("CompleteCalibration get Calibration Type:{$}", (int)CCOS_CALIBRATION_TYPE_DARK);
//		printf("CompleteCalibration get Calibration Type: dark\n");
//	}
//	else if (((UltrasonicProbe*)m_pDetectors)->GetUltrasonicProbeCalibType() == CCOS_CALIBRATION_TYPE_XRAY)
//	{
//		Info("UltrasonicProbe Ctrl Calibration Type:{$}", (int)CCOS_CALIBRATION_TYPE_XRAY);
//		printf("CompleteCalibration get Calibration Type: xray\n");
//		DWORD nRet = WaitForSingleObject(m_UploadCalibMapOver, 60000);
//		if (WAIT_OBJECT_0 == nRet)
//		{
//			Info("got event m_UploadCalibMapOver");
//		}
//		else if (WAIT_TIMEOUT == nRet)
//		{
//			Info("wait event m_UploadCalibMapOver timeout");
//		}
//		else
//		{
//			Info("wait event m_UploadCalibMapOver error");
//		}
//	}
//	printf("CompleteCalibration set detector status standby\n");
//	m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//	m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_STANDBY);
//	if (m_bOnlyHaveFpd) 
//	{
//		//通知子系统结束暗场校正太快了，导致后边的服务通知app的消息混乱了（不是一个进程的原因）acqservice，故此处延时1s
//		printf("Sleep 1s,then send progress 100\n");
//		Info("Sleep 1s,then send progress 100");
//		Sleep(1000);
//	}
//	
//	m_CalibUnit->SetCalibrationProgress(100);//make progress
//	//m_SyncUnit->FPDReadyNotify(true);
//	Info("==============================CompleteCalibration over");
//	return true;
//}
//
//void nsFPD::FPDDeviceUltrasonicProbe::AbortCalibration()
//{
//	Info("==============================AbortCalibration");
//	printf("--func-- AbortCalibration\n");
//
//	CCOS_CALIBRATION_TYPE nCalibrationType = m_CalibUnit->GetCalibrationType();
//	if (CCOS_CALIBRATION_TYPE_DARK == nCalibrationType)
//	{
//		m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//		m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_ERROR);
//		m_CalibUnit->SetCalibrationProgress(100);
//
//		Info("==============================AbortCalibration over");
//		return;
//	}
//
//	m_eAppStatus = APP_STATUS_CAL_END;
//	((UltrasonicProbe*)m_pDetectors)->AbortCalibration(this);
//
//	m_DetectorCtrlUnit->SetDetectorStatus(DETECTOR_STATUS_STANDBY);
//	m_CalibUnit->SetCalibrationStatus(CCOS_CALIBRATION_STATUS_ERROR);
//	m_CalibUnit->SetCalibrationProgress(100);
//	m_AcqUnit->SendNoNeedWaitImage(true);
//
//	Info("==============================AbortCalibration over");
//}

void nsFPD::FPDDeviceUltrasonicProbe::OnProcessTemperature(int nID, float fTemperature)
{
	string strWarnErrorCode = "";
	float fMaxTempGap = 6.0f;
	if (m_stDeviceConfig.strDeviceName.find("UltrasonicProbe") >= 0)
	{
		fMaxTempGap = 12.0f;
	}

	if (fTemperature >= m_stDeviceConfig.fTemperMaxLimit)
	{
		Info("Exceed Max Temperature");
		m_stDeviceConfig.nTemperatureStatus = TEMP_TOO_HIGH;
		if (m_stDeviceConfig.bActived)
		{
			strWarnErrorCode = "ERR_FPD_TEMPHIGH_NOT_ACQ";
		}
	}
	else if (fTemperature <= m_stDeviceConfig.fTemperMinLimit)
	{
		m_stDeviceConfig.nTemperatureStatus = TEMP_TOO_LOW;
		if (m_stDeviceConfig.bActived)
		{
			Info("Exceed Min Temperature");
			strWarnErrorCode = "ERR_FPD_TEMPLOW_NOT_ACQ";
		}
	}
	else if (fTemperature <= m_stDeviceConfig.fTemperLowLimit)
	{
		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;
		Info("Exceed Temperature Low Warning");
		//m_WarnAndError->OnErrorX("ERR_FPD_TEMPHIGH_NOT_ACQ");
		//m_WarnAndError->OnErrorX("ERR_FPD_TEMPLOW_NOT_ACQ");
		strWarnErrorCode = "WAR_FPD_TEMPERTURE_LOW";
	}
	else if (fTemperature > m_stDeviceConfig.fTemperWarning)
	{
		Info("Exceed Temperature High Warning");
		//m_WarnAndError->OnErrorX("ERR_FPD_TEMPHIGH_NOT_ACQ");
		//m_WarnAndError->OnErrorX("ERR_FPD_TEMPLOW_NOT_ACQ");
		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;
		strWarnErrorCode = "WAR_FPD_TEMPERATURE_HIGH";
	}
	else if ((m_stDeviceConfig.fCalibTemperature > 1.0f) && (abs(fTemperature - m_stDeviceConfig.fCalibTemperature) >= fMaxTempGap))
	{
		Info("Exceed Calibration Temperature");
		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;
		strWarnErrorCode = "WAR_FPD_EXCEED_CALB_TEMPER";
		//m_WarnAndError->OnErrorX("ERR_FPD_TEMPHIGH_NOT_ACQ");
		//m_WarnAndError->OnErrorX("ERR_FPD_TEMPLOW_NOT_ACQ");
	}
	else if ((fTemperature <= m_stDeviceConfig.fTemperWarning) && (fTemperature > m_stDeviceConfig.fTemperLowLimit))
	{
		Info("Temperature Normal");
		//m_WarnAndError->OnErrorX("ERR_FPD_TEMPHIGH_NOT_ACQ");
		//m_WarnAndError->OnErrorX("ERR_FPD_TEMPLOW_NOT_ACQ");
		//m_stDeviceConfig.nTemperatureStatus = TEMP_NORMAL;
	}
}

//有些板子的reset会持续很长时间，所以这里的调用要谨慎
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::Reset()
{
	printf("--Func-- Reset\n");
	Info("==============================Reset");
	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
	if (((UltrasonicProbe*)m_pDetectors)->ResetDetector(this)) 
	{
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else 
	{
		Ret = RET_STATUS::RET_FAILED;
	}

	Info("==============================Reset over");
	return Ret;
}

/***
* 客户端获取探测器信息
***/
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetDetectorInfo(string& strFDI)
{
	ResDataObject strDetectorInfo;
	string strTempTemp = " ";

	Info("Get Detector Info");

	if (m_stDeviceConfig.strPanelSerial == "")
	{
		Info("Get Detector Info Failed, Send Default Info");

		strDetectorInfo.add("DetectorName", "Simulator");
		strDetectorInfo.add("DetectorSN", "Simulator");
		strDetectorInfo.add("Firmware", " ");
		strDetectorInfo.add("APFirmware", " ");
		strDetectorInfo.add("Software", m_stDeviceConfig.strSoftware.c_str());
		strDetectorInfo.add("SSID", " ");
		strDetectorInfo.add("LifeTime", "0");
		strDetectorInfo.add("PowerOn", "0");
		strDetectorInfo.add("DateCode", " ");
		strDetectorInfo.add("PartNumber", " ");
		strDetectorInfo.add("WifiDataRate", " ");
		strDetectorInfo.add("WifiChannel", "0");
		strDetectorInfo.add("DetectorExist", "0");
		strDetectorInfo.add("SystemAS", "0");
		strDetectorInfo.add("CalibrationDate", "0");
		strDetectorInfo.add("CalibrationDue", "0");
		strDetectorInfo.add("CalibrationExist", "0");
		strDetectorInfo.add("CommunicationStatus", "0");
		strDetectorInfo.add("DetectorTemperature", "0");
		strDetectorInfo.add("FDCalibrationTemperature", "0");
		strDetectorInfo.add("TemperatureStatus", "0");
		strDetectorInfo.add("WaitTime", "0");
		strDetectorInfo.add("DetectorWifiSignal", "0");
		strDetectorInfo.add("DetectorBattery", "0");
		strDetectorInfo.add("ShockSensor", "NULL");
		strDetectorInfo.add("FirmwareUpdate", "0");
		//encode

		strFDI = strDetectorInfo.encode();

		return RET_STATUS::RET_SUCCEED;
	}

	strDetectorInfo.add("DetectorName", m_stDeviceConfig.strDeviceName.c_str());
	strDetectorInfo.add("DetectorSN", m_stDeviceConfig.strPanelSerial.c_str());
	strDetectorInfo.add("Firmware", m_stDeviceConfig.strFirmware.c_str());
	strDetectorInfo.add("APFirmware", "NULL");
	strDetectorInfo.add("Software", m_stDeviceConfig.strSoftware.c_str());
	strDetectorInfo.add("SSID", m_stDeviceConfig.strWifiSSID.c_str());
	strDetectorInfo.add("LifeTime", m_stDeviceConfig.nLifeTime);
	strDetectorInfo.add("PowerOn", m_stDeviceConfig.nPowerOn);
	strDetectorInfo.add("DateCode", m_stDeviceConfig.strDateCode.c_str());
	strDetectorInfo.add("PartNumber", m_stDeviceConfig.strPartNumber.c_str());
	strDetectorInfo.add("WifiDataRate", m_stDeviceConfig.nWifiDataRate);
	strDetectorInfo.add("WifiChannel", m_stDeviceConfig.nWifiChannel);
	strDetectorInfo.add("DetectorExist", m_stDeviceConfig.bExisted);

	//System Workstation
	if (m_stDeviceConfig.strDeviceName.find("UltrasonicProbe") >= 0)
	{
		strDetectorInfo.add("SystemAS", 3);
	}
	else
	{
		strDetectorInfo.add("SystemAS", 3);
	}
	//DetectorCalibrationDate
	if (m_stDeviceConfig.strCalibrationDate != " ")
	{
		if (m_stDeviceConfig.strCalibrationDate.find("19700101") != std::string::npos)
		{
			strDetectorInfo.add("CalibrationDate", "0");
			strDetectorInfo.add("CalibrationDue", "0");
			strDetectorInfo.add("CalibrationExist", 0);
		}
		else
		{
			strDetectorInfo.add("CalibrationDate", m_stDeviceConfig.strCalibrationDate.c_str()/*"20210610"*/);
			strDetectorInfo.add("CalibrationDue", m_stDeviceConfig.strCalibrationDue.c_str()/*"20210610"*/);
			strDetectorInfo.add("CalibrationExist", 1);
		}
	}
	else
	{
		strDetectorInfo.add("CalibrationDate", "0");
		strDetectorInfo.add("CalibrationDue", "0");
		strDetectorInfo.add("CalibrationExist", 0);
	}

	if (m_stDeviceConfig.bConnectStatus)
	{
		strDetectorInfo.add("CommunicationStatus", 1);
	}
	else
	{
		strDetectorInfo.add("CommunicationStatus", 0);
	}

	strDetectorInfo.add("FDCalibrationTemperature", m_stDeviceConfig.fCalibTemperature);
	strDetectorInfo.add("ShockSensor", m_nShockCounts);
	strDetectorInfo.add("FirmwareUpdate", 0);

	strFDI = strDetectorInfo.encode();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsFPD::FPDDeviceUltrasonicProbe::ResetConnect()
{
	((UltrasonicProbe*)m_pDetectors)->Disconnect();
	((UltrasonicProbe*)m_pDetectors)->Connect(this,m_strWorkPath.c_str());
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetFreeze(int nFreeze)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetFreeze(nFreeze);
	}
	else 
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SwitchProbe(int nProbeType)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SwitchProbe(nProbeType);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SwitchProbeMode(int nProbeMode)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SwitchProbeMode(nProbeMode);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetBGain(int nGain)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetBGain(nGain);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetBDepth(int nDepth)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetBDepth(nDepth);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetBFrequency(float fFrequency)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetBFrequency(fFrequency);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetBFocus(int nFocus)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetBFocus(nFocus);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetBHarmonic(int nHarmonic)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetBHarmonic(nHarmonic);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetBPower(int nPower)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetBPower(nPower);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetBDynamicRange(int nRange)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetBDynamicRange(nRange);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetBDepth(int& nDepth, float& fDepthCm)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetBDepth(nDepth, fDepthCm);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetBFrequency(float& fFrequency)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetBFrequency(fFrequency);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetBGain(int& nGain)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetBGain(nGain);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetBFocus(int& nFocus, float& fFocusCm)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetBFocus(nFocus, fFocusCm);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetBDynamicRange(int& nRange)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetBDynamicRange(nRange);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetCRoi(int x1, int x2, int y1, int y2)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetCRoi(x1, x2, y1, y2);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetCGain(int nGain)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetCGain(nGain);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetPostLevel(int nLevel)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetPostLevel(nLevel);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetMirror(int nMirror)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetMirror(nMirror);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetCFrequency(float fFrequency)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetCFrequency(fFrequency);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetCSpeedWallFilter(int nSpeedWallFilter)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetCSpeedWallFilter(nSpeedWallFilter);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetCRangeWallFilter(int nRangeWallFilter)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetCRangeWallFilter(nRangeWallFilter);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetCPersistence(int nPersistence)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetCPersistence(nPersistence);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetCLinearAngle(int nAngle)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetCLinearAngle(nAngle);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetCPrf(int nPrf)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetCPrf(nPrf);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetCFrequency(float& fFrequency)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetCFrequency(fFrequency);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetCGain(int& nGain)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetCGain(nGain);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetCPrf(int& nPrf)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetCPrf(nPrf);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::GetCLinearAngle(int& nAngle)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->GetCLinearAngle(nAngle);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetTgc1(int nTgc)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetTgc1(nTgc);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetTgc2(int nTgc)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetTgc2(nTgc);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetTgc3(int nTgc)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetTgc3(nTgc);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetTgc4(int nTgc)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetTgc4(nTgc);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetTgc5(int nTgc)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetTgc5(nTgc);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetTgc6(int nTgc)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetTgc6(nTgc);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetTgc7(int nTgc)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetTgc7(nTgc);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}
RET_STATUS nsFPD::FPDDeviceUltrasonicProbe::SetTgc8(int nTgc)
{
	if (m_stDeviceConfig.bConnectStatus)
	{
		return g_pDetector->SetTgc8(nTgc);
	}
	else
	{
		Error("UltraSonicProbe is not connected!");
		return RET_STATUS::RET_FAILED;
	}
}