PhysicalDevice/Generator/Delta/CCOS.Dev.Generator.Delta_50KCXAF/CCOS.Dev.Generator.Delta_50KCXAF.cpp

// CCOS.Dev.GEN.Delta.cpp : Linux version of Delta Generator Driver
// Note: Some Chinese comments may appear garbled due to encoding conversion (GBK to UTF-8).
//       This does not affect code functionality.

#include <assert.h>
#include <functional>
#include <unordered_map>
#include <fstream>
#include <set>
#include <dlfcn.h>
#include <cstdio>
#include <unistd.h>
#include "LogicDevice.h"
#include "CCOS.Dev.Generator.Delta_50KCXAF.h"
#include "Helper.JSON.hpp"
#include "LogLocalHelper.h"
#include "Log4CPP.h"

using namespace std::placeholders;
using namespace CCOS::Dev::Detail::Generator;
namespace nsGEN = CCOS::Dev::Detail::Generator;

static const int msTimeOut_Lock = 500;

// Linux 环境下的 SCF 库文件名
static const auto COM_SCFDllName = "libSerialSCF.so";
static const auto TCP_SCFDllName = "libTcpipSCF.so";

// 定义 Sleep 宏(如果头文件中没有定义)
#ifndef Sleep
#define Sleep(ms) std::this_thread::sleep_for(std::chrono::milliseconds(ms))
#endif

#define Delta_Com_NormalLen 20
#define Delta_LoopDefTime 1500
#define Delta_LoopExpTime 100
#define KVP_MAX  150
#define KVP_MIN  40

#define WORD_HIGH(a) (a>>4)
#define WORD_LOW(a) (( a & 0x0F))
#define COMMANDHEAD 0xF0
#define COMMANDEND 0x88

/* Control characters */
#define STX  0x02	/* Start of DATA */
#define ETX  0x03	/* End of DATA */
#define ACK  0x06	/* Acknowlage */
#define NAK  0x15	/* not acknowlage */
#define BYTE_1	1
#define BYTE_2	2
#define BYTE_4	4
#define BYTE_6	6
#define BYTE_10	10
#define BYTE_12	12

//-----------------------------------------------------------------------------
//		计算校验码
//-----------------------------------------------------------------------------
UINT8 GetCRC8(char* pBuffer, UINT16 bufSize)
{
	char High[16] = { 0x00, 0x70, 0xe0, 0x90, 0xc7, 0xb7, 0x27, 0x57, 0x89, 0xf9, 0x69, 0x19, 0x4e, 0x3e, 0xae, 0xde };
	char Low[16] = { 0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15, 0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d };
	UINT8 crc = 0;
	if (bufSize <= 0)
		return crc;
	for (int i = 0; i < bufSize; i++)
	{
		UINT8 result = (crc ^ pBuffer[i]);
		UINT8 high = WORD_HIGH(result);
		UINT8 low = WORD_LOW(result);
		crc = High[high] ^ Low[low];
	}
	return crc;
}

//-----------------------------------------------------------------------------
//		DeltaMobileDevice
//-----------------------------------------------------------------------------

nsGEN::DeltaMobileDevice* nsGEN::DeltaMobileDevice::g_GenDevice = NULL;
atomic<int> nsGEN::DeltaMobileDevice::m_iLoopTime = Delta_LoopDefTime;
atomic<bool> nsGEN::DeltaMobileDevice::m_bExtraFlag = true;

nsGEN::DeltaMobileDevice::DeltaMobileDevice(std::shared_ptr <IOEventCenter> center, std::shared_ptr<SCFWrapper> SCF, string configfile) : super(center)
	, superGen()
	, m_SCF(SCF)
{
	assert(EventCenter);
	m_strConfigPath = configfile;
	g_GenDevice = this;
	ResDataObject temp;
	temp.loadFile(configfile.c_str());
	m_GenConfig = temp["CONFIGURATION"];
	TransJsonText(m_GenConfig);

	// Linux 版本：简化版本信息输出
	string version = "1.0.0.0";  // 可以从 CMakeLists.txt 的 PROJECT_VERSION 获取
	FINFO("\n===============log begin : module version:{$} ===================\n", version.c_str());

	// Linux 版本：动态库版本信息（简化）
	string strVersion = "1.0.0.0";
	FINFO("=====================log begin :dll version{$}====================", strVersion.c_str());
	//初始化参数
	m_DoseUnit.m_KV.reset(new KVMould(70.0, 40.0, 150.0, 1.0));
	m_DoseUnit.m_MA.reset(new MAMould(10.0, 10.0, 1000.0, 1.0));
	m_DoseUnit.m_MS.reset(new MSMould(1.0, 1.0, 63000.0, 1.0));
	m_DoseUnit.m_MAS.reset(new MASMould(0.4, 0.4, 10000.0, 1.0));
	m_DoseUnit.m_Techmode.reset(new TECHMODEMould(AttrKey::TECHMODE_NOAEC_3P, AttrKey::TECHMODE_NOAEC_3P, AttrKey::TECHMODE_MAX, 1));
	m_DoseUnit.m_WS.reset(new WORKSTATIONMould(AttrKey::TABLE, AttrKey::TABLE, AttrKey::GENWS_MAX, 1));
	m_DoseUnit.m_Focus.reset(new FOCUSMould(AttrKey::FOCUS_LARGE, AttrKey::FOCUS_SMALL, AttrKey::FOCUS_LARGE, 1));
	m_DoseUnit.m_AECField.reset(new AECFIELDMould(0, 0, 111, 1));
	m_DoseUnit.m_AECFilm.reset(new AECFILMMould(0, 0, 3, 1));
	m_DoseUnit.m_AECDensity.reset(new AECDENSITYMould(0, -4, 4, 1));
	m_DoseUnit.m_HE.reset(new TUBEHEATMould(0, 0, 100, 1));
	m_DoseUnit.m_PostKV.reset(new POSTKVMould(40.0, 40.0, 150.0, 1.0));
	m_DoseUnit.m_PostMA.reset(new POSTMAMould(10.0, 10.0, 1000.0, 1.0));
	m_DoseUnit.m_PostMS.reset(new POSTMSMould(1.0, 1.0, 63000.0, 1.0));
	m_DoseUnit.m_PostMAS.reset(new POSTMASMould(0.4, 0.4, 10000.0, 1.0));

	m_DoseUnit.m_GenSynState.reset(new GENSYNSTATEMould(AttrKey::GENERATOR_RAD_OFF, AttrKey::GENERATOR_SYNC_ERR, AttrKey::GENERATOR_SYNC_MAX, 1));
	m_DoseUnit.m_GenState.reset(new GENSTATEMould(AttrKey::GENERATOR_STATUS_INIT, AttrKey::GENERATOR_STATUS_SHUTDOWN, AttrKey::GENERATOR_STATUS_MAX, 1));
	m_DoseUnit.m_GenTotalExpNumber.reset(new TOTALEXPNUMMould(0, 0, 9999, 1));
	m_DoseUnit.m_GenTotalAcqTimes.reset(new TOTALACQTIMESMould(0, 0, 9999, 1));
	m_DoseUnit.m_GenTubeCoolWaitTimes.reset(new TUBECOOLTIMEMould(0, 0, 9999, 1));
	m_DoseUnit.m_GenTubeOverLoadNumber.reset(new TUBEOVERLOADNUMMould(0, 0, 9999, 1));
	m_DoseUnit.m_GenCurrentExpNumber.reset(new CUREXPNUMMould(0, 0, 9999, 1));
	m_DoseUnit.m_ExpMode.reset(new EXPMODEMould(AttrKey::EXPMODE_TYPE::Single));
	m_DoseUnit.m_FrameRate.reset(new FRAMERATEMould(0, 0, 30, 1));
	//
	m_DoseUnit.m_FLMode.reset(new FLUModeMould(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_NOTFLU));
	m_DoseUnit.m_PPS.reset(new PPSMould(0,0,1,0));
	m_DAP.reset(new DevDAP::DOSEMould(0.0, 0.0, 1000.0, 0.01));
	m_MSGUnit.reset(new nsDetail::MSGUnit(center, nsGEN::GeneratorUnitType));
	// Register device
	Register();
	// Linux版本：使用 m_SCF 进行直接通信，不再使用 DeliverModule
	// Retrieve firmware version
	RetrieveFirewareVersion();
	// Load configuration data
	GetConfData();
	// Linux版本：启用硬件状态查询线程标志
	m_bExtraFlag = true;
	m_nCountTimes = 0;

	// 启动硬件状态监控线程
	StartHardwareStatusThread();
	// Initialize error messages
	m_ErrorMessages = {
		{"DELTA_ERR_0000", "LOST CONNECT"},
		{"DELTA_ERR_0001", "PC Invalid Command"},
		{"DELTA_ERR_0002", "Door Interlock"},
		{"DELTA_ERR_0003", "Interlock"},
		{"DELTA_ERR_0004", "Prep Timeout"},
		{"DELTA_ERR_0005", "Ready Timeout"},
		{"DELTA_ERR_0006", "Filament Timeout"},
		{"DELTA_ERR_0007", "No Library Data"},
		{"DELTA_ERR_0008", "No Calibration Data"},
		{"DELTA_ERR_0009", "SW Configuration File Empty"},
		{"DELTA_ERR_0010", "Calibration Manually Terminated"},
		{"DELTA_ERR_0011", "Manually Terminate Exposure"},
		{"DELTA_ERR_0012", "PREP Manually Terminate"},
		{"DELTA_ERR_0013", "Seasoning Manually Terminated"},
		{"DELTA_ERR_0014", "AC Voltage UVP"},
		{"DELTA_ERR_0015", "Bucky ready open"},
		{"DELTA_ERR_0017", "Not get AEC Ramp"},
		{"DELTA_ERR_0018", "AEC calibration over range"},
		{"DELTA_ERR_0019", "AEC exposure time out"},
		{"DELTA_ERR_0020", "Snap over power rating"},
		{"DELTA_ERR_1001", "SW OTP"},
		{"DELTA_ERR_1002", "Thermal Switch"},
		{"DELTA_ERR_1003", "XRAY Over HU"},
		{"DELTA_ERR_1004", "Aux Power Off"},
		{"DELTA_ERR_1005", "DR reset fail"},
		{"DELTA_ERR_1006", "DR ready fail"},
		{"DELTA_ERR_1007", "Battery communication loss"},
		{"DELTA_ERR_1008", "DAP communication loss"},
		{"DELTA_ERR_1009", "Fluoroscopic time out"},
		{"DELTA_ERR_1010", "DAP device error"},
		{"DELTA_ERR_1011", "Snap over time"},
		{"DELTA_ERR_2001", "SW Vout OVP"},
		{"DELTA_ERR_2002", "SW Vout UVP"},
		{"DELTA_ERR_2003", "SW Anode OCP"},
		{"DELTA_ERR_2004", "SW Anode UCP"},
		{"DELTA_ERR_2005", "Input Voltage OVP" },
		{"DELTA_ERR_2006", "Input Voltage UVP" },
		{"DELTA_ERR_2007", "24 VDC UVP" },
		{"DELTA_ERR_2008", "HW Vout OVP"},
		{"DELTA_ERR_2009", "Capacitive Protection"},
		{"DELTA_ERR_2010", "Primary OCP"},
		{"DELTA_ERR_2011", "HW Cathode OCP"},
		{"DELTA_ERR_2012", "HW Anode OCP"},
		{"DELTA_ERR_2013", "Charger OTP" },
		{"DELTA_ERR_2014", "PFC BUS UVP" },
		{"DELTA_ERR_2015", "Flow fault"},
		{"DELTA_ERR_2016", "PFC start fail"},
		{"DELTA_ERR_3001", "SW Thermal sense fault"},
		{"DELTA_ERR_3002", "Fan 1 Fault"},
		{"DELTA_ERR_3003", "Fan 2 Fault"},
		{"DELTA_ERR_3004", "Filament Power Fault"},
		{"DELTA_ERR_3005", "Soft Start Fail"},
		{"DELTA_ERR_3006", "MA Test Point Open"},
		{"DELTA_ERR_3007", "Tank Connect" },
		{"DELTA_ERR_3008", "Self-Test FERROR"},
		{"DELTA_ERR_3009", "Motor Short"},
		{"DELTA_ERR_3010", "Motor Invalid command"},
		{"DELTA_ERR_3011", "Motor OCP1"},
		{"DELTA_ERR_3012", "Motor OCP2"},
		{"DELTA_ERR_3013", "Motor Communication Loss"},
		{"DELTA_ERR_3014", "Motor Main Open"},
		{"DELTA_ERR_3015", "Motor Shift Open"},
		{"DELTA_ERR_3016", "Charger Fail"},
		{"DELTA_ERR_3017", "Bus UVP"},
		{"DELTA_ERR_3018", "Battery UVP"},
		{"DELTA_ERR_3019", "Cart UVP"},
		{"DELTA_ERR_3020", "Inverter error"},
		{"DELTA_ERR_3021", "Discharge Relay Fail" },
		{"DELTA_ERR_3022", "Battery OVP"},
		{"DELTA_ERR_3023", "Battery OCP" },
		{"DELTA_ERR_3024", "Battery OTP" },
		{"DELTA_ERR_3025", "Battery Fail"},
		{"DELTA_ERR_3026", "APS1 Fail"},
		{"DELTA_ERR_3027", "APS2 Fail"},
		{"DELTA_ERR_3028", "APS3 Fail"},
		{"DELTA_ERR_3029", "Capacitator error" },
		{"DELTA_ERR_3030", "Fan 3 Fault"},
		{"DELTA_ERR_3031", "Fan 4 Fault"},
		{"DELTA_ERR_3032", "PFC OTP and Brown out"},
		{"DELTA_ERR_4001", "SW Current Unbalance"},
		{"DELTA_ERR_4002", "SW Filament OCP"},
		{"DELTA_ERR_4003", "Shoot Inv1"},
		{"DELTA_ERR_4004", "Shoot Inv2"},
		{"DELTA_ERR_4005", "HW Filament Rms"},
		{"DELTA_ERR_4006", "FERROR Repeat 5 Times"},
	};
	m_WarnMessages = {
		{"DELTA_WARN_001", "mode inhibited"},
		{"DELTA_WARN_002", "out of tube rating"},
		{"DELTA_WARN_003", "out of power"},
		{"DELTA_WARN_004", "out of work"},
		{"DELTA_WARN_005", "out of voltage range"},
		{"DELTA_WARN_006", "out of current range"},
		{"DELTA_WARN_007", "out of time or FPS range"},
		{"DELTA_WARN_008", "out of mas range"},
		{"DELTA_WARN_009", "time too small"},
		{"DELTA_WARN_010", "parameter ok"},
		{"DELTA_WARN_011", "mas too small"},
		{"DELTA_WARN_012", "no cmd"},
		{"DELTA_WARN_013", "data not complete(reserved)"},
		{"DELTA_WARN_014", "out of tube HU"},
		{"DELTA_WARN_015", "out of filament current range"},
		{"DELTA_WARN_016", "no library data" },
		{"DELTA_WARN_017", "tube PN not match"},
		{"DELTA_WARN_018", "focal spot not support"},
		{"DELTA_WARN_019", "data break"},
		{"DELTA_WARN_020", "EEPROM BUSY"},
		{"DELTA_WARN_021", "exposure result empty"},
		{"DELTA_WARN_022", "tube calibration data empty" },
		{"DELTA_WARN_023", "XRAY interval time"},
		{"DELTA_WARN_024", "filament current limit"},
		{"DELTA_WARN_025", "out of generator HU"},
		{"DELTA_WARN_026", "out of motor HU"},
		{"DELTA_WARN_160", "invalid cmd"},
	};
}		  


std::string CCOS::Dev::Detail::Generator::DeltaMobileDevice::GetDynamicLibraryPath()
{
	// Linux 版本：使用 dladdr 获取动态库路径
	Dl_info dl_info;
	// 将静态成员函数指针转换为void*用于dladdr
	void* addr = reinterpret_cast<void*>(&DeltaMobileDevice::GetDynamicLibraryPath);
	if (dladdr(addr, &dl_info)) {
		std::string fullPath(dl_info.dli_fname);
		size_t pos = fullPath.find_last_of("/");
		FINFO("Delta dll fullPath {$}", fullPath.c_str());
		if (pos != std::string::npos) {
			return fullPath.substr(0, pos);
		}
		return fullPath;
	}
	// 如果获取失败，返回当前工作目录
	FWARN("Failed to get dynamic library path, using current directory");
	return ".";
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::GetConfData()
{
	int Num;
	if (m_GenConfig.GetKeyCount("RadKV") > 0)
	{
		if (m_GenConfig.GetKeyCount("RadKVSize") > 0)
		{
			Num = (int)m_GenConfig["RadKVSize"];
			for (int i = 0; i < Num; i++)
			{
				int nKV = (int)m_GenConfig["RadKV"][i];
				m_vecKV.push_back(nKV);
			}
		}
		FINFO("m_vecKV {$}", m_vecKV.size());
	}
	else
	{
		FINFO("no RadKV");
	}
	if (m_GenConfig.GetKeyCount("RadMAS") > 0)
	{
		if (m_GenConfig.GetKeyCount("RadMASSize") > 0)
		{
			Num = (int)m_GenConfig["RadMASSize"];
			for (int i = 0; i < Num; i++)
			{
				int nMAS = (int)m_GenConfig["RadMAS"][i];
				m_vecMAS.push_back(nMAS);
			}
		}
		FINFO("m_vecMAS {$}", m_vecMAS.size());
	}
	else
	{
		FINFO("no RadMAS");
	}

	if (m_GenConfig.GetKeyCount("RadMA") > 0)
	{
		if (m_GenConfig.GetKeyCount("RadMASize") > 0)
		{
			Num = (int)m_GenConfig["RadMASize"];
			for (int i = 0; i < Num; i++)
			{
				int nMA = (int)m_GenConfig["RadMA"][i];
				m_vecMA.push_back(nMA);
			}
		}
		FINFO("m_vecMA {$}", m_vecMA.size());
	}
	else
	{
		FINFO("no RadMA");
	}

	if (m_GenConfig.GetKeyCount("RadMS") > 0)
	{
		if (m_GenConfig.GetKeyCount("RadMSSize") > 0)
		{
			Num = (int)m_GenConfig["RadMSSize"];
			for (int i = 0; i < Num; i++)
			{
				int nMS = (int)m_GenConfig["RadMS"][i];
				m_vecMS.push_back(nMS);
			}
		}
		FINFO("m_vecMS {$}", m_vecMS.size());
	}
	else
	{
		FINFO("no RadMS");
	}


	if (m_GenConfig.GetKeyCount("TableDAEC") > 0)
	{
		m_nTableUsePanelAEC = (int)(m_GenConfig["TableDAEC"]);
		FINFO("TableDAEC {$}", m_nTableUsePanelAEC);
	}
	else
	{
		FINFO("TableDAEC disable");
	}
	if (m_GenConfig.GetKeyCount("FreeDAEC") > 0)
	{
		m_nFreeUsePanelAEC = (int)(m_GenConfig["FreeDAEC"]);
		FINFO("FreeDAEC {$}", m_nFreeUsePanelAEC);
	}
	else
	{
		FINFO("FreeDAEC disable");
	}
	if (m_GenConfig.GetKeyCount("WallDAEC") > 0)
	{
		m_nWallUsePanelAEC = (int)(m_GenConfig["WallDAEC"]);
		FINFO("WallDAEC {$}", m_nWallUsePanelAEC);
	}
	else
	{
		FINFO("WallDAEC disable");
	}
	if (m_GenConfig.GetKeyCount("TableDDR") > 0)
	{
		m_nTableUsePanelDDR = (int)(m_GenConfig["TableDDR"]);
		FINFO("TableDDR {$}", m_nTableUsePanelDDR);
	}
	else
	{
		FINFO("TableDDR disable");
	}
	if (m_GenConfig.GetKeyCount("WallDDR") > 0)
	{
		m_nWallUsePanelDDR = (int)(m_GenConfig["WallDDR"]);
		FINFO("WallDDR {$}", m_nWallUsePanelDDR);
	}
	else
	{
		FINFO("WallDDR disable");
	}
	if (m_GenConfig.GetKeyCount("FreeDDR") > 0)
	{
		m_nFreeUsePanelDDR = (int)(m_GenConfig["FreeDDR"]);
		FINFO("FreeDDR {$}", m_nFreeUsePanelDDR);
	}
	else
	{
		FINFO("FreeDDR disable");
	}
	if (m_GenConfig.GetKeyCount("SendXwindowToDetector") > 0)
	{
		FINFO("SendXwindowToDetector {$}", (int)m_GenConfig["SendXwindowToDetector"]);
	}
	if (m_GenConfig.GetKeyCount("DEframeRate") > 0)
	{
		m_nDEFrameRate = (int)m_GenConfig["DEframeRate"];
	}
	FINFO("DEframeRate {$}", m_nDEFrameRate);
}

nsGEN::DeltaMobileDevice::~DeltaMobileDevice()
{
	FINFO("========================================");
	FINFO("DeltaMobileDevice Destructor Starting...");
	FINFO("========================================");

	FINFO("Stopping hardware status thread...");
	m_bExtraFlag = false;

	if (m_pHardwareStatusThread.joinable()) {
		FINFO("Waiting for hardware status thread to join...");
		m_pHardwareStatusThread.join();
		FINFO("Hardware status thread joined successfully");
	} else {
		FINFO("Hardware status thread not joinable, skipping join");
	}

	g_GenDevice = nullptr;

	if (m_pDetectorClient)
	{
		if (!m_pDetectorClient->IsClosed())
		{
			m_pDetectorClient->Close();
		}
		// unique_ptr will automatically delete, no need for manual delete
		m_pDetectorClient.reset();
	}

	FINFO("========================================");
	FINFO("DeltaMobileDevice Destructor Completed");
	FINFO("========================================");
}

std::string nsGEN::DeltaMobileDevice::GetGUID() const
{
	FINFO("\n===============GetGUID : {$} ===================\n", GeneratorUnitType);
	return GeneratorUnitType;
}
void nsGEN::DeltaMobileDevice::Register()
{
	auto Disp = m_Dispatch.Lock().As();
	superGen::Register(Disp);
	superGen::RegisterRAD(Disp);
	superGen::RegisterAEC(Disp);
	superGen::RegisterExpEnable(Disp);
	superGen::RegisterGeneratortoSyncStatus(Disp);
	Disp->Get.Push(m_MSGUnit->GetKey().c_str(), [this](std::string& out) { out = m_MSGUnit->JSGet(); return RET_STATUS::RET_SUCCEED; });
}

RET_STATUS nsGEN::DeltaMobileDevice::IncKV()
{
	if (!m_DoseUnit.m_KV->CanInc())  return RET_STATUS::RET_SUCCEED;
	m_DoseUnit.m_KV->Inc();
	SetKV(m_DoseUnit.m_KV->Get());
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::DecKV()
{
	if (!m_DoseUnit.m_KV->CanDec())  return RET_STATUS::RET_SUCCEED;
	m_DoseUnit.m_KV->Dec();
	SetKV(m_DoseUnit.m_KV->Get());
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetKV(float value)
{
	if (!m_DoseUnit.m_KV->Verify(value))  return RET_STATUS::RET_SUCCEED;
	FINFO("{$}KV", value);
	ChangeGenParam((int)value, m_DoseUnit.m_MA->Get(), m_DoseUnit.m_MS->Get(), m_DoseUnit.m_MAS->Get());
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::DeltaMobileDevice::IncMA()
{
	if (!m_DoseUnit.m_MA->CanInc())  return RET_STATUS::RET_SUCCEED;
	float fMA = m_DoseUnit.m_MA->Get();
	int pos = GetFacFloatValue(m_vecMA, fMA);
	FINFO("Current ma: {$}, pos: {$}", fMA, pos);

	pos++;
	if (pos >= 0 && pos < m_vecMA.size())
	{
		if (m_vecMAS[pos] == (m_nTubeMaBFMinValue * 100))
		{
			SetFocus(AttrKey::FOCUS_LARGE);
		}
		fMA = m_vecMA[pos];
		FINFO("Inc to MA: {$}", fMA);
		ChangeGenParam(m_DoseUnit.m_KV->Get(), fMA, m_DoseUnit.m_MS->Get(), m_DoseUnit.m_MAS->Get());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::DecMA()
{
	if (!m_DoseUnit.m_MA->CanDec())  return RET_STATUS::RET_SUCCEED;
	float fMA = m_DoseUnit.m_MA->Get();
	int pos = GetFacFloatValue(m_vecMA, fMA);
	FINFO("Current ma: {$}, pos: {$}", fMA, pos);

	pos--;
	if (pos >= 0 && pos < m_vecMA.size())
	{
		if (m_vecMA[pos] == (m_nTubeMaSFMaxValue * 100)) //small focus max value
		{
			SetFocus(AttrKey::FOCUS_TYPE::FOCUS_SMALL);//设置为小焦点
		}
		fMA = m_vecMA[pos];
		FINFO("Dec to MA: {$}", fMA);
		ChangeGenParam(m_DoseUnit.m_KV->Get(), fMA, m_DoseUnit.m_MS->Get(), m_DoseUnit.m_MAS->Get());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetMA(float value)
{
	if (!m_DoseUnit.m_MA->Verify(value))  return RET_STATUS::RET_SUCCEED;
	FINFO("{$}MA", value);
	ChangeGenParam(m_DoseUnit.m_KV->Get(), value, m_DoseUnit.m_MS->Get(), m_DoseUnit.m_MAS->Get());
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::DeltaMobileDevice::IncMS()
{
	if (!m_DoseUnit.m_MS->CanInc())  return RET_STATUS::RET_SUCCEED;
	float fMS = m_DoseUnit.m_MS->Get();
	int pos = GetFacFloatValue(m_vecMS, fMS);
	FINFO("Current ms: {$}, pos: {$}", fMS, pos);

	pos++;
	if (pos >= 0 && pos < m_vecMS.size())
	{
		fMS = m_vecMS[pos];
		FINFO("Inc to MS: {$}", fMS);
		ChangeGenParam(m_DoseUnit.m_KV->Get(), m_DoseUnit.m_MA->Get(), fMS, m_DoseUnit.m_MAS->Get());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::DecMS()
{
	if (!m_DoseUnit.m_MS->CanDec())  return RET_STATUS::RET_SUCCEED;
	float fMS = m_DoseUnit.m_MS->Get();
	int pos = GetFacFloatValue(m_vecMS, fMS);
	FINFO("Current ms: {$}, pos: {$}", fMS, pos);

	pos--;
	if (pos >= 0 && pos < m_vecMS.size())
	{
		float fms = m_vecMS[pos];
		FINFO("Dec to MS: {$}", fms);
		ChangeGenParam(m_DoseUnit.m_KV->Get(), m_DoseUnit.m_MA->Get(), fms, m_DoseUnit.m_MAS->Get());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetMS(float value)
{
	if (!m_DoseUnit.m_MA->Verify(value))  return RET_STATUS::RET_SUCCEED;
	FINFO("{$}MS", value);
	ChangeGenParam(m_DoseUnit.m_KV->Get(), m_DoseUnit.m_MA->Get(), value, m_DoseUnit.m_MAS->Get());
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::DeltaMobileDevice::IncMAS()
{
	if (!m_DoseUnit.m_MAS->CanInc()) return RET_STATUS::RET_SUCCEED;
	float fMAS = m_DoseUnit.m_MAS->Get();
	int pos = GetFacFloatValue(m_vecMAS, fMAS);
	FINFO("Current mas: {$}, pos: {$}", fMAS, pos);

	pos++;
	if (pos >= 0 && pos < m_vecMAS.size())
	{
		fMAS = m_vecMAS[pos];
		FINFO("Inc to MAS: {$}", fMAS);
		ChangeGenParam(m_DoseUnit.m_KV->Get(), m_DoseUnit.m_MA->Get(), m_DoseUnit.m_MS->Get(), fMAS);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::DecMAS()
{
	if (!m_DoseUnit.m_MAS->CanDec())  return RET_STATUS::RET_SUCCEED;
	float fMAS = m_DoseUnit.m_MAS->Get();
	int pos = GetFacFloatValue(m_vecMAS, fMAS);
	FINFO("Current mas: {$}, pos: {$}", fMAS, pos);

	pos--;
	if (pos >= 0 && pos < m_vecMAS.size())
	{
		fMAS = m_vecMAS[pos];
		FINFO("Dec to MAS: {$}", fMAS);
		ChangeGenParam(m_DoseUnit.m_KV->Get(), m_DoseUnit.m_MA->Get(), m_DoseUnit.m_MS->Get(), fMAS);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetMAS(float value)
{
	if (!m_DoseUnit.m_MA->Verify(value))  return RET_STATUS::RET_SUCCEED;
	FINFO("{$}MAS", value);
	ChangeGenParam(m_DoseUnit.m_KV->Get(), m_DoseUnit.m_MA->Get(), m_DoseUnit.m_MS->Get(), value);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::DeltaMobileDevice::SetTechmode(int value)
{
	//51A1
	if (!m_DoseUnit.m_Techmode->Verify(value))  return RET_STATUS::RET_SUCCEED;
	FINFO("[0xF0, 0x51, 0xA1, 0xxx] Techmode: {$}", value);
	char cmdbuf[13] = { 0xF0, 0x51, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	m_DoseUnit.m_Techmode->Update(value);
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_NOAEC_3P)
	{
		SetDAECEnable(0);//禁用DAEC
		cmdbuf[3] = 2;
		FormatCommand(cmdbuf, 13);
		string temp(cmdbuf, 13);
		m_strCommand = temp;
		HWSendWaitACKCMD(m_strCommand, 4);
	}
	else if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_NOAEC_2P)
	{
		SetDAECEnable(0);//禁用DAEC
		cmdbuf[3] = 3;
		FormatCommand(cmdbuf, 13);
		string temp(cmdbuf, 13);
		m_strCommand = temp;
		HWSendWaitACKCMD(m_strCommand, 4);
	}
	else if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_AEC_3P)//aec
	{
		if (m_DoseUnit.m_WS->Get() == AttrKey::TABLE)
		{
			if (m_nTableUsePanelAEC == 1)
			{
				SetDAECEnable(1);
				cmdbuf[3] = 2;//time
				FormatCommand(cmdbuf, 13);
				string temp(cmdbuf, 13);
				m_strCommand = temp;
				HWSendWaitACKCMD(m_strCommand, 4);
			}
			else
			{
				SetDAECEnable(0);
				cmdbuf[3] = 1;//应用GEN的aec功能
				cmdbuf[4] = m_nChamberIndex;//chabmer index

				int nAECFieldSel = 2;
				switch (m_DoseUnit.m_AECField->Get())
				{
				case 100:
					nAECFieldSel = 1;
					break;
				case 10:
					nAECFieldSel = 2;
					break;
				case 110:
					nAECFieldSel = 3;
					break;
				case 1:
					nAECFieldSel = 4;
					break;
				case 101:
					nAECFieldSel = 5;
					break;
				case 11:
					nAECFieldSel = 6;
					break;
				case 111:
					nAECFieldSel = 7;
					break;
				default:
					nAECFieldSel = 2;
					break;
				}
				cmdbuf[5] = nAECFieldSel;//field
				cmdbuf[6] = 0;
				cmdbuf[7] = 0;
				FormatCommand(cmdbuf, 13);
				string temp(cmdbuf, 13);
				m_strCommand = temp;
				HWSendWaitACKCMD(m_strCommand, 4);
				SetAECInformation(m_nChamberIndex, m_DoseUnit.m_AECField->Get(), m_DoseUnit.m_AECDensity->Get(), m_DoseUnit.m_AECFilm->Get());
			}
		}
		else if (m_DoseUnit.m_WS->Get() == AttrKey::WALL)
		{
			if (m_nWallUsePanelAEC == 1)
			{
				SetDAECEnable(1);
				cmdbuf[3] = 2;//time
				FormatCommand(cmdbuf, 13);
				string temp(cmdbuf, 13);
				m_strCommand = temp;
				HWSendWaitACKCMD(m_strCommand, 4);
			}
			else
			{
				SetDAECEnable(0);
				cmdbuf[3] = 1;//应用GEN的aec功能
				cmdbuf[4] = m_nChamberIndex;//chabmer index

				int nAECFieldSel = 2;
				switch (m_DoseUnit.m_AECField->Get())
				{
				case 100:
					nAECFieldSel = 1;
					break;
				case 10:
					nAECFieldSel = 2;
					break;
				case 110:
					nAECFieldSel = 3;
					break;
				case 1:
					nAECFieldSel = 4;
					break;
				case 101:
					nAECFieldSel = 5;
					break;
				case 11:
					nAECFieldSel = 6;
					break;
				case 111:
					nAECFieldSel = 7;
					break;
				default:
					nAECFieldSel = 2;
					break;
				}
				cmdbuf[5] = nAECFieldSel;//field
				cmdbuf[6] = 0;
				cmdbuf[7] = 0;
				FormatCommand(cmdbuf, 13);
				string temp(cmdbuf, 13);
				m_strCommand = temp;
				HWSendWaitACKCMD(m_strCommand, 4);
			}
		}
		else if (m_DoseUnit.m_WS->Get() == AttrKey::MOBILE)
		{

			if (m_nFreeUsePanelAEC == 1)
			{
				SetDAECEnable(1);
				cmdbuf[3] = 2;//time
				FormatCommand(cmdbuf, 13);
				string temp(cmdbuf, 13);
				m_strCommand = temp;
				HWSendWaitACKCMD(m_strCommand, 4);
			}
			else
			{
				SetDAECEnable(0);
				cmdbuf[3] = 1;//应用GEN的aec功能
				cmdbuf[4] = m_nChamberIndex;//chabmer index

				int nAECFieldSel = 2;
				switch (m_DoseUnit.m_AECField->Get())
				{
				case 100:
					nAECFieldSel = 1;
					break;
				case 10:
					nAECFieldSel = 2;
					break;
				case 110:
					nAECFieldSel = 3;
					break;
				case 1:
					nAECFieldSel = 4;
					break;
				case 101:
					nAECFieldSel = 5;
					break;
				case 11:
					nAECFieldSel = 6;
					break;
				case 111:
					nAECFieldSel = 7;
					break;
				default:
					nAECFieldSel = 2;
					break;
				}
				cmdbuf[5] = nAECFieldSel;//field
				cmdbuf[6] = 0;
				cmdbuf[7] = 0;
				FormatCommand(cmdbuf, 13);
				string temp(cmdbuf, 13);
				m_strCommand = temp;
				
				HWSendWaitACKCMD(m_strCommand, 4);
				if (m_DoseUnit.m_AECFilm->Get() == 0)
					SetAECInformation(m_nChamberIndex, m_DoseUnit.m_AECField->Get(), m_DoseUnit.m_AECDensity->Get(), m_DoseUnit.m_AECFilm->Get());
			}
		}
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetFocus(int value)
{
	//5AA1
	if (!m_DoseUnit.m_Focus->Verify(value)) return RET_STATUS::RET_SUCCEED;
	FINFO("[0xF0, 0x5A, 0xA1, 0x00] focus:{$}", value);
	char cmdbuf[13] = { 0xF0, 0x5A, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	if (value == 0)
	{
		cmdbuf[3] = 2;
	}
	else if (value == 1)
	{
		cmdbuf[3] = 1;
	}
	else
	{
		cmdbuf[3] = 3;
	}
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetAECDensity(int value)
{
	if (!m_DoseUnit.m_AECDensity->Verify(value))  return RET_STATUS::RET_SUCCEED;
	FINFO("AECDensity:{$}", value);
	if (value < -3)
	{
		value = -3;
	}
	else if (value > 3)
	{
		value = 3;
	}
	if (m_DoseUnit.m_AECDensity->Get() != value)
	{
		SetAECInformation(1, m_DoseUnit.m_AECField->Get(), value, m_DoseUnit.m_AECFilm->Get());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetAECField(int value)
{
	if (!m_DoseUnit.m_AECField->Verify(value))  return RET_STATUS::RET_SUCCEED;
	FINFO("AECField:{$}", value);
	if (m_DoseUnit.m_AECField->Get() != value)
	{
		SetAECInformation(1, value, m_DoseUnit.m_AECDensity->Get(), m_DoseUnit.m_AECFilm->Get());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetAECFilm(int value)
{
	if (!m_DoseUnit.m_AECFilm->Verify(value))  return RET_STATUS::RET_SUCCEED;
	FINFO("AECFilm:{$}", value);
	if (m_DoseUnit.m_AECFilm->Get() != value)
	{
		SetAECInformation(1, m_DoseUnit.m_AECField->Get(), m_DoseUnit.m_AECDensity->Get(), value);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS  nsGEN::DeltaMobileDevice::SetWS(const string value)
{
	FINFO("WorkStation:{$}", value);
	m_DoseUnit.m_WS->Update(atoi(value.c_str()));
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::DeltaMobileDevice::SetAPR(const _tAPRArgs& t)
{
	m_tAPRdata = t;
	FINFO("Focus:{$}, Techmode:{$}, AECField:{$}, AECFilm:{$}, AECDensity:{$}, KV:{$}, MA:{$}, MS:{$}, KV2:{$}, MA2:{$}, MS2:{$}, MAS:{$}", 
			   m_tAPRdata.nFocus, m_tAPRdata.nTechmode, m_tAPRdata.nAECField, m_tAPRdata.nAECFilm, m_tAPRdata.nAECDensity, m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS, m_tAPRdata.fKV2, m_tAPRdata.fMA2, m_tAPRdata.fMS2, m_tAPRdata.fMAS);

	if (m_tAPRdata.fKV2 != 0)
	{
		SetDualEnergyCommand(m_tAPRdata);
	}
	else
	{
		SetRadMode(0, 0);

		if ((int)m_tAPRdata.fMA > m_nTubeMaSFMaxValue)
		{
			SetFocus(1);
		}
		else
		{
			SetFocus(0);
		}
		SetTechmode(m_tAPRdata.nTechmode);

		if (m_tAPRdata.nTechmode == AttrKey::TECHMODE_AEC_3P)
		{
			if (m_tAPRdata.nWS == AttrKey::TABLE)
			{
				if (m_nTableUsePanelAEC != 1)
				{
					if (m_DoseUnit.m_AECFilm->Get() == 0)
						m_DoseUnit.m_AECFilm->Update(1);
					SetAECInformation(m_nChamberIndex, m_tAPRdata.nAECField, m_tAPRdata.nAECDensity, m_tAPRdata.nAECFilm);
					SetAECKV_MA_MS((int)m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS);
				}
				else
				{
					SetRADKV_MA_MS((int)m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS);
				}
			}
			else if (m_tAPRdata.nWS == AttrKey::WALL)
			{
				if (m_nWallUsePanelAEC != 1)
				{
					if (m_tAPRdata.nAECFilm == 0)
						m_tAPRdata.nAECFilm = 1;
					SetAECInformation(m_nChamberIndex, m_tAPRdata.nAECField, m_tAPRdata.nAECDensity, m_tAPRdata.nAECFilm);
					SetAECKV_MA_MS((int)m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS);
				}
				else
				{
					SetRADKV_MA_MS((int)m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS);
				}
			}
			else if (m_tAPRdata.nWS == AttrKey::MOBILE)
			{
				if (m_nFreeUsePanelAEC != 1)
				{
					if (m_tAPRdata.nAECFilm == 0)
						m_tAPRdata.nAECFilm = 1;
					SetAECInformation(m_nChamberIndex, m_tAPRdata.nAECField, m_tAPRdata.nAECDensity, m_tAPRdata.nAECFilm);
					SetAECKV_MA_MS((int)m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS);
				}
				else
				{
					SetRADKV_MA_MS((int)m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS);
				}
			}
		}
		else if (m_tAPRdata.nTechmode == AttrKey::TECHMODE_NOAEC_MAS_MA)
		{
			SetRADKV_MAS((int)m_tAPRdata.fKV, m_tAPRdata.fMAS);
		}
		else
		{
			//m_bPostAP = true;
			SetRADKV_MA_MS((int)m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS);
		}
	}
	return RET_STATUS::RET_SUCCEED;
}

bool nsGEN::DeltaMobileDevice::SetDualEnergyCommand(const _tAPRArgs& t)
{
	if (!m_bIsDualExp)
		SetRadMode(1, 1);

	if (m_nExposureNumber == 0)
	{
		FINFO("Dual Energy First APR KV:{$}, MA:{$}, MS:{$}, MAS:{$}", t.fKV, t.fMA, t.fMS, t.fMAS);
		m_bIsDualExp = true;
		//设置双能第一组曝光参数
		SetAPRForDual(t.nWS, t.nFocus, t.nTechmode, t.nAECField, t.nAECFilm, t.nAECDensity, t.fKV, t.fMA, t.fMS, t.fMAS);
		SetFrameRate(m_nDEFrameRate);
	}
	else if (m_nExposureNumber == 1)
	{
		//2 set 2nd array param
		FINFO("Dual Energy Second APR KV:{$}, MA:{$}, MS:{$}", t.fKV2, t.fMA2, t.fMS2);
		//设置第二组参数
		if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_AEC_3P)
		{
			SetAECInformation(m_nChamberIndex, t.nAECField, t.nAECDensity, 0);
			SetAECKV_MA_MS((int)t.fKV2, t.fMA2, t.fMS2);
		}
		else if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_NOAEC_2P)
		{
			SetRADKV_MAS((int)t.fKV2, t.fMA2 * t.fMS2 / 1000);
		}
		else
		{
			SetRADKV_MA_MS((int)t.fKV2, t.fMA2, t.fMS2);
		}
		//m_bIsDualExp = false; //第二次设定之后，主动false
		//m_nExposureNumber = 0;
	}

	return true;
}


bool nsGEN::DeltaMobileDevice::SetAPRForDual(int nWS, int nFO, int nET, int nAECFieldSel, int nAECFilmSel, float fAECDensity, float fKV, float fMA, float fMS, float fMAS)
{
	FINFO("Focus:{$}, Techmode:{$}, AECField:{$}, AECFilm:{$}, AECDensity:{$}, KV:{$}, MA:{$}, MS:{$}, MAS:{$}",
		m_tAPRdata.nFocus, m_tAPRdata.nTechmode, m_tAPRdata.nAECField, m_tAPRdata.nAECFilm, m_tAPRdata.nAECDensity, m_tAPRdata.fKV, m_tAPRdata.fMA, m_tAPRdata.fMS, m_tAPRdata.fMAS);
	//客户说160是 small FO的最大值。 180是大焦点的最小值
	if ((int)fMA > m_nTubeMaSFMaxValue)
	{
		SetFocus(1);
	}
	else
	{
		SetFocus(0);
	}
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_AEC_3P)
	{
		if (nAECFilmSel == 0)
			nAECFilmSel = 1;
		SetAECInformation(m_nChamberIndex, nAECFieldSel, fAECDensity, nAECFilmSel);
		SetAECKV_MA_MS((int)fKV, fMA, fMS);

	}
	else if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_NOAEC_2P)
	{
		SetRADKV_MAS((int)fKV, fMAS);
	}
	else
	{
		SetRADKV_MA_MS((int)fKV, fMA, fMS);
	}
	return true;
}

RET_STATUS nsGEN::DeltaMobileDevice::QueryHE(int& value)
{
	FINFO("{$}", value);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::QueryPostKV(float& value)
{
	FINFO("{$}", value);
	m_DoseUnit.m_PostKV->Update(m_DoseUnit.m_KV->Get());
	value = m_DoseUnit.m_PostKV->Get();
	return RET_STATUS::RET_FAILED;
}
RET_STATUS nsGEN::DeltaMobileDevice::QueryPostMA(float& value)
{
	FINFO("{$}", value);
	value = m_DoseUnit.m_PostMA->Get();
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::QueryPostMS(float& value)
{
	FINFO("{$}", value);
	value = m_DoseUnit.m_PostMS->Get();
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::QueryPostMAS(float& value)
{
	FINFO("{$}", value);
	value = m_DoseUnit.m_PostMAS->Get();
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetGenSynState(int value)
{
	FINFO("{$}", value);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetGenState(int value)
{
	FINFO("{$}", value);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::DeltaMobileDevice::SetExpMode(std::string value)
{
	FINFO("ExpMode {$}", value.c_str());
	if (value == AttrKey::EXPMODE_TYPE::Single)
	{
		SetRadMode(1, 0);
	}
	else if (value == AttrKey::EXPMODE_TYPE::TOMO)
	{
		SetRadMode(1, 1);
	}
	else
	{
		SetFLFMode(value);
	}
	m_DoseUnit.m_ExpMode->Update(value);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetFLFMode(std::string value)
{
	//54A2
	FINFO("[0xF0, 0x54, 0xA2, 0xxx]FLFMode:{$}[2:CF,3:PF]", value);
	char cmdbuf[13] = { 0xF0, 0x54, 0xA2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	int ExpMode = -1;
	if (value == AttrKey::EXPMODE_TYPE::CoutineSerial)
	{
		ExpMode = 2;
	}
	else
	{
		ExpMode = 3;
	}
	cmdbuf[3] = ExpMode;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetEXAMMode(std::string value)
{
	FINFO("EXAMMode:{$}", value.c_str());
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetFrameRate(float frameRate)
{
	//5DAD
	if (m_DoseUnit.m_FrameRate->Verify(frameRate))
	{
		//双能是序列点片，是需要配置帧率的
		FINFO("[0xF0, 0x6D, 0xAD, 0xxx]framerate:{$}", frameRate);
		char cmdbuf[19] = { 0xF0, 0x6D, 0xAD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0xDB, 0x00, 0x88 };
		cmdbuf[3] = frameRate * 10;
		FormatCommand(cmdbuf, 19);
		string temp(cmdbuf, 19);
		m_strCommand = temp;
		HWSendWaitACKCMD(m_strCommand, 4);
	}
	return RET_STATUS::RET_SUCCEED;
}

//貌似最好有时间间隔
RET_STATUS nsGEN::DeltaMobileDevice::RefreshData()
{
	FINFO("RefreshData");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetExpEnable()
{
	//5CA3
	FINFO("[0xF0, 0x5C, 0xA3, 0x00]");
	char cmdbuf[13] = { 0xF0, 0x5C, 0xA3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC5, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	if (m_DoseUnit.m_GenState->Get() != nsGEN::AttrKey::GENERATOR_STATUS_ERROR)
	{
		m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_STANDBY);
		FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::SetExpDisable()
{
	//5CA3
	FINFO("[0xF0, 0x5C, 0xA3, 0x01]");
	char cmdbuf[13] = { 0xF0, 0x5C, 0xA3, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::DeltaMobileDevice::Reset()
{
	FINFO("Reset[0xF0 ,0x59 ,0xA1 ,CurErrLevel:{$}]", m_nCurErrLevel);
	char cmdbuf[13] = { 0xF0 ,0x59 ,0xA1 ,0x01 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x88 };
	cmdbuf[3] = m_nCurErrLevel;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return RET_STATUS::RET_SUCCEED;
}

//-----------------------------------------------------------------------------
//		ProcessCmd
//-----------------------------------------------------------------------------
void nsGEN::DeltaMobileDevice::ProcessClientData(const char* pData, unsigned long nDataLength, void* lparam)
{
	FINFO("pData {$}", pData);
	DeltaMobileDevice* pCurGen = (DeltaMobileDevice*)lparam;
	pCurGen->HWSend(pData, nDataLength);
}

RET_STATUS nsGEN::DeltaMobileDevice::HWSendWaitACKCMD(string strCommand, int headLengh)
{
	return HWSend(strCommand.c_str(), strCommand.length(), false, TIMEOUTVALUE);
}

RET_STATUS nsGEN::DeltaMobileDevice::HWSend(const char* strCommand, int length, bool reSend, int nTimeOut)
{
	if (!m_SCF) {
		FINFO("Failed - Serial communication interface not initialized");
		return RET_STATUS::RET_FAILED;
	}

	if (!m_SCF->IsConnected())
	{
		FERROR("Failed - Device not connected");
		return RET_STATUS::RET_FAILED;
	}

	// Use length parameter if provided, otherwise calculate
	int cmdLen = (length > 0) ? length : strlen(strCommand);

	// Build packet with CRC
	const int maxCmdLen = 256;
	if (cmdLen > maxCmdLen - 1)
	{
		FERROR("Command too long: {$} bytes, max allowed: {$} bytes\n", cmdLen, maxCmdLen - 1);
		return RET_STATUS::RET_FAILED;
	}

	char strSendCommand[maxCmdLen] = { 0 };
	memcpy(strSendCommand, strCommand, cmdLen);

	// Add CRC8 checksum
	UINT8 crc = GetCRC8(strSendCommand, cmdLen);
	strSendCommand[cmdLen] = crc;
	int totalLen = cmdLen + 1;  // Command + CRC

	// Print hex dump for debugging
	std::string hexStr;
	hexStr.reserve(totalLen * 3);
	int printLen = std::min(totalLen, 32);
	for (int i = 0; i < printLen; i++) {
		char buf[4];
		snprintf(buf, sizeof(buf), "%02X ", (unsigned char)strSendCommand[i]);
		hexStr += buf;
	}
	if (totalLen > 32) hexStr += "...";

	FINFO("==OUT== Packet[{$}]: HEX=[{$}]\n", totalLen, hexStr.c_str());

	// Send with retry mechanism
	int maxRetry = reSend ? 2 : 1;
	unsigned int retLength = 0;

	for (int retry = 0; retry < maxRetry; retry++)
	{
		if (retry > 0)
		{
			FWARN("Retry sending packet, attempt {$}/{$}\n", retry + 1, maxRetry);
			Sleep(100);
		}

		if (m_SCF->Lock(1000) == WAIT_OBJECT_0)
		{
			// 使用实际长度totalLen，而不是strlen
			int result = m_SCF->SendPacket(strSendCommand, (unsigned int)totalLen, nTimeOut, retLength);
			m_SCF->Unlock();

			if (result == SCF_SUCCEED)
			{
				if (retry > 0)
				{
					FINFO("Send succeeded after {$} retries\n", retry);
				}
				return RET_STATUS::RET_SUCCEED;
			}
			else
			{
				FERROR("SendPacket failed, result={$}, retry={$}/{$}\n", result, retry + 1, maxRetry);
			}
		}
		else
		{
			FERROR("Lock failed, retry={$}/{$}\n", retry + 1, maxRetry);
		}
	}

	FERROR("Send failed after {$} attempts\n", maxRetry);
	return RET_STATUS::RET_FAILED;
}
void nsGEN::DeltaMobileDevice::FireErrorMessage(const bool Act, const int Code, const char* ResInfo)
{
	string ErrorCode("DELTA_ERR_");
	ErrorCode += std::to_string(Code);
	int level = DELTA_MOBILE_ABNORMAL_LEVEL::REG_ERRO;
	if (Act)
	{
		FERROR("add {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->AddErrorMessage(ErrorCode.c_str(), level, ResInfo);
	}
	else
	{
		FERROR("del {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->DelErrorMessage(ErrorCode.c_str(), level, ResInfo);
	}
}
void nsGEN::DeltaMobileDevice::FireWarnMessage(const bool Act, const int Code, const char* ResInfo)
{
	string WarnCode("DELTA_WAR_");
	WarnCode += std::to_string(Code);
	int level = DELTA_MOBILE_ABNORMAL_LEVEL::REG_WARN;
	if (Act)
	{
		FERROR("add {$}:{$}", WarnCode.c_str(), ResInfo);
		m_MSGUnit->AddWarnMessage(WarnCode.c_str(), level, ResInfo);
	}
	else
	{
		FERROR("del {$}:{$}", WarnCode.c_str(), ResInfo);
		m_MSGUnit->DelWarnMessage(WarnCode.c_str(), level, ResInfo);
	}
}

//-----------------------------------------------------------------------------
//		ProcessCmd
//-----------------------------------------------------------------------------

void nsGEN::DeltaMobileDevice::FireNotify(std::string key, std::string content)
{
	EventCenter->OnNotify(1, key, content);
}

bool nsGEN::DeltaMobileDevice::DecodeFrame(const char* strPackage, int nLength)
{
	char strSendCommand[10] = { 0 };
	string str = "";
	for (int i = 0; i < nLength; i++)
	{
		snprintf(strSendCommand, sizeof(strSendCommand), "%02X", (BYTE)strPackage[i]);
		str += strSendCommand;
		str += " ";
	}
	FINFO("==IN== {$}", str);
	if ((BYTE)strPackage[0] == 0xF0)
	{
		if (strPackage[nLength - 4] != 0x0A)
		{
			//RetrieveExposureResult();
			char WarnCode[20];
			snprintf(WarnCode, sizeof(WarnCode), "DELTA_WARN_%03d", strPackage[nLength - 4]);
			int level = 1;
			FINFO("DELTA_WARN_CODE{$}", WarnCode);
			auto it = m_WarnMessages.find(WarnCode);
			if (it != m_WarnMessages.end())
			{
				m_MSGUnit->AddWarnMessage(WarnCode, level, it->second.c_str());
			}
			return 0;// warn，就不要此命令了？
		}
	}

	const char* chdigital;
	m_nCountTimes = 0;
	if (UINT8(strPackage[0]) != 0xF0)
	{
		FINFO("simple cmd:{$}", strPackage);


		if (strPackage[0] == 'C' && strPackage[1] == 'X' && strPackage[2] == 'L')
		{
			m_nProcessXrayon = false;
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
		}

		if (strPackage[0] == 'E' && strPackage[1] == 'R' && strPackage[2] == 'R')
		{
			chdigital = strPackage + 3;
			int errornumber = atoi(chdigital);
			m_nProcessXrayon = false;
			if (errornumber < 3000) //warn
			{
				char WarnCode[20];
				snprintf(WarnCode, sizeof(WarnCode), "DELTA_WARN_%04d", strPackage[nLength - 4]);
				int level = 1;
				FINFO("DELTA_WARN_CODE{$}", WarnCode);
				auto itwarn = m_WarnMessages.find(WarnCode);
				if (itwarn != m_WarnMessages.end())
				{
					m_MSGUnit->AddWarnMessage(WarnCode, level, itwarn->second.c_str());
				}

				//如果error=0012，那么表示一档松开。那么应该发送release，取消本次曝光，否则会出现超时的问题

				if (errornumber == 12 || errornumber == 1006)
				{
					m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
					FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				}
				if (errornumber >= 4000)
				{
					m_nCurErrLevel = 3;
				}
				if (errornumber >= 3000)
				{
					m_nCurErrLevel = 1;
				}

				char ErrCode[20];
				snprintf(ErrCode, sizeof(ErrCode), "DELTA_ERR_%04d", strPackage[3]);
				FINFO("DELTA_ERR_CODE{$}", ErrCode);
				auto iterr = m_ErrorMessages.find(ErrCode);
				if (iterr != m_ErrorMessages.end())
				{
					m_MSGUnit->AddErrorMessage(ErrCode, level, iterr->second.c_str());
				}
			}
		}


		if (strPackage[0] == 'R' && strPackage[1] == 'O' && strPackage[2] == 'N')//RON RDY XON OFF
		{
			m_nProcessXrayon = true;
			if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::CONVENTIONAL)
			{
				m_DoseUnit.m_Handswitch->Update(AttrKey::HANDSWITCH_STATUS::HANDSWITCH_STATUS_Release);
				FireNotify(m_DoseUnit.m_Handswitch->GetKey(), m_DoseUnit.m_Handswitch->JSGet());
				FINFO("Updata m_DoseUnit.m_Handswitch {$}", m_DoseUnit.m_Handswitch->JSGet());
			}
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_SYNC::GENERATOR_RAD_PREPARE);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			FINFO("Updata m_DoseUnit.m_GenSynState {$}", m_DoseUnit.m_GenSynState->JSGet());
		}
		if (strPackage[0] == 'R' && strPackage[1] == 'D' && strPackage[2] == 'Y')//RON RDY XON OFF
		{
			m_nProcessXrayon = true;
			if (m_DoseUnit.m_GenSynState->Get() != AttrKey::GENERATOR_SYNC::GENERATOR_RAD_PREPARE)
			{
				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_SYNC::GENERATOR_RAD_PREPARE);
				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				FINFO("Updata m_DoseUnit.m_GenSynState {$}", m_DoseUnit.m_GenSynState->JSGet());
			}
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_SYNC::GENERATOR_RAD_READY);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			FINFO("Updata m_DoseUnit.m_GenSynState {$}", m_DoseUnit.m_GenSynState->JSGet());
			Sleep(20);//此发生器RDY和XON有时消息会过快，导致工作流没反应过来。所以加个睡眠。
			FINFO("m_bIsDualExp:{$}, m_nExposureNumber:{$}", m_bIsDualExp, m_nExposureNumber);
			if (m_bIsDualExp && (m_nExposureNumber == 1))
			{
				try
				{
					if (m_GenConfig.GetKeyCount("SendXwindowToDetector") > 0)
					{
						if ((int)m_GenConfig["SendXwindowToDetector"] == 1)
						{
							m_pDetectorClient = std::make_unique<LogicClient>("DV3_Detector", "", "NSQ", false);
							if (m_pDetectorClient->Open("CCOS/DEVICE/Detector", ALL_ACCESS)) //换成探测器的路径
							{
								FDEBUG("Ccos_V3 Create DV3_Detector Client success");
							}
						}
					}
				}
				catch (const std::exception&)
				{

				}
				if (m_pDetectorClient != nullptr)
				{
					if (!m_pDetectorClient->IsClosed())
					{
						FINFO("m_pDetectorClient is open");
						ResDataObject Request, Response;
						Request.add("P0", 1);
						m_pDetectorClient->Action("DualSecondExpReady", Request, Response, 4993);
					}
					else
					{
						FINFO("DV3_Detector Client is Close");
					}
				}
				else
				{
					FINFO("DV3_FullUCB Client is NULL");
				}
				m_bIsDualExp = false; //第二次设定之后，主动false
				m_nExposureNumber = 0;
			}
		}
		if (strPackage[0] == 'X' && strPackage[1] == 'O' && strPackage[2] == 'N')//RON RDY XON OFF
		{
			m_nProcessXrayon = true;
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_SYNC::GENERATOR_RAD_XRAYON);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			FINFO("Updata m_DoseUnit.m_GenSynState {$}", m_DoseUnit.m_GenSynState->JSGet());
			m_bXronMsg = true;
		}
		if (strPackage[0] == 'O' && strPackage[1] == 'F' && strPackage[2] == 'F')//RON RDY XON OFF
		{
			if (m_bXronMsg == false)
			{
				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_SYNC::GENERATOR_RAD_XRAYON);
				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				FINFO("Updata m_DoseUnit.m_GenSynState {$}", m_DoseUnit.m_GenSynState->JSGet());
			}
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_SYNC::GENERATOR_RAD_XRAYOFF);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			RetrieveExposureResult();
			if (m_bIsDualExp)
			{
				m_nExposureNumber = 1;
				SetDualEnergyCommand(m_tAPRdata);
				FINFO("dual: setapr 2nd.");
			}
			m_nProcessXrayon = false;
			m_bXronMsg = false;
		}
		return 0;
	}
	switch (UINT8(strPackage[1]))
	{
		case 0x50:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0xA1:
				FINFO("[50A1]Restore factory settings successfully");
				break;
			default:
				break;
			}
			break;
		}
		case 0x51:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				int nET = (int)(strPackage[3]);
				if (nET == 1)
				{
					m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_AEC_3P);
				}
				else if (nET == 2)
				{
					if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::TABLE)
					{
						if (m_nTableUsePanelAEC == 1)
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_AEC_3P);
						}
						else
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_3P);
						}
					}
					else if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::WALL)
					{

						if (m_nWallUsePanelAEC == 1)
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_AEC_3P);
						}
						else
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_3P);
						}
					}
					else if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::MOBILE)
					{

						if (m_nFreeUsePanelAEC == 1)
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_AEC_3P);
						}
						else
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_3P);
						}
					}
					else
					{
						m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_2P);
					}

				}
				else if (nET == 3)
				{
					m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_2P);
				}
				FireNotify(m_DoseUnit.m_Techmode->GetKey(), m_DoseUnit.m_Techmode->JSGet());
				FINFO("[5101]:ET {$}", m_DoseUnit.m_Techmode->Get());
				break;
			}
			case 0xA1:
			{
				chdigital = strPackage + 3;
				int nET = (int)(strPackage[3]);
				if (nET == 1)
				{
					m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_TYPE::TECHMODE_AEC_3P);
					FireNotify(m_DoseUnit.m_Techmode->GetKey(), m_DoseUnit.m_Techmode->JSGet());
					m_AECinformation.Chamber = (int)(strPackage[4]);
					m_AECinformation.Field = (int)(strPackage[5]);
					m_AECinformation.Density = (int)(strPackage[6]);
					m_AECinformation.FilmScreenSpeed = (int)(strPackage[7]);
					UpdataAECInformation(m_AECinformation);
				}
				else if (nET == 2)//如果当前是DAEC模式，那么返回的是time，但是可能需要选中 AEC 按钮
				{
					if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::TABLE)
					{
						if (m_nTableUsePanelAEC == 1)
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_AEC_3P);
						}
						else
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_3P);
						}
					}
					else if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::WALL)
					{
						if (m_nWallUsePanelAEC == 1)
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_AEC_3P);
						}
						else
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_3P);
						}
					}
					else if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::MOBILE)
					{
						if (m_nFreeUsePanelAEC == 1)
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_AEC_3P);
						}
						else
						{
							m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_3P);
						}
					}
					FireNotify(m_DoseUnit.m_MA->GetKey(), m_DoseUnit.m_MA->JSGet());
					FireNotify(m_DoseUnit.m_MS->GetKey(), m_DoseUnit.m_MS->JSGet());
				}
				else if (nET == 3)
				{
					m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_NOAEC_2P);
				}
				FireNotify(m_DoseUnit.m_Techmode->GetKey(), m_DoseUnit.m_Techmode->JSGet());
				FINFO("[51A1]:TechMode:{$}", m_DoseUnit.m_Techmode->Get());
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x52:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				FINFO("[5201]");
				break;
			}
			case 0xA1:
			{
				chdigital = strPackage + 3;
				FINFO("[52A1]");
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x53:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				FINFO("[5301]");
				break;
			}
			case 0xA0:
			{
				//53A0
				FINFO("Reset fluexposuretime successfully");
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x54:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				int RadMode = (BYTE)strPackage[4];
				int DesMode = (BYTE)strPackage[5];
				if (RadMode == 0)
				{
					m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::Single);
				}
				else
				{
					m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::TOMO);
				}
				FireNotify(m_DoseUnit.m_ExpMode->GetKey(), m_DoseUnit.m_ExpMode->JSGet());
				FINFO("[5401]:RadMode[0 rad, 1 serial rad]:{$}, DesMode[0 dis DES, 1 en DES]:{$}",RadMode, DesMode);
				break;
			}
			case 0x02:
			{
				chdigital = strPackage + 3;
				int FluMode = (BYTE)strPackage[4];
				if (FluMode == 2)
				{
					m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::CoutineSerial);
				}
				else
				{
					m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::PulseSerial);
				}
				FireNotify(m_DoseUnit.m_ExpMode->GetKey(), m_DoseUnit.m_ExpMode->JSGet());
				FINFO("[5402]:FluMode[0 CF, 1 PF]:{$}", FluMode);
				break;
			}
			case 0xA1:
			{
				chdigital = strPackage + 3;
				if ((int)(strPackage[3]) == 0)
				{
					m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::Single);
				}
				else
				{
					m_DoseUnit.m_ExpMode->Update(AttrKey::EXPMODE_TYPE::TOMO);
				}
				FireNotify(m_DoseUnit.m_ExpMode->GetKey(), m_DoseUnit.m_ExpMode->JSGet());
				if ((int)(strPackage[4]) == 0)
				{
					FINFO("Not DE");
				}
				else
				{
					FINFO("DE");
				}
				FINFO("[54A1]:ExpMode:{$}", m_DoseUnit.m_ExpMode->GetKey());
				break;
			}
			case 0xA2:
			{
				chdigital = strPackage + 3;
				FINFO("[54A2]");
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x55:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			case 0xA1:
			{
				m_AECinformation.Chamber = (int)(strPackage[3]);
				m_AECinformation.Field = (int)(strPackage[4]);
				m_AECinformation.Density = (int)(strPackage[5]);
				m_AECinformation.FilmScreenSpeed = (int)(strPackage[6]);
				UpdataAECInformation(m_AECinformation);
				FINFO("[5501]: AEC");
				break;
			}
			case 0xA2:
			{
				//kv
				int nKv = (BYTE)(strPackage[3]);
				m_DoseUnit.m_KV->Update(nKv);
				FireNotify(m_DoseUnit.m_KV->GetKey(), m_DoseUnit.m_KV->JSGet());
				//ma
				float fMA = ((BYTE)(strPackage[4]) * 256 + (BYTE)strPackage[5]) / 10.0f;
				m_DoseUnit.m_MA->Update(fMA);
				FireNotify(m_DoseUnit.m_MA->GetKey(), m_DoseUnit.m_MA->JSGet());
				//aec reference kv
				//not ms
				float m_fMS = ((BYTE)strPackage[6] * 256 + (BYTE)strPackage[7]) / 10.0f;
				m_DoseUnit.m_MS->Update(m_fMS);
				FireNotify(m_DoseUnit.m_MS->GetKey(), m_DoseUnit.m_MS->JSGet());
				int hundred_aec_referenc_kv = (BYTE)strPackage[6] * 256 + (BYTE)strPackage[7];

				float mas = m_DoseUnit.m_MA->Get() * m_DoseUnit.m_MS->Get() / 1000.0f;
				GetFacFloatValue(m_vecMAS, mas);
				m_DoseUnit.m_MAS->Update(mas);
				FireNotify(m_DoseUnit.m_MAS->GetKey(), m_DoseUnit.m_MAS->JSGet());
				FINFO("[55 A2]: Updata: KV: {$}, MA: {$}, MS: {$}, MAS: {$}",
					m_DoseUnit.m_KV->GetKey(), m_DoseUnit.m_MA->GetKey(), m_DoseUnit.m_MS->GetKey(), m_DoseUnit.m_MAS->GetKey());
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x56:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x02:
			{
				//查询脉冲帧率，不用
				chdigital = strPackage + 3;
				FINFO("[56 02]: AEC.");
				break;
			}
			case 0xA1:
			{
				chdigital = strPackage + 3;
				//kv
				int nKv = (BYTE)(strPackage[3]);
				m_DoseUnit.m_KV->Update(nKv);
				FireNotify(m_DoseUnit.m_KV->GetKey(), m_DoseUnit.m_KV->JSGet());

				//ma
				float fMA = ((BYTE)(strPackage[4]) * 256 + (BYTE)strPackage[5]) / 10.0f;
				m_DoseUnit.m_MA->Update(fMA);
				FireNotify(m_DoseUnit.m_MA->GetKey(), m_DoseUnit.m_MA->JSGet());

				//ms
				float fMS = ((BYTE)(strPackage[6]) * 65536 + (BYTE)strPackage[7] * 256 + (BYTE)strPackage[8]) / 10.0f;
				m_DoseUnit.m_MS->Update(fMS);
				FireNotify(m_DoseUnit.m_MS->GetKey(), m_DoseUnit.m_MS->JSGet());

				float mas = m_DoseUnit.m_MA->Get() * m_DoseUnit.m_MS->Get() / 1000.0f;
				GetFacFloatValue(m_vecMAS, mas);
				m_DoseUnit.m_MAS->Update(mas);
				FireNotify(m_DoseUnit.m_MAS->GetKey(), m_DoseUnit.m_MAS->JSGet());
				FINFO("[56 A1]: Time mode: Updata: KV: {$}, MA: {$}, MS: {$}, MAS: {$}",
					m_DoseUnit.m_KV->GetKey(), m_DoseUnit.m_MA->GetKey(), m_DoseUnit.m_MS->GetKey(), m_DoseUnit.m_MAS->GetKey());
				break;
			}
			case 0xA2:
			{
				//56A2
				m_DoseUnit.m_PPS->Update((int)(strPackage[3]));
				FireNotify(m_DoseUnit.m_PPS->GetKey(), m_DoseUnit.m_PPS->JSGet());
				FINFO("[56 A2]: FrameRate:{$}", (int)(strPackage[3]));
				break;
			}
			case 0xA3:
			{
				//͸�Ӽ���kv ma mas  56A3
				int value = 0;
				chdigital = strPackage + 3;
				m_DoseUnit.m_FLKV->Update((int)(strPackage[3]));
				FireNotify(m_DoseUnit.m_FLKV->GetKey(), m_DoseUnit.m_FLKV->JSGet());
				value = (int)(strPackage[4] << 8 | strPackage[5]);
				m_DoseUnit.m_FLMA->Update(value);
				FireNotify(m_DoseUnit.m_FLMA->GetKey(), m_DoseUnit.m_FLMA->JSGet());
				value = (int)(strPackage[6] << 16 | strPackage[7] << 8 | strPackage[8]);
				m_DoseUnit.m_FLMA->Update(value);
				FireNotify(m_DoseUnit.m_FLMA->GetKey(), m_DoseUnit.m_FLMA->JSGet());
				FINFO("[56 A3]: MS MODE: FKV:{$}, FMA:{$}", m_DoseUnit.m_FLKV->Get(), m_DoseUnit.m_FLMA->Get());
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x57://-----------------------------------------------------------首次进入时，直接切换到mas，ma ms 没有消失****************bug
		{
			switch (UINT8(strPackage[2]))
			{
			case 0xA1:
			{
				//57A1
				//mas模式下的 kv mas 解析
				chdigital = strPackage + 3;
				//kv
				int nKv = (int)(strPackage[3]);
				m_DoseUnit.m_KV->Update(nKv);
				FireNotify(m_DoseUnit.m_KV->GetKey(), m_DoseUnit.m_KV->JSGet());

				//ma
				float fMA = ((BYTE)(strPackage[4]) * 256 + (BYTE)strPackage[5]) / 10.0f;
				m_DoseUnit.m_MA->Update(fMA);
				FireNotify(m_DoseUnit.m_MA->GetKey(), m_DoseUnit.m_MA->JSGet());

				//ms----MAS 模式下，返回的ms值。
				float fMS = ((BYTE)(strPackage[6]) * 65536 + (BYTE)strPackage[7] * 256 + (BYTE)strPackage[8]) / 10.0f;
				m_DoseUnit.m_MS->Update(fMS);
				FireNotify(m_DoseUnit.m_MS->GetKey(), m_DoseUnit.m_MS->JSGet());
				float mas = m_DoseUnit.m_MA->Get() * m_DoseUnit.m_MS->Get() / 1000.0f;
				GetFacFloatValue(m_vecMAS, mas);
				m_DoseUnit.m_MAS->Update(mas);
				FireNotify(m_DoseUnit.m_MAS->GetKey(), m_DoseUnit.m_MAS->JSGet());
				FINFO("[57 A1]: MAS mode: Updata: KV: {$}, MA: {$}, MS: {$}, MAS: {$}(calc)", m_DoseUnit.m_KV->Get(), m_DoseUnit.m_MA->Get(), m_DoseUnit.m_MS->Get(), m_DoseUnit.m_MAS->Get());
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x58:
		{
			switch (UINT8(strPackage[2]))
			{
			case 1:
			{
				int dapStatus = (int)(strPackage[2]);
				if (1 == dapStatus)
				{
					//dap enable
					//5801
					float fDap = 0;
					UINT8 tmpBuf[4] = { 0 };
					tmpBuf[0] = strPackage[7];
					tmpBuf[1] = strPackage[6];
					tmpBuf[2] = strPackage[5];
					tmpBuf[3] = strPackage[4];
					memcpy(&fDap, tmpBuf, 4);
					int nDAP = (int)fDap;			//mGycm^2
				}
				else
				{
					//dap disable
				}
				break;
			}
			case 2:
			{
				//dap rate
				float fDapRate = 0;
				UINT8 tmpBuf[4] = { 0 };
				tmpBuf[0] = strPackage[6];
				tmpBuf[1] = strPackage[5];
				tmpBuf[2] = strPackage[4];
				tmpBuf[3] = strPackage[3];
				memcpy(&fDapRate, tmpBuf, 4);
				//mGycm^2/s
				break;
			}
			case 0xA1:
			{
				FINFO("[58 A1]: clear dap and dap rate success!");
				break;
			}
			default:
				break;
			}

			break;
		}
		case 0x59:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0xA1:
			{
				chdigital = strPackage + 3;
				int nResetLevel = (int)(strPackage[3]);
				FINFO("[59 A1]:");
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x5A:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				if ((UINT8)(strPackage[3]) == 1)
				{
					m_DoseUnit.m_Focus->Update(AttrKey::FOCUS_TYPE::FOCUS_LARGE);
				}
				else
				{
					m_DoseUnit.m_Focus->Update(AttrKey::FOCUS_TYPE::FOCUS_SMALL);
				}
				FireNotify(m_DoseUnit.m_Focus->GetKey(), m_DoseUnit.m_Focus->JSGet());
				FINFO("[5A 01]:Focus: {$}", m_DoseUnit.m_Focus->Get());
				break;
			}
			case 0xA1:
			{
				chdigital = strPackage + 3;
				if ((UINT8)(strPackage[3]) == 1)
				{
					m_DoseUnit.m_Focus->Update(AttrKey::FOCUS_TYPE::FOCUS_LARGE);
				}
				else
				{
					m_DoseUnit.m_Focus->Update(AttrKey::FOCUS_TYPE::FOCUS_SMALL);
				}
				FireNotify(m_DoseUnit.m_Focus->GetKey(), m_DoseUnit.m_Focus->JSGet());
				FINFO("[5A A1]: FO:{$}", m_DoseUnit.m_Focus->Get());
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x5B:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				//5B01
				chdigital = strPackage + 3;
				FINFO("0:No select, 1:bucky 1, 2:bucky 2, 3 :all select");
				FINFO("[5B 01] Select bucky is {$} ", (int)(strPackage[3]));
				break;
			}
			case 0xA1:
			{
				//5BA1
				FINFO("[5B A1]");
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x5C:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0xA1:
			{
				chdigital = strPackage + 3;
				FINFO("[5C A1]:Gen Operate Status is Shutdown");
				break;
			}
			case 0xA2:
			{
				chdigital = strPackage + 3;
				FINFO("[5C A2]:Gen Operate Status is StandBy");
				break;
			}
			case 0x03:
			case 0xA3:
			{
				int nExpEnable = (int)(strPackage[3]);
				FINFO("[5C A3/03]: m_bExpEnable");
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x5E:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				FINFO("[5E 01]Tube ID {$} ", (int)(strPackage[3]));
				break;
			}
			case 0x02:
			{
				chdigital = strPackage + 3;
				FINFO("[5E 01]:tube id is 2");
				break;
			}
			case 0x03:
			{
				chdigital = strPackage + 3;
				FINFO("[5E 03]");
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x5F:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				//5F01
				int hu = int(strPackage[3] << 8 | strPackage[4]);
				m_DoseUnit.m_HE->Update(hu / 10);
				FireNotify(m_DoseUnit.m_HE->GetKey(), m_DoseUnit.m_HE->JSGet());
				FINFO("[5F 01]:HU1 :{$}", hu);

				hu = int(strPackage[5] << 8 | strPackage[6]);
				//m_DoseUnit.m_HE->Update(hu / 10);
				//FireNotify(m_DoseUnit.m_HE->GetKey(), m_DoseUnit.m_HE->JSGet());
				FINFO("[5F 01]:HU2 :{$}", hu / 10);

				hu = int(strPackage[7] << 8 | strPackage[8]);
				//m_DoseUnit.m_HE->Update(hu / 10);
				//FireNotify(m_DoseUnit.m_HE->GetKey(), m_DoseUnit.m_HE->JSGet());
				FINFO("[5F 01]:HU3 :{$}", hu / 10);
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x61:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				string GenFirmwareVersion = AnalysisCommand(BYTE_6, chdigital, TransToType::tochar);

				chdigital = strPackage + 9;
				string ConsoleFirmwareVersion = AnalysisCommand(BYTE_6, chdigital, TransToType::tochar);
				FINFO("[61 01]:Generator firmware version {$}, Console firmware version {$}", GenFirmwareVersion, ConsoleFirmwareVersion);
				break;

			}
			case 0x02:
			{
				chdigital = strPackage + 3;
				string str = AnalysisCommand(BYTE_12, chdigital, TransToType::tochar);
				FINFO("[61 02]:Mode version {$}", str);
				break;
			}
			case 0x03:
			{
				chdigital = strPackage + 3;
				string str = AnalysisCommand(BYTE_6, chdigital, TransToType::tochar);
				FINFO("[61 03]:Mode version {$}", str);
				break;
			}
			case 0x04:
			{
				chdigital = strPackage + 3;
				m_nMaxKW = (int)(strPackage[3] << 8 | strPackage[4]);
				m_nMaxMA = (int)(strPackage[5] << 8 | strPackage[6]);
				m_nMaxMAS = (int)(strPackage[7] << 8 | strPackage[8]);
				m_nMaxKV = (int)(strPackage[9]);
				int nFo = (int)(strPackage[10]);
				int nRotor = (int)(strPackage[11]);
				int nMotorFirmwareVersion = (int)(strPackage[12] << 8 | strPackage[13]);
				int nSWCfgFileVersion = (int)(strPackage[14]);
				FINFO("Max Power:KW:{$}, MA:{$}, MAS:{$}, KV:{$}, Mas:{$}, Vlotage:{$}, Focal Spot:{$}, Rotor:{$}, Motor firmware version:{$}, SW file version:{$}",
					m_nMaxKW, m_nMaxMA, m_nMaxMAS, m_nMaxKV,nFo,nRotor,nMotorFirmwareVersion,nSWCfgFileVersion);
				break;
			}
			case 0x05:
			{
				chdigital = strPackage + 3;
				int maxDeratingPower = (int)(strPackage[3] << 8 | strPackage[4]);
				int maxDeratingMa = (int)(strPackage[5] << 8 | strPackage[6]);
				int maxDeratingMas = (int)(strPackage[7] << 8 | strPackage[8]);
				int maxDeratingKv = (int)(strPackage[9]);
				int minDeratingMa = (int)(strPackage[10] << 8 | strPackage[11]);
				int maxDeratingMs = (int)(strPackage[12] << 8 | strPackage[13]);
				break;
			}
			case 0x06:
			{
				chdigital = strPackage + 3;
				string str = AnalysisCommand(BYTE_6, chdigital, TransToType::tochar);
				FINFO("[61 06]AEC&DAP Version {$}", str);
				break;
			}
			case 0xA5:
			{
				chdigital = strPackage + 3;
				FINFO("[61 A5]");
				break;
			}
			case 0x07:
			case 0xA7:
			{
				int nAccuracy = (int)(strPackage[3]);
				FINFO("[61 07/A7]");
				break;
			}
			case 0xAC:
			{
				int nDaecStatus = (int)(strPackage[3]);
				FINFO("[61 AC]");
				break;
			}
			default:
				break;
			}

			break;
		}
		case 0x62:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				string str = AnalysisCommand(BYTE_10, chdigital, TransToType::tochar);
				chdigital = strPackage + 13;
				string tubestr = AnalysisCommand(BYTE_2, chdigital, TransToType::tochar);
				FINFO("[62 01]Tube Part Number:[$], Tube library version:[$]", str, tubestr);
				break;
			}
			case 0x02:
			{
				chdigital = strPackage + 3;
				int SF_LS_MaxPower = (int)(strPackage[3] << 8 | strPackage[4]);
				int LF_LS_MaxPower = (int)(strPackage[5] << 8 | strPackage[6]);
				int SF_HS_MaxPower = (int)(strPackage[7] << 8 | strPackage[8]);
				int LF_HS_MaxPower = (int)(strPackage[9] << 8 | strPackage[10]);
				FINFO("[62 02]:SF_LS_MaxPower: [$], LF_LS_MaxPower: [$], SF_HS_MaxPower: [$], LF_HS_MaxPower: [$]",
					SF_LS_MaxPower, LF_LS_MaxPower, SF_HS_MaxPower, LF_HS_MaxPower);
				break;
			}
			case 0x03:
			{
				chdigital = strPackage + 3;
				int SF_standbycurrent = (int)(strPackage[3] << 8 | strPackage[4]);
				int SF_maxcurrent = (int)(strPackage[5] << 8 | strPackage[6]);
				int LF_standbycurrent = (int)(strPackage[7] << 8 | strPackage[8]);
				int LF_maxcurrent = (int)(strPackage[9] << 8 | strPackage[10]);
				FINFO("[62 02]:SF_standbycurrent: {$},SF_maxcurrent {$}, LF_standbycurrent: {$}, LF_maxcurrent: {$}",
					SF_standbycurrent, SF_maxcurrent, LF_standbycurrent, LF_maxcurrent);
				break;
			}
			case 0x04:
			{
				chdigital = strPackage + 3;
				int HUWarning = (int)(strPackage[3]);
				int HULimit = (int)(strPackage[4]);
				FINFO("[62 04]HU warning: {$}, HU limit: {$}", HUWarning, HULimit);
				break;
			}
			case 0x05:
			{
				chdigital = strPackage + 3;
				int maxTubeKv = (int)(strPackage[3]);
				int max_SF_TubecurrentMA = (int)(strPackage[4] << 8 | strPackage[5]);
				int max_LF_TubecurrentMA = (int)(strPackage[6] << 8 | strPackage[7]);
				FINFO("[62 05]:maxTubeKv: {$}, max_SF_TubecurrentMA: {$}, max_LF_TubecurrentMA: {$}", maxTubeKv, max_SF_TubecurrentMA, max_LF_TubecurrentMA);
				break;
			}
			case 0xA2:
			{
				chdigital = strPackage + 3;
				int SF_LS_MaxPower = (int)(strPackage[3] << 8 | strPackage[4]);
				int LF_LS_MaxPower = (int)(strPackage[5] << 8 | strPackage[6]);
				int SF_HS_MaxPower = (int)(strPackage[7] << 8 | strPackage[8]);
				int LF_HS_MaxPower = (int)(strPackage[9] << 8 | strPackage[10]);
				FINFO("[62 A2]:SF_LS_MaxPower: {$},LF_LS_MaxPower: {$}, SF_HS_MaxPower: {$}, LF_HS_MaxPower: {$}", SF_LS_MaxPower, LF_LS_MaxPower, SF_HS_MaxPower, LF_HS_MaxPower);
				break;
			}
			case 0xA3:
			{
				chdigital = strPackage + 3;
				int SF_standbycurrent = (int)(strPackage[3] << 8 | strPackage[4]);
				int SF_maxcurrent = (int)(strPackage[5] << 8 | strPackage[6]);
				int LF_standbycurrent = (int)(strPackage[7] << 8 | strPackage[8]);
				int LF_maxcurrent = (int)(strPackage[9] << 8 | strPackage[10]);
				FINFO("[62 A3]:SF_standbycurrent: {$}, SF_maxcurrent: {$}, LF_standbycurrent: {$}, LF_maxcurrent: {$}", SF_standbycurrent, SF_maxcurrent, LF_standbycurrent, LF_maxcurrent);
				break;
			}
			case 0xA4:
			{
				chdigital = strPackage + 3;
				int HUWarning = (int)(strPackage[3]);
				int HULimit = (int)(strPackage[4]);
				FINFO("[62 A4]");
				break;
			}
			case 0xA5:
			{
				//Set tube derating information.----这个功能可能暂时用不到。先不管。
				chdigital = strPackage + 3;
				FINFO("[62 A5]");
				break;
			}
			case 0xA6:
			{
				//62A6
				int meter = (int)(strPackage[3] << 8 | strPackage[4]);
				FINFO("[62 A6]{$}meter", meter / 10);
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x63:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				int Errid = (int)(strPackage[3] << 8 | strPackage[4]);
				int ErrCode = (int)(strPackage[5] << 8 | strPackage[6]);
				FINFO("[63 01]:Errid: {$}, ErrCode: {$}", Errid, ErrCode);
				break;
			}

			case 0x02:
			{
				chdigital = strPackage + 3;
				FINFO("[63 02]");
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x64:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				/*
				0x00 = INITIAL
				0x01 = STANDBY
				0x02 = READY
				0x03 = OPERATE
				0x04 = SHUTDOWN
				0x05 = CALIBRATION
				0x06 = SEASON
				*/
				int nGenStatus = (int)(strPackage[3]);
				if (0 == nGenStatus)
				{
					FINFO("[64 01 01]: GENERATOR_STATUS_INIT");
					m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS::GENERATOR_STATUS_INIT);
					FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
				}
				else if (1 == nGenStatus)
				{
					FINFO("[64 01 01] :GENERATOR_STATUS_CHARGING");
					m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS::GENERATOR_STATUS_CHARGING);
					FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
				}
				else if (2 == nGenStatus)
				{
					FINFO("[64 01 02]: GENERATOR_STATUS_STANDBY");
					m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS::GENERATOR_STATUS_STANDBY);
					FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());

				}
				else if (3 == nGenStatus)
				{
					FINFO("[64 01 03]: GENERATOR_STATUS_ERROR");
					m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS::GENERATOR_STATUS_EXP);
					FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
				}
				else if (4 == nGenStatus)
				{
					FINFO("[64 01 04]: GENERATOR_STATUS_SHUTDOWN");
					m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS::GENERATOR_STATUS_SHUTDOWN);
					FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
				}
				else if (5 == nGenStatus)
				{
					FINFO("[64 01 05]: GENERATOR_STATUS_CALIBRATION");
					m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS::GENERATOR_STATUS_CALIBRATION);
					FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
				}
				else if (6 == nGenStatus)
				{
					FINFO("[64 01 06]: GENERATOR_STATUS_ERROR");
					m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS::GENERATOR_STATUS_ERROR);
					FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
				}
				break;
			}
			case 0x02:
			{
				chdigital = strPackage + 3;
				m_DoseUnit.m_PostKV->Update((int)strPackage[3]);
				FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());
				int TUBE_current = (int)(strPackage[4] << 8 | strPackage[5]);
				int Operate_MS = (int)(strPackage[6] << 16 | strPackage[7] << 8 | strPackage[8]);
				int Operate_MAS = (int)(strPackage[9] << 16 | strPackage[10] << 8 | strPackage[11]);
				int SNAP_rate = int(strPackage[12]);
				m_DoseUnit.m_FrameRate->Update(SNAP_rate);
				FireNotify(m_DoseUnit.m_FrameRate->GetKey(), m_DoseUnit.m_FrameRate->JSGet());
				FINFO("[64 02]:");
				break;
			}
			case 0x03:
			{
				m_DoseUnit.m_FLKV->Update((int)strPackage[3]);
				FireNotify(m_DoseUnit.m_FLKV->GetKey(), m_DoseUnit.m_FLKV->JSGet());
				int TUBE_current = (int)(strPackage[4] << 8 | strPackage[5]);
				int Operate_MS = (int)(strPackage[6] << 16 | strPackage[7] << 8 | strPackage[8]);
				int Operate_MAS = (int)(strPackage[9] << 16 | strPackage[10] << 8 | strPackage[11]);
				FINFO("[64 03]: FLKV: {$}, TUBE_current: {$}, Operate_MS: {$}, Operate_MAS: {$}", m_DoseUnit.m_FLKV->Get(), TUBE_current, Operate_MS, Operate_MAS);
				break;
			}
			case 0xAD:
			{
				int framerate = (int)(strPackage[3]) / 10;
				m_DoseUnit.m_FrameRate->Update(framerate);
				FireNotify(m_DoseUnit.m_FrameRate->GetKey(), m_DoseUnit.m_FrameRate->JSGet());
				FINFO("[6D AD]: FrameRate: {$}", framerate);
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x65:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			{
				chdigital = strPackage + 3;
				//kv
				int postKv = (BYTE)(strPackage[3]) * 256 + (BYTE)strPackage[4];
				m_DoseUnit.m_PostKV->Update(postKv);
				FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());
				//ma
				int nPostMa = (BYTE)(strPackage[5]) * 256 + (BYTE)strPackage[6];
				float fpostMa = nPostMa / 10.0f;
				m_DoseUnit.m_PostMA->Update(fpostMa);
				FireNotify(m_DoseUnit.m_PostMA->GetKey(), m_DoseUnit.m_PostMA->JSGet());

				//ap-postmas
				int nPostMas = (BYTE)(strPackage[7]) * 65536 + (BYTE)strPackage[8] * 256 + (BYTE)strPackage[9];
				float fpostMAS = nPostMas / 100.0f;
				m_DoseUnit.m_PostMAS->Update(fpostMAS);
				FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());

				//at-postms
				int nPostMs = (BYTE)(strPackage[10]) * 65536 + (BYTE)strPackage[11] * 256 + (BYTE)strPackage[12];
				float fpostMS = nPostMs / 10.0f;
				m_DoseUnit.m_PostMS->Update(fpostMS);
				FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());
				FINFO("[65 01]: postKV: {$}, postMA: {$}, postMAS: {$}, postMS: {$}", postKv, fpostMa, fpostMAS, fpostMS);
				break;
			}
			default:
				break;
			}
			break;
		}
		case 0x6B:
		{
		}
		break;
		case 0x6C:
		{
			int soc = (BYTE)(strPackage[3]) * 256 + (BYTE)strPackage[4];
			int vol = (BYTE)(strPackage[5]) * 256 + (BYTE)strPackage[6];
			int charge = (BYTE)(strPackage[7]) * 256 + (BYTE)strPackage[8];
			int temperature = (BYTE)(strPackage[9]) * 256 + (BYTE)strPackage[10];
			int ac = (BYTE)strPackage[11];
			m_DoseUnit.m_BatteryPowerState->Update(soc);
			FireNotify(m_DoseUnit.m_BatteryPowerState->GetKey(), m_DoseUnit.m_BatteryPowerState->JSGet());
			m_DoseUnit.m_BatteryChargeState->Update(charge);
			FireNotify(m_DoseUnit.m_BatteryChargeState->GetKey(), m_DoseUnit.m_BatteryChargeState->JSGet());
			FINFO("[6C]: battery: {$}, temperature: {$}", soc, temperature);
		}
		break;
		case 0x6D:
		{
			switch ((int)(strPackage[3]))
			{
			case 0xA1:
			{
				//6Da1
				FINFO("[6D A1]: Set ABSMode successful");
				break;
			}
			case 0xA2:
			{
				switch ((int)(strPackage[3]))
				{
				case 0:
				{
					FINFO("[64 A2 00]Cruve disable");
					break;
				}				
				case 1:
				{
					FINFO("[64 A2 01]Cruve 1");
					break;
				}				
				case 2:
				{
					FINFO("[64 A2 02]Cruve 2");
					break;
				}				
				case 3:
				{
					FINFO("[64 A2 03]Cruve 3");
					break;
				}
				default:
					break;
				}
				break;
			}
			default:
				break;
			}
		}
		break;
		case 0x6E:
		{
			switch (UINT8(strPackage[2]))
			{
			case 0x01:
			case 0xA1:
			{
				break;
			}
			case 0x02:
			case 0xA2:
			{
				//此命令比较特殊，切换为胶片模式，需要把下面俩值都设置为0.
				int nDetector1SynMode = (int)(strPackage[3]);
				int nDetector2SynMode = (int)(strPackage[4]);
				FINFO("[6E A2]");
				break;
			}
			default:
				break;
			}
			break;
		}

		default:

			break;
	}
	return true;
}

bool nsGEN::DeltaMobileDevice::ChangeGenParam(int kv, float fma, float fms, float fmas)
{
	FINFO("KV: {$}, MA: {$}, MS: {$}, MAS: {$}", kv, fma, fms, fmas);
	if (m_DoseUnit.m_Techmode->Get() == 0)
	{
		SetRADKV_MA_MS(kv, fma, fms);
	}
	else if (m_DoseUnit.m_Techmode->Get() == 1)
	{
		SetRADKV_MAS(kv, fmas);
	}
	else if (m_DoseUnit.m_Techmode->Get() == 2)
	{
		if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::TABLE)
		{
			if (m_nTableUsePanelAEC == 1)
			{
				SetRADKV_MA_MS(kv, fma, fms);

			}
			else
			{
				SetAECKV_MA_MS(kv, fma, fms);
			}
		}
		else if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::WALL)
		{
			if (m_nWallUsePanelAEC == 1)
			{
				SetRADKV_MA_MS(kv, fma, fms);
			}
			else
			{
				SetAECKV_MA_MS(kv, fma, fms);
			}
		}
		else if (m_DoseUnit.m_WS->Get() == AttrKey::GENWS_TYPE::MOBILE)
		{
			if (m_nFreeUsePanelAEC == 1)
			{
				SetRADKV_MA_MS(kv, fma, fms);

			}
			else
			{
				SetAECKV_MA_MS(kv, fma, fms);
			}
		}
	}
	return true;
}
//F0 6E A2 01 01 00 00 00 00 00 00 00 00 00 00 00 6C 00 88 发送消息
bool nsGEN::DeltaMobileDevice::SetRADKV_MA_MS(int kv, float ma, float ms)
{
	//56A1
	FINFO("[0xF0, 0x56, 0xA1]: KV: {$}, MA: {$}, MS: {$}", kv, ma, ms);
	char cmdbuf[20] = { 0xF0, 0x56, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	cmdbuf[3] = kv;

	//确保ma合理
	int posMA = GetFacFloatValue(m_vecMA, ma);//找到之后，再缩小10倍，写入数据帧
	int nTemp = ma * 10;
	cmdbuf[4] = nTemp >> 8;
	cmdbuf[5] = nTemp % 256;

	//确保ms合理
	int posMS = GetFacFloatValue(m_vecMS, ms);
	nTemp = ms * 10;
	cmdbuf[6] = nTemp >> 16;
	cmdbuf[7] = nTemp >> 8;
	cmdbuf[8] = nTemp % 256;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return true;
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::SetFLUKV_MA_MAS(int fkv, float fma, float fmas)
{
	//56A3
	FINFO("[0xF0, 0x56, 0xA3]:FKV: {$}, FMA: {$}, FMAS: {$}", fkv, fma ,fmas);
	char cmdbuf[13] = { 0xF0, 0x56, 0xA3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	//KV
	cmdbuf[3] = fkv;
	//MA
	int postvalue = GetFacFloatValue(m_vecFMA, fma);
	int nTemp = fma * 10;
	cmdbuf[4] = nTemp >> 8;
	cmdbuf[5] = nTemp % 256;
	//mas
	postvalue = GetFacFloatValue(m_vecFMAS, fmas);
	nTemp = fmas * 100;
	cmdbuf[6] = nTemp >> 16;
	cmdbuf[7] = nTemp >> 8;
	cmdbuf[8] = nTemp % 256;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::SetTubeDeratingPower()
{
	//62A2
	FINFO("[0xF0, 0x62, 0xA2]");
	//char cmdbuf[19] = { 0xF0, 0x62, 0xA2, 0x00, 0x00, 0x00, 0x00,0x00, 0x00, 0x00,0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	//cmdbuf[3] = kv;
	////确保mas合理
	//int nHundredMAS = 100 * mas;
	//int posMAS = GetFacFloatValue(m_vecMAS, nHundredMAS);
	//int nMAS = nHundredMAS;// 0x57 命令中 mas 需要放大100倍,所以恰好
	//cmdbuf[6] = nMAS >> 16;
	//cmdbuf[7] = nMAS >> 8;
	//cmdbuf[8] = nMAS % 256;
	//FormatCommand(cmdbuf, 13);
	//string temp(cmdbuf, 13);
	//m_strCommand = temp;
	//HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::SelectBucky(int bucky)
{
	//5BA1
	FINFO("[0xF0, 0x5B, 0xA1]:bucky: {$}", bucky);
	char cmdbuf[13] = { 0xF0, 0x5B, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	cmdbuf[3] = bucky;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::SetGeneratorOperateStatus(int status)
{
	//5B00
	FINFO("[0xF0, 0x5C]:status: {$}", status);
	char cmdbuf[13] = { 0xF0, 0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	cmdbuf[2] = status;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::SelectTubeID(int TubeID)
{
	//F05B
	FINFO("[0xF0, 0x5E]:TubeID: {$}", TubeID);
	char cmdbuf[13] = { 0xF0, 0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	cmdbuf[2] = TubeID;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveDAPValue()
{
	//F05801
	FINFO("[0xF0, 0x58, 0x01]");
	char cmdbuf[13] = { 0xF0, 0x58, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

bool nsGEN::DeltaMobileDevice::SetRADKV_MAS(int kv, float mas)
{
	//57A1
	FINFO("[0xF0, 0x57, 0xA1]: KV: {$}, MAS: {$}", kv, mas);
	char cmdbuf[20] = { 0xF0, 0x57, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	cmdbuf[3] = kv;
	//确保mas合理
	int posMAS = GetFacFloatValue(m_vecMAS, mas);
	int nMAS = mas * 100;// 0x57 命令中 mas 需要放大100倍,所以恰好
	cmdbuf[6] = nMAS >> 16;
	cmdbuf[7] = nMAS >> 8;
	cmdbuf[8] = nMAS % 256;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return true;
}

void nsGEN::DeltaMobileDevice::SetAECKV_MA_MS(int kv, float ma, float ms)
{
	//55A2
	FINFO("[0xF0, 0x55, 0xA2]: KV: {$}, MA; {$}, MS: {$}", kv, ma, ms);
	char cmdbuf[13] = { 0xF0, 0x55, 0xA2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9C, 0x00, 0x88 };
	cmdbuf[3] = kv;

	//确保ma合理
	int posMA = GetFacFloatValue(m_vecMA, ma);
	int nTemp = ma * 10;
	cmdbuf[4] = nTemp >> 8;
	cmdbuf[5] = nTemp % 256;

	//确保ms合理
	int posMS = GetFacFloatValue(m_vecMS, ms);
	nTemp = ms * 10;
	cmdbuf[6] = nTemp >> 16;
	cmdbuf[7] = nTemp >> 8;
	cmdbuf[8] = nTemp % 256;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

RET_STATUS CCOS::Dev::Detail::Generator::DeltaMobileDevice::SetABSMode(int nMode)
{
	//6DA1
	FINFO("[0xF0, 0x6D, 0xA1]: nMode {$}", nMode);
	char cmdbuf[20] = { 0xF0, 0x6D, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x88 };
	cmdbuf[3] = nMode;
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS CCOS::Dev::Detail::Generator::DeltaMobileDevice::SetABSCurve(int curveNum)
{
	//6DA2
	FINFO("[0xF0, 0x6D, 0xA2]: curveNum {$}", curveNum);
	char cmdbuf[20] = { 0xF0, 0x6D, 0xA2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x88 };
	cmdbuf[3] = curveNum;
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return RET_STATUS::RET_SUCCEED;
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::SetCableLngth(int lenght)
{
	//62A5
	FINFO("[0xF0, 0x62, 0xA5]: lenght {$}", lenght);
	char cmdbuf[19] = { 0xF0, 0x62, 0xA5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x88 };
	int meters = lenght * 10;
	cmdbuf[3] = meters >> 8;
	cmdbuf[4] = meters % 256;
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void nsGEN::DeltaMobileDevice::SetAECInformation(int chamber, int field, int density, int film)
{
	FINFO("[0xF0, 0x55, 0xA1]: chamber: {$}, field: {$}, density: {$}, film: {$}", chamber, field, density, film);
	char cmdbuf[13] = { 0xF0, 0x55, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9C, 0x00, 0x88 };
	cmdbuf[3] = chamber;
	//field转换
	switch (field)
	{
	case 1:
		cmdbuf[4] = 0x04;
		break;
	case 10:
		cmdbuf[4] = 0x02;
		break;
	case 100:
		cmdbuf[4] = 0x01;
		break;
	case 101:
		cmdbuf[4] = 0x05;
		break;
	case 110:
		cmdbuf[4] = 0x03;
		break;
	case 11:
		cmdbuf[4] = 0x06;
		break;
	case 111:
		cmdbuf[4] = 0x07;
		break;
	default:
		break;
	}

	//density转换
	switch (density)
	{
	case -3:
		cmdbuf[5] = 0;
		break;
	case -2:
		cmdbuf[5] = 1;
		break;
	case -1:
		cmdbuf[5] = 2;
		break;
	case 0:
		cmdbuf[5] = 3;
		break;
	case 1:
		cmdbuf[5] = 4;
		break;
	case 2:
		cmdbuf[5] = 5;
		break;
	case 3:
		cmdbuf[5] = 6;
		break;
	default:
		cmdbuf[5] = 0;
		break;
	}
	switch (film)
	{
	case 100:
	{
		cmdbuf[6] = 0x00;
		break;
	}
	case 200:
	{
		cmdbuf[6] = 0x01;
		break;
	}
	case 400:
	{
		cmdbuf[6] = 0x02;
		break;
	}
	case 800:
	{
		cmdbuf[6] = 0x04;
		break;
	}
	default:
		break;
	}
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}
int  nsGEN::DeltaMobileDevice::GetFacFloatValue(vector<float> Index, float& value)
{
	int nlength = static_cast <int>(Index.size());
	if (nlength == 0)
	{
		return -1;
	}

	int nPos = 0;
	int nValue = 0;
	for (int i = 0; i < nlength; i++)
	{
		if (value == Index[i])
		{
			nPos = i;
			break;
		}
		else if (i == nlength - 1)
		{
			nPos = i;
			break;
		}
		else if ((value > Index[i]) && (value < Index[i + 1]))
		{
			nPos = (abs(value - Index[i + 1]) > abs(value - Index[i])) ? i : (i + 1);//就近原则
			break;
		}
		else if (value < Index[0])
		{
			nPos = 0;
			break;
		}
	}
	value = Index[nPos];
	return nPos;
}
void nsGEN::DeltaMobileDevice::SetRadMode(int radmode, int desmode)
{
	//54A1
	FINFO("[0xF0, 0x54, 0xA1]: RadMode: {$}, desmode: {$}", radmode, desmode);
	char cmdbuf[13] = { 0xF0, 0x54, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	cmdbuf[3] = radmode;
	cmdbuf[4] = desmode;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

std::string nsGEN::DeltaMobileDevice::uint8ArrayToHexStr(const UINT8* array, size_t length) 
{
	std::ostringstream ss;
	ss << std::hex << std::setfill('0'); // 设置十六进制格式和填充字符  
	for (size_t i = 0; i < length; ++i) {
		ss << std::setw(2) << static_cast<int>(array[i]) <<  ' '; // 转换为int以支持十六进制输出，并设置宽度为2  
	}
	return ss.str(); // 返回转换后的字符串  
}

bool nsGEN::DeltaMobileDevice::SetDAECEnable(int enable)
{
	//61AC
	if (enable)
	{
		FINFO("[0xF0, 0x61, 0xAC, 0x01]: DAECEnable :{$}", enable);
		char cmdbuf[20] = { 0xF0, 0x61, 0xAC, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0xDB, 0x00, 0x88 };
		FormatCommand(cmdbuf, 19);
		string temp(cmdbuf, 19);
		m_strCommand = temp;
		HWSendWaitACKCMD(m_strCommand, 4);
	}
	else
	{
		FINFO("[0xF0, 0x61, 0xAC, 0x02]: DAECDisable: {$}", enable);
		char cmdbuf[20] = { 0xF0, 0x61, 0xAC, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x88 };
		FormatCommand(cmdbuf, 19);
		string temp(cmdbuf, 19);
		m_strCommand = temp;
		HWSendWaitACKCMD(m_strCommand, 4);
	}
	return true;
}

//-----------------------------------------------------------------------------
//		DecodeFrame
//-----------------------------------------------------------------------------
static bool DecodeFrame(const char* strFrame, int length)
{
	if (nsGEN::DeltaMobileDevice::g_GenDevice)
	{
		nsGEN::DeltaMobileDevice::g_GenDevice->DecodeFrame(strFrame, length);
	}
	return true;
}

void nsGEN::DeltaMobileDevice::RetrieveExposureResult(void)
{
	//6501
	FINFO("[0xF0, 0x65, 0x01]");
	char cmdbuf[20] = { 0xF0, 0x65, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveRadioMode()
{
	//5401
	FINFO("[0xF0, 0x54, 0x01]");
	char cmdbuf[13] = { 0xF0, 0x54, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveFluMode()
{
	//5402
	FINFO("[0xF0, 0x54, 0x02]");
	char cmdbuf[13] = { 0xF0, 0x54, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveAECInformation()
{
	//5501
	FINFO("[0xF0, 0x55, 0x01]");
	char cmdbuf[13] = { 0xF0, 0x55, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::UpdataAECInformation(AECINFORM aec)
{
	switch (aec.Field)
	{
	case 1:
		m_DoseUnit.m_AECField->Update(AttrKey::AEC_100);
		break;
	case 2:
		m_DoseUnit.m_AECField->Update(AttrKey::AEC_010);
		break;
	case 3:
		m_DoseUnit.m_AECField->Update(AttrKey::AEC_110);
		break;
	case 4:
		m_DoseUnit.m_AECField->Update(AttrKey::AEC_001);
		break;
	case 5:
		m_DoseUnit.m_AECField->Update(AttrKey::AEC_101);
		break;
	case 6:
		m_DoseUnit.m_AECField->Update(AttrKey::AEC_010);
		break;
	case 7:
		m_DoseUnit.m_AECField->Update(AttrKey::AEC_111);
		break;
	default:
		m_DoseUnit.m_AECField->Update(AttrKey::AEC_010);
		break;
	}
	FireNotify(m_DoseUnit.m_AECField->GetKey(), m_DoseUnit.m_AECField->JSGet());
	FINFO("AEC: field: {$}", m_DoseUnit.m_AECField->GetKey());
	//density
	switch (aec.Density)
	{
	case 0:
		m_DoseUnit.m_AECDensity->Update(-3);
		break;
	case 1:
		m_DoseUnit.m_AECDensity->Update(-2);
		break;
	case 2:
		m_DoseUnit.m_AECDensity->Update(-1);
		break;
	case 3:
		m_DoseUnit.m_AECDensity->Update(0);
		break;
	case 4:
		m_DoseUnit.m_AECDensity->Update(1);
		break;
	case 5:
		m_DoseUnit.m_AECDensity->Update(2);
		break;
	case 6:
		m_DoseUnit.m_AECDensity->Update(3);
		break;
	default:
		m_DoseUnit.m_AECDensity->Update(0);
		break;
	}
	FireNotify(m_DoseUnit.m_AECDensity->GetKey(), m_DoseUnit.m_AECDensity->JSGet());
	FINFO("AEC: Density: {$}", m_DoseUnit.m_AECDensity->GetKey());
	//film --->ysj++ 是否需要转换？？
	int nAECFilmSpeed = 0;
	switch (aec.FilmScreenSpeed)
	{
	case 0:
		nAECFilmSpeed = 100;
		break;
	case 1:
		nAECFilmSpeed = 200;
		break;
	case 2:
		nAECFilmSpeed = 400;
		break;
	case 3:
		nAECFilmSpeed = 800;
		break;
	default:
		break;
	}
	m_DoseUnit.m_AECFilm->Update(nAECFilmSpeed);
	FireNotify(m_DoseUnit.m_AECFilm->GetKey(), m_DoseUnit.m_AECFilm->JSGet());
	FINFO("AEC: Film: {$}", m_DoseUnit.m_AECFilm->GetKey());
}

//void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveHU()
//{
//	//5F01
//	FINFO("[0xF0, 0x5F, 0x01]");
//	char cmdbuf[13] = { 0xF0, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x88 };
//	FormatCommand(cmdbuf, 13);
//	string temp(cmdbuf, 13);
//	m_strCommand = temp;
//	HWSendWaitACKCMD(m_strCommand, 4);
//}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::CheckGeneratorStatus()
{
	//6401
	FINFO("[0xF0, 0x64, 0x01]");
	char cmdbuf[19] = { 0xF0, 0x64, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::ReportRadExposurePostParam()
{
	//6402
	FINFO("[0xF0, 0x64, 0x02]");
	char cmdbuf[19] = { 0xF0, 0x64, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::ReportFluExposurePostParam()
{
	//6403
	FINFO("[0xF0, 0x64, 0x03]");
	char cmdbuf[19] = { 0xF0, 0x64, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveFocalSpot()
{
	//5A01
	FINFO("[0xF0, 0x5A, 0x01]");
	char cmdbuf[13] = { 0xF0, 0x5A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveBucky()
{
	//5B01
	FINFO("[0xF0, 0x5B, 0x01]");
	char cmdbuf[13] = { 0xF0, 0x5B, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveTubeID()
{
	//5E03
	FINFO("[0xF0, 0x5E, 0x03]");
	char cmdbuf[13] = { 0xF0, 0x5E, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

int nsGEN::DeltaMobileDevice::FormatCommand(char* buf, int len)
{
	if (len < 4)
	{
		return -1;
	}
	UINT8 crc = GetCRC8(buf + 1, len - 4);
	buf[len - 3] = crc;
	return crc;
}

string CCOS::Dev::Detail::Generator::DeltaMobileDevice::AnalysisCommand(int number, const char* chdigital, int type)
{
	string str = "";
	char arrChar[BYTE_4] = { 0 };
	for (int i = 0; i < number; i++)
	{
		if (type == TransToType::tochar)
		{
			//转成符号
			snprintf(arrChar, sizeof(arrChar) / sizeof(arrChar[0]), "%c", (BYTE)chdigital[i]);
		}
		else if (type == TransToType::toint)
		{
			//转成int数
			snprintf(arrChar, sizeof(arrChar) / sizeof(arrChar[0]), "%d", (BYTE)chdigital[i]);
		}
		else
		{
			//转成hex
			snprintf(arrChar, sizeof(arrChar) / sizeof(arrChar[0]), "%X", (BYTE)chdigital[i]);
		}
		
		str += arrChar;
	}
	return str;
}

void nsGEN::DeltaMobileDevice::RetrieveFirewareVersion()
{
	//6101
	FINFO("[0xF0, 0x61, 0x01]");
	char cmdbuf[19] = { 0xF0, 0x61, 0x01, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveModelName()
{
	//6102
	FINFO("[0xF0, 0x61, 0x02]");
	char cmdbuf[19] = { 0xF0, 0x61, 0x02, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveSerialNumber()
{
	//6103
	FINFO("[0xF0, 0x61, 0x03]");
	char cmdbuf[19] = { 0xF0, 0x61, 0x03, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveMaxRating()
{
	//6104
	FINFO("[0xF0, 0x61, 0x04]");
	char cmdbuf[19] = { 0xF0, 0x61, 0x04, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveGeneratroDerating()
{
	//6105
	FINFO("[0xF0, 0x61, 0x05]");
	char cmdbuf[19] = { 0xF0, 0x61, 0x05, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveAECDAPFirmwareVersion()
{
	//6106
	FINFO("[0xF0, 0x61, 0x06]");
	char cmdbuf[19] = { 0xF0, 0x61, 0x06, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveTubePartNumber()
{
	//6201
	FINFO("[0xF0, 0x62, 0x01]");
	char cmdbuf[19] = { 0xF0, 0x62, 0x01, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveTubeMaxPower()
{
	//6202
	FINFO("[0xF0, 0x62, 0x02]");
	char cmdbuf[19] = { 0xF0, 0x62, 0x02, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveTubeFilamentCurrent()
{
	//6203
	FINFO("[0xF0, 0x62, 0x03]");
	char cmdbuf[19] = { 0xF0, 0x62, 0x03, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveTubeHULimit()
{
	//6204
	FINFO("[0xF0, 0x62, 0x04]");
	char cmdbuf[19] = { 0xF0, 0x62, 0x04, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveTubeDeratingInformation()
{
	//6205
	FINFO("[0xF0, 0x62, 0x05]");
	char cmdbuf[19] = { 0xF0, 0x62, 0x05, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveRunningMode()
{
	//5101
	FINFO("[0xF0, 0x51, 0x01]");
	char cmdbuf[19] = { 0xF0, 0x51, 0x01, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveDataAndTime()
{
	//5201
	FINFO("[0xF0, 0x52, 0x01]");
	char cmdbuf[19] = { 0xF0, 0x52, 0x01, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveErrorCode()
{
	//6301
	FINFO("[0xF0, 0x63, 0x01]");
	char cmdbuf[19] = { 0xF0, 0x63, 0x01, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void CCOS::Dev::Detail::Generator::DeltaMobileDevice::RetrieveErrorParameters()
{
	//6302
	FINFO("[0xF0, 0x63, 0x02]");
	char cmdbuf[19] = { 0xF0, 0x63, 0x02, 0x00, 0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00, 0x00, 0x00, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

std::string nsGEN::DeltaMobileDevice::GetFileVersion(std::string strFilePathName)
{
	// Linux 版本：简化版本信息获取
	// 在 Linux 上，共享库的版本信息通常不存储在文件内部
	// 可以从 CMakeLists.txt 的 PROJECT_VERSION 获取，或者直接返回固定版本号

	FINFO("GetFileVersion called for: {$}", strFilePathName.c_str());

	// 检查文件是否存在
	if (access(strFilePathName.c_str(), F_OK) != 0) {
		FWARN("File not found: {$}", strFilePathName.c_str());
		return "0.0.0.0";
	}

	// 返回默认版本号（可以从配置文件或编译时定义获取）
	return "1.0.0.0";
}

//"HWS": "1",
//"CMD" : "2",
//"FRE" : "3"
RET_STATUS nsGEN::DeltaMobileDevice::ActiveSyncMode(_tSyncModeArgs value)
{
	m_cfgCurrentWSSYN = value;
	FINFO("WS{$}, SyncMode{$}, SyncValue{$}", m_cfgCurrentWSSYN.strWS, m_cfgCurrentWSSYN.strSyncMode, m_cfgCurrentWSSYN.strSyncValue);
	if (m_cfgCurrentWSSYN.strWS == "Free")
	{
		SetNoDrMode();
	}
	else
	{
		if (m_cfgCurrentWSSYN.strSyncMode == "FRE")
		{
			SetNoDrMode();
		}
		else
		{
			SetSyncOutMode();
			SeleckDetectorNumber(0);
			SetSyncOutMode();
			SeleckDetectorNumber(1);
		}
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS CCOS::Dev::Detail::Generator::DeltaMobileDevice::ResetFluTimer(int ntype)
{
	//53A0
	FINFO("[0xF0, 0x53, 0xA0]");
	char cmdbuf[13] = { 0xF0, 0x53, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA5, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS CCOS::Dev::Detail::Generator::DeltaMobileDevice::SetPPS(float frameRate)
{
	//56A2
	FINFO("[0xF0, 0x56, 0xA2, 0x00]: frameRate: {$}", frameRate);
	char cmdbuf[13] = { 0xF0, 0x56, 0xA2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x88 };
	int nPPS = (int)(frameRate * 10);
	cmdbuf[3] = nPPS >> 8;
	cmdbuf[4] = nPPS % 256;
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
	return RET_STATUS::RET_SUCCEED;
}

void nsGEN::DeltaMobileDevice::SeleckDetectorNumber(int detectorID)
{
	//6EA1
	FINFO("[0xF0, 0x6E, 0xA1, 0xxx]: detectorID: {$}", detectorID);
	char cmdbuf[19] = { 0xF0, 0x6E, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x88 };
	cmdbuf[3] = detectorID;
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void nsGEN::DeltaMobileDevice::SetNoDrMode()
{
	//6EA2
	FINFO("[0xF0, 0x6E, 0xA2, 0x00]");
	char cmdbuf[20] = { 0xF0, 0x6E, 0xA2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA5, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void nsGEN::DeltaMobileDevice::SetSyncOutMode()
{
	//6EA2
	FINFO("[0xF0, 0x6E, 0xA2, 0x01]");
	char cmdbuf[20] = { 0xF0, 0x6E, 0xA2, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

void nsGEN::DeltaMobileDevice::RetrieveBatteryRunningInformation()
{
	//6C02
	FINFO("[0xF0, 0x6C, 0x02, 0x00]");
	CHAR cmdbuf[20] = { 0xF0, 0x6C, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC5, 0x00, 0x88 };
	FormatCommand(cmdbuf, 19);
	string temp(cmdbuf, 19);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

bool nsGEN::DeltaMobileDevice::StartHardwareStatusThread()
{
	FINFO("========================================");
	FINFO("Starting Hardware Status Thread...");

	if (!m_pHardwareStatusThread.joinable())
	{
		FINFO("Creating new hardware status thread");
		m_pHardwareStatusThread = std::thread(HardwareStatusThread, this);
		FINFO("Hardware status thread created successfully");
		FINFO("========================================");
		return true;
	}

	FWARN("Hardware status thread already running");
	FINFO("========================================");
	return false;
}
void nsGEN::DeltaMobileDevice::HardwareStatusThread(DeltaMobileDevice* pParam)
{
	FINFO("========================================");
	FINFO("HardwareStatusThread Entry");
	FINFO("========================================");

	DeltaMobileDevice* pCurGen = pParam;
	if (pCurGen == NULL)
	{
		FERROR("HardwareStatusThread: pParam is NULL, exiting thread");
		return;
	}

	// Load loop time from config
	if (pCurGen->m_GenConfig.GetFirstOf("loopTime") >= 0)
	{
		if ((int)pCurGen->m_GenConfig["loopTime"] >= 100)
		{
			pCurGen->m_iLoopTime = (int)pCurGen->m_GenConfig["loopTime"];
		}
	}

	int currtTime = pCurGen->m_iLoopTime;
	int loopCount = 0;

	FINFO("Hardware status monitoring started");
	FINFO("Initial loop time: {$} ms", currtTime);

	while (pCurGen->m_bExtraFlag)
	{
		// Check if loop time has changed
		if (currtTime != pCurGen->m_iLoopTime)
		{
			FINFO("Loop time changed from {$} ms to {$} ms", currtTime, pCurGen->m_iLoopTime.load());
			currtTime = pCurGen->m_iLoopTime;
		}

		Sleep(currtTime);
		loopCount++;

		// Print statistics every 10 loops
		if (loopCount % 10 == 0)
		{
			FINFO("Hardware status thread loop count: {$}", loopCount);
		}

		// Execute hardware status queries if not in exposure
		if (pCurGen->m_nProcessXrayon == false)
		{
			pCurGen->GetHE();
			pCurGen->RetrieveBatteryRunningInformation();
			pCurGen->CheckGeneratorStatus();

			pCurGen->m_nCountTimes++;
			if (pCurGen->m_nCountTimes >= 25)
			{
				char ErrCode[20];
				snprintf(ErrCode, sizeof(ErrCode), "DELTA_ERR_%04d", 0);
				FINFO("{$}", ErrCode);
				int level = DELTA_MOBILE_ABNORMAL_LEVEL::REG_ERRO;
				auto iterr = pCurGen->m_ErrorMessages.find(ErrCode);
				if (iterr != pCurGen->m_ErrorMessages.end())
				{
					pCurGen->m_MSGUnit->AddErrorMessage(ErrCode, level, iterr->second.c_str());
				}
			}
		}
	}

	FINFO("========================================");
	FINFO("Hardware status thread stopping...");
	FINFO("Total loop count: {$}", loopCount);
	FINFO("HardwareStatusThread Exit");
	FINFO("========================================");
}

void nsGEN::DeltaMobileDevice::GetHE()
{
	//5F01
	FINFO("[0xF0, 0x5F, 0x01, 0x00]");
	char cmdbuf[13] = { 0xF0, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x88 };
	FormatCommand(cmdbuf, 13);
	string temp(cmdbuf, 13);
	m_strCommand = temp;
	HWSendWaitACKCMD(m_strCommand, 4);
}

//bool CDeltaGenOprCtl::RelayCtlExpCommand(bool Out1, bool Out2, bool Out3, bool Out4)
//{
//	//CGenOprCtl::RelayCtlExpCommand(Out1, Out2, Out3, Out4);
//	CString log;
//	log.Format("Enter RelayCtlExpCommand, out1 %d, out2 %d, out3 %d, out4 %d", Out1, Out2, Out3, Out4);
//	logfile->WriteLog(log, LOG_INFORMATION, LOG_DEBUG, true);
//	//5C A5 01 02  二档按下
//	//5C A5 02   松开手闸
//	//5C A4 01 45 43 4F 4D
//	UINT8 cmdbuf_test[13] = { 0xF0, 0x5C, 0xA4, 0x01, 0x45, 0x43, 0x4F, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x88 };
//	FormatCommand(cmdbuf_test, 13);
//	SendCommands(cmdbuf_test, 13);
//	if (Out1 == true && Out2 == false && Out3 == false && Out4 == false)
//	{
//		UINT8 cmdbuf_cancel[13] = { 0xF0, 0x5C, 0xA5, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88 };
//		FormatCommand(cmdbuf_cancel, 13);
//		SendCommands(cmdbuf_cancel, 13);
//		LogInfo("handswitch 1");
//	}
//
//	if (Out1 == true && Out2 == true && Out3 == false && Out4 == false)
//	{
//		//m_bIsMobileExp = true;
//		UINT8 cmdbuf_exposure[13] = { 0xF0, 0x5C, 0xA5, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88 };
//		FormatCommand(cmdbuf_exposure, 13);
//		SendCommands(cmdbuf_exposure, 13);
//		LogInfo("start exposure");
//	}
//
//	if (Out1 == false && Out2 == false && Out3 == false && Out4 == false)
//	{
//		UINT8 release_pre[13] = { 0xF0, 0x5C, 0xA5, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88 };
//		FormatCommand(release_pre, 13);
//		SendCommands(release_pre, 13);
//		LogInfo("release pre");
//	}
//
//	UINT8 cmdbuf_refresh[13] = { 0xF0, 0x5C, 0xA5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88 };
//	FormatCommand(cmdbuf_refresh, 13);
//	SendCommands(cmdbuf_refresh, 13);
//	return true;
//}
//-----------------------------------------------------------------------------
//		DeltaDriver
//-----------------------------------------------------------------------------

nsGEN::DeltaDriver::DeltaDriver()
{
	m_bDemoConnected = false;
	m_pAttribute.reset(new ResDataObject);
	m_pDescription.reset(new ResDataObject);
}

nsGEN::DeltaDriver::~DeltaDriver()
{
	FINFO("========================================");
	FINFO("DeltaDriver Destructor Entry");
	FINFO("========================================");

	// Disconnect if still connected
	if (m_scfWrapper && m_scfWrapper->IsConnected())
	{
		FINFO("SCF still connected, calling Disconnect()");
		Disconnect();
	}

	// Clean up device pointer (just nullify, actual device managed by unique_ptr in CreateDevice)
	m_pDevice = nullptr;

	FINFO("DeltaDriver Destructor Completed");
	FINFO("========================================");
}

auto nsGEN::DeltaDriver::CreateDevice(int index) -> std::unique_ptr <IODevice>
{
	FINFO("========================================");
	FINFO("DeltaDriver::CreateDevice() Entry");
	FINFO("Device index: {$}", index);

	if (!m_scfWrapper || !m_scfWrapper->IsConnected())
	{
		FERROR("SCF wrapper not connected, cannot create device");
		FINFO("========================================");
		return nullptr;
	}

	FINFO("Creating DeltaMobileDevice...");
	m_pDevice = new DeltaMobileDevice(EventCenter, m_scfWrapper, m_ConfigFileName);
	auto dev = std::unique_ptr <IODevice>(new IODevice(m_pDevice));

	FINFO("DeltaMobileDevice created successfully");
	FINFO("========================================");
	return dev;
}

void nsGEN::DeltaDriver::FireNotify(int code, std::string key, std::string content)
{
	EventCenter->OnNotify(code, key, content);
}


void nsGEN::DeltaDriver::Prepare()
{
	FINFO("========================================");
	FINFO("DeltaDriver::Prepare() Starting...");
	FINFO("========================================");

	// 初始化日志系统
	std::string strLogPath = GetProcessDirectory() + R"(/Conf/log_config.xml)";
	std::string LogHost = "DevDelta";
	std::string moduleName = "DevDelta";

	FINFO("Initializing log module...");
	FINFO("Log config path: {$}", strLogPath.c_str());
	FINFO("Log host: {$}", LogHost.c_str());
	FINFO("Module name: {$}", moduleName.c_str());

	bool ret = initLogModule(
		LogHost,       // 主机名（用于日志路径中的{host}占位符）
		moduleName,        // 唯一模块名
		strLogPath,  // 配置文件路径
		true           // 是否输出到控制台（可选）
	);

	if (!ret) {
		std::cerr << "Log init failed!" << std::endl;
		FERROR("Failed to initialize log module");
		return;
	}

	FINFO("Log module initialized successfully");
	Delta_SetLocalModuleName(moduleName);

	FINFO("Getting connection DLL from config: {$}", m_ConfigFileName.c_str());
	m_SCFDllName = GetConnectDLL(m_ConfigFileName);
	FINFO("SCF DLL name: {$}", m_SCFDllName.c_str());

	FINFO("Calling parent Prepare()...");
	super::Prepare();

	FINFO("========================================");
	FINFO("DeltaDriver::Prepare() Completed");
	FINFO("========================================");
}

bool DATA_ACTION nsGEN::DeltaDriver::Connect()
{
	std::lock_guard<std::mutex> lock(m_connectionMutex);
	const auto currentState = m_connectionState.load();
	auto now = std::chrono::steady_clock::now();

	// 1. 处理可重试的失败状态
	if (currentState == ConnectionState::Failed) {
		if ((now - m_lastConnectionAttempt) >= RETRY_INTERVAL && m_connectionRetryCount < MAX_RETRY_COUNT) {
			m_connectionState = ConnectionState::Disconnected;
		}
		else {
			return false; // 不满足重试条件，直接返回
		}
	}

	// 2. 检查无效状态（正在连接/已连接但实际有效）
	if (currentState == ConnectionState::Connecting) {
		FINFO("Already connecting (type: {$})",
			m_currentConnType == ConnectionType::Serial ? "Serial" : "Ethernet");
		return true;
	}
	if (currentState == ConnectionState::Connected && m_scfWrapper && m_scfWrapper->IsConnected()) {
		FINFO("Already connected (type: {$})",
			m_currentConnType == ConnectionType::Serial ? "Serial" : "Ethernet");
		return true;
	}

	// 3. 检查重试间隔
	if (m_connectionRetryCount > 0 && (now - m_lastConnectionAttempt) < RETRY_INTERVAL) {
		FINFO("Retry in {$}s (type: {$})",
			std::chrono::duration_cast<std::chrono::seconds>(RETRY_INTERVAL - (now - m_lastConnectionAttempt)).count(),
			m_currentConnType == ConnectionType::Serial ? "Serial" : "Ethernet");
		return false;
	}

	// 4. 开始连接流程
	m_connectionState = ConnectionState::Connecting;
	m_lastConnectionAttempt = now;

	FINFO("========================================");
	FINFO("DeltaDriver::Connect() Entry");
	FINFO("Retry count: {$}/{$}", m_connectionRetryCount, MAX_RETRY_COUNT);
	FINFO("Connection type: {$}", m_currentConnType == ConnectionType::Serial ? "Serial" : "Ethernet");

	// 获取连接参数
	ResDataObject Connection = GetConnectParam(m_ConfigFileName);
	FINFO("Connection params: {$}", Connection.encode());

	// 创建 SCF包装器
	if (!m_scfWrapper) {
		FINFO("Creating SCFWrapper...");
		m_scfWrapper = std::make_shared<SCFWrapper>();

		// 初始化 SCF 库
		FINFO("Initializing SCF with DLL: {$}", m_SCFDllName.c_str());
		if (!m_scfWrapper->Initialize(m_SCFDllName)) {
			FERROR("SCFWrapper Initialize failed");
			m_connectionRetryCount++;
			m_connectionState = ConnectionState::Failed;
			FINFO("========================================");
			return false;
		}
	}

	// 尝试连接
	FINFO("Attempting to connect...");
	int connectResult = m_scfWrapper->Connect(
		Connection,  // 传递 ResDataObject 引用，而不是字符串
		&nsGEN::DeltaDriver::callbackPackageProcess,
		SCF_PACKET_TRANSFER,
		3000
	);

	if (connectResult != SCF_SUCCEED) {
		FERROR("SCFWrapper Connect failed with error code: {$}", connectResult);
		m_connectionRetryCount++;
		m_connectionState = ConnectionState::Failed;
		FINFO("========================================");
		return false;
	}

	// 启动自动接收
	FINFO("Starting auto receive...");
	m_scfWrapper->StartAutoReceive();

	// 连接成功
	m_connectionRetryCount = 0;
	m_connectionState = ConnectionState::Connected;

	FINFO("Connection successful!");
	FINFO("========================================");
	return true;
}

void nsGEN::DeltaDriver::Disconnect()
{
	FINFO("========================================");
	FINFO("DeltaDriver::Disconnect() Entry");

	if (m_scfWrapper) {
		FINFO("Stopping auto receive...");
		m_scfWrapper->StopAutoReceive();
		FINFO("Auto receive stopped");

		FINFO("Disconnecting SCF wrapper...");
		m_scfWrapper->Disconnect();
		FINFO("SCF wrapper disconnected");

		m_connectionState = ConnectionState::Disconnected;
		FINFO("Connection state set to Disconnected");
	} else {
		FINFO("SCF wrapper is null, nothing to disconnect");
	}

	m_bDemoConnected = false;
	FINFO("========================================");
	FINFO("DeltaDriver::Disconnect() Exit");
	FINFO("========================================");
}

bool nsGEN::DeltaDriver::isConnected() const
{
	const auto state = m_connectionState.load();

	// 1. 连接中/实际已连接：返回true（无需重连）
	if (state == ConnectionState::Connecting || (m_scfWrapper && m_scfWrapper->IsConnected())) {
		return true;
	}

	// 2. 失败状态处理：判断是否允许重试
	if (state == ConnectionState::Failed) {
		auto now = std::chrono::steady_clock::now();
		const auto timeSinceLast = now - m_lastConnectionAttempt;

		// 2.1 达到最大重试次数，但超过重置间隔：重置计数，允许重新重试
		if (m_connectionRetryCount >= MAX_RETRY_COUNT && timeSinceLast >= RESET_RETRY_AFTER) {
			FINFO("Max retries reached, resetting count after {$}s",
				std::chrono::duration_cast<std::chrono::seconds>(timeSinceLast).count());
			m_connectionRetryCount = 0;  // 重置计数（因mutable修饰，const函数可修改）
		}

		// 2.2 不适合重连（时间未到 或 次数仍超限）：返回true阻止重连
		if (timeSinceLast < RETRY_INTERVAL || m_connectionRetryCount >= MAX_RETRY_COUNT) {
			FINFO(timeSinceLast < RETRY_INTERVAL ?
				"Retry later ({$}s)" : "Max retries, waiting {$}s to reset",
				std::chrono::duration_cast<std::chrono::seconds>(
					timeSinceLast < RETRY_INTERVAL ? RETRY_INTERVAL - timeSinceLast : RESET_RETRY_AFTER - timeSinceLast
				).count()
			);
			return true;
		}

		// 2.3 满足重试条件：返回false允许上层重新调用Connect()
		FINFO("Retry condition met, allowing reconnect attempt");
		return false;
	}

	// 3. 断开状态：允许重连
	FINFO("State is Disconnected, allowing connect attempt");
	return false;
}

std::string nsGEN::DeltaDriver::DriverProbe()
{
	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", "Delta");
		HardwareInfo.add("ProductID", "DMG50KCXAF");
		HardwareInfo.add("SerialID", "Drv");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

std::string nsGEN::DeltaDriver::GetResource()
{
	ResDataObject r_config, temp;
	if (!temp.loadFile(m_ConfigFileName.c_str()))
	{
		return "";
	}

	m_ConfigAll = temp;
	r_config = temp["CONFIGURATION"];
	m_Configurations = r_config;

	ResDataObject DescriptionTemp;
	ResDataObject DescriptionSend;
	ResDataObject m_DescriptionSend;
	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
	{
		//便利ConfigToolInfo 中 所有的AttributeInfo 属性段
		int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
		m_pAttribute->clear();
		m_pDescription->clear();
		for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
		{
			DescriptionTemp.clear();
			DescriptionSend.clear();
			ListTemp.clear();

			//AttributeType
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Type"];
			DescriptionTemp.add(ConfKey::CcosType, strTemp.c_str());//CcosGeneratorAttribute
			DescriptionSend.add(ConfKey::CcosType, strTemp.c_str());//CcosGeneratorAttribute

			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);	//得到strValue的值

			//2. 赋值
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];

			if ("int" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str()));
			}
			else if ("float" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str()));
			}
			else //其它先按string类型处理
			{
				(*m_pAttribute).add(strTemp.c_str(), strValue.c_str());
			}

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

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

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

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

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

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

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

	ResDataObject resDeviceResource;
	resDeviceResource.add(ConfKey::CcosGeneratorAttribute, (*m_pAttribute));
	resDeviceResource.add(ConfKey::CcosGeneratorDescription, (*m_pDescription));

	ResDataObject DescriptionTempEx;
	DescriptionTempEx.add(ConfKey::CcosGeneratorConfig, resDeviceResource);
	m_DeviceConfig.clear();
	m_DeviceConfig = DescriptionTempEx;

	resDeviceResource.clear();

	resDeviceResource.add(ConfKey::CcosGeneratorAttribute, (*m_pAttribute));
	resDeviceResource.add(ConfKey::CcosGeneratorDescription, m_DescriptionSend);
	DescriptionTempEx.clear();
	DescriptionTempEx.add(ConfKey::CcosGeneratorConfig, resDeviceResource);

	m_DeviceConfigSend.clear();

	m_DeviceConfigSend = DescriptionTempEx;

	string res = m_DeviceConfigSend.encode();

	return res;
}

std::string nsGEN::DeltaDriver::DeviceProbe()
{
	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", "Delta");
		HardwareInfo.add("ProductID", "DMG50KCXAF");
		HardwareInfo.add("SerialID", "Dev");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

void nsGEN::DeltaDriver::Dequeue(const char* Packet, DWORD Length)
{
	DecodeFrame(Packet, Length);
}

PACKET_RET nsGEN::DeltaDriver::callbackPackageProcess(const char* RecData, uint32_t nLength, uint32_t& PacketLength)
{
	FINFO("Enter callbackPackageProcess(const char* RecData, uint32_t nLength:{$}, uint32_t& PacketLength:{$}", nLength, PacketLength);
	bool bHasHead = false;
	for (uint32_t i = 0; i < nLength; i++)
	{
		//寻找包头
		if ((UINT8)RecData[i] == COMMANDHEAD)
		{
			if ((i != 0) && (bHasHead == false)) //包头之前的数据格式不对，全部扔掉
			{
				PacketLength = i;
				char strtemp[Delta_Com_NormalLen] = { 0 };
				memcpy(strtemp, RecData, PacketLength);
				FERROR("==IN unknown format data ==:{$},UselessDataLength={$},TotalLength={$} \n", strtemp, PacketLength, nLength);
				return PACKET_USELESS;
			}
			else
			{
				bHasHead = true;
			}
		}
		//寻找包尾
		if (((UINT8)RecData[i] == COMMANDEND) && ((nLength-1) == i))
		{
			if (bHasHead)
			{
				PacketLength = i + 1;			        //+1 because ETX
				char strtemp[Delta_Com_NormalLen] = { 0 };
				memcpy(strtemp, RecData, PacketLength);	//只有ETX+数据，-2 排除 checkSum ETX。
				// Linux版本：移除 DeliverModule 的 CheckReceive 调用
				return PACKET_ISPACKET;
			}
			else //有包尾但无包头
			{
				PacketLength = i + 1;
				char strtemp[Delta_Com_NormalLen] = { 0 };
				memcpy(strtemp, RecData, PacketLength);
				return PACKET_USELESS;
			}
		}
		else if (((BYTE)RecData[i] ==  0x0D) && (3 == i))
		{
			bHasHead = true;
			PacketLength = i + 1;			        //+1 because ETX
			char strtemp[Delta_Com_NormalLen] = { 0 };
			memcpy(strtemp, RecData, PacketLength);	//只有ETX+数据，-2 排除 checkSum ETX。
			// Linux版本：移除 DeliverModule 的 CheckReceive 调用
			return PACKET_ISPACKET;
		}
	}
	if (bHasHead)
	{
		PacketLength = 0;
	}
	return PACKET_NOPACKET;
}

bool nsGEN::DeltaDriver::GetDeviceConfig(std::string& Cfg)
{
	Cfg = m_DeviceConfigSend.encode();
	return true;
}

bool nsGEN::DeltaDriver::SetDeviceConfig(std::string Cfg)
{
	FINFO("--Func-- SetDeviceConfig {$}", Cfg.c_str());

	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("nConfigInfoCount {$}", 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]))
					{
						FINFO("SetDeviceConfigValue over");
						bSaveFile = true;
					}
				}
				else
				{
					FINFO("{$} is not a RW configuration item", strKey.c_str());
				}
			}
			else
			{
				FINFO("without this attribute {$}", strKey.c_str());
			}
		}
		catch (ResDataObjectExption& e)
		{
			FERROR("SetDriverConfig crashed: {$}", e.what());
			return false;
		}
	}

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

bool nsGEN::DeltaDriver::SaveConfigFile(bool bSendNotify)
{
	m_ConfigAll["CONFIGURATION"] = m_Configurations;

	bool bRt = m_ConfigAll.SaveFile(m_ConfigFileName.c_str());
	FINFO("SaveConfigFile over {$}", bRt);
	return true;
}

bool nsGEN::DeltaDriver::GetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, string& strValue)
{
	strValue = "";
	string strTemp = pInnerKey;
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		int pos = 0;
		ResDataObject resTemp = config;
		while ((pos = strTemp.find_first_of(',')) != string::npos)
		{
			string Key = strTemp.substr(0, pos);
			string TempValue = resTemp[Key.c_str()].encode();

			resTemp.clear();
			resTemp.decode(TempValue.c_str());
			strTemp = strTemp.substr(pos + 1, strTemp.length() - pos - 1);
		}
		if (strTemp != "")
		{
			strValue = (string)resTemp[strTemp.c_str()];
		}
		else
		{
			strValue = (string)resTemp;
		}
	}
	return true;
}

bool nsGEN::DeltaDriver::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自己的配置文件读取
	{
		try {
			int pos = 0;
			ResDataObject* resTemp = &config;
			while ((pos = strTemp.find_first_of(',')) != string::npos)
			{
				string Key = strTemp.substr(0, pos);
				resTemp = &(*resTemp)[Key.c_str()];
				strTemp = strTemp.substr(pos + 1, strTemp.length() - pos - 1);
			}
			if (strTemp != "")
			{
				(*resTemp)[strTemp.c_str()] = szValue;
			}
			else
			{
				*resTemp = szValue;
			}
		}
		catch (ResDataObjectExption& e)
		{
			FERROR("SetDriverConfigvalue crashed: {$}", e.what());
			return false;
		}
	}
	return true;
}
//-----------------------------------------------------------------------------
//		GetIODriver & CreateIODriver
//-----------------------------------------------------------------------------

static nsGEN::DeltaDriver  gIODriver;

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

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