PhysicalDevice/Generator/PSG/CCOS.Dev.Generator.PSG_HD/CCOS.Dev.Generator.PSG_HD.cpp

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

#include <assert.h>
#include <functional>
#include <unordered_map>
#include <fstream>  
#include <cmath>
#include <climits>
#include <unordered_set>
#include <algorithm>
#include "LogicDevice.h"
using namespace std::placeholders;
#include "Log4CPP.h"
#include "Helper.JSON.hpp"
#include "CCOS.Dev.Generator.PSG_HD.h"

using namespace CCOS::Dev::Detail::Generator;
namespace nsGEN = CCOS::Dev::Detail::Generator;
const uint8_t STX = 0x02, CR = 0x0D, LF = 0x0A;
const char TERM = ';';

static nsGEN::PSGHDDriver* pIODriver = nullptr;

#define PSGHD_LARGE_POWER 5
#define PSGHD_SMALL_POWER 1.1
#define PSGHD_MAX_HEAT 225
#define PSGHD_MIN_MA 1.0
#define PSGHD_MAX_MA 1000.0
#define PSGHD_MIN_MS 1.0
#define PSGHD_MAX_MS 10001.0

//设置相关常量
#define PSGHD_LoopDefHBTime 1000
#define PSGHD_LoopExpHBTime 500
static const int msTimeOut_Lock = 500; //通讯接口锁定时间
#define PSGHD_Com_NormalLen 150
#define PSGHD_ETX           0x03
#define PSGHD_RESOK         "$"
#define Sleep(ms) std::this_thread::sleep_for(std::chrono::milliseconds(ms))

static const auto COM_SCFDllName = "libSerialSCF.so";
static const auto TCP_SCFDllName = "libTcpipSCF.so";
static const float msSteps[] = {
	40,  50,  60,  80,  100,  120,  160,
	200,  250,  320,  400,  500,  630,  800,
	1000,  1250,  1600,  2000
};

static const float maSteps[] = {
	1.00f,  1.25f,  1.6f,  2.00f,  2.50f,  3.00f
};

static const size_t msStepCount = sizeof(msSteps) / sizeof(msSteps[0]);
static const size_t maStepCount = sizeof(maSteps) / sizeof(maSteps[0]);

//Log4CPP::Logger* gLogger = nullptr;

struct tFrameMapping
{
	static const int MaxLen = 7;		//	前缀不能超过 7 个字符 !
	using cbFun = std::function <void(const char*, int)>;

	char strHead[MaxLen];
	int NbOfCharOfHead;
	cbFun fun;

	// 关键修改：将char*改为const char*，兼容字符串常量
	tFrameMapping(const char* str, int len, cbFun f)
	{
		assert(len < MaxLen);			// len最大只能是4

		for (int i = 0; i < len; i++)
			strHead[i] = str[i];
		NbOfCharOfHead = len;
		fun = f;
	}
};

// 响应操作对照表
static std::list <tFrameMapping> arFrame;

static bool DecodeFrame(const char* data, int len) {
	if (!data || len < 8) {
		FINFO("DecodeFrame: Invalid input");
		return false;
	}

	int pos = 0;
	bool hasValid = false;

	while (pos < len) {
		while (pos < len && (uint8_t)data[pos] != STX) pos++;
		if (pos >= len) {
			FINFO("DecodeFrame: No STX found");
			break;
		}
		int start = pos;

		int end = -1;
		for (int i = start + 1; i < len - 1; i++) {
			if ((uint8_t)data[i] == CR && (uint8_t)data[i + 1] == LF) {
				end = i + 1;
				break;
			}
		}
		if (end == -1) {
			FINFO("DecodeFrame: Incomplete cmd (no CRLF)");
			break;
		}
		int cmdLen = end - start + 1;

		auto match = [&](const tFrameMapping& item) {
			if (item.NbOfCharOfHead >= cmdLen) return false;
			for (int i = 0; i < item.NbOfCharOfHead; i++) {
				if (data[start + 1 + i] != item.strHead[i]) return false;
			}
			return true;
			};

		auto it = std::find_if(arFrame.begin(), arFrame.end(), match);
		if (it != arFrame.end()) {
			// Extract ARG (between header and ';')
			int argStart = start + 1 + it->NbOfCharOfHead;
			int argEnd = -1;
			for (int i = argStart; i < end; i++) {
				if (data[i] == TERM) {
					argEnd = i;
					break;
				}
			}
			if (argEnd > argStart) {
				it->fun(data + argStart, argEnd - argStart);
				FINFO("DecodeFrame: Parsed cmd: [{$}], ARG len: {$}", it->strHead, argEnd - argStart);
				hasValid = true;
			}
			else FINFO("DecodeFrame: Cmd missing ';'");
		}
		else FINFO("DecodeFrame: No matching header");

		pos = end + 1; // Next cmd start
	}

	return hasValid;
}

//-----------------------------------------------------------------------------
//		PSGHDDevice
//-----------------------------------------------------------------------------

atomic<int> nsGEN::PSGHDDevice::m_iLoopTime = PSGHD_LoopDefHBTime;
atomic<bool> nsGEN::PSGHDDevice::m_bExtraFlag = false;
static atomic<bool>HeartBeatFlag = false;

nsGEN::PSGHDDevice::PSGHDDevice(std::shared_ptr <IOEventCenter> center, std::shared_ptr<SCFWrapper> SCF, string configfile)
	: super(center)
	, superGen()
	,m_SCF(SCF)
	, m_bConnectFlag(false)
	, HeartBeatFlag(false)
{
	m_bExtraFlag = true;

	//初始化
	m_bExpEnable = false;
	m_iLoopTime.store(PSGHD_LoopDefHBTime);
	for (int i = 0; i < 18; i++)
	{
		m_bFaultList[i] = false;
	}
	m_iMaxPower = PSGHD_LARGE_POWER; //KW
	MaxHeatContent = PSGHD_MAX_HEAT; //KJ

	FINFO("\n===============log begin : version:0.0.0.0 ===================\n");
	//设置发生器属性集合各个值的范围及精度
	m_DoseUnit.m_KV.reset(new KVMould(0.0, 39.0, 151.0, 1.0));
	m_DoseUnit.m_MA.reset(new MAMould(0.0, PSGHD_MIN_MA, PSGHD_MAX_MA, 0.1));   
	m_DoseUnit.m_MS.reset(new MSMould(0.0, PSGHD_MIN_MS, PSGHD_MAX_MS, 0.01));
	m_DoseUnit.m_MAS.reset(new MASMould(0.0, 0.1, 1000.0, 0.01));
	m_DoseUnit.m_Techmode.reset(new TECHMODEMould(AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_2P, AttrKey::TECHMODE_NOAEC_3P, AttrKey::TECHMODE_AEC_MAS_MA, 1));
	m_DoseUnit.m_WS.reset(new WORKSTATIONMould(1, 0, 5, 1));
	m_DoseUnit.m_Focus.reset(new FOCUSMould(AttrKey::FOCUS_TYPE::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, 2, 1));
	m_DoseUnit.m_AECDensity.reset(new AECDENSITYMould(0, -3, 3, 1));
	m_DoseUnit.m_GenHE.reset(new GENHEATMould(0, 0, 100, 1));
	m_DoseUnit.m_HE.reset(new TUBEHEATMould(0, 0, 100, 1));
	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(0, 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, 16, 1));
	m_DoseUnit.m_FLMode.reset(new FLUModeMould(AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_NOTFLU));
	m_DoseUnit.m_BatteryChargeState.reset(new BATTERYCHARGSTATEMould(0, 0, 1, 1));
	m_DoseUnit.m_TubeTargetMaterial.reset(new TUBETARGETMATERIALMould(AttrKey::TUBETARGETMATERIAL_TYPE::MO));
	m_DoseUnit.m_TubeAngle.reset(new TUBEANGLEMould(0, -45, 45, 1));
	m_DoseUnit.m_FLIntTime.reset(new FLUIntTimeMould(0.0, 0.0, 100.0, 0.1));
	m_DoseUnit.m_FLAccTime.reset(new FLAccTimeMould(0.0, 0.0, 999.0, 0.1));
	m_DoseUnit.m_FLKV.reset(new FLUKVMould(0, 40, 125, 1));
	m_DoseUnit.m_FLMS.reset(new FLUMSMould(10.0, 10.0, 999999.0, 0.01));
	m_DoseUnit.m_FLMA.reset(new FLUMAMould(0.5, 0.5, 99.0, 0.1));
	m_DoseUnit.m_ABSStatus.reset(new FLUABSStatusMould(0, 0, 2, 1));
	m_DoseUnit.m_PPS.reset(new PPSMould(0.5,0.5, 30, 0.1));
	m_DoseUnit.m_DoseLevel.reset(new FLUDoseLevelMould(0, 0, 2, 1));
	m_DoseUnit.m_FLMode.reset(new FLUModeMould(0, 0, 4, 1));
	m_DoseUnit.m_Curve.reset(new FLUCurveMould(0, 0, 3, 1));
			   
	//Actual exposure parameters 值
	m_DoseUnit.m_PostKV.reset(new POSTKVMould(0.0, 40.0, 120.0, 1.0));
	m_DoseUnit.m_PostMA.reset(new POSTMAMould(0.0, 1.0, 1000.0, 0.1));
	m_DoseUnit.m_PostMS.reset(new POSTMSMould(0.0, 1.0, 10000.0, 0.01));
	m_DoseUnit.m_PostMAS.reset(new POSTMASMould(0.0, 0.5, 1000.0, 0.01));
	//发生器告警及错误消息
	m_MSGUnit.reset(new nsDetail::MSGUnit(center, nsGEN::GeneratorUnitType));
	
	m_hGenPostEvent = LinuxEvent::CreateEvent(LinuxEvent::MANUAL_RESET, false);

	//配置响应操作对照表 供发生器回传的数据触发相应的操作
	OnCallBack();

	//将发生器可以对外提供的指令注册集进行补充
	Register();
	LoadConfig(configfile);
	
	//启动硬件状态轮询进程
	StartHardwareStatusThread();
}

nsGEN::PSGHDDevice::~PSGHDDevice()
{
	m_bExtraFlag = false;
	if (m_pHardwareStatusThread.joinable()) {
		m_pHardwareStatusThread.join();
	}
	FINFO("\n===============log end ===================\n");
	arFrame.clear();
}

std::string nsGEN::PSGHDDevice::GetGUID() const
{	
	FINFO("===============GetGUID : {$} ===================\n", GeneratorUnitType);
	return GeneratorUnitType;
}

void nsGEN::PSGHDDevice::Register()
{
	auto Disp = m_Dispatch.Lock().As();

	superGen::Register(Disp);
	superGen::RegisterRAD(Disp);
	superGen::RegisterAEC(Disp);
	superGen::RegisterExpEnable(Disp);
	superGen::RegisterGeneratortoSyncStatus(Disp);
	superGen::RegisterFluoro(Disp);

	Disp->Get.Push(m_MSGUnit->GetKey().c_str(), [this](std::string& out) { out = m_MSGUnit->JSGet(); return RET_STATUS::RET_SUCCEED; });
	Disp->Get.Push(AttrKey::DENHEAT, [this](std::string& out) { out = m_DoseUnit.m_GenHE->JSGet(); return RET_STATUS::RET_SUCCEED; });
	auto fun_Clear_DAP = [this](auto in, auto& out)
	{
		return Clear_DAP();
	};
	Disp->Action.Push("Clear_DAP", fun_Clear_DAP);
	auto fun_GetValue_DAP = [this](auto in, auto& out)
	{
		float value = 0;
		RET_STATUS ret = GetValue_DAP(value);
		out = ToJSON(value);
		return ret;
	};
	Disp->Action.Push("GetValue_DAP", fun_GetValue_DAP);
}

RET_STATUS nsGEN::PSGHDDevice::IncKV()
{
	FINFO("Enter PSGHDDevice::IncKV()\n");
	if (!m_DoseUnit.m_KV->CanInc())  return RET_STATUS::RET_SUCCEED;
	m_DoseUnit.m_KV->Inc();
	return SetKV(m_DoseUnit.m_KV->Get());
}

RET_STATUS nsGEN::PSGHDDevice::DecKV()
{
	if (!m_DoseUnit.m_KV->CanDec())  return RET_STATUS::RET_SUCCEED;
	m_DoseUnit.m_KV->Dec();
	return SetKV(m_DoseUnit.m_KV->Get());
}

RET_STATUS nsGEN::PSGHDDevice::SetKV(float value)
{
	if (!m_DoseUnit.m_KV->Verify(value)) return RET_STATUS::RET_SUCCEED;

	char temp[50] = { 0 };
	int kvValue = (int)(value * 10); // 转换为协议单位（100V）
	snprintf(temp, sizeof(temp), "VREF %04d", kvValue);

	return HWSend(temp, strlen(temp));
}

RET_STATUS nsGEN::PSGHDDevice::IncMA()
{
	float currentMA = m_DoseUnit.m_MA->Get();

	// 查找当前值在档位中的位置
	size_t currentIndex = maStepCount;
	for (size_t i = 0; i < maStepCount; ++i) {
		if (fabs(maSteps[i] - currentMA) < 1e-6f) {
			currentIndex = i;
			break;
		}
	}

	if (currentIndex >= maStepCount - 1) {
		return RET_STATUS::RET_SUCCEED;  // 已经是最大值
	}

	return SetMA(maSteps[currentIndex + 1]);
}

RET_STATUS nsGEN::PSGHDDevice::DecMA()
{
	float currentMA = m_DoseUnit.m_MA->Get();

	// 查找当前值在档位中的位置
	size_t currentIndex = maStepCount;
	for (size_t i = 0; i < maStepCount; ++i) {
		if (fabs(maSteps[i] - currentMA) < 1e-6f) {
			currentIndex = i;
			break;
		}
	}

	if (currentIndex == 0 || currentIndex >= maStepCount) {
		return RET_STATUS::RET_SUCCEED;  // 已经是最小值或无效值
	}

	return SetMA(maSteps[currentIndex - 1]);
}

RET_STATUS nsGEN::PSGHDDevice::SetMA(float value)
{
	// 找到最接近的合法档位值
	size_t closestIndex = 0;
	float minDiff = fabsf(maSteps[0] - value);

	for (size_t i = 1; i < maStepCount; ++i) {
		float diff = fabsf(maSteps[i] - value);
		if (diff < minDiff) {
			minDiff = diff;
			closestIndex = i;
		}
	}

	// 转换为协议单位并发送命令
	char command[50] = { 0 };
	snprintf(command, sizeof(command), "IREF %04d", (int)(maSteps[closestIndex] * 100));
	return HWSend(command, strlen(command));
}

RET_STATUS nsGEN::PSGHDDevice::IncMS()
{
	float currentMS = m_DoseUnit.m_MS->Get();

	// 查找当前值在档位中的位置
	size_t currentIndex = msStepCount;
	for (size_t i = 0; i < msStepCount; ++i) {
		if (fabs(msSteps[i] - currentMS) < 1e-6f) {
			currentIndex = i;
			break;
		}
	}

	if (currentIndex >= msStepCount - 1) {
		return RET_STATUS::RET_SUCCEED;  // 已经是最大值
	}

	return SetMS(msSteps[currentIndex + 1]);
}

RET_STATUS nsGEN::PSGHDDevice::DecMS()
{
	float currentMS = m_DoseUnit.m_MS->Get();

	// 查找当前值在档位中的位置
	size_t currentIndex = msStepCount;
	for (size_t i = 0; i < msStepCount; ++i) {
		if (fabs(msSteps[i] - currentMS) < 1e-6f) {
			currentIndex = i;
			break;
		}
	}

	if (currentIndex == 0 || currentIndex >= msStepCount) {
		return RET_STATUS::RET_SUCCEED;  // 已经是最小值或无效值
	}

	return SetMS(msSteps[currentIndex - 1]);
}

RET_STATUS nsGEN::PSGHDDevice::SetMS(float value)
{
	// 找到最接近的合法档位值
	size_t closestIndex = 0;
	float minDiff = fabsf(msSteps[0] - value);

	for (size_t i = 1; i < msStepCount; ++i) {
		float diff = fabsf(msSteps[i] - value);
		if (diff < minDiff) {
			minDiff = diff;
			closestIndex = i;
		}
	}

	// 发送命令
	char command[50] = { 0 };
	snprintf(command, sizeof(command), "SMS %07d", static_cast<int>(msSteps[closestIndex] * 100));
	return HWSend(command, strlen(command));
}

RET_STATUS nsGEN::PSGHDDevice::IncMAS()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::DecMAS()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::SetMAS(float value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::SetTechmode(int value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::SetEXAMMode(std::string value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::SetAPR(const _tAPRArgs& t)
{
	m_bGenBusy = true;
	FINFO("APR:KV={$},MA={$},MS={$},MAS={$},Focus={$},Techmode={$},WS={$},AECDensity={$},AECField={$},AECFilm={$}", t.fKV, t.fMA, t.fMS, t.fMAS, t.nFocus, t.nTechmode, t.nWS, t.nAECDensity, t.nAECField, t.nAECFilm);

	SetKV(t.fKV);
	Sleep(50);
	SetMA(t.fMA);
	Sleep(80);
	SetMS(t.fMS);

	m_bGenBusy = false;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::RefreshData()
{
	if (!m_bGenBusy)
	{
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::SetFocus(int value)
{
	if (!m_DoseUnit.m_Focus->Verify(value)) return RET_STATUS::RET_SUCCEED;

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::Reset()
{
	FINFO("clear all errors \n");
	return HWSend("CLR",3);//仅重置错误状态
}

RET_STATUS nsGEN::PSGHDDevice::ActiveSyncMode(_tSyncModeArgs value)
{
	FINFO("value.strSyncMode: {$}, value.strSyncValue: {$}, value.strWS: {$} \n", value.strSyncMode, value.strSyncValue, value.strWS);
	int nSyncModeValue = atoi(value.strSyncValue.c_str());

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::SetCollimatorLight(unsigned short value)
{
	FINFO("Attempting to set collimator light value:{$}", value);
	return HWSend("COL", 3);
}

RET_STATUS nsGEN::PSGHDDevice::SetDeviceSleepState(const int value)
{
	m_bSleepState = (bool)value;
	FINFO("Attempting to set device sleep state: {$}({$})",
		value, m_bSleepState ? "sleeping" : "awake");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::PSGHDDevice::QueryHE(int& value) 
{
	return RET_STATUS::RET_SUCCEED;
}

void nsGEN::PSGHDDevice::SubscribeSelf(ccos_mqtt_connection* conn)
{
	//订阅GEN所有Action
		//SubscribeTopic(conn, "CCOS/DEVICE/Generator/Action/#"); Moduld层默认订阅了这个Action，如果这边也订阅的话就会执行两遍Action，可能会出问题
}

RET_STATUS nsGEN::PSGHDDevice::SetAECDensity(int value) 
{
	if (!m_DoseUnit.m_AECDensity->Verify(value)) return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_AEC) return RET_STATUS::RET_FAILED;

	int nAECDensity = m_DoseUnit.m_AECDensity->Get();
	if (value < m_DoseUnit.m_AECDensity->Get())
	{
		if (value < m_DoseUnit.m_AECDensity->Get() - 1)
		{
			nAECDensity = (int)value;
		}
		else
		{
			nAECDensity = nAECDensity - 1;
		}
	}
	else if (value > m_DoseUnit.m_AECDensity->Get())
	{
		if (value > m_DoseUnit.m_AECDensity->Get() + 1)
		{
			nAECDensity = (int)value;
		}
		else
		{
			nAECDensity = nAECDensity + 1;
		}
	}

	m_DoseUnit.m_AECDensity->Update(value);

	char temp[50] = { 0 };
	if (nAECDensity >= 0)
	{
		snprintf(temp, sizeof(temp), "FN+%01d", (int)nAECDensity);
	}
	else
	{
		snprintf(temp, sizeof(temp), "FN-%01d", (int)nAECDensity);
	}

	return HWSend(temp, strlen(temp));
}
RET_STATUS nsGEN::PSGHDDevice::SetAECField(int value) 
{
	if (!m_DoseUnit.m_AECField->Verify(value))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)	return RET_STATUS::RET_FAILED;
	m_DoseUnit.m_AECField->Update(value);
	char temp[50] = { 0 };
	snprintf(temp, sizeof(temp), "FI%03d", (int)value);
	return HWSend(temp, strlen(temp));
}
RET_STATUS nsGEN::PSGHDDevice::SetAECFilm(int value)
{
	if (!m_DoseUnit.m_AECFilm->Verify(value))  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)	return RET_STATUS::RET_FAILED;
	m_DoseUnit.m_AECFilm->Update(value);
	char temp[50] = { 0 };
	snprintf(temp, sizeof(temp), "FS%03d", (int)value);

	return HWSend(temp, strlen(temp));
}
RET_STATUS  nsGEN::PSGHDDevice::SetWS(const string value) 
{
	FINFO("Enter SetWS {$}", value);
	int tempws = 0;
	if (value == "Table")  tempws = (int)m_GenConfig["WSTable"];
	else if (value == "Wall")  tempws = (int)m_GenConfig["WSWall"];
	else if (value == "Direct")  tempws = (int)m_GenConfig["WSConventional"];
	else if (value == "Free")  tempws = (int)m_GenConfig["WSFree"];
	else if (value == "Tomo")  tempws = (int)m_GenConfig["WSTomo"];
	m_DoseUnit.m_WS->Update(tempws);
	char temp[50] = { 0 };
	snprintf(temp, sizeof(temp), "WS%01d", tempws);
	return HWSend(temp, strlen(temp));
}
RET_STATUS nsGEN::PSGHDDevice::QueryPostKV(float& value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::QueryPostMA(float& value) 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::QueryPostMS(float& value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::QueryPostMAS(float& value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::StartMove() //发生器无此设置
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::EndMove() //发生器无此设置
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::SetGenSynState(int value) 
{
	FINFO("Enter SetGenSynState...{$} \n", value);
	//if (AttrKey::GENERATOR_RAD_XRAYON == value)	
	//{
	//	FINFO("SetGenSynState be call.this is soft syn mode.");
	//	HWSend("XR2",3);
	//	m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON);
	//	FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
	//}
	//else if(AttrKey::GENERATOR_FLU_XRAYON == value)
	//{
	//	FINFO("SetGenSynState be call.this is soft syn mode.");
	//	//HWSend("FLX2", 4);
	//	//m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_FLU_XRAYON);
	//	//FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
	//}

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::SetGenState(int value) 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::SetExpMode(std::string value) 
{	
	FINFO("Enter SetExpMode...{$} \n",value.c_str());
	m_DoseUnit.m_ExpMode->Update(value);
	FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::SetFrameRate(float frameRate)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::PSGHDDevice::SetExpEnable() 
{
	FINFO("SetExpEnable in\n");
	m_bExpEnable = true;
	return HWSend("ENBL 1", 6);
}
RET_STATUS nsGEN::PSGHDDevice::SetExpDisable() 
{
	FINFO("SetExpDisable in\n");
	m_bExpEnable = false;
	return HWSend("ENBL 0", 6);
}

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

}

RET_STATUS nsGEN::PSGHDDevice::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())
	{
		FINFO("Failed - Device not connected");
		return RET_STATUS::RET_FAILED;
	}
	// 构造协议格式：<STX>CMD<SP>ARG;<CS><CR><LF>
	char strSendCommand[100] = { 0 };
	int len = 0;
	strSendCommand[len++] = 0x02; // STX

	// 复制命令部分
	memcpy(strSendCommand + len, strCommand, length);
	len += length;

	// 添加分号
	strSendCommand[len++] = ';';

	// 计算校验和（从STX后开始到分号';'）
	uint16_t sum = 0;
	for (int i = 1; i < len; i++)
	{
		sum += (uint8_t)strSendCommand[i];
	}
	uint8_t checksum = (uint8_t)(sum & 0xFF);
	checksum = 0x100 - checksum;
	checksum &= 0x7F;
	checksum |= 0x40;

	strSendCommand[len++] = checksum;
	strSendCommand[len++] = 0x0D; // CR
	strSendCommand[len++] = 0x0A; // LF


	// 打印数据包前16字节的十六进制（含控制字符）便于调试
	/*std::string hexStr;
	int printLen = std::min(len, 16);
	for (int i = 0; i < printLen; i++) {
		char buf[4];
		snprintf(buf, sizeof(buf), "%02X ", (uint8_t)strSendCommand[i]);
		hexStr += buf;
	}
	if (len > 16) hexStr += "...";
	FINFO("Packet (hex, total len: {$}) - [{$}]", len, hexStr);*/
	// 发送
	unsigned int retLength;
	if (m_SCF->Lock(1000) == WAIT_OBJECT_0)
	{
		int result = m_SCF->SendPacket(strSendCommand, len, nTimeOut, retLength);
		m_SCF->Unlock();
		if (result == SCF_SUCCEED) {
			// 打印发送命令的关键信息（命令内容+完整包长度）
			FINFO("Command to send - [{$}] (raw command length: {$}) - Success - Sent {$} bytes",
				std::string(strCommand, length), len, retLength);
			return RET_STATUS::RET_SUCCEED;
		}
		else {
			FINFO("HWSend: Failed - SendPacket returned error code: {$}", result);
			return RET_STATUS::RET_FAILED;
		}
	}
	else
	{
		FINFO("HWSend: Failed - Could not acquire lock within 1000ms");
		return RET_STATUS::RET_FAILED;
	}
	return RET_STATUS::RET_SUCCEED;
}

void nsGEN::PSGHDDevice::FireNotify(string key, int context)
{
	char szInfo[64] = { 0 };
	snprintf(szInfo, sizeof(szInfo), "%d", context); // Linux 标准函数
	std::string str = szInfo;
	EventCenter->OnNotify(1, key, str);
}

void nsGEN::PSGHDDevice::FireNotify(std::string key, float context)
{
	char szInfo[16] = { 0 };
	snprintf(szInfo, sizeof(szInfo), "%.2f", context); // Linux 标准函数
	std::string str = szInfo;
	EventCenter->OnNotify(1, key, str);
}

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

void nsGEN::PSGHDDevice::FireErrorMessage(const bool Act, const int Code, const char* ResInfo)
{
	string ErrorCode("PSGHD_ERR_");
	ErrorCode += std::to_string(Code);
	int level = PSG_HD_REGULATION_LEVEL::REG_ERRO;
	if (Act)
	{
		FINFO("add {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->AddErrorMessage(ErrorCode.c_str(), level, ResInfo);
	}
	else
	{
		FINFO("del {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->DelErrorMessage(ErrorCode.c_str(), level, ResInfo);
	}
}

void nsGEN::PSGHDDevice::FireWarnMessage(const bool Act, const int Code, const char* ResInfo)
{
	string ErrorCode("PSGHD_WAR_");
	ErrorCode += std::to_string(Code);
	int level = PSG_HD_REGULATION_LEVEL::REG_WARN;
	if (Act)
	{
		FINFO("add {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->AddWarnMessage(ErrorCode.c_str(), level, ResInfo);
	}
	else
	{
		FINFO("del {$}:{$}", ErrorCode.c_str(), ResInfo);
		m_MSGUnit->DelWarnMessage(ErrorCode.c_str(), level, ResInfo);
	}
}

void nsGEN::PSGHDDevice::OnCallBack()
{
	// 无操作处理函数
	auto HWNotProcess = [](const char* value, int length) -> void
		{
			FINFO("HWNotProcess: Command data (len: {$}) no need to process", length);
		};

	// 处理VREF响应 (电压参考)
	auto HWVREF = [this](const char* data, int length) -> void
		{
			// 需至少4字节数据（XXXX）
			if (length < 4) {
				FINFO("HWVREF: Invalid data length ({$} < 4), skip", length);
				return;
			}

			char kvStr[5] = { 0 };
			strncpy(kvStr, data, 4);
			int kvValue = atoi(kvStr);
			float actualKV = kvValue / 10.0f; // 转换为kV

			m_DoseUnit.m_KV->Update(actualKV);
			FireNotify(AttrKey::KV, m_DoseUnit.m_KV->JSGet());
			FINFO("HWVREF: Parsed actual KV = {$} kV", actualKV);
		};


	// 处理IREF响应 (电流参考)
	auto HWIREF = [this](const char* data, int length) -> void
		{
			if (length < 4) { // 需4字节（XXXX）
				FINFO("HWIREF: Invalid data length ({$} < 4), skip", length);
				return;
			}

			char maStr[5] = { 0 };
			strncpy(maStr, data, 4); // 直接取data
			int maValue = atoi(maStr);
			float actualMA = maValue / 100.0f; // 转换为mA

			m_DoseUnit.m_MA->Update(actualMA);
			FireNotify(AttrKey::MA, m_DoseUnit.m_MA->JSGet());
			FINFO("HWIREF: Parsed actual MA = {$} mA", actualMA);
		};

	// 处理ENBL响应 (X射线使能)
	auto HWENBL = [this](const char* data, int length) -> void
		{
			if (length < 1) { // 需1字节（X）
				FINFO("HWENBL: Invalid data length ({$} < 1), skip", length);
				return;
			}

			// 直接取data[0]（无需跳过"ENBL "）
			char enblStr = data[0];
			bool isEnabled = (enblStr == '1');
			FINFO("HWENBL: X-ray enable status = {$}", isEnabled ? "Enabled" : "Disabled");
		};

	// 处理WDTE响应 (看门狗定时器)
	auto HWWDTE = [this](const char* data, int length) -> void
		{
			if (length < 1) { // 需1字节（X）
				FINFO("HWWDTE: Invalid data length ({$} < 1), skip", length);
				return;
			}

			char wdtStr = data[0]; // 直接取data[0]
			bool isWdtEnabled = (wdtStr == '1');
			FINFO("HWWDTE: Watchdog status = {$}", isWdtEnabled ? "Enabled" : "Disabled");
		};


	// 处理WDTT响应 (看门狗定时器重置)
	auto HWWDTT = [this](const char* data, int length) -> void
		{
			if (length < 1) { // 基础长度校验
				FINFO("HWWDTT: Invalid data length ({$} < 1), skip", length);
				return;
			}
			FINFO("HWWDTT: Watchdog timer reset response received");
		};

	// 处理CLR响应 (故障清除)
	auto HWCLR = [this](const char* data, int length) -> void
		{
			if (length < 1) {
				FINFO("HWCLR: Invalid data length ({$} < 1), skip", length);
				return;
			}
			FINFO("HWCLR: Received fault clear response, performing fault clearing");
		};

	// 处理SMS响应 (曝光时间)
	auto HWSMS = [this](const char* data, int length) -> void
		{
			if (length < 7) { // 需7字节（XXXXXXX）
				FINFO("HWSMS: Invalid data length ({$} < 7), skip", length);
				return;
			}

			char smsStr[8] = { 0 };
			strncpy(smsStr, data, 7); // 直接取data
			long timeValue = atol(smsStr);
			float exposureTime = timeValue * 0.01f; // 转换为ms

			m_DoseUnit.m_MS->Update(exposureTime);
			FireNotify(AttrKey::MS, m_DoseUnit.m_MS->JSGet());
			FINFO("HWSMS: Parsed exposure time = {$} ms", exposureTime);
		};

	// 处理FLT响应 (故障状态)
	auto HWFLT = [this](const char* data, int length) -> void
		{
			if (length < 3) { // 需3字节（XXX）
				FINFO("HWFLT: Invalid data length ({$} < 3), skip", length);
				return;
			}

			char faultStr[4] = { 0 };
			strncpy(faultStr, data, 3);
			int faultCode = atoi(faultStr);

			if (faultCode != 0)
			{
				static const std::unordered_map<int, std::string> errorMessages = {
					{2, "充电回路异常"}, {3, "存储芯片损坏"}, {136, "灯丝电流1超过限值"},
					{140, "阳极kV超过限值，曝光异常中止"}, {142, "高压发生器或球管打火，曝光异常中止"},
					{165, "高压发生器启动过程中，母线电压过低"}, {205, "高压发生器唤醒或启动过程中二级手闸被按下"},
					{206, "高压发生器电池电量低，请充电"}, {208, "曝光时间间隔较短，请稍后曝光"},
					{209, "曝光过程中禁止调节参数"}, {210, "一级手闸重复触发，请使用单一手闸执行曝光操作"},
					{216, "电池充电中"}, {218, "kV参数超过限值"}, {219, "mA参数超过限值"},
					{220, "ms参数超过限值"}, {229, "高压发生器功率超过限值"}, {230, "球管功率超过限值"},
					{231, "帧频参数超过限值"}, {249, "高压发生器母线电压超过限值"}, {255, "kV建立超时"},
					{259, "曝光过程中提前松开手闸"}, {260, "曝光过程中禁止调节参数"}, {263, "曝光过程中kV过高，曝光异常中止"},
					{267, "曝光过程中mA过低，曝光异常中止"}, {268, "曝光过程中mA过高，曝光异常中止"}, {281, "曝光过程中功率超过限值，曝光异常中止"}
				};
				static const std::unordered_set<int> firstSixErrors = { 2, 3, 136, 140, 142, 165 };

				char errorCodeStr[20];
				snprintf(errorCodeStr, sizeof(errorCodeStr), "PSGHD_FLT_%d", faultCode);
				int level = 1;

				auto it = errorMessages.find(faultCode);
				if (it != errorMessages.end())
				{
					if (firstSixErrors.count(faultCode))
						m_MSGUnit->AddErrorMessage(errorCodeStr, level, it->second.c_str());
					else
						m_MSGUnit->AddWarnMessage(errorCodeStr, level, it->second.c_str());
					FINFO("HWFLT: Fault code {$} detected - {$}", faultCode, it->second.c_str());
				}
			}
			else
			{
				char errorCodeStr[20];
				snprintf(errorCodeStr, sizeof(errorCodeStr), "PSGHD_FLT_0");
				int level = 1;

				m_MSGUnit->DelWarnMessage(errorCodeStr, level, "");
				m_MSGUnit->DelErrorMessage(errorCodeStr, level, "");
				FINFO("HWFLT: Fault cleared (fault code 0)");
			}
		};

	// 处理工作相位响应 (RST<aaa>)
	auto HWPhase = [this](const char* data, int length) -> void
		{
			if (length < 3) { // 需3字节（aaa）
				FINFO("HWPhase: Invalid data length ({$} < 3), skip", length);
				return;
			}

			char phaseCodeStr[4] = { 0 };
			strncpy(phaseCodeStr, data, 3);
			int phaseCode = atoi(phaseCodeStr);

			auto updateAndNotify = [this](nsGEN::AttrKey::GENERATOR_STATUS status)
				{
					if (m_DoseUnit.m_GenState->Update(status))
					{
						FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
						FINFO("HWPhase: Generator status updated to {$}", static_cast<int>(status));
					}
				};

			switch (phaseCode)
			{
			case 1: updateAndNotify(nsGEN::AttrKey::GENERATOR_STATUS_INIT); break;
			case 7: updateAndNotify(nsGEN::AttrKey::GENERATOR_STATUS_ERROR); break;
			case 9: case 11: updateAndNotify(nsGEN::AttrKey::GENERATOR_STATUS_EXP); break;
			default: FINFO("HWPhase: Unsupported phase code {$}", phaseCode); break;
			}
		};

	auto HWVMON = [this](const char* data, int length) -> void
		{
			if (length < 4) { // 需4字节（XXXX）
				FINFO("HWVMON: Invalid data length ({$} < 4), skip", length);
				return;
			}

			char vmonStr[5] = { 0 };
			strncpy(vmonStr, data, 4); // 直接取data
			int vmonValue = atoi(vmonStr);
			float actualVMON = vmonValue / 10.0f; // 转换为kV

			m_DoseUnit.m_PostKV->Update(actualVMON);
			FireNotify(AttrKey::POSTKV, m_DoseUnit.m_PostKV->JSGet());
			FINFO("HWVMON: Parsed monitoring KV = {$} kV", actualVMON);
		};

	auto HWIMON = [this](const char* data, int length) -> void
		{
			if (length < 4) { // 需4字节（XXXX）
				FINFO("HWIMON: Invalid data length ({$} < 4), skip", length);
				return;
			}

			char imonStr[5] = { 0 };
			strncpy(imonStr, data, 4); // 直接取data
			int imonValue = atoi(imonStr);
			float actualIMON = imonValue / 100.0f; // 转换为mA

			m_DoseUnit.m_PostMA->Update(actualIMON);
			FireNotify(AttrKey::POSTMA, m_DoseUnit.m_PostMA->JSGet());
			FINFO("HWIMON: Parsed monitoring MA = {$} mA", actualIMON);
		};

	auto HWRAT = [this](const char* data, int length) -> void
		{
			if (length < 7) { // 需7字节（XXXXXXX）
				FINFO("HWRAT: Invalid data length ({$} < 7), skip", length);
				return;
			}

			char ratStr[8] = { 0 };
			strncpy(ratStr, data, 7); // 直接取data
			int ratio = atoi(ratStr);
			float actualRatio = ratio / 100.0f;

			m_DoseUnit.m_PostMS->Update(actualRatio);
			FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());
			FINFO("HWRAT: Parsed ratio parameter = {$}", actualRatio);
		};

	auto HWPOW = [this](const char* data, int length) -> void
		{
			if (length < 1) { // 需1字节（X）
				FINFO("HWPOW: Invalid data length ({$} < 1), skip", length);
				return;
			}

			char powStr = data[0]; // 直接取data[0]
			bool isPowerOn = (powStr == '1');
			FINFO("HWPOW: Power status = {$}", isPowerOn ? "On" : "Off");
		};

	auto HWEOK = [this](const char* data, int length) -> void
		{
			if (length < 1) { // 需1字节（X）
				FINFO("HWEOK: Invalid data length ({$} < 1), skip", length);
				return;
			}

			char eokStr = data[0]; // 直接取data[0]
			bool isReady = (eokStr == '1');

			if (isReady)
			{
				if (m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_STANDBY))
				{
					FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
					FINFO("HWEOK: Device ready, status updated to STANDBY");
				}
			}
			else
			{
				if (m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_SLEEP))
				{
					FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
					FINFO("HWEOK: Device not ready, status updated to SLEEP");
				}
			}
		};

	auto HWECD = [this](const char* data, int length) -> void
		{
			if (length < 3) { // 需3字节（XXX）
				FINFO("HWECD: Invalid data length ({$} < 3), skip", length);
				return;
			}

			char ecdStr[4] = { 0 };
			strncpy(ecdStr, data, 3); // 直接取data
			int countdown = atoi(ecdStr);
			FINFO("HWECD: High-voltage OK light countdown = {$}s", countdown);
		};

	auto HWSOC = [this](const char* data, int length) -> void
		{
			if (length < 3) { // 需3字节（XXX）
				FINFO("HWSOC: Invalid data length ({$} < 3), skip", length);
				return;
			}

			char socStr[4] = { 0 };
			strncpy(socStr, data, 3); // 直接取data
			int remainingPower = atoi(socStr);
			FINFO("HWSOC: Generator remaining power = {$}%", remainingPower);
		};

	auto HWFLX = [this](const char* data, int length) -> void
		{
			if (length < 1) { // 需1字节（X）
				FINFO("HWFLX: Invalid data length ({$} < 1), skip", length);
				return;
			}

			char flxStr[2] = { 0 };
			strncpy(flxStr, data, 1);
			int fluoroMode = atoi(flxStr);
			FINFO("HWFLX: Fluorescence mode detected = {$}", fluoroMode);

			if (fluoroMode == 2)
			{
				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON);
				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				FINFO("HWFLX: X-ray turned ON (mode 2)");
			}
			else if (fluoroMode == 1)
			{
				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_READY);
				m_hGenPostEvent->ResetEvent();
				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				FINFO("HWFLX: X-ray ready (mode 1)");
			}
			else if (fluoroMode == 0)
			{
				m_bGenBusy = false;
				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYOFF);
				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				FINFO("HWFLX: X-ray turned OFF (mode 0)");
			}
		};

	auto HWVER = [this](const char* data, int length) -> void
		{
			if (length < 6) { // 需6字节（XXXXXX）
				FINFO("HWVER: Invalid data length ({$} < 6), skip", length);
				return;
			}

			char verStr[7] = { 0 };
			strncpy(verStr, data, 6); // 直接取data
			std::string version(verStr);
			FINFO("HWVER: Generator version = {$}", version);
		};

	auto HWVSN = [this](const char* data, int length) -> void
		{
			if (length < 8) { // 需8字节（XXXXXXXX）
				FINFO("HWVSN: Invalid data length ({$} < 8), skip", length);
				return;
			}

			char vsnStr[9] = { 0 };
			strncpy(vsnStr, data, 8); // 直接取data
			std::string serialNumber(vsnStr);
			FINFO("HWVSN: Generator serial number = {$}", serialNumber);
		};

	auto HWMAS = [this](const char* data, int length) -> void
		{
			if (length < 3) { // 至少3字节（避免atof解析错误）
				FINFO("HWMAS: Invalid data length ({$} < 3), skip", length);
				return;
			}

			float fmas = atof(data) / 100.0f; // 直接用data解析
			if (m_DoseUnit.m_MAS->Update(fmas))
			{
				FireNotify(AttrKey::MAS, m_DoseUnit.m_MAS->JSGet());
				FINFO("HWMAS: Parsed MAS value = {$}", fmas);
			}
		};

	auto HWAP = [this](const char* data, int length) -> void
		{
			if (length < 3) { // 至少3字节（避免atof解析错误）
				FINFO("HWAP: Invalid data length ({$} < 3), skip", length);
				return;
			}

			float fmas = atof(data) / 100.0f; // 直接用data解析
			m_DoseUnit.m_PostMAS->Update(fmas);
			FireNotify(AttrKey::POSTMAS, m_DoseUnit.m_PostMAS->JSGet());
			FINFO("HWAP: Parsed POSTMAS value = {$}", fmas);
		};

	auto HWWS = [this](const char* data, int length) -> void
		{
			if (length < 1) { // 需1字节以上（避免atoi解析错误）
				FINFO("HWWS: Invalid data length ({$} < 1), skip", length);
				return;
			}

			int nValue = atoi(data); // 直接用data解析
			m_DoseUnit.m_WS->Update(nValue);
			FireNotify(m_DoseUnit.m_WS->GetKey(), m_DoseUnit.m_WS->JSGet());
			FINFO("HWWS: Parsed WS parameter = {$}", nValue);
		};

	auto HWEHE = [this](const char* data, int length) -> void
		{
			if (length < 1) { // 需1字节以上
				FINFO("HWEHE: Invalid data length ({$} < 1), skip", length);
				return;
			}

			m_iHeartBeats = 0;
			int nhe = atoi(data); // 直接用data解析
			if (m_DoseUnit.m_HE->Update(nhe))
			{
				FireNotify(m_DoseUnit.m_HE->GetKey(), m_DoseUnit.m_HE->JSGet());
				FINFO("HWEHE: Parsed HE parameter = {$}", nhe);
			}
		};

	arFrame.clear();

	// 指令映射表补充
	arFrame.push_back(tFrameMapping("VREF ", 5, HWVREF));
	arFrame.push_back(tFrameMapping("IREF ", 5, HWIREF));
	arFrame.push_back(tFrameMapping("VMON ", 5, HWVMON));
	arFrame.push_back(tFrameMapping("IMON ", 5, HWIMON));
	arFrame.push_back(tFrameMapping("ENBL ", 5, HWENBL));
	arFrame.push_back(tFrameMapping("RST ", 4, HWPhase));
	arFrame.push_back(tFrameMapping("SMS ", 4, HWSMS));
	arFrame.push_back(tFrameMapping("RAT ", 4, HWRAT));
	arFrame.push_back(tFrameMapping("POW ", 4, HWPOW));
	arFrame.push_back(tFrameMapping("EOK ", 4, HWEOK));
	arFrame.push_back(tFrameMapping("ECD ", 4, HWECD));
	arFrame.push_back(tFrameMapping("FLX ", 4, HWFLX));
	arFrame.push_back(tFrameMapping("FLT ", 4, HWFLT));
	arFrame.push_back(tFrameMapping("RHE ", 4, HWEHE));
	arFrame.push_back(tFrameMapping("VER ", 4, HWVER));
	arFrame.push_back(tFrameMapping("VSN ", 4, HWVSN));
	arFrame.push_back(tFrameMapping("CLR", 4, HWCLR));
	arFrame.push_back(tFrameMapping("EC", 2, HWNotProcess));
	arFrame.push_back(tFrameMapping("PW", 2, HWNotProcess));	
	arFrame.push_back(tFrameMapping("MX", 2, HWMAS));
	arFrame.push_back(tFrameMapping("WS", 2, HWWS));
}

bool nsGEN::PSGHDDevice::ReConnect()
{
	FINFO("Enter PSG_reConnect");
	m_SCF->Disconnect();
	if (!pIODriver)
	{
		FINFO("PSG_reConnect:Driver null");
	}
	else
	{
		// 需要将 pIODriver 转换为 PSGHDDriver*
		PSGHDDriver* driver = dynamic_cast<PSGHDDriver*>(pIODriver.get());
		if (driver && driver->ReConnection())
		{
			FireErrorMessage(false, 1, "lost Connect");
			m_bConnectFlag = true;
			FINFO("PSG_reConnect success");
			return true;
		}
		else
		{
			FINFO("PSG_reConnect failed");
		}
	}
	return false;
}

int nsGEN::PSGHDDevice::GetGenState()
{
	if (m_DoseUnit.m_GenState != NULL)
	{
		return m_DoseUnit.m_GenState->Get();
	}
	else
	{
		return 0;
	}
}

int nsGEN::PSGHDDevice::LoadConfig(string configfile)
{
	FINFO("=====================LoadConfig=========================");
	// 检查文件是否存在
	std::ifstream file(configfile);
	if (!file) {
		// 文件不存在，直接返回空的Connection对象
		FINFO("Config file does not exist: {$}", configfile.c_str());
		return -1;
	}

	if (m_bIsConfigLoaded)
	{
		FINFO("Configuration already loaded.");
		return 0;
	}

	ResDataObject temp;
	temp.loadFile(configfile.c_str());
	m_GenConfig = temp["CONFIGURATION"];
	TransJsonText(m_GenConfig);

	if (m_GenConfig.GetKeyCount("loopEnable") > 0)
	{
		m_bExtraFlag = (int)m_GenConfig["loopEnable"];
	}

	if (m_GenConfig.GetKeyCount(ConfKey::CcosTubeInfo) > 0)
	{
		string tempValue = (string)m_GenConfig[ConfKey::CcosTubeInfo];
		m_DoseUnit.m_TubeInfo.reset(new TUBEINFOMould(tempValue));
		FireNotify(AttrKey::TUBEINFO, m_DoseUnit.m_TubeInfo->JSGet());
	}

	if (m_GenConfig.GetKeyCount(ConfKey::CcosFocusSmall) > 0)
	{
		float tempValue = (float)m_GenConfig[ConfKey::CcosFocusSmall];
		m_DoseUnit.m_FocusSmall = tempValue;
	}

	if (m_GenConfig.GetKeyCount(ConfKey::CcosFocusLarge) > 0)
	{
		float tempValue = (float)m_GenConfig[ConfKey::CcosFocusLarge];
		m_DoseUnit.m_FocusLarge = tempValue;
	}

	if (m_GenConfig.GetKeyCount("GenCtrlMode") > 0)
	{
		m_nCtlMode = (float)m_GenConfig["GenCtrlMode"];//default 2
		float tempValue = (float)m_GenConfig[ConfKey::CcosFocusLarge];
	}

	if (m_GenConfig.GetKeyCount("USECECMD") > 0)
	{
		m_bUseCECmd = (bool)m_GenConfig["USECECMD"];
	}

	m_bIsConfigLoaded = true;
	return 0;
}

bool nsGEN::PSGHDDevice::ECHO(void)
{
	return HWSend("ECH", 3);
}

bool nsGEN::PSGHDDevice::StartHardwareStatusThread()
{
	if (!m_pHardwareStatusThread.joinable())
	{
		m_pHardwareStatusThread = std::thread(HardwareStatusThread, this);
		return true;
	}
	return false;
}

void PSGHDDevice::HardwareStatusThread(PSGHDDevice* pParam)
{
	if (pParam == nullptr)
	{
		return;
	}

	PSGHDDevice* pCurGen = pParam;
	pCurGen->HeartBeatFlag = true;

	int messageIndex = 0;

	while (pCurGen->m_bExtraFlag)
	{
		// 获取当前循环时间并休眠
		int currentLoopTime = pCurGen->m_iLoopTime;
		Sleep(currentLoopTime);

		// 每5次循环发送状态查询命令
		if (messageIndex % 5 == 0)
		{
			pCurGen->HWSend("RHE", 3);
			Sleep(100);
			pCurGen->HWSend("RST", 3);
			Sleep(100);
			pCurGen->HWSend("EOK", 3);
		}

		messageIndex++;

		// 防止messageIndex无限增长导致溢出
		if (messageIndex >= INT_MAX - 10)
		{
			messageIndex = 0;
		}
	}

	// 线程退出时重置心跳标志
	pCurGen->HeartBeatFlag = false;
}

//-----------------------------------------------------------------------------
//		PSGHDDriver
//-----------------------------------------------------------------------------

nsGEN::PSGHDDriver::PSGHDDriver()
	: m_scfWrapper(std::make_shared<SCFWrapper>())
{
	m_pAttribute.reset(new ResDataObject());
	m_pDescription.reset(new ResDataObject());
}

nsGEN::PSGHDDriver::~PSGHDDriver()
{
	Disconnect();
}

void nsGEN::PSGHDDriver::Prepare()
{
	// 初始化日志系统
	string strLogPath = GetProcessDirectory() + R"(\Conf\log_config.xml)";
	if (!Log4CPP::init("DevPSGHD", "GEN.PSG_HD", strLogPath, true)) {
		std::cerr << "Failed to initialize log system! Using default configuration." << std::endl;
		// 即使配置文件加载失败，也可以继续使用默认配置
	}
	m_SCFDllName = GetConnectDLL(m_ConfigFileName);
	FINFO("Prepare is OK.SCFDllName is {$}", m_SCFDllName);
}

std::string nsGEN::PSGHDDriver::DriverProbe()
{
	FINFO("DriverProbe in \n");
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
		HardwareInfo.add("MinorID", r_config["CONFIGURATION"]["MinorID"]);
		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
	}
	else
	{
		HardwareInfo.add("MajorID", "Generator");
		HardwareInfo.add("MinorID", "Dr");
		HardwareInfo.add("VendorID", "PSGHD");
		HardwareInfo.add("ProductID", "HF");
		HardwareInfo.add("SerialID", "Drv");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

bool nsGEN::PSGHDDriver::ReConnection()
{
	Disconnect();
	FINFO("ReConnection:SCF Disconnect");
	ResDataObject Connection = GetConnectParam(m_ConfigFileName);
	FINFO("ReConnection:{$} \n", Connection.encode());

	auto erCode = m_scfWrapper->Connect(Connection, &PSGHDDriver::callbackPackageProcess, SCF_PACKET_TRANSFER, 3000);
	if (erCode == SCF_SUCCEED)
	{
		Sleep(1000);
		// 重新设置数据接收回调
		m_scfWrapper->SetDataReceivedCallback([this](const char* data, uint32_t length) {
			this->Dequeue(data, length);
			});

		// 启动自动接收
		m_scfWrapper->StartAutoReceive();
		return true;
	}
	else
	{
		FINFO("ReConnection failed");
	}
	return false;
}

bool nsGEN::PSGHDDriver::Connect()
{
	std::lock_guard<std::mutex> lock(m_connectionMutex);

	if (m_connectionState.load() == ConnectionState::Failed) {
		auto now = std::chrono::steady_clock::now();
		if ((now - m_lastConnectionAttempt) >= RETRY_INTERVAL && m_connectionRetryCount < MAX_RETRY_COUNT) {
			m_connectionState.store(ConnectionState::Disconnected); // 合法：非const函数
		}
	}

	if (m_connectionState.load() == ConnectionState::Connected ||
		m_connectionState.load() == ConnectionState::Connecting) {
		FINFO("Already connected or connecting");
		return true;
	}

	auto now = std::chrono::steady_clock::now();
	if ((now - m_lastConnectionAttempt) < RETRY_INTERVAL && m_connectionRetryCount > 0) {
		FINFO("Too soon to retry connection");
		return false;
	}

	m_connectionState.store(ConnectionState::Connecting);
	m_lastConnectionAttempt = now;
	m_connectionRetryCount++;

	FINFO("Enter {$},configlef={$}\n", __FUNCTION__, m_ConfigFileName.c_str());
	ResDataObject Connection = GetConnectParam(m_ConfigFileName);
	FINFO("connections:{$} \n", Connection.encode());

	try {
		if (!m_scfWrapper->Initialize(m_SCFDllName)) {
			FINFO("Failed to initialize SCFWrapper: {$}", m_scfWrapper->GetLastError());
			m_connectionState.store(ConnectionState::Failed);
			return false;
		}

		m_scfWrapper->SetDataReceivedCallback([this](const char* data, uint32_t length) {
			this->Dequeue(data, length);
			});

		auto erCode = m_scfWrapper->Connect(Connection, &PSGHDDriver::callbackPackageProcess, SCF_NORMAL_TRANSFER, 3000);
		if (erCode != SCF_SUCCEED) {
			FINFO("Connection failed with error code: {$}", erCode);
			m_connectionState.store(ConnectionState::Failed);
			return false;
		}

		if (!m_scfWrapper->StartAutoReceive()) {
			FINFO("Failed to start auto receive");
			m_connectionState.store(ConnectionState::Failed);
			return false;
		}

		m_connectionState.store(ConnectionState::Connected);
		m_connectionRetryCount = 0;
		FINFO("Connection established successfully");
		return true;
	}
	catch (const std::exception& e) {
		FINFO("Exception during connection: {$}", e.what());
		m_connectionState.store(ConnectionState::Failed);
		return false;
	}
}

auto nsGEN::PSGHDDriver::CreateDevice(int index) -> std::unique_ptr <IODevice>
{
	FINFO("CreateDevice in\n");

	m_pDevice = new PSGHDDevice(EventCenter, m_scfWrapper, m_ConfigFileName);
	auto dev = std::unique_ptr <IODevice>(new IODevice(m_pDevice));

	FINFO("CreateDevice out\n");
	return dev;
}

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

bool nsGEN::PSGHDDriver::isConnected() const
{
	FINFO("isConnected in");
	if (m_connectionState.load() == ConnectionState::Connecting) {
		FINFO("Connection in progress, skipping additional connect attempts");
		return true;
	}

	if (m_scfWrapper && m_scfWrapper->IsConnected()) {
		FINFO("m_scfWrapper->IsConnected()");
		return true;
	}

	auto now = std::chrono::steady_clock::now();
	auto timeSinceLastAttempt = now - m_lastConnectionAttempt;

	if (m_connectionState.load() == ConnectionState::Failed) {
		if (timeSinceLastAttempt < RETRY_INTERVAL) {
			FINFO("Too soon to retry connection");
			return false;
		}
		if (m_connectionRetryCount >= MAX_RETRY_COUNT) {
			FINFO("Max connection retries exceeded");
			return false;
		}
	}

	return false;
}

std::string nsGEN::PSGHDDriver::GetResource()
{
	FDEBUG("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的值

			//printf("********************************innerkey=%s --strValue = %s\n", strTemp.c_str(), strValue.c_str());

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

			//printf("********************************outkey =%s --strValue = %s\n", 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;

	//Debug("local ************* get resource over {$}", DescriptionTempEx.encode());
	//printf("local ************* get resource over %s \n", DescriptionTempEx.encode());


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

	//printf("%s", res.c_str());

	//Debug("get resource over {$}", DescriptionTempEx.encode());
	//("************* get resource over %s \n", DescriptionTempEx.encode());

	return res;
}

std::string nsGEN::PSGHDDriver::DeviceProbe()
{
	FINFO("std::string nsGEN::PSGHDDriver::DeviceProbe() in\n");
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
		HardwareInfo.add("MinorID", r_config["CONFIGURATION"]["MinorID"]);
		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
	}
	else
	{
		HardwareInfo.add("MajorID", "Generator");
		HardwareInfo.add("MinorID", "Dr");
		HardwareInfo.add("VendorID", "PSGHD");
		HardwareInfo.add("ProductID", "HF");
		HardwareInfo.add("SerialID", "Dev");
	}
	string ret = HardwareInfo.encode();
	FINFO("std::string nsGEN::PSGHDDriver::DeviceProbe() out\n");
	return ret;
}

void nsGEN::PSGHDDriver::Disconnect()
{
	if (m_scfWrapper) {
		m_scfWrapper->StopAutoReceive();
		m_scfWrapper->Disconnect();
	}
}

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

PACKET_RET nsGEN::PSGHDDriver::callbackPackageProcess(const char* RecData, uint32_t nLength, uint32_t& PacketLength)
{
	// 日志：进入数据包处理函数，记录输入长度
	FINFO("[PSGHDDriver] 开始处理数据包，输入长度: [{$}]", nLength);

	if (nLength < 3)
	{
		// 日志：数据包长度不足
		FINFO("[PSGHDDriver] 数据包长度小于3，无效数据包，返回PACKET_USELESS");
		return PACKET_USELESS;
	}

	// 查找STX (0x02)
	int startIndex = -1;
	for (uint32_t i = 0; i < nLength; i++)
	{
		if (RecData[i] == 0x02)
		{
			startIndex = i;
			break;
		}
	}

	if (startIndex == -1)
	{
		// 日志：未找到STX标记
		FINFO("[PSGHDDriver] 未找到STX(0x02)标记，返回PACKET_USELESS");
		return PACKET_USELESS;
	}
	// 日志：找到STX标记
	FINFO("[PSGHDDriver] 找到STX(0x02)标记，位置: [{$}]", startIndex);

	// 查找CRLF (0x0D, 0x0A)
	int endIndex = -1;
	for (uint32_t i = startIndex + 1; i < nLength - 1; i++)
	{
		if (RecData[i] == 0x0D && RecData[i + 1] == 0x0A)
		{
			endIndex = i;
			break;
		}
	}

	if (endIndex == -1)
	{
		// 日志：未找到CRLF结束标记
		FINFO("[PSGHDDriver] 未找到CRLF(0x0D,0x0A)结束标记，返回PACKET_NOPACKET");
		return PACKET_NOPACKET;
	}
	// 日志：找到CRLF标记
	FINFO("[PSGHDDriver] 找到CRLF(0x0D,0x0A)标记，位置: [{$}]", endIndex);

	// 计算数据包长度
	PacketLength = endIndex + 2 - startIndex;
	FINFO("[PSGHDDriver] 数据包处理完成，有效长度: [{$}]，返回PACKET_ISPACKET", PacketLength);

	return PACKET_ISPACKET;
}


bool nsGEN::PSGHDDriver::GetDeviceConfig(std::string& Cfg)
{
	Cfg = m_DeviceConfigSend.encode();

	printf("GetDeviceConfig over , %s", Cfg.c_str());

	return true;
}

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

	printf("\n--Func-- SetDeviceConfig %s\n", Cfg.c_str());

	ResDataObject DeviceConfig;
	DeviceConfig.decode(Cfg.c_str());

	ResDataObject DescriptionTempEx;
	DescriptionTempEx = DeviceConfig["DeviceConfig"]["Attribute"];
	FDEBUG("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());
		printf("%s\n", 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]))
					{
						FDEBUG("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)
		{
			printf("\nSetDriverConfig crashed: %s\n", e.what());
			FERROR("SetDriverConfig crashed: {$}", e.what());
			return false;
		}
	}

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

bool nsGEN::PSGHDDriver::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::PSGHDDriver::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();

			//	printf("-TempValue=== %s", TempValue.c_str());

			resTemp.clear();
			resTemp.decode(TempValue.c_str());
			strTemp = strTemp.substr(pos + 1, strTemp.length() - pos - 1);

			//printf("-************--%s", strTemp.c_str());

		}
		if (strTemp != "")
		{
			strValue = (string)resTemp[strTemp.c_str()];
		}
		else
		{
			strValue = (string)resTemp;
		}
	}

	//printf("------------%s", strValue.c_str());

	return true;
}

bool nsGEN::PSGHDDriver::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::PSGHDDriver  gIODriver;

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

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