PhysicalDevice/Detector/CCOS.Dev.FPD.Demo/CCOS.Dev.FPD.Demo.cpp

// CCOS.Dev.FPD.Demo.cpp : 定义 DLL 应用程序的导出函数。
//

#include <pthread.h> 
#include "FileVersion.hpp"
#include "CCOS.Dev.FPD.Demo.h"
#include "common_api.h"
#include "DICOMImageHeadKey.h"
#include "dcm.hpp"
#include "LogLocalHelper.h"       
#include "Log4CPP.h"


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

 //Log4CPP::Logger*mLog::gLogger = nullptr;

extern const char* g_szMouldPath;

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

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

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

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

nsFPD::FPDDemoDriver::~FPDDemoDriver()
{
	if (dev != nullptr)
	{
		delete dev;
		dev = nullptr;
	}
}

void nsFPD::FPDDemoDriver::Prepare()
{
	std::string strLogPath = GetProcessDirectory() + R"(/Conf/log_config.xml)";
	std::string LogHost = "DemoFPD"; // 确保这是正确的值
	std::string moduleName = "DemoFPD";
	bool ret = initLogModule(
		LogHost,       // 主机名（用于日志路径中的{host}占位符）
		moduleName,        // 唯一模块名
		strLogPath,  // 配置文件路径
		true           // 是否输出到控制台（可选）
	);
	if (!ret) {
		std::cerr << "Log init failed!" << std::endl;
		return;
	}
	FPDDemoSetLocalModuleName(moduleName);
}

bool nsFPD::FPDDemoDriver::Connect()
{
	printf("--Func-- driver connect \r\n");
	FINFO("--Func-- driver connect");
	dev = new FPDDemoDevice(EventCenter, m_ConfigFileName);
	m_bConnect = true;
	return m_bConnect;
}

void nsFPD::FPDDemoDriver::Disconnect()
{
	printf("--Func-- driver disconnect \r\n");
	FINFO("--Func-- driver disconnect");
	if (dev != nullptr)
	{
		delete dev;
		dev = nullptr;
	}
	m_bConnect = false;
}

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

auto nsFPD::FPDDemoDriver::CreateDevice(int index) -> std::unique_ptr <IODevice>
{
	FINFO("nsFPD::FPDDemoDriver::CreateDevice({$})", index);
	if (index == 0)
	{
		auto Driver = std::unique_ptr <IODevice>(new IODevice(dev));
		dev->CreateDevice();
		dev->Register();
		return Driver;
	}
	else 
	{
		FINFO("CreateDevice index:{$}", index);
		return nullptr;
	}
}

std::string nsFPD::FPDDemoDriver::DriverProbe()
{
	FINFO("nsFPD::FPDDemoDriver::Driver_Probe");
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
		HardwareInfo.add("MinorID", r_config["CONFIGURATION"]["MinorID"]);
		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
	}
	else
	{
		HardwareInfo.add("MajorID", "Generator");
		HardwareInfo.add("MinorID", "Dr");
		HardwareInfo.add("VendorID", "ZSKK");
		HardwareInfo.add("ProductID", "Demo");
		HardwareInfo.add("SerialID", "Driver");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

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


/***
** 说明: 设置配置文件内容
***/
bool nsFPD::FPDDemoDriver::SetDeviceConfigValue(ResDataObject & config, const char* pInnerKey, int nPathID, const char* szValue)
{
	string strTemp = pInnerKey;
	FINFO("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
		{
			FERROR("Error Configuration item: {$}", pInnerKey);
			return false;
		}
	}


	return true;
}

bool nsFPD::FPDDemoDriver::GetDeviceConfig(std::string& Cfg)
{
	GetResource();
	Cfg = m_DeviceConfig.encode();

	FINFO("GetDeviceConfig over");

	return true;
}

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

	ResDataObject DescriptionTempEx;
	DescriptionTempEx = DeviceConfig["DeviceConfig"]["Attribute"];
	FINFO("Attribute:{$}", DescriptionTempEx.encode());

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

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

bool nsFPD::FPDDemoDriver::SaveConfigFile(bool bSendNotify)
{
	m_ConfigAll["CONFIGURATION"] = m_Configurations;

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

std::string nsFPD::FPDDemoDriver::GetResource()
{
	ResDataObject r_config, temp;
	if (!temp.loadFile(m_ConfigFileName.c_str()))
	{
		FDEBUG("GetResource load File failed! file name:{$}", m_ConfigFileName);
		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...

	/***
	* 1. 通过循环，将所有配置项写到pDeviceConfig
	* 2. 记录配置项的内部key以及配置类型，类型对应了不同配置文件路径，用于读写真实值
	***/
	try
	{
		int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
		m_pAttribute->clear();
		m_pDescription->clear();
		for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
		{
			DescriptionTemp.clear();
			ListTemp.clear();
			//AttributeType
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Type"];
			DescriptionTemp.add(AttributeType, strTemp.c_str());
			//FINFO(g_pFPDCtrlLog, "--> {$}: {$}", 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()));
				//FINFO(g_pFPDCtrlLog, "Key {$}: {$}", strTemp.c_str(), atoi(strValue.c_str()));
			}
			else if ("float" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atof(strValue.c_str()));
				//FINFO(g_pFPDCtrlLog, "Key {$}: {$}", strTemp.c_str(), atof(strValue.c_str()));
			}
			else //其它先按string类型处理
			{
				(*m_pAttribute).add(strTemp.c_str(), strValue.c_str());
				//FINFO(g_pFPDCtrlLog, "Key {$}: {$}", strTemp.c_str(), strValue.c_str());
			}

			//AttributeAccess
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Access"];
			DescriptionTemp.add(AttributeAccess, strTemp.c_str());
			//FINFO(g_pFPDCtrlLog, "{$}: {$}", AttributeAccess, strTemp.c_str());

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

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

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

			//AttributeRequired
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Required"];
			DescriptionTemp.add(AttributeRequired, strTemp.c_str());
			//FINFO(g_pFPDCtrlLog, "{$}: {$}", AttributeRequired, strTemp.c_str());

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

			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
			(*m_pDescription).add(strTemp.c_str(), DescriptionTemp);
		}
	}
	catch (exception e)
	{
		FERROR("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 res = DescriptionTempEx.encode();

	//Debug("resDeviceResource :{$} \n", DescriptionTempEx.encode());
	return res;
}

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

nsFPD::FPDDemoDevice::FPDDemoDevice(std::shared_ptr<IOEventCenter> center, string ConfigPath)
	: FPDDeviceMould("DemoFPD")
{
	m_strWorkPath = GetProcessDirectory();

	m_AcqUnit.reset(new OemAcq(center, this));
	m_SyncUnit.reset(new OemSync(center, this));
	m_CalibUnit.reset(new OemCalib(center, this));
	m_DetectorCtrlUnit.reset(new OemDetectorCtrl(center, this));
	m_DetectorConfiguration.reset(new DetectorConfiguration(ConfigPath));
	//m_WarnAndError.reset(new FPDErrorWarning(center, DetectorUnitType, m_strWorkPath));
	EventCenter = center;

	m_mode750MT = modeFULL;
	m_nCalibrationType = CCOS_CALIBRATION_TYPE_NONE;
	m_eWorkStatus = DETECTOR_WORK_ACQUIRE;
	m_vDemoImagePath.clear();
	m_pPreviewImageHead = nullptr;
	m_pFullImageHead = nullptr;
	m_nCurrentLogicMode = DEFAULT;
	m_bPreviewEnable = false;
	m_nPreviewWidth = 0;
	m_nPreviewHeight = 0;
	m_nFullWidth = 0;
	m_nFullHeight = 0;
	m_nBits = 16;
	m_nPixelSpacing = 143;
	m_nFrameRate = 1;
	m_nTotalFrameNum = 0;
	m_nSendImageCountInStitch = 0;
	pRadImgBuffer = nullptr;
	m_bDcmLoaded = false;
	m_bIsSendFluFrame = false;
	m_bRadMode = true;
	m_bFluMode = false;
	m_nSendImageInterval = 0;
	m_bFor750MT = false;
	m_fFluPPS = 40.0f;

	m_hFPDScanThread = 0;
	m_AcqReqEvt = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET,false);
	m_StopReqEvt = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, false);
	m_Exit = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, false);
	m_SendFluFrame = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, false);
	m_hToggleEvent = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, false);

	m_AcqLoopCount = 0;
	m_AcquiredCount = 0;
	m_CalibrationRoundCount = 0;
	m_CalibrationExpCount = 0;
}

nsFPD::FPDDemoDevice::~FPDDemoDevice()
{
	m_Exit->SetEvent();
	
	//等待onFPDScanThread 线程退出
	m_hToggleEvent->Wait(10000);
	m_vDemoImagePath.clear();

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

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

bool nsFPD::FPDDemoDevice::Prepare()
{
	FINFO("FPDDemoDevice::Prepare");
	//SetMaxBlockSize(const char *pQueName, DWORD FullBlockSize, DWORD FullBlockCount, DWORD PrevBlockSize, DWORD PrevBlockCount)
	EventCenter->OnMaxBlockSize("DemoQue", 5000 * 5000 * 2, 3, 2500 * 2500 * 2, 1);
	Connect();
	return true;
}

void nsFPD::FPDDemoDevice::SubscribeSelf(ccos_mqtt_connection* conn)
{
	cout << "FPDDemoDevice::SubscribeSelf in" << endl;
	SubscribeTopic(conn, "CCOS/DEVICE/Generator/zskkdemo/demo/1234/Notify/GENERATORSYNCSTATE");
}

void nsFPD::FPDDemoDevice::RegisterCtrl(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::GetFPDinformation, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorInfo);
	Dispatch->Action.Push(ActionKey::ActiveDetector, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSActiveDetector);
	Dispatch->Action.Push(ActionKey::RESET, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRESET);
	Dispatch->Action.Push(ActionKey::EnterExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSEnterExam);
	Dispatch->Action.Push(ActionKey::ExitExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSExitExam);

	Dispatch->Get.Push(AttrKey::DetectorStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDStatus);
	Dispatch->Get.Push(AttrKey::DetectorConnectStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetConnectStatus);
	Dispatch->Get.Push(AttrKey::FieldofViewShape, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewShape);
	Dispatch->Get.Push(AttrKey::FieldofViewDimension, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewDimension);
	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::DateofLastDetectorCalibration, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDateofLastDetectorCalibration);
	Dispatch->Get.Push(AttrKey::TimeofLastDetectorCalibration, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTimeofLastDetectorCalibration);
	Dispatch->Get.Push(AttrKey::DetectorConditionsNominalFlag, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorConditionsNominalFlag);
	Dispatch->Get.Push(AttrKey::FPDSensitivity, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDSensitivity);
	Dispatch->Get.Push(AttrKey::PixelData, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetPixelData);
	Dispatch->Get.Push(AttrKey::TargetEXI, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTargetEXI);
	Dispatch->Get.Push(AttrKey::FieldofViewShape, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewShape);
	Dispatch->Get.Push(AttrKey::FieldofViewDimension, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewDimension);
	Dispatch->Get.Push(AttrKey::DetectorType, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorType);
}

void nsFPD::FPDDemoDevice::RegisterAcq(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::SetAcqMode, m_AcqUnit.get(), &AcqUnit::JSSetAcqMode);
	Dispatch->Action.Push("SetDemoImage", m_AcqUnit.get(), &AcqUnit::JSSetDemoImage);
	Dispatch->Action.Push(ActionKey::SetValue_PPS, m_AcqUnit.get(), &AcqUnit::JSSetFluPPS);
	Dispatch->Action.Push(ActionKey::SetExposureTimes, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetExposureTimes);

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

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

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

	Dispatch->Update.Push("GENERATORSYNCSTATE", m_SyncUnit.get(), &SyncUnit::JSUpdateGENERATORSYNCSTATE);
}

void nsFPD::FPDDemoDevice::RegisterCalib(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::UploadCalibrationFiles, m_CalibUnit.get(), &CalibUnit::JSUploadCalibrationFiles);
	Dispatch->Action.Push(ActionKey::SetSID, m_CalibUnit.get(), &CalibUnit::JSSetSID);
	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->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);
}

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

void nsFPD::FPDDemoDevice::Register()
{
	auto Disp = m_Dispatch.Lock().As();
	RegisterCtrl(Disp);
	RegisterAcq(Disp);
	RegisterSync(Disp);
	RegisterCalib(Disp);
	RegisterOthers(Disp);
}

bool nsFPD::FPDDemoDevice::LoadConfig()
{
	if (!m_DetectorConfiguration->LoadConfigurations(m_stDeviceConfig, m_ACQMODElist))
	{
		FERROR( "Load configuration file failed!!!");
		return false;
	}

	if (m_DetectorConfiguration->m_Configurations.GetFirstOf("DemoDevType") >= 0)
	{
		std::string strDemoDevType = (const char*)m_DetectorConfiguration->m_Configurations["DemoDevType"];
		if (strDemoDevType.find("750MT") != std::string::npos)
		{
			m_bFor750MT = true;
			FINFO("[Demo for 750MT]");
		}
	}

	m_DetectorCtrlUnit->SetDetectorConditionsNominalFlag("YES");
	m_DetectorCtrlUnit->SetTargetEXI("5000");
	m_DetectorCtrlUnit->SetFieldofViewShape("RECTANGLE");
	m_DetectorCtrlUnit->SetFieldofViewDimension("444\\444");
	m_DetectorCtrlUnit->SetDetectorType("SCINTILLATOR");

	//const char* strkey, float initialvalue, float min, float WarnMin,float WarnMax, float CalibWarnMin, float CalibWarnMax, float max, float accuracy,std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter
	m_Temperature.reset(new DeviceTemperatureMould("DetectorTrixellTemperature", 0.0f, 0.0f, 0.0f, 50.0f, 5.0f, 45.0f, 60.0f, 0.0f, EventCenter));
	//const char* strkey, int initialvalue, int min,int WarnMin, int WarnMax, int CalibWarnMin, int CalibWarnMax,int max, int accuracy, std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter
	m_Battery.reset(new DeviceBatteryMould("DetectorTrixellBattery", 80, 10, 20,70, 20, 80, 100, 0, EventCenter));
	//const char* strkey, int initialvalue, int min, int WarnMin, int WarnMax, int CalibWarnMin, int CalibWarnMax, int max, int accuracy,std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter
	m_Wifi.reset(new DeviceWifiMould("DetectorTrixellWifi", 90, 30, 30, 90, 40, 90, 100, 0, EventCenter));

	m_pSeqList = new SeqImages();
	return true;
}

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

	return true;
}

RET_STATUS nsFPD::FPDDemoDevice::Connect()
{
	FINFO("------------------------ FPD {$}, {$} Start running.------------------------", m_stDeviceConfig.strDeviceName.c_str(), this);
	SendInfoLog("DEV_LOG_FPD_INIT_START");
	int threadRet;
	if (m_hFPDScanThread == 0)
	{
		// 使用pthread_create创建线程，第四个参数为传递给线程函数的参数
		threadRet = pthread_create(&m_hFPDScanThread, NULL,
			&nsFPD::FPDDemoDevice::onFPDScanThread, this);
		if (threadRet != 0)
		{
			return RET_STATUS::RET_FAILED;
		}
	}
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_WAKEUP));//Connect
	SendInfoLog("DEV_LOG_FPD_INIT_SUCCESS");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDemoDevice::DisConnect()
{
	SendInfoLog("DEV_LOG_FPD_DISCONNECT");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_SHUTDOWN));//DisConnect
	return RET_STATUS::RET_SUCCEED;
}


void nsFPD::FPDDemoDevice::SendInfoLog(string strLogKey, int nValue)
{
	auto strValue = std::to_string(nValue);

	SendInfoLog(strLogKey, strValue);
}
void nsFPD::FPDDemoDevice::SendInfoLog(string strLogKey, float fValue)
{
	auto strValue = std::to_string(fValue);

	SendInfoLog(strLogKey, strValue);
}
void nsFPD::FPDDemoDevice::SendInfoLog(string strLogKey, bool bRealSN)
{
	SendLog(strLogKey, "Info", bRealSN);
}
void nsFPD::FPDDemoDevice::SendInfoLog(string strLogKey, string strValue)
{
	SendLog(strLogKey, "Info", true, strValue);
}

void nsFPD::FPDDemoDevice::SendLog(string strLogKey, string strLogLevel, bool bRealSN, string strValue)
{
	string strMsgText = "";
	if ("" != strValue)
	{
		strMsgText += strValue;
	}

	FINFO("Send system Log strLogKey:{$}, strMsgText:{$}", strLogKey.c_str(), strMsgText.c_str());
	EventCenter->OnSystemLog(1, strLogKey.c_str(), strMsgText.c_str(),"");
}

void nsFPD::FPDDemoDevice::NotifyWindowOnAndOff()
{
	SendInfoLog("DEV_LOG_FPD_WINDOWON");
	m_SyncUnit->XWindowOnNotify();

	int nXWinTime = 1000 / m_nFrameRate - 20;
	FINFO("Xwindow time: {$}", nXWinTime);
	if (nXWinTime > 2)
	{
		usleep((nXWinTime / 2)*1000);
	}
	else 
	{
		FERROR("m_nFrameRate is too large,please make it samller!");
		return;
	}

	SendInfoLog("DEV_LOG_FPD_WINDOWOFF");
	m_SyncUnit->XWindowOffNotify();
}

bool nsFPD::FPDDemoDevice::Acq_Proc()
{
	FINFO("Acq_Proc start...");
	cout << "FPDDemoDevice::Acq_Proc-Acq_Proc start... " << endl;
	DWORD dwTick1 = GetTickCount();
	bool ret = false;

	//RAD 推一次图 透视时只要没有stopacq那么就一直推图
	Thread_Lock();
	if (m_eWorkStatus == DETECTOR_WORK_ACQUIRE)
	{
		//发图
		FINFO("Send Image");
		SendInfoLog("DEV_LOG_FPD_IMAGE");
		if (m_bFor750MT && m_mode750MT == modePreview)
		{
			sleep(1);
			ret = MakeFrame(DEMOEXAMMODE_AEC_PREVIEW);
			m_mode750MT = modeFULL;
			sleep(1);
			ret = MakeFrame(DEMOEXAMMODE_RAD);
			m_SyncUnit->XWindowOffNotify();
		}
		else if (m_bRadMode)
		{
			sleep(1);
			if (m_bPreviewEnable)
			{
				ret = MakeFrame(DEMOEXAMMODE_PREVIEW);
				sleep(1);
			}
			ret = MakeFrame(DEMOEXAMMODE_RAD);
			m_SyncUnit->XWindowOffNotify();
		}
		else if (m_bFluMode)
		{
			m_SendFluFrame->SetEvent();
		}
		else
		{
			sleep(1);
			ret = MakeFrame();
			m_SyncUnit->XWindowOffNotify();
		}
		if (ret)
		{
			++m_AcquiredCount;
			FINFO("Acquired:{$},AcqLimits:{$}", m_AcquiredCount, m_AcqLoopCount);
			if (m_AcqLoopCount != INFINITE)
			{
				if (m_AcquiredCount >= m_AcqLoopCount)
				{
					ResetFrame();
					StopAcquisition_Inside();
				}
			}
		}
	}
	else
	{
		ret = true;
		CCOS_CALIBRATION_TYPE type = m_CalibUnit->GetCalibrationType();
		FINFO("Calibration type: {$}", (int)type);

		++m_AcquiredCount;

		if (type == CCOS_CALIBRATION_TYPE_DARK)
		{
			//暗场
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//dark calib
			m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
			m_CalibUnit->SetCalibrationProgress("100");

			m_StopReqEvt->SetEvent();
			FINFO("SetEvent m_StopReqEvt");
			FINFO("Stop dark Calibration");
		}
		else if (type == CCOS_CALIBRATION_TYPE_XRAY)
		{
			m_SyncUnit->XWindowOnNotify();
			//Sleep(500);
			m_SyncUnit->XWindowOffNotify();
			m_CalibrationExpCount++;

			if (m_CalibrationExpCount >= 3)
			{
				m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//gain calib
				m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
				m_CalibUnit->SetCalibrationProgress("100");

				m_StopReqEvt->SetEvent();
				FINFO("SetEvent m_StopReqEvt");
				FINFO("Stop gain Calibration");
			}
			else
			{
				PauseCalibration();
				m_CalibUnit->SetCalibrationProgress(to_string(10 + m_CalibrationRoundCount * 30 + m_AcquiredCount * 3));//make progress
				FINFO("PauseCalibration");
			}
			FINFO("m_CalibrationExpCount = {$}", m_CalibrationExpCount);
		}
	}
	Thread_UnLock();
	
	usleep(150000); //停一下，等待stop命令，避免多出图

	FINFO("Acq_Proc end... TickCount={$}", GetTickCount() - dwTick1);
	return ret;
}


bool nsFPD::FPDDemoDevice::MakeFrame(DEMOEXAMMODE eExamMode)
{
	FINFO("MakeFrame Begin");
	if (DEMOEXAMMODE_PREVIEW == eExamMode || DEMOEXAMMODE_AEC_PREVIEW == eExamMode)
	{
		FINFO("OemAcq::MakeFrame DEMOEXAMMODE_PREVIEW {$}", pRadImgBuffer);
		//if (nullptr == pRadImgBuffer)
		//{
		//	FERROR("Rad raw buffer is NULL");
		//	return false;
		//}
		//DWORD dwScaleX = m_nFullWidth / m_nPreviewWidth;
		//DWORD dwScaleY = m_nFullHeight / m_nPreviewHeight;
		//FINFO("OemAcq::MakeFrame scalex={$} scaley={$}", dwScaleX, dwScaleY);
		//unsigned short* bufPreview = new unsigned short[m_nPreviewWidth * m_nPreviewHeight];
		//for (int i = 0; i < m_nPreviewHeight; i++)
		//{
		//	for (int j = 0; j < m_nPreviewWidth; j++)
		//	{
		//		bufPreview[i * m_nPreviewWidth + j] = pRadImgBuffer[i * dwScaleY * m_nFullWidth + j * dwScaleX];
		//	}
		//}
		m_stImgCreateTime = { 0 };
		GetLocalTime(&m_stImgCreateTime);
		FINFO("Preview image create time-{$}:{$}:{$}:{$}", m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);

		m_SyncUnit->ImageReadingNotify();
		FINFO("Add preview rad raw({$} {$})", m_nPreviewWidth, m_nPreviewHeight);
		string ImagePreview = GetProcessDirectory() + "/DemoImage/ImagePreview.raw";
		if (DEMOEXAMMODE_PREVIEW == eExamMode)
			AddFrameWithRawHead(IMAGE_PREVIEW, m_nPreviewHeight * m_nPreviewWidth, ImagePreview);
		else
			AddFrameWithRawHead(IMAGE_AEC_PREVIEW, m_nPreviewHeight * m_nPreviewWidth, ImagePreview);

		FINFO("End Preview");
		//delete[] bufPreview;
		return true;
	}
	else if (DEMOEXAMMODE_RAD == eExamMode)
	{
		//if (nullptr == pRadImgBuffer)
		//{
		//	FERROR("Rad raw buffer is NULL");
		//	return false;
		//}
		m_stImgCreateTime = { 0 };
		GetLocalTime(&m_stImgCreateTime);
		FINFO("Full image create time-{$}:{$}:{$}:{$}", m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);

		m_SyncUnit->ImageReadingNotify();

		m_AcqUnit->ImagerPixelSpacingNotify(m_nPixelSpacing);

		FINFO("Add rad raw({$} {$})", m_nFullWidth, m_nFullHeight);
		string ImageFULL = GetProcessDirectory() + "/DemoImage/ImageFULL.raw";
		AddFrameWithRawHead(IMAGE_FULL, m_nFullWidth * m_nFullHeight, ImageFULL);

		FINFO("End RAD");
		return true;
	}
	else if (DEMOEXAMMODE_FLU == eExamMode)
	{
		m_SyncUnit->ImageReadingNotify();
		FINFO("Add flu raw({$} {$})", m_nFullWidth, m_nFullHeight);
		AddFrameWithRawHead(IMAGE_FULL, m_pSeqList->GetImage(), m_nFullWidth * m_nFullHeight);
		FINFO("Send Frame ID:{$}",m_pSeqList->GetCurrentFrameID());

		FINFO("End FLU");
		return true;
	}
	else 
	{
		if (nullptr == pRadImgBuffer)
		{
			FERROR("Rad raw buffer is NULL");
			return false;
		}
		GlobalTime st = { 0 };
		GetLocalTime(&st);
		FINFO("Full image create time-{$}:{$}:{$}:{$}", st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);

		m_SyncUnit->ImageReadingNotify();
		FINFO("Add rad raw({$} {$})", m_nFullWidth, m_nFullHeight);
		AddFrameWithRawHead(IMAGE_FULL, pRadImgBuffer, m_nFullWidth * m_nFullHeight);

		FINFO("MakeFrame End [{$}]", (int)eExamMode);
		return true;
	}

	FERROR("MakeFrame Illegal End, exam mode:{$}", (int)eExamMode);
	return false;
}

/***
* 重置图像ID，新一轮采集时可以重新从第一张图像开始给上层传图
***/
bool nsFPD::FPDDemoDevice::ResetFrame()
{
	FINFO("Reset frame id");
	return m_pSeqList->ResetImageID();
}

void nsFPD::FPDDemoDevice::SendFluFrame()
{
	FINFO("enter into SendFluFrame");
	bool ret = false;
	m_bIsSendFluFrame = true;

	//先重置frameID
	ResetFrame();
	FINFO("m_nSendImageInterval:{$}", m_nSendImageInterval);

	while (m_bIsSendFluFrame)
	{
		//这里根据设置的帧率计算睡多长时间
		int sleepTime = m_nSendImageInterval;
		if (sleepTime == 0) 
		{
			sleepTime = 20;
		}
		FINFO("sleepTime:{$}", sleepTime);
		usleep(sleepTime*1000);
		ret = MakeFrame(DEMOEXAMMODE_FLU);
		if (!ret) 
		{
			FERROR("Send flu frame fail!");
			m_bIsSendFluFrame = false;
		}
		//把dcm中的图发送一遍后就结束
		FINFO("m_pSeqList->GetCurrentFrameID:{$},m_nTotalFrameNum:{$}", m_pSeqList->GetCurrentFrameID(), m_nTotalFrameNum);
		if (m_pSeqList->GetCurrentFrameID() == m_nTotalFrameNum - 1)
		{
			FINFO("stop send image");
			break;
		}
		m_pSeqList->GetNext();
	}
	m_SyncUnit->XWindowOffNotify();

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//SendFluFrame 结束
	FINFO("SendFluFrame Over");
}

void* nsFPD::FPDDemoDevice::onFPDScanThread(PVOID pvoid)
{
	nsFPD::FPDDemoDevice* pOpr = (nsFPD::FPDDemoDevice*)pvoid;
	FINFO("Enter Scan Thread");
	bool bExit = false;

	std::vector<std::shared_ptr<LinuxEvent>> pHandles;
	pHandles.push_back(pOpr->m_StopReqEvt);
	pHandles.push_back(pOpr->m_AcqReqEvt);
	pHandles.push_back(pOpr->m_Exit);
	pHandles.push_back(pOpr->m_SendFluFrame);

	while (!bExit)
	{
		int dwResult = LinuxEvent::WaitForMultipleEvents(pHandles, INFINITE);
		if (dwResult == WAIT_OBJECT_0) //m_StopReqEvt
		{
			pOpr->m_bIsSendFluFrame = false;
			pOpr->ResetFrame();
		}
		else if (dwResult == WAIT_OBJECT_0 + 1) //m_AcqReqEvt
		{
			printf("FPDDemoDevice::onFPDScanThread:Acq_Proc\r\n");
			if (!pOpr->Acq_Proc())
			{
				FERROR("Acq_Proc failed!");
			}
		}
		else if (dwResult == WAIT_OBJECT_0 + 2)//m_Exit
		{
			bExit = true;
		}
		else if (dwResult == WAIT_OBJECT_0 + 3)//m_SendFluFrame
		{
			pOpr->SendFluFrame();
		}
	}

	FINFO( "Exit Scan Thread");
	pOpr->m_hToggleEvent->SetEvent();
	return 0;
}

RET_STATUS nsFPD::FPDDemoDevice::GetDetectorInfo(string& strFDI)
{
	ResDataObject strDetectorInfo;
	string strTempTemp = " ";

	FINFO("Get Detector Info");

	strDetectorInfo.add("DetectorName", "Simulator");
	strDetectorInfo.add("DetectorSN", "Simulator");
	strDetectorInfo.add("Firmware", " ");
	strDetectorInfo.add("APFirmware", " ");
	strDetectorInfo.add("Software", "n.a.");
	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;	
}

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

	switch (nExamStatus)
	{
	case APP_STATUS_WORK_BEGIN:
	{
		FINFO("Enter into Exam Windows");
		m_eAppStatus = APP_STATUS_WORK_BEGIN;
		int nStatus = 0;
		m_Battery->SetRemainPowerValue(80, nStatus);
		m_Temperature->SetTemperature(30.0f, nStatus);
		m_Wifi->SetSignalValue(90, nStatus);
	}
		break;
	case APP_STATUS_WORK_END:
	{
		FINFO("Quit Exam Windows");
		m_eAppStatus = APP_STATUS_WORK_END;
		int nStatus = 0;
		m_Battery->SetRemainPowerValue(80, nStatus);
		m_Temperature->SetTemperature(30.0f, nStatus);
		m_Wifi->SetSignalValue(90, nStatus);
	}
		break;
	case APP_STATUS_DETSHARE_BEGIN:
		FINFO("Enter into Detector Share Windows");
		//FINFO( "Send Shock data");
		//m_psobThis->SendCmd(m_nDeviceIndex, Parameter_A, CMDID_SHOCK_SENSOR, String_C, m_strShockSensor);
		m_eAppStatus = APP_STATUS_DETSHARE_BEGIN;
		break;
	case APP_STATUS_DETSHAR_END:
		m_eAppStatus = APP_STATUS_IDLE;
		FINFO("Quit Detector Share Windows");
		m_eAppStatus = APP_STATUS_DETSHAR_END;
		break;
	case APP_STATUS_CAL_BEGIN:
		FINFO("Enter into Calibration Windows");
		m_eAppStatus = APP_STATUS_CAL_BEGIN;
		break;
	case APP_STATUS_CAL_END:
		FINFO("Quit Calibration Windows");
		m_eAppStatus = APP_STATUS_CAL_END;
		break;
	case APP_STATUS_WORK_IN_SENSITIVITY:
		FINFO("Enter into sensitivity test interface");
		m_eAppStatus = APP_STATUS_WORK_IN_SENSITIVITY;
		break;
	default:
		break;
	}

	return RET_STATUS::RET_SUCCEED;
}

bool nsFPD::FPDDemoDevice::GetLogicMode(string& strAcqMode, int& nLogicMode) 
{
	if (strAcqMode == "RAD")
	{
		nLogicMode = RAD;
	}
	else if (strAcqMode == "CF")
	{
		nLogicMode = CF;
	}
	else if (strAcqMode == "PF")
	{
		nLogicMode = PF;
	}
	else if (strAcqMode == "Stitch")
	{
		nLogicMode = STITCH;
	}
	else if (strAcqMode == "1")
	{
		nLogicMode = RAD;
	}
	else if (strAcqMode == "2")
	{
		nLogicMode = CF;
	}
	else if (strAcqMode == "3")
	{
		nLogicMode = PF;
	}
	else if (strAcqMode == "4")
	{
		nLogicMode = STITCH;
	}
	else
	{
		FERROR("Not support mode!");
		return false;
	}
	return true;
}

RET_STATUS nsFPD::FPDDemoDevice::SetAcqMode(string strAcqMode)
{
	printf("FPDDemoDevice::SetAcqMode strAcqMode:%s\r\n", strAcqMode.c_str());
	FINFO("FPDDemoDevice::SetAcqMode strAcqMode:{$}", strAcqMode);
	
	if (m_bFor750MT)
	{
		if (strAcqMode == "AEC")
			m_mode750MT = modePreview;
		else
			m_mode750MT = modeFULL;
	}

	int nLogicMode = RAD;
	bool bRet = GetLogicMode(strAcqMode, nLogicMode);
	if (!bRet)
	{
		return RET_STATUS::RET_FAILED;
	}
	
	int nAcqMode = 0;
	try
	{
		ResDataObject& ModeInfo = m_ACQMODElist[nLogicMode - 1];
		nAcqMode = ModeInfo[CcosAcqModeIdx];
		FINFO("nAcqMode = {$}", nAcqMode);
		if (nAcqMode != nLogicMode)
		{
			FERROR("input param invalid, can not support");
			return RET_STATUS::RET_INVALID;
		}
		m_nPixelSpacing = (int)ModeInfo[CcosImagePixelSpacing];
		m_nFrameRate = (int)ModeInfo[CcosFrameRate];
		m_nSendImageInterval = (int)ModeInfo["SendImageInterval"];
		m_nFullWidth = (int)ModeInfo["ImageWidth"];
		m_nFullHeight= (int)ModeInfo["ImageHeight"];
		FINFO("m_nPixelSpacing:{$},m_nFrameRate:{$},m_nSendImageInterval:{$}", m_nPixelSpacing, m_nFrameRate, m_nSendImageInterval);
		int nTemp = (int)ModeInfo["PreviewEnable"];
		if (nTemp > 0)
		{
			FINFO("Preview enable");
			m_bPreviewEnable = true;
			m_nPreviewWidth = (int)ModeInfo["PreviewWidth"];
			m_nPreviewHeight = (int)ModeInfo["PreviewHeight"];
			m_AcqUnit->SetPrevImageInfo(true, m_nPreviewHeight, m_nPreviewWidth, false);
		}
		else 
		{
			FINFO("Preview Disable");
		}

		m_AcqLoopCount = ModeInfo[CcosLoopCount]; //改为从modeinfo读取
		//选择模式后，重新加载demo图
		if (nLogicMode == RAD)
		{
			m_bRadMode = true;
		}
		else
		{
			m_bRadMode = false;
		}
		if (nLogicMode == CF || nLogicMode == PF)
		{
			m_bFluMode = true;
		}
		else 
		{
			m_bFluMode = false;
		}

		m_nCurrentLogicMode = nLogicMode;
	}
	catch (...)
	{
		FINFO("Illegal mode index!!!");
		return RET_STATUS::RET_NOSUPPORT;
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDemoDevice::SetXwindow(float XwindowSize)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDemoDevice::PrepareAcquisition()
{
	FINFO("PrepareAcquisition");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//PrepareAcquisition
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDemoDevice::StartAcquisition(string in)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;
	SendInfoLog("DEV_LOG_FPD_STARTACQ");

	FINFO("StartAcquisition in:{$}", in);
	if (in.length() > 0)
	{
		ret = SetAcqMode(in);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			FERROR("StartAcquisition SetAcqMode fail!");
			Thread_UnLock();
			return ret;
		}
	}

	if (m_nCurrentLogicMode == RAD || m_nCurrentLogicMode == CF || m_nCurrentLogicMode == PF)
	{
		//if (m_vDemoImagePath.size() == 0)
		//{
		//	FERROR("Not set demo image path, please check!");
		//	return RET_STATUS::RET_FAILED;
		//}
		//string strTemp = m_vDemoImagePath[0];
		//size_t nPos = strTemp.rfind(".");
		//strTemp = strTemp.substr(nPos);
		//makeLowerStr(strTemp);
		//if (strTemp.find("dcm") == string::npos)
		//{
		//	FERROR("Not support this kind of image");
		//	return RET_STATUS::RET_FAILED;
		//}
		//if (!LoadDCMDemo(m_vDemoImagePath[0].c_str()))
		//{
		//	return RET_STATUS::RET_FAILED;
		//}
	}
	else if (m_nCurrentLogicMode == STITCH)
	{
		if (m_vDemoImagePath.size() == 0)
		{
			FERROR("Not set demo image path, please check!");
			return RET_STATUS::RET_FAILED;
		}
		if (m_nSendImageCountInStitch >= m_vDemoImagePath.size())
		{
			FERROR("There is only {$} image in vector!", m_vDemoImagePath.size());
			return RET_STATUS::RET_FAILED;
		}
		
		string strTemp = m_vDemoImagePath[m_nSendImageCountInStitch];
		size_t nPos = strTemp.rfind(".");
		strTemp = strTemp.substr(nPos);
		makeLowerStr(strTemp);
		if (strTemp.find("dcm") == string::npos)
		{
			FERROR("Not support this kind of image");
			return RET_STATUS::RET_FAILED;
		}
		if (!LoadDCMDemo(m_vDemoImagePath[m_nSendImageCountInStitch].c_str()))
		{
			return RET_STATUS::RET_FAILED;
		}
		m_nSendImageCountInStitch++;
	}

	//如果没有调用SetDemoImage,那么开始采集时报错
	//if (!m_bDcmLoaded) 
	//{
	//	FERROR("not load dcm, please check!");
	//	return ret;
	//}

	//if (m_bFor750MT && m_bRadMode)
	//{
	//	//m_AcqLoopCount = 2; // Preview and full
	//}

	m_eWorkStatus = DETECTOR_WORK_ACQUIRE;
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));
	m_SyncUnit->XWindowOnNotify();
	//推图
	m_AcqReqEvt->SetEvent();
	ret = RET_STATUS::RET_SUCCEED;
	FINFO("StartAcquisition over");
	return ret;
}

RET_STATUS nsFPD::FPDDemoDevice::StopAcquisition_Inside()
{
	FINFO("StopAcquisition_Inside");
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	SendInfoLog("DEV_LOG_FPD_STOPACQ_INSIDE");
	m_AcquiredCount = 0;

	//通知设备停止采集
	m_StopReqEvt->SetEvent();
	return ret;
}

RET_STATUS nsFPD::FPDDemoDevice::StopAcquisition()
{
	FINFO("StopAcquisition");
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	SendInfoLog("DEV_LOG_FPD_STOPACQ");

	if (m_eWorkStatus == DETECTOR_WORK_CALIBRATE)
	{
		FINFO("StopAcquisition over");
		return ret;
	}
	m_StopReqEvt->SetEvent();
	m_AcquiredCount = 0;
	usleep(600000);
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//StopAcquisition
	FINFO("StopAcquisition over");
	return ret;
}

RET_STATUS nsFPD::FPDDemoDevice::SetSID(int nSID)
{
	return RET_STATUS::RET_SUCCEED;
}

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

RET_STATUS nsFPD::FPDDemoDevice::ActiveCalibration(CCOS_CALIBRATION_TYPE in)
{
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	SendInfoLog("DEV_LOG_FPD_ACTIVE_CALIB");
	m_CalibrationRoundCount = 0;
	m_CalibrationExpCount = 0;
	m_nCalibrationType = in;
	m_eWorkStatus = DETECTOR_WORK_CALIBRATE;
	return ret;
}

RET_STATUS nsFPD::FPDDemoDevice::GetRequestedDose(std::string& strout)
{
	ResDataObject out;

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		out.add("Dose", 0.0f);
		out.add("kV", 0.0f);
		out.add("mA", 0.0f);
		out.add("ms", 0.0f);
		out.add("mAs", 0.0f);
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_nCalibrationType)
	{
		out.add("Dose", 1200.0f);
		out.add("kV", 40.0f);
		out.add("mA", 10.0f);
		out.add("ms", 20.0f);
		out.add("mAs", 1.0f);
	}

	strout = out.encode();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDemoDevice::PrepareCalibration()
{
	FINFO("PrepareCalibration");
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	SendInfoLog("DEV_LOG_FPD_PREP_CALIB");
	return ret;
}

RET_STATUS nsFPD::FPDDemoDevice::StartCalibration()
{
	FINFO("StartCalibration");
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	SendInfoLog("DEV_LOG_FPD_START_CALIB");
	return ret;
}

RET_STATUS nsFPD::FPDDemoDevice::PauseCalibration()
{
	FINFO("PauseCalibration");
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	SendInfoLog("DEV_LOG_FPD_PAUSE_CALIB");

	//通知设备停止采集
	m_StopReqEvt->SetEvent();
	m_CalibUnit->PauseCalibration();

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//PauseCalibration
	return ret;
}

RET_STATUS nsFPD::FPDDemoDevice::StopCalibration()
{
	FINFO("StopCalibration start");
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
	SendInfoLog("DEV_LOG_FPD_STOP_CALIB");

	m_CalibrationRoundCount = 3;
	m_StopReqEvt->SetEvent();
	m_CalibrationExpCount = 0;
	m_eWorkStatus = DETECTOR_WORK_ACQUIRE; //StopCalibration
	FINFO("StopCalibration over");
	return ret;
}

RET_STATUS nsFPD::FPDDemoDevice::SetFluPPS(float fFluPPS)
{
	FINFO("SetFluPPS:{$}",fFluPPS);
	m_fFluPPS = fFluPPS;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDemoDevice::SetSyncMode(SYNC_MODE nSyncMode, HARDWARE_TRIGGER_MODE TriggerMode)
{
	FINFO( "SetSyncMode({$}) TriggerMode({$})", (int)nSyncMode, (int)TriggerMode);
	return RET_STATUS::RET_SUCCEED;
}

/***
**	说明：设置demo图路径
**	UI根据协议给探测器驱动传不同的demo图地址，加载不同demo图
**	目前用于点片模式，其它模式还需要再考虑
***/
RET_STATUS nsFPD::FPDDemoDevice::SetDemoImage(string& strPath1, string& strPath2, string& strPath3)
{
	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	FINFO("SetDemoImage path1:{$},path2:{$},path3:{$}", strPath1, strPath2, strPath3);
	m_nSendImageCountInStitch = 0;
	m_bDcmLoaded = false;
	m_vDemoImagePath.clear();
	if (strPath1.size() > 0)
	{
		m_vDemoImagePath.push_back(strPath1);
	}
	if (strPath2.size() > 0)
	{
		m_vDemoImagePath.push_back(strPath2);
	}
	if (strPath3.size() > 0)
	{
		m_vDemoImagePath.push_back(strPath3);
	}
	return Ret;
}

bool nsFPD::FPDDemoDevice::LoadDCMDemo(const char* pPath)
{
	dcm objDcm;
	bool bRet = false;

	bRet = objDcm.Load(pPath);
	if (!bRet)
	{
		FERROR("Load dcm failed, {$}", pPath);
		return false;
	}

	int nWidth = objDcm.nWidth;
	int nHeight = objDcm.nHeight;
	int nBits = objDcm.nBits;
	int nFrame = objDcm.nFrames;
	m_nTotalFrameNum = objDcm.nFrames;

	m_nFullWidth = nWidth;
	m_nFullHeight = nHeight;
	m_nBits = nBits; //使用dcm格式的demo图时，图像位数使用真实值
	m_AcqUnit->SetFulImageInfo(m_nFullHeight, m_nFullWidth, nBits, false);

	if (nFrame > 0)
	{
		m_pSeqList->ClearImage();
		for (int i = 0; i < nFrame; i++)
		{
			unsigned short* pRaw = new unsigned short[(unsigned long long)nWidth * nHeight];
			memcpy(pRaw, objDcm.ppData[i], sizeof(unsigned short) * nWidth * nHeight);
			m_pSeqList->PushMemImage(pRaw, nWidth, nHeight, i);
			FINFO("Load dcm success(width: {$} height: {$} bits: {$} frame: {$})",
				nWidth, nHeight, nBits, i);
		}
	}

	//点片图buffer
	if (pRadImgBuffer != NULL)
	{
		delete[]pRadImgBuffer;
		pRadImgBuffer = NULL;
	}
	pRadImgBuffer = new unsigned short[nWidth * nHeight];
	memcpy(pRadImgBuffer, (unsigned short*)objDcm.ppData[0], nWidth * nHeight * sizeof(unsigned short));
	
	FINFO("Load dcm success(width: {$} height: {$} bits: {$} frames: {$})", nWidth, nHeight, nBits, nFrame);

	m_bDcmLoaded = true;
	return true;
}

bool nsFPD::FPDDemoDevice::LoadRadDemo(const char* pPath, int nImgSizeX, int nImgSizeY, int nBits, int nPixelSpacing)
{
	if (pRadImgBuffer != nullptr)
	{
		delete[]pRadImgBuffer;
		pRadImgBuffer = NULL;
	}
	pRadImgBuffer = new unsigned short[nImgSizeX * nImgSizeY];
	if (!pRadImgBuffer)
	{
		// 内存分配失败处理
		return false;
	}

	size_t imgDataSize = static_cast<size_t>(nImgSizeX) * nImgSizeY * 2;
	FILE* fp = fopen(pPath, "rb");  // 以二进制读模式打开
	if (!fp)
	{
		FERROR("Load raw failed, %s", pPath);
		delete[] pRadImgBuffer;
		pRadImgBuffer = nullptr;
		return false;
	}

	size_t returnedLenth = fread(pRadImgBuffer, 1, imgDataSize, fp);
	if (returnedLenth != imgDataSize)
	{
		FERROR("The size of raw is not right, %zu", returnedLenth);
		fclose(fp);
		delete[] pRadImgBuffer;
		pRadImgBuffer = nullptr;
		return false;
	}

	fclose(fp);
	return true;
}

/***
** 说明：清除错误
**   如果在采集过程中，停止采集
***/
RET_STATUS nsFPD::FPDDemoDevice::ResetError()
{
	FINFO("ResetError");
	StopAcquisition();
	return RET_STATUS::RET_SUCCEED;
}

string nsFPD::FPDDemoDevice::MakeImageHead(IMAGE_VIEW_TYPE Type, string ImagePath)
{
	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_nFullWidth);
			json.add(SM_IMAGE_HEIGHT, m_nFullHeight);
			json.add(SM_IMAGE_BIT, 16);
			json.add(SM_IMAGE_TAG, 1);
			json.add(SM_IMAGE_INDEX, 1);
			json.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
			json.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
			json.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
			json.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
			json.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
			json.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
			json.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
			json.add(SM_IMAGE_LSB, "5000");
			json.add(SM_IMAGE_DOSE, m_stDeviceConfig.nDoseOfEXI);
			json.add(SM_IMAGE_PIXELSPACING, m_nPixelSpacing);
			json.add(SM_IMAGE_PIXELREPRESENTATION, m_stDeviceConfig.fPixelSpace);
			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, "0.181818");
			json.add("ImagePath", ImagePath.c_str());

			m_pFullImageHead->add(SM_IMAGE_HEAD, json);
		}
		else
		{
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_WIDTH] = m_nFullWidth;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_HEIGHT] = m_nFullHeight;
			(*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_PIXELSPACING] = m_nPixelSpacing;
			(*m_pFullImageHead)[SM_IMAGE_HEAD]["ImagePath"] = ImagePath.c_str();
		}

		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_nPreviewWidth);
			json.add(SM_IMAGE_HEIGHT, m_nPreviewHeight);
			json.add(SM_IMAGE_BIT, 16);
			json.add(SM_IMAGE_TAG, 1);
			json.add(SM_IMAGE_INDEX, 1);
			json.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
			json.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
			json.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
			json.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
			json.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
			json.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
			json.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
			json.add(SM_IMAGE_LSB, "5000");
			json.add(SM_IMAGE_DOSE, m_stDeviceConfig.nDoseOfEXI);
			json.add(SM_IMAGE_ROTATION, "No");
			json.add(SM_IMAGE_FLIP, "No");
			json.add(SM_IMAGE_ORIGINX, "0");
			json.add(SM_IMAGE_ORIGINY, "0");
			json.add(SM_IMAGE_PIXELSPACING, m_nPixelSpacing);
			json.add(SM_IMAGE_PIXELREPRESENTATION, "1");
			json.add("ImagePath", ImagePath.c_str());

			m_pPreviewImageHead->add(SM_IMAGE_HEAD, json);
		}
		else
		{
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_WIDTH] = m_nPreviewWidth;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_HEIGHT] = m_nPreviewHeight;
			(*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]["ImagePath"] = ImagePath.c_str();
		}

		return (*m_pPreviewImageHead).encode();
	}
}

RET_STATUS nsFPD::FPDDemoDevice::AddFrameWithRawHead(IMAGE_VIEW_TYPE Type, unsigned short* pFrameBuff, DWORD FrameSize)
{
	string strImageHead = MakeImageHead(Type);
	FINFO("AddFrameWithRawHead: {$}", strImageHead);
	return m_AcqUnit->AddFrameWithRawHead(Type, strImageHead, pFrameBuff, FrameSize);
}

RET_STATUS nsFPD::FPDDemoDevice::AddFrameWithRawHead(IMAGE_VIEW_TYPE Type, DWORD FrameSize, string ImagePath)
{
	string strImageHead = MakeImageHead(Type, ImagePath);
	FINFO("AddFrameWithRawHead: {$}", strImageHead);
	return m_AcqUnit->AddFrameWithRawHead(Type, strImageHead, FrameSize);
}

RET_STATUS nsFPD::FPDDemoDevice::ActiveSyncMode(int nSyncMode)
{
	FINFO("ActiveSyncMode nSyncMode:{$}", nSyncMode);
	return RET_SUCCEED;
}