PhysicalDevice/Detector/PZMedical/DIOS.Dev.FPD.PZMedicalRF/DIOS.Dev.FPD.PZMedical.cpp

#include "stdafx.h"
#include "FileVersion.hpp"
#include "CCOS.Dev.FPD.PZMedical.h"
#include "common_api.h"
#include "DICOMImageHeadKey.h"
#include "PZMedicalCtrl.h"
namespace nsFPD = CCOS::Dev::Detail::Detector;


Log4CPP::Logger* gLogger = nullptr;


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


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


nsFPD::PZMedicalDriver::PZMedicalDriver()
{
	pObjDev = nullptr;
	m_bConnect = false; //缺省为false
	m_pAttribute.reset(new ResDataObject());
	m_pDescription.reset(new ResDataObject());
}


nsFPD::PZMedicalDriver::~PZMedicalDriver()
{
	//貌似已经被上层释放了，此处再次释放会崩溃
	//if (nullptr != pObjDev)
	//{
	//	delete pObjDev;
	//	pObjDev = nullptr;
	//}
}


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

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

}


bool nsFPD::PZMedicalDriver::Connect()
{
	Info(__FUNCTION__);
	pObjDev = new FPDDevicePZMedical(EventCenter, m_ConfigFileName);
	m_bConnect = true;
	return true;
}


void nsFPD::PZMedicalDriver::Disconnect()
{
	Info(__FUNCTION__);
	m_bConnect = false; //disconnect置为false
}


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


auto nsFPD::PZMedicalDriver::CreateDevice(int index)->std::unique_ptr <IODevice>
{
	Info(__FUNCTION__);
	auto Device = std::unique_ptr<IODevice>(new IODevice(pObjDev));
	if (!pObjDev->CreateDevice())
	{
		return nullptr;
	}
	pObjDev->Register();
	return Device;
}


std::string nsFPD::PZMedicalDriver::DriverProbe()
{
	Debug(__FUNCTION__);
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		auto Child = r_config[NODE_CONFIGURATION];
		HardwareInfo.add(NODE_MajorID, Child[NODE_MajorID]);
		HardwareInfo.add(NODE_MinorID, Child[NODE_MinorID]);
		HardwareInfo.add(NODE_VendorID, Child[NODE_VendorID]);
		HardwareInfo.add(NODE_ProductID, Child[NODE_ProductID]);
		HardwareInfo.add(NODE_SerialID, Child[NODE_SerialID]);
	}
	else
	{
		HardwareInfo.add(NODE_MajorID, "Detector");
		HardwareInfo.add(NODE_MinorID, "Driver");
		HardwareInfo.add(NODE_VendorID, "CareRay");
		HardwareInfo.add(NODE_ProductID, "CareRay");
		HardwareInfo.add(NODE_SerialID, "1234");
	}
	string str = HardwareInfo.encode();
	return str;
}


/***
** 获取ID和配置
***/
std::string nsFPD::PZMedicalDriver::GetResource()
{
	ResDataObject r_config, temp;
	if (!temp.loadFile(m_ConfigFileName.c_str()))
	{
		return "";
	}

	m_ConfigAll = temp;
	r_config = temp[NODE_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
	{
		string strFPD = (string)r_config[NODE_VendorID];
		ConfigInfo FPDVender(ConfKey::CcosDetectorType, "string", "R", "TRUE", strFPD.c_str());
		AddConfig(FPDVender);
		strFPD = (string)r_config[NODE_ProductID];
		ConfigInfo FPDModel(ConfKey::CcosDetectorModel, "string", "R", "TRUE", strFPD.c_str());
		AddConfig(FPDModel);

		int nConfigInfoCount = (int)r_config[NODE_ConfigToolInfo].GetKeyCount(NODE_AttributeInfo);
		for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
		{
			DescriptionTemp.clear();
			ListTemp.clear();

			auto Child = r_config[NODE_ConfigToolInfo][nInfoIndex][NODE_AttributeDescripition];

			strType = (string)Child[AttributeType];
			strAccess = (string)Child[AttributeAccess];
			strRequired = (string)Child[AttributeRequired];
			strDefaultValue = (string)Child[AttributeDefaultValue];

			strTemp = (string)r_config[NODE_ConfigToolInfo][nInfoIndex][NODE_AttributeKey];
			ConfigInfo  FPDAttr(strTemp.c_str(), strType.c_str(), strAccess.c_str(), strRequired.c_str(), strDefaultValue.c_str());

			//AttributeKey
			//1. 根据AttributeType，内部key和配置路径，拿到当前的真实值
			strTemp = (string)r_config[NODE_ConfigToolInfo][nInfoIndex][NODE_InnerKey];
			nTemp = (int)r_config[NODE_ConfigToolInfo][nInfoIndex][NODE_PathID];
			GetDeviceConfigValue(r_config, strTemp.c_str(), nTemp, strValue);
			//2. 赋值
			FPDAttr.SetCurrentValue(strValue.c_str());

			strRangeMin = (string)Child[AttributeRangeMin];
			strRangeMax = (string)Child[AttributeRangeMax];
			if (strRangeMax != "" && strRangeMin != "") //不需要的配置项为空
			{
				FPDAttr.SetRange(strRangeMin.c_str(), strRangeMax.c_str());
			}

			//AttributeList
			nTemp = Child["ListNum"];
			if (nTemp > 0) //ListNum不大于0时说明不需要list配置
			{
				for (int nListIndex = 0; nListIndex < nTemp; nListIndex++)
				{
					strTemp = (string)Child[NODE_ListInfo][nListIndex];
					sprintf_s(sstream, "%d", nListIndex);
					ListTemp.add(sstream, strTemp.c_str());
				}
				FPDAttr.SetList(ListTemp.encode());
			}

			AddConfig(FPDAttr);
		}
	}
	catch (ResDataObjectExption& e)
	{
		Error("Get config error: {$}", e.what());
		return "";
	}

	ResDataObject resAttr, resDescription;
	for (auto Item : m_ConfigInfo)
	{
		resAttr.add(Item.GetKey(), Item.GetCurrentValue());
		resDescription.add(Item.GetKey(), Item.GetDescription());
	}
	ResDataObject resDeviceResource;
	resDeviceResource.add(ConfKey::CcosDetectorAttribute, resAttr);
	resDeviceResource.add(ConfKey::CcosDetectorDescription, resDescription);

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

	m_DeviceConfig = DescriptionTempEx;
	(*m_pAttribute) = resAttr;
	(*m_pDescription) = resDescription;

	string res = DescriptionTempEx.encode();

	//Debug("get resource over {$}", DescriptionTempEx.encode());

	return res;
}


std::string nsFPD::PZMedicalDriver::DeviceProbe()
{
	Debug(__FUNCTION__);
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		auto Child = r_config[NODE_CONFIGURATION];
		HardwareInfo.add(NODE_MajorID, Child[NODE_MajorID]);
		HardwareInfo.add(NODE_MinorID, "Device");
		HardwareInfo.add(NODE_VendorID, Child[NODE_VendorID]);
		HardwareInfo.add(NODE_ProductID, Child[NODE_ProductID]);
		HardwareInfo.add(NODE_SerialID, Child[NODE_SerialID]);
	}
	else
	{
		HardwareInfo.add(NODE_MajorID, "Detector");
		HardwareInfo.add(NODE_MinorID, "Device");
		HardwareInfo.add(NODE_VendorID, "CareRay");
		HardwareInfo.add(NODE_ProductID, "CareRay");
		HardwareInfo.add(NODE_SerialID, "1234");
	}
	string str = HardwareInfo.encode();
	return str;
}


bool nsFPD::PZMedicalDriver::GetDeviceConfig(std::string& Cfg)
{
	Info(__FUNCTION__);
	Cfg = m_DeviceConfig.encode();
	return true;
}


bool nsFPD::PZMedicalDriver::SetDeviceConfig(std::string Cfg)
{
	Info("{$} {$}", __FUNCTION__, 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.c_str());
			try
			{
				if (m_pAttribute->GetFirstOf(strKey.c_str()) >= 0)
				{
					strAccess = (string)(*m_pDescription)[strKey.c_str()][AttributeAccess];
					if ("rw" == strAccess)
					{
						//修改对应配置，在其他单元的配置项要同时调用其修改函数修改真实值
						//1. 修改内存中的值，用于给上层发消息
						(*m_pAttribute)[strKey.c_str()] = temp[j];
						//2. 拿到Innerkey
						int nConfigInfoCount = (int)m_Configurations[NODE_ConfigToolInfo].GetKeyCount(NODE_AttributeInfo);
						Info("ConfigInfo Count: {$}", nConfigInfoCount);
						string strTemp = ""; //存储AttributeKey
						for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
						{
							strTemp = (string)m_Configurations[NODE_ConfigToolInfo][nInfoIndex][NODE_AttributeKey];
							if (strTemp == strKey)
							{
								strTemp = (string)m_Configurations[NODE_ConfigToolInfo][nInfoIndex][NODE_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)
	{
		//3. 重新保存配置文件
		SaveConfigFile(true);
	}
	return true;
}


bool nsFPD::PZMedicalDriver::SaveConfigFile(bool bSendNotify)
{
	m_ConfigAll[NODE_CONFIGURATION] = m_Configurations;

	m_ConfigAll.SaveFile(m_ConfigFileName.c_str());
	Info("SaveConfigFile over");
	return true;
}


bool nsFPD::PZMedicalDriver::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[NODE_connections][pInnerKey];
		}
		else if (DetectorVender == strTemp || DetectorModel == strTemp ||
			DetectorDescription == strTemp || DetectorSerialNumber == strTemp)
		{
			strValue = (string)config[pInnerKey];
		}
		else if (SyncType == strTemp || FPDWorkStation == strTemp ||
			ImageWidth == strTemp || ImageHeight == strTemp)
		{
			strValue = (string)config[NODE_ModeTable][NODE_DetectorMode][pInnerKey];
		}
		else if (TempMaxLimit == strTemp || ReConnect == strTemp ||
			TempUpperLimit == strTemp || TempLowerLimit == strTemp || TempMinLimit == strTemp ||
			BatLowerLimit == strTemp || BatMiniLimit == strTemp ||
			BatLowerLimitInCali == strTemp || WifiLowerLimit == strTemp ||
			WifiMiniLimit == strTemp || HighPowerTimeout == strTemp ||
			ShowTemperature == strTemp || ShowWifi == strTemp ||
			ShowBattery == strTemp || ShowBluetooth == strTemp ||
			FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp || CcosDetectorAttachedFlag == strTemp)
		{
			strValue = (string)config[pInnerKey];
		}
		else
		{
			strValue = "";
			Warn("Error Configuration item: {$}", pInnerKey);
		}
	}
	return true;
}


bool nsFPD::PZMedicalDriver::SetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, const char* szValue)
{
	string strTemp = pInnerKey;
	Trace("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)
		{
			config["ModeTable"]["DetectorMode"][pInnerKey] = szValue;
		}
		else if (TempMaxLimit == strTemp || ReConnect == strTemp ||
			TempUpperLimit == strTemp || TempLowerLimit == strTemp ||
			BatLowerLimit == strTemp || BatMiniLimit == strTemp ||
			BatLowerLimitInCali == strTemp || WifiLowerLimit == strTemp ||
			WifiMiniLimit == strTemp || HighPowerTimeout == strTemp ||
			ShowTemperature == strTemp || ShowWifi == strTemp ||
			ShowBattery == strTemp || ShowBluetooth == strTemp ||
			FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp)
		{
			config[pInnerKey] = szValue;
		}
		else
		{
			Warn("Error Configuration item: {$}", pInnerKey);
			return false;
		}
	}
	return true;
}


//-----------------------------------------------------------------------------
//		FPDDevicePZMedical
//-----------------------------------------------------------------------------
extern PZMedicalCtrl* g_pDetector;


nsFPD::FPDDevicePZMedical::FPDDevicePZMedical(std::shared_ptr<IOEventCenter> center, std::string strConfigPath)
	: m_bConnect(false)
	, m_pDetector(nullptr)
	, m_pImgBuffer(nullptr)
	, m_nCurrentMode(-1)
	, m_fCurrentPPS(0.0f)
	, m_fFactorEXI2UGY(0.0f)
	, m_eSyncMode(SYNC_HARDWARE)
	, m_fCurrentDetectorTemperature(-273.15f)
{
	super::EventCenter = center;
	m_strWorkPath = GetProcessDirectory();
	m_DetectorCtrlUnit.reset(new OemCtrl(center, this));
	m_AcqUnit.reset(new OemAcq(center, this));
	m_SyncUnit.reset(new OemSync(center, this));
	m_CalibUnit.reset(new OemCalib(center, this));
	m_DetectorConfiguration.reset(new DetectorConfiguration(strConfigPath));

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_SHUTDOWN));
	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
}


nsFPD::FPDDevicePZMedical::~FPDDevicePZMedical()
{
}


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


bool nsFPD::FPDDevicePZMedical::Prepare()
{
	Info("=====Prepare");
	int nFrameCount = m_stDeviceConfig.nMaxFrameNum;
	Info("Max frame count: {$}", nFrameCount);
	//动态没有预览图
	EventCenter->OnMaxBlockSize("RfQue", 1500 * 1500 * 2, nFrameCount, 10 * 10 * 2, 1);

	Connect();
	return true;
}


bool nsFPD::FPDDevicePZMedical::CreateDevice()
{
	Info(__FUNCTION__);
	if (!LoadConfig())
	{
		Error("Load configuration file failed!!!");
		return false;
	}

	if (g_pDetector == nullptr)
	{
		m_pDetector = new PZMedicalCtrl();
		g_pDetector = m_pDetector;
		Info("Create SDK ctrl ok");
	}
	else
	{
		m_pDetector = g_pDetector;
		Info("SDK ctrl Already exit");
	}
	//多板可使用多DPC设备对象实现
	//return g_pDetector->DriverEntry(this, m_DetectorConfiguration->m_Configurations);
	m_pDetector->DriverEntry(this, m_DetectorConfiguration->m_Configurations);
	return true;
}


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

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


RET_STATUS nsFPD::FPDDevicePZMedical::Connect()
{
	m_DetectorCtrlUnit->SetAttachStatus(to_string(1)); //没有attach功能，直接上发1，使客户端显示探测器状态

	if (m_stDeviceConfig.bSupportDDR) //是否支持DDR采集功能
	{
		m_DetectorCtrlUnit->SetSupportDDR(to_string(1));
	}
	else
	{
		m_DetectorCtrlUnit->SetSupportDDR(to_string(0));
	}

	RET_STATUS ret = RET_STATUS::RET_FAILED;
	if (m_pDetector->Connect(this, m_strWorkPath.c_str()))
	{
		m_bConnect = true;
		ret = RET_STATUS::RET_SUCCEED;
	}
	return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::EnterExam(int nExamMode)
{
	Info("{$} ({$})",__FUNCTION__, 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;
	}

	m_pDetector->EnterExamMode(nExamMode);

	return RET_STATUS::RET_SUCCEED;
}

/***
* 激活对应的探测器
***/
RET_STATUS nsFPD::FPDDevicePZMedical::ActiveDetector(bool bActive)
{
	Info("=====ActiveDetector");
	int nDetectorID = 1;
	if (!m_pDetector->ActiveDetector(nDetectorID))
	{
		return RET_STATUS::RET_FAILED;
	}
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::SetAcqMode(std::string strAcqmode)
{
	Info("=====SetAcqMode ({$})", strAcqmode);
	RET_STATUS ret = RET_STATUS::RET_FAILED;
	int nMode = 0;

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


	if (strAcqmode.find("RAD") != std::string::npos)
	{
		nMode = 1;
	}
	else if (strAcqmode.find("CF") != std::string::npos && m_fCurrentPPS < 16.0f)
	{
		nMode = 3;
	}
	else if (strAcqmode.find("PF") != std::string::npos && m_fCurrentPPS < 16.0f)
	{
		nMode = 4;
	}
	else if (strAcqmode.find("CF") != std::string::npos && m_fCurrentPPS >= 16.0f)
	{
		nMode = 5;
	}
	else if (strAcqmode.find("PF") != std::string::npos && m_fCurrentPPS >= 16.0f)
	{
		nMode = 6;
	}
	else
	{
		Error("Undefined Acq mode, return");
		return ret;
	}

	//判重
	if (m_nCurrentMode == nMode)
	{
		Info("Same mode, return true");
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		return RET_STATUS::RET_SUCCEED;
	}

	//获取当前模式号对应的配置
	if (!m_DetectorConfiguration->GetDetModeInfo(nMode, m_stModeInfo))
	{
		Error("Illegal mode!");
		return ret;
	}

	int nImgX = m_stModeInfo.nImageWidth;
	int nImgY = m_stModeInfo.nImageHeight;
	//申请图像内存
	if (nullptr != m_pImgBuffer)
	{
		delete m_pImgBuffer;
		m_pImgBuffer = nullptr;
	}
	m_pImgBuffer = new WORD[(size_t)nImgX * (size_t)nImgY];

	//发送图像信息
	if (m_stModeInfo.nRotateAngle == 90 || m_stModeInfo.nRotateAngle == 270)
	{
		m_AcqUnit->SetFulImageInfo(nImgX, nImgY, m_stModeInfo.nPhySizeInfoBit, false);
	}
	else
	{
		m_AcqUnit->SetFulImageInfo(nImgY, nImgX, m_stModeInfo.nPhySizeInfoBit, false);
	}
	Info("Sync Mode: {$}, ", m_stModeInfo.nSyncType);

	if (m_pDetector->SetAcqMode(m_stModeInfo, m_stCalibInfo, nMode))
	{
		m_nCurrentMode = nMode;
		ret = RET_STATUS::RET_SUCCEED;
	}

	int Sensitivity = (int)m_stModeInfo.nSensitivity;
	char szValue[32];
	sprintf_s(szValue, sizeof(szValue), "%d", Sensitivity);
	m_DetectorCtrlUnit->SetFPDSensitivity(szValue);
	Info("FPD Sensitivity: {$}", Sensitivity);

	m_fFactorEXI2UGY = 100.0f / (float)m_stModeInfo.nSensitivity * 1.0f;
	Info("FactorEXI2UGY: {$}", m_fFactorEXI2UGY);

	Info("SetAcqMode over");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::GetSyncMode(SYNC_MODE& eSyncMode)
{
	Info("=====GetSyncMode");
	eSyncMode = m_eSyncMode;
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::PrepareAcquisition()
{
	Info("=====PrepareAcquisition");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

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

	Info("PrepareAcquisition over");
	return RET_STATUS::RET_SUCCEED; //下面不要，到踩脚闸和按手闸再走


	//m_SyncUnit->FPDReadyNotify(false); //prepare前置为初值
	//if (m_pDetector->PrepareAcquisition(this))
	//{
	//	ret = RET_STATUS::RET_SUCCEED;
	//	m_SyncUnit->FPDReadyNotify(true); //prepare succeed
	//}
	//Info("PrepareAcquisition over");
	//return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::StartAcquisition(string in)
{
	Info("=====StartAcquisition: {$}", in);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

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

	ret = SetAcqMode(in);

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));

	if (in == "RAD")
	{
		
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			Error("StartAcquisition SetAcqMode(RAD) fail!");
			return ret;
		}
		if (!m_pDetector->PrepareAcquisition(this))
		{
			Info("RAD pre failed");
			return RET_STATUS::RET_FAILED;
		}
		ret = RET_STATUS::RET_SUCCEED;
		m_pDetector->m_bGrabStatus = true;
		Info("RAD delay time: {$}", m_stDeviceConfig.nRADDelayTime);
		Sleep(m_stDeviceConfig.nRADDelayTime);
	}
	else if (in == "CF")
	{
		if (!m_pDetector->PrepareAcquisition(this))
		{
			Info("CF pre failed");
			return RET_STATUS::RET_FAILED;
		}
		ret = RET_STATUS::RET_SUCCEED;
		Info("StartAcquisition(CF)");
	}
	else if (in == "PF")
	{
		if (!m_pDetector->PrepareAcquisition(this))
		{
			Info("PF pre failed");
			return RET_STATUS::RET_FAILED;
		}
		ret = RET_STATUS::RET_SUCCEED;
		Info("StartAcquisition(PF)");
	}
	else
	{
		Error("Not support this mode, mode name:{$}", in);
		return ret;
	}

	//重新整理：工作流要求先设置采集状态(5)后发开窗状态
	if (m_pDetector->StartAcquisition(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
	}

	Info("StartAcquisition over");
	return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::StopAcquisition()
{
	Info("=====StopAcquisition");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

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

	
	if (m_pDetector->StopAcquisition(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	}
	
	Info("StopAcquisition over");
	return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::SetFluPPS(float fFluPPS)
{
	Info("=====SetFluPPS: {$}", fFluPPS);

	m_fCurrentPPS = fFluPPS;

	if (!m_pDetector->SetFluPPS(fFluPPS))
	{
		return RET_STATUS::RET_FAILED;
	}
	m_AcqUnit->FluPPSNotify(fFluPPS);
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::GetFluPPS(float& fFluPPS)
{
	m_pDetector->GetFluPPS(fFluPPS);
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::ActiveCalibration(CCOS_CALIBRATION_TYPE eType)
{
	Info("=====ActiveCalibration ({$})", (int)eType);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		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())
	{
		if (DETECTOR_STATUS_ACQ == m_DetectorCtrlUnit->GetDetectorStatus())
		{
			Error("ActiveCalibration failed. Detector at Acq status");
		}
		return RET_STATUS::RET_FAILED;
	}

	assert(m_pDetector);

	if (m_pDetector->ActiveCalibration(this, eType))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ACTIVE));
		m_CalibUnit->SetCalibrationProgress(to_string(0));
	}
	else
	{
		Error("Active calibration failed");
	}
	Info("ActiveCalibration over");
	return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::PrepareCalibration()
{
	Info("=====PrepareCalibration");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

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

	m_SyncUnit->FPDReadyNotify(false); //prepare前置为初值
	if (m_pDetector->PrepareCalibration(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_SyncUnit->FPDReadyNotify(true); //prepare succeed
	}
	else
	{
		Error("Prepare calibration failed");
	}
	Info("PrepareCalibration over");
	return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::GetRequestedDose(string& strDose)
{
	Info("=====GetRequestedDose");
	//fDose = m_fDose;
	strDose = to_string(100); //暂时写死
	Info("Dose request: {$}", strDose);
	Info("GetRequestedDose over");
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::GetCalibrationStep(int nDetectorID, std::string& strCalibrationStepInfo)
{
	Info("=====GetCalibrationStep");

	Info("GetCalibrationStep over");
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::StartCalibration()
{
	Info("=====StartCalibration");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

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

	if ((m_CalibUnit->GetCalibrationStatus() != CCOS_CALIBRATION_STATUS_PAUSE) && (m_CalibUnit->GetCalibrationStatus() != CCOS_CALIBRATION_STATUS_ACTIVE))
	{
		Error("Start calibration failed, in {$} status", (int)m_CalibUnit->GetCalibrationStatus());
		return ret;
	}

	if (DETECTOR_STATUS_STANDBY != m_DetectorCtrlUnit->GetDetectorStatus())
	{
		if (DETECTOR_STATUS_ACQ == m_DetectorCtrlUnit->GetDetectorStatus())
		{
			Error("Start calibration failed. Detector at Acq status");
		}
		return ret;
	}

	if (m_CalibUnit->GetCalibrationStatus() == CCOS_CALIBRATION_STATUS_RUNNING)
	{
		Error("Detector already at calib status");
		return ret;
	}

	if (m_pDetector->StartCalibration(this))
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_RUNNING));
		ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		Error("Start calibration failed");
	}
	Info("StartCalibration over");
	return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::StopCalibration()
{
	Info("=====StopCalibration");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

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

	if (m_pDetector->StopCalibration(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress(to_string(100));
	}
	else
	{
		Error("Start calibration failed");
	}
	Info("StopCalibration over");
	return ret;
}


RET_STATUS nsFPD::FPDDevicePZMedical::AcceptCalibration()
{
	Info("=====AcceptCalibration");
	m_pDetector->ConfirmCalExposure();
	Info("AcceptCalibration over");
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::RejectCalibration()
{
	Info("=====RejectCalibration");
	m_pDetector->RejectCalExposure();
	Info("RejectCalibration over");
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::SaveCalibrationFile(bool bSaveFlag)
{
	Info("=====SaveCalibrationFile ({$})", bSaveFlag);
	Info("SaveCalibrationFile over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDevicePZMedical::StartOffset(bool isAll)
{
	//品臻只需要刷新点片Offset
	Info("=====StartOffset: {$}", isAll);
	m_pDetector->StartOffset(0);
	m_nCurrentMode = 0;
	Info("StartOffset over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDevicePZMedical::AbortOffset()
{
	Info("=====AbortOffset");
	m_pDetector->AbortOffset();
	Info("AbortOffset over");
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDevicePZMedical::UpdateModeInRunning(std::vector<AcqModeInfo>& vAcqModeList)
{
	/*FINFO("--Func-- UpdateModeInRunning");
	m_vAcqModeInfoList.assign(vAcqModeList.begin(), vAcqModeList.end());
	for (size_t i = 0; i < m_vAcqModeInfoList.size(); i++)
	{
		if (m_vAcqModeInfoList[i].fFrequency == m_fCurrentPPS)
		{
			g_pDetector->UpdateModeInRunning(m_vAcqModeInfoList[i].nModeID, m_vAcqModeInfoList[i].fFrequency);
			break;
		}
	}*/
	Info("UpdateModeInRunning, mode size: {$}", vAcqModeList.size());
	for (size_t i = 0; i < vAcqModeList.size(); i++)
	{
		Info("index: {$}, ModeID: {$}, frequence: {$}", i, vAcqModeList[i].nModeID, vAcqModeList[i].fFrequency);
	}
	return RET_SUCCEED;
}


bool nsFPD::FPDDevicePZMedical::Support_DarkCalib()
{
	//支持暗场校正
	return true;
}


bool nsFPD::FPDDevicePZMedical::Support_XrayCalib()
{
	//支持亮场校正
	return true;
}


bool nsFPD::FPDDevicePZMedical::Support_HaveImageCalib()
{
	return true;
}


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


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


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


bool nsFPD::FPDDevicePZMedical::LoadConfig()
{
	if (!m_DetectorConfiguration->LoadConfigurations(m_stDeviceConfig))
	{
		Error("Load configuration file failed!!!");
		return false;
	}

	m_DetectorCtrlUnit->SetDetectorType("SCINTILLATOR");
	//不同采集模式可能会有不同的值，后面在考虑
	auto strSensitivity = to_string(m_stDeviceConfig.AcqModeInfo.nSensitivity);
	m_DetectorCtrlUnit->SetFPDSensitivity(strSensitivity);
	m_DetectorCtrlUnit->SetPixelData("");
	m_DetectorCtrlUnit->SetTargetEXI("5000");
	m_AcqUnit->SetMaxFrameRate(m_stDeviceConfig.fMaxFrameRate);
	auto nOffsetinteral = to_string(m_stDeviceConfig.nOffsetInterval);
	m_CalibUnit->SetOffsetInterval(nOffsetinteral);
	Info("Offset interval: {$} minutes", nOffsetinteral);
	m_DetectorCtrlUnit->SetDetectorWidth(to_string(m_stDeviceConfig.nMaxImgWidth));
	m_DetectorCtrlUnit->SetDetectorHeight(to_string(m_stDeviceConfig.nMaxImgHeight));

	//暂时发特定值
	m_DetectorCtrlUnit->SetDateofLastDetectorCalibration(m_stDeviceConfig.strCalibrationDate);
	m_DetectorCtrlUnit->SetTimeofLastDetectorCalibration(m_stDeviceConfig.strCalibrationTime);

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

	m_Temperature.reset(new DeviceTemperatureMould("DetectorTemperature", 0.0f, m_stDeviceConfig.fTemperLowLimit, m_stDeviceConfig.fTemperMinWarn, 
		m_stDeviceConfig.fTemperMaxWarn, m_stDeviceConfig.fTemperMinWarn, m_stDeviceConfig.fTemperMaxWarn, m_stDeviceConfig.fTemperMaxLimit, 0.0f, EventCenter));

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

	return true;
}


void nsFPD::FPDDevicePZMedical::RegisterCtrl(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("ActiveDetector", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSActiveDetector);
	Dispatch->Action.Push(ActionKey::EnterExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSEnterExam);
	Dispatch->Action.Push(ActionKey::ExitExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSExitExam);
	Dispatch->Get.Push(CcosDetectorStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDStatus);
	Dispatch->Get.Push(AttrKey::DetectorType, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorType);
	Dispatch->Get.Push(AttrKey::Description, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDescription);
	Dispatch->Get.Push(AttrKey::DetectorID, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorID);
	Dispatch->Get.Push(AttrKey::FPDSensitivity, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDSensitivity);
	Dispatch->Get.Push(AttrKey::PixelData, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetPixelData);
	Dispatch->Get.Push(AttrKey::TargetEXI, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTargetEXI);
	Dispatch->Action.Push(ActionKey::SetXrayOnNum, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetXrayOnNum);
	Dispatch->Action.Push(ActionKey::SetExposureTimes, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetExposureTimes);
	Dispatch->Get.Push(CcosDetectorAttachedFlag, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachStatus);
	Dispatch->Get.Push("SupportDDR", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetSupportDDR);
	Dispatch->Get.Push(AttrKey::DetectorWidth, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorWidth);
	Dispatch->Get.Push(AttrKey::DetectorHeight, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorHeight);

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

	Dispatch->Update.Push(ConfKey::CcosDetectorSerialNumber, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateSerialNumber);
}


void nsFPD::FPDDevicePZMedical::RegisterAcq(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::SetAcqMode, m_AcqUnit.get(), &AcqUnit::JSSetAcqMode);
	Dispatch->Action.Push(ActionKey::SetValue_PPS, m_AcqUnit.get(), &AcqUnit::JSSetFluPPS);

	Dispatch->Get.Push(CcosZskkFPDState, m_AcqUnit.get(), &AcqUnit::JSGetZskkFPDState);
	Dispatch->Get.Push(AttrKey::NoNeedWaitImage, m_AcqUnit.get(), &AcqUnit::JSGetNoNeedWaitImage);
	Dispatch->Get.Push(AttrKey::ImgDataInfo, m_AcqUnit.get(), &AcqUnit::JSGetLastImage);
	Dispatch->Get.Push(AttrKey::FluPPS, m_AcqUnit.get(), &AcqUnit::JSGetFluPPS);
	Dispatch->Get.Push(AttrKey::MaxFrameRate, m_AcqUnit.get(), &AcqUnit::JSGetMaxFrameRate);

	Dispatch->Update.Push(AttrKey::ModeInRunning, m_AcqUnit.get(), &AcqUnit::JSUpdateModeInRunning);
}


void nsFPD::FPDDevicePZMedical::RegisterSync(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::SetSyncMode, m_SyncUnit.get(), &SyncUnit::JSSetSyncMode);
	Dispatch->Action.Push(ActionKey::SetXwindowSize, m_SyncUnit.get(), &SyncUnit::JSSetXwindowSize);
	Dispatch->Action.Push(ActionKey::PrepareAcquisition, m_SyncUnit.get(), &SyncUnit::JSPrepareAcquisition);
	Dispatch->Action.Push(ActionKey::StartAcquisition, m_SyncUnit.get(), &SyncUnit::JSStartAcquisition);
	Dispatch->Action.Push(ActionKey::StopAcquisition, m_SyncUnit.get(), &SyncUnit::JSStopAcquisition);
	Dispatch->Get.Push(CcosSyncMode, m_SyncUnit.get(), &SyncUnit::JSGetSyncMode);
	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(AttrKey::FPDExpReady, m_SyncUnit.get(), &SyncUnit::JSGetExpReadyStatus);
}


void nsFPD::FPDDevicePZMedical::RegisterCalib(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::ActiveCalibration, m_CalibUnit.get(), &CalibUnit::JSActiveCalibration);
	Dispatch->Action.Push(ActionKey::GetRequestedDose, m_CalibUnit.get(), &CalibUnit::JSGetRequestedDose);
	Dispatch->Action.Push(ActionKey::PrepareCalibration, m_CalibUnit.get(), &CalibUnit::JSPrepareCalibration);
	Dispatch->Action.Push(ActionKey::StartCalibration, m_CalibUnit.get(), &CalibUnit::JSStartCalibration);
	Dispatch->Action.Push(ActionKey::StopCalibration, m_CalibUnit.get(), &CalibUnit::JSStopCalibration);
	Dispatch->Action.Push(ActionKey::SetCorrectionType, m_CalibUnit.get(), &CalibUnit::JSSetCorrectionType);
	Dispatch->Action.Push(ActionKey::StartOffset, m_CalibUnit.get(), &CalibUnit::JSStartOffset);
	Dispatch->Action.Push(ActionKey::AbortOffset, m_CalibUnit.get(), &CalibUnit::JSAbortOffset);

	Dispatch->Get.Push(AttrKey::CalibrationStatus, m_CalibUnit.get(), &CalibUnit::JSGetCalibStatus);
	Dispatch->Get.Push(AttrKey::CalibrationProgress, m_CalibUnit.get(), &CalibUnit::JSGetCalibProgress);
	Dispatch->Get.Push(AttrKey::UploadCalibrationFilesResult, m_CalibUnit.get(), &CalibUnit::JSGetUploadCalibrationFilesResult);
	Dispatch->Get.Push(AttrKey::SupportCalibrationType, m_CalibUnit.get(), &CalibUnit::JSGetSupportCalibrationType);
	Dispatch->Get.Push(AttrKey::OffsetStatus, m_CalibUnit.get(), &CalibUnit::JSGetOffsetStatus);
	Dispatch->Get.Push(AttrKey::OffsetCounts, m_CalibUnit.get(), &CalibUnit::JSGetOffsetCounts);
	Dispatch->Get.Push(AttrKey::OffsetProgress, m_CalibUnit.get(), &CalibUnit::JSGetOffsetProgress);
	Dispatch->Get.Push(AttrKey::OffsetInterval, m_CalibUnit.get(), &CalibUnit::JSGetOffsetInterval);

	Dispatch->Set.Push(AttrKey::OffsetInterval, m_CalibUnit.get(), &CalibUnit::SetOffsetInterval);
	Dispatch->Update.Push(AttrKey::OffsetInterval, m_CalibUnit.get(), &CalibUnit::JSUpdateOffsetInterval);
}


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


void nsFPD::FPDDevicePZMedical::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::FPDDevicePZMedical::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.strFPDSN = pszMsg;
		Info("OnEventProcessConf: Detector {$} SN {$}", nDetectorID, pszMsg);
		m_DetectorCtrlUnit->SetDetectorID(m_stDeviceConfig.strFPDSN);
		break;
	}
	default:
		break;
	}
}


void nsFPD::FPDDevicePZMedical::OnEventProcessInfo(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
	case EVT_INFO_CALIBRATIOIN_TIME:
	{
		m_stDeviceConfig.strCalibrationDate = pszMsg;
		Info("OnEventProcessInfo: Detector {$} Calibration Time: {$}", nDetectorID, pszMsg);
		m_DetectorCtrlUnit->SetDateofLastDetectorCalibration(m_stDeviceConfig.strCalibrationDate);
		m_DetectorCtrlUnit->SetTimeofLastDetectorCalibration("");
		break;
	}
	default:
		break;
	}
}


void nsFPD::FPDDevicePZMedical::OnEventProcessStatus(int nDetectorID, int nEventID, int nEventLevel,
	const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
	case EVT_STATUS_PANEL:
	{
		//ENUM_PANEL_STATUS m_ePanelStatus = (ENUM_PANEL_STATUS)nParam1;
		if (PANEL_START_ACQ == nParam1)
		{
			Info("Panel Status: Start acq");
			m_stImgCreateTime = { 0 };
			GetLocalTime(&m_stImgCreateTime);
			Info("DDR image create time-{$}:{$}:{$}.{$}",
				m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);
		}
		else if (PANEL_END_ACQ == nParam1)
		{
			Info("Panel Status: End acq");
			if (m_pDetector->StopAcquisition(this))
			{
				m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
			}
		}
		else if (PANEL_AEC_PRE_END == nParam1)
		{
			Info("Panel Status: AEC pre-shoot end");
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		}
		else if (PANEL_READY_EXP == nParam1)
		{
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				m_SyncUnit->ExpReadyNotify(m_stModeInfo.nXwindow);
			}
			else
			{
				m_SyncUnit->ExpReadyNotify(0);
			}
		}
		else if (PANEL_XWINDOW_ON == nParam1) //Xwindow On
		{
			m_stImgCreateTime = { 0 };
			GetLocalTime(&m_stImgCreateTime);
			Info("Full image create time-{$}:{$}:{$}.{$}",
				m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);
			Info("XWindowON");
			m_SyncUnit->XWindowOnNotify();
		}
		else if (PANEL_XWINDOW_OFF == nParam1) // Xwindow Off
		{
			m_SyncUnit->XWindowOffNotify();
		}
	}
		break;
	case EVT_STATUS_CALIBRATIOIN:
	{
		ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
		switch (eStatus)
		{
		case PANEL_EVENT_START:
			break;
		case PANEL_EVENT_END_OK:
		case PANEL_EVENT_END_ERROR:
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
			m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
			m_CalibUnit->SetCalibrationProgress(to_string(100));//make progress
			break;
		case PANEL_EVENT_TIMEOUT:
			break;
		default:
			break;
		}
	}
		break;
	case EVT_STATUS_SINGLEEXP:
	{
		if (DOSE_ACCEPT == nParam1)
		{
			Info("Calibration Result is acceptable");
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
			m_CalibUnit->PauseCalibration();
		}
		else
		{
			Warn("Not support this param({$})", nParam1);
		}
	}
		break;
	case EVT_STATUS_TEMPERATURE:
	{
		float fTemperature = fParam2;
		m_fCurrentDetectorTemperature = fParam2;
	//	if (fTemperature > m_fTemperMaxLimit)
	//	{
	//		AddErrMsg("14", "temperature_toohigh");
	//	}
	//	else if (fTemperature >= m_fTemperWarning)
	//	{
	//		AddWarnMsg("14", "temperature_high");
	//	}
	//	else if (fTemperature < m_fTemperMinLimit)
	//	{
	//		AddErrMsg("14", "temperature_toolow");
	//	}
	//	else if (fTemperature <= m_fTemperLowLimit)
	//	{
	//		AddWarnMsg("14", "temperature_low");
	//	}
	//	else
	//	{
	//		DelErrMsg("14");
	//	}
		SendTemperatureValue(fTemperature);
	}
		break;
	case EVT_STATUS_WIFI:
	{
		int nWifiLevel = nParam1;
	//	if (nWifiLevel < m_nWifiLimit)
	//	{
	//		AddErrMsg("15", "wifi_toolow");
	//	}
	//	else if (nWifiLevel <= m_nWifiWarning)
	//	{
	//		AddWarnMsg("15", "wifi_low");
	//	}
	//	else
	//	{
	//		DelErrMsg("15");
	//	}
		SendWifiValue(nWifiLevel);
	}
		break;
	case EVT_STATUS_BATTERY_VALUE:
	{
		int nBatteryValue = nParam1;
	//	if (nBatteryValue < m_nBatteryLimit)
	//	{
	//		AddErrMsg("16", "battery_toolow");
	//	}
	//	else if (nBatteryValue <= m_nBatteryWarning)
	//	{
	//		AddWarnMsg("16", "battery_low");
	//	}
	//	else
	//	{
	//		DelErrMsg("16");
	//	}
		SendBatteryValue(nBatteryValue);
	}
		break;
	case PANEL_OFFSET_CAL:
	{
		if (OFFSET_IDLE == nParam1)
		{
			Info("Offset is Idle");
			m_CalibUnit->SetOffsetStatus("Idle");
			m_CalibUnit->SetOffsetProgress("1");
			m_CalibUnit->SetOffsetCounts("1");
		}
		else if (OFFSET_RUNNING == nParam1)
		{
			Info("Offset is Running");
			m_CalibUnit->SetOffsetStatus("Running");
			m_CalibUnit->SetOffsetProgress("0");
			m_CalibUnit->SetOffsetCounts("1");
		}
		else if (OFFSET_ERROR == nParam1)
		{
			Info("Offset is error");
			m_CalibUnit->SetOffsetStatus("Error");
			m_CalibUnit->SetOffsetProgress("1");
			m_CalibUnit->SetOffsetCounts("1");
		}
		break;
	}
	default:
		Warn("Not support this status({$})", nEventID);
		break;
	}
}


void nsFPD::FPDDevicePZMedical::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("Image Arrived");
		int nImgX = m_stModeInfo.nImageWidth;
		int nImgY = m_stModeInfo.nImageHeight;
		int nAngle = m_stModeInfo.nRotateAngle;
		memcpy(m_pImgBuffer, pParam, (size_t)nImgX * (size_t)nImgY * sizeof(WORD));

		//暂时先用假值，有需要再改
		ResDataObject objImageHead, objTemp;
		objTemp.add(SM_IMAGE_TYPE, (int)IMAGE_FULL);
		objTemp.add(SM_IMAGE_BIT, 16);
		objTemp.add(SM_IMAGE_TAG, 1);
		objTemp.add(SM_IMAGE_INDEX, 1);
		objTemp.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
		objTemp.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
		objTemp.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
		objTemp.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
		objTemp.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
		objTemp.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
		objTemp.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
		objTemp.add(SM_IMAGE_LSB, "5000");
		objTemp.add(SM_IMAGE_DOSE, m_stModeInfo.nSensitivity);
		objTemp.add(SM_IMAGE_PIXELSPACING, m_stModeInfo.nPixelPitch);
		objTemp.add(SM_IMAGE_PIXELREPRESENTATION, "1");
		objTemp.add(SM_IMAGE_FLIP, "No");
		objTemp.add(SM_IMAGE_ORIGINX, "0");
		objTemp.add(SM_IMAGE_ORIGINY, "0");
		objTemp.add(SM_IMAGE_EXI2UGY, m_fFactorEXI2UGY);
		objTemp.add(SM_IMAGE_TEMP, m_fCurrentDetectorTemperature);

		if (0 != nAngle)
		{
			m_AcqUnit->RotateImage(m_pImgBuffer, nImgY, nImgX, nAngle);
		}
		if (90 == nAngle || 270 == nAngle)
		{
			objTemp.add(SM_IMAGE_WIDTH, nImgY);
			objTemp.add(SM_IMAGE_HEIGHT, nImgX);
			objTemp.add(SM_IMAGE_ROTATION, "Yes");
		}
		else
		{
			objTemp.add(SM_IMAGE_WIDTH, nImgX);
			objTemp.add(SM_IMAGE_HEIGHT, nImgY);
			objTemp.add(SM_IMAGE_ROTATION, "No");
		}
		objImageHead.add(SM_IMAGE_HEAD, objTemp);
		Trace("Full image head: {$}", objImageHead.encode());

		RET_STATUS ret = RET_STATUS::RET_FAILED;
		ret = m_AcqUnit->AddFrameWithRawHead(IMAGE_FULL, objImageHead.encode(), m_pImgBuffer, nImgX * nImgY);
		Info("Add image over, {$}", (int)ret);
	}
		break;
	case EVT_DATA_PREVIEW_IMAGE:
	{
		Info("Preview Image Arrived");
		int nImgX = 96;
		int nImgY = 96;
		int nAngle = m_stModeInfo.nRotateAngle;
		memcpy(m_pImgBuffer, pParam, (size_t)nImgX * (size_t)nImgY * sizeof(WORD));

		//暂时先用假值，有需要再改
		ResDataObject objImageHead, objTemp;
		objTemp.add(SM_IMAGE_TYPE, (int)IMAGE_AEC_PREVIEW);
		objTemp.add(SM_IMAGE_BIT, 16);
		objTemp.add(SM_IMAGE_TAG, 1);
		objTemp.add(SM_IMAGE_INDEX, 1);
		objTemp.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
		objTemp.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
		objTemp.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
		objTemp.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
		objTemp.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
		objTemp.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
		objTemp.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
		objTemp.add(SM_IMAGE_LSB, "5000");
		objTemp.add(SM_IMAGE_DOSE, m_stModeInfo.nSensitivity);
		objTemp.add(SM_IMAGE_PIXELSPACING, m_stModeInfo.nPixelPitch);
		objTemp.add(SM_IMAGE_PIXELREPRESENTATION, "1");
		objTemp.add(SM_IMAGE_FLIP, "No");
		objTemp.add(SM_IMAGE_ORIGINX, "0");
		objTemp.add(SM_IMAGE_ORIGINY, "0");
		objTemp.add(SM_IMAGE_EXI2UGY, m_fFactorEXI2UGY);
		objTemp.add(SM_IMAGE_TEMP, m_fCurrentDetectorTemperature);

		if (0 != nAngle)
		{
			m_AcqUnit->RotateImage(m_pImgBuffer, nImgY, nImgX, nAngle);
		}
		if (90 == nAngle || 270 == nAngle)
		{
			objTemp.add(SM_IMAGE_WIDTH, nImgY);
			objTemp.add(SM_IMAGE_HEIGHT, nImgX);
			objTemp.add(SM_IMAGE_ROTATION, "Yes");
		}
		else
		{
			objTemp.add(SM_IMAGE_WIDTH, nImgX);
			objTemp.add(SM_IMAGE_HEIGHT, nImgY);
			objTemp.add(SM_IMAGE_ROTATION, "No");
		}
		objImageHead.add(SM_IMAGE_HEAD, objTemp);
		Info("Preview image head: {$}", objImageHead.encode());
		RET_STATUS ret = RET_STATUS::RET_FAILED;
		ret = m_AcqUnit->AddFrameWithRawHead(IMAGE_AEC_PREVIEW, objImageHead.encode(), m_pImgBuffer, nImgX * nImgY);
		Info("Add preview image over, {$}", (int)ret);
	}
		break;
	default:
		Warn("Not support this data({$})", nEventID);
		break;
	}
}


void nsFPD::FPDDevicePZMedical::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)
			{
				//AddErrMsg("0", "communication error");
				SendTemperatureValue(0);
				SendWifiValue(0);
				SendBatteryValue(0);
				m_bConnect = false;
			}
			else if (strTemp.find("false") != std::string::npos)
			{
				//DelErrMsg("0");
			}
		}
		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({$})", nEventID);
		break;
	}
}


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