完成模型、服务的重构，目前运行正常，考虑合并分支

Release/IDL/C909_V1/ATA04/Aerodynamics_heartbeat.cxx

@@ -0,0 +1,43 @@
+#include "Aerodynamics_heartbeat.hpp"
+namespace XNSim::C909::ATA04
+{
+Aerodynamics_heartbeat_Interface::Aerodynamics_heartbeat_Interface()
+{
+	MAP_DATA_FUNC(aero_model_heartbeat);
+}
+Aerodynamics_heartbeat_Interface::~Aerodynamics_heartbeat_Interface()
+{
+}
+void Aerodynamics_heartbeat_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::Aerodynamics_heartbeatPubSubType>("XNSim::C909::ATA04::Aerodynamics_heartbeat", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::Aerodynamics_heartbeatPubSubType>("XNSim::C909::ATA04::Aerodynamics_heartbeat", modelId, std::bind(&Aerodynamics_heartbeat_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::Aerodynamics_heartbeatPubSubType>("XNSim::C909::ATA04::Aerodynamics_heartbeat", modelId, std::bind(&Aerodynamics_heartbeat_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::Aerodynamics_heartbeatPubSubType>("XNSim::C909::ATA04::Aerodynamics_heartbeat", modelId);
+	}
+}
+void Aerodynamics_heartbeat_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::Aerodynamics_heartbeat();
+}
+void Aerodynamics_heartbeat_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void Aerodynamics_heartbeat_Interface::inputDataListener(const XNSim::C909::ATA04::Aerodynamics_heartbeat &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/Aerodynamics_heartbeat.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class Aerodynamics_heartbeat_Interface final : public XNDDSInterface
+{
+public:
+	Aerodynamics_heartbeat_Interface();
+	virtual ~Aerodynamics_heartbeat_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::Aerodynamics_heartbeat &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.aero_model_heartbeat(), model_data->aero_model_heartbeat);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.aero_model_heartbeat(), model_data->aero_model_heartbeat);
+	}
+private:
+	XNSim::C909::ATA04::Aerodynamics_heartbeat data;
+	XNSim::C909::ATA04::Aerodynamics_heartbeat out_data;
+};
+}

Release/IDL/C909_V1/ATA04/Aerodynamics_input.cxx

@@ -0,0 +1,69 @@
+#include "Aerodynamics_input.hpp"
+namespace XNSim::C909::ATA04
+{
+Aerodynamics_input_Interface::Aerodynamics_input_Interface()
+{
+	MAP_DATA_FUNC(l_04_i_aerocomac_alpha_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_alpdot_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_beta_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_press_alt_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_tas_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_mach_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_nx_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_ny_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_nz_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_p_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_q_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_r_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_qbar_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_blcg_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_bscg_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_wlcg_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_ail_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_elv_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_rud_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_stab_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_gear_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_flap_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_slat_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_spl_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_tnet_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_kice_f8);
+	MAP_DATA_FUNC(l_04_i_aerocomac_alt_agl_f8);
+}
+Aerodynamics_input_Interface::~Aerodynamics_input_Interface()
+{
+}
+void Aerodynamics_input_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::Aerodynamics_inputPubSubType>("XNSim::C909::ATA04::Aerodynamics_input", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::Aerodynamics_inputPubSubType>("XNSim::C909::ATA04::Aerodynamics_input", modelId, std::bind(&Aerodynamics_input_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::Aerodynamics_inputPubSubType>("XNSim::C909::ATA04::Aerodynamics_input", modelId, std::bind(&Aerodynamics_input_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::Aerodynamics_inputPubSubType>("XNSim::C909::ATA04::Aerodynamics_input", modelId);
+	}
+}
+void Aerodynamics_input_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::Aerodynamics_input();
+}
+void Aerodynamics_input_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void Aerodynamics_input_Interface::inputDataListener(const XNSim::C909::ATA04::Aerodynamics_input &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/Aerodynamics_input.hpp

@@ -0,0 +1,88 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class Aerodynamics_input_Interface final : public XNDDSInterface
+{
+public:
+	Aerodynamics_input_Interface();
+	virtual ~Aerodynamics_input_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::Aerodynamics_input &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.l_04_i_aerocomac_alpha_f8(), model_data->l_04_i_aerocomac_alpha_f8);
+		assign_value_get(data.l_04_i_aerocomac_alpdot_f8(), model_data->l_04_i_aerocomac_alpdot_f8);
+		assign_value_get(data.l_04_i_aerocomac_beta_f8(), model_data->l_04_i_aerocomac_beta_f8);
+		assign_value_get(data.l_04_i_aerocomac_press_alt_f8(), model_data->l_04_i_aerocomac_press_alt_f8);
+		assign_value_get(data.l_04_i_aerocomac_tas_f8(), model_data->l_04_i_aerocomac_tas_f8);
+		assign_value_get(data.l_04_i_aerocomac_mach_f8(), model_data->l_04_i_aerocomac_mach_f8);
+		assign_value_get(data.l_04_i_aerocomac_nx_f8(), model_data->l_04_i_aerocomac_nx_f8);
+		assign_value_get(data.l_04_i_aerocomac_ny_f8(), model_data->l_04_i_aerocomac_ny_f8);
+		assign_value_get(data.l_04_i_aerocomac_nz_f8(), model_data->l_04_i_aerocomac_nz_f8);
+		assign_value_get(data.l_04_i_aerocomac_p_f8(), model_data->l_04_i_aerocomac_p_f8);
+		assign_value_get(data.l_04_i_aerocomac_q_f8(), model_data->l_04_i_aerocomac_q_f8);
+		assign_value_get(data.l_04_i_aerocomac_r_f8(), model_data->l_04_i_aerocomac_r_f8);
+		assign_value_get(data.l_04_i_aerocomac_qbar_f8(), model_data->l_04_i_aerocomac_qbar_f8);
+		assign_value_get(data.l_04_i_aerocomac_blcg_f8(), model_data->l_04_i_aerocomac_blcg_f8);
+		assign_value_get(data.l_04_i_aerocomac_bscg_f8(), model_data->l_04_i_aerocomac_bscg_f8);
+		assign_value_get(data.l_04_i_aerocomac_wlcg_f8(), model_data->l_04_i_aerocomac_wlcg_f8);
+		assign_value_get(data.l_04_i_aerocomac_ail_f8(), model_data->l_04_i_aerocomac_ail_f8);
+		assign_value_get(data.l_04_i_aerocomac_elv_f8(), model_data->l_04_i_aerocomac_elv_f8);
+		assign_value_get(data.l_04_i_aerocomac_rud_f8(), model_data->l_04_i_aerocomac_rud_f8);
+		assign_value_get(data.l_04_i_aerocomac_stab_f8(), model_data->l_04_i_aerocomac_stab_f8);
+		assign_value_get(data.l_04_i_aerocomac_gear_f8(), model_data->l_04_i_aerocomac_gear_f8);
+		assign_value_get(data.l_04_i_aerocomac_flap_f8(), model_data->l_04_i_aerocomac_flap_f8);
+		assign_value_get(data.l_04_i_aerocomac_slat_f8(), model_data->l_04_i_aerocomac_slat_f8);
+		assign_value_get(data.l_04_i_aerocomac_spl_f8(), model_data->l_04_i_aerocomac_spl_f8);
+		assign_value_get(data.l_04_i_aerocomac_tnet_f8(), model_data->l_04_i_aerocomac_tnet_f8);
+		assign_value_get(data.l_04_i_aerocomac_kice_f8(), model_data->l_04_i_aerocomac_kice_f8);
+		assign_value_get(data.l_04_i_aerocomac_alt_agl_f8(), model_data->l_04_i_aerocomac_alt_agl_f8);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.l_04_i_aerocomac_alpha_f8(), model_data->l_04_i_aerocomac_alpha_f8);
+		assign_value_set(data.l_04_i_aerocomac_alpdot_f8(), model_data->l_04_i_aerocomac_alpdot_f8);
+		assign_value_set(data.l_04_i_aerocomac_beta_f8(), model_data->l_04_i_aerocomac_beta_f8);
+		assign_value_set(data.l_04_i_aerocomac_press_alt_f8(), model_data->l_04_i_aerocomac_press_alt_f8);
+		assign_value_set(data.l_04_i_aerocomac_tas_f8(), model_data->l_04_i_aerocomac_tas_f8);
+		assign_value_set(data.l_04_i_aerocomac_mach_f8(), model_data->l_04_i_aerocomac_mach_f8);
+		assign_value_set(data.l_04_i_aerocomac_nx_f8(), model_data->l_04_i_aerocomac_nx_f8);
+		assign_value_set(data.l_04_i_aerocomac_ny_f8(), model_data->l_04_i_aerocomac_ny_f8);
+		assign_value_set(data.l_04_i_aerocomac_nz_f8(), model_data->l_04_i_aerocomac_nz_f8);
+		assign_value_set(data.l_04_i_aerocomac_p_f8(), model_data->l_04_i_aerocomac_p_f8);
+		assign_value_set(data.l_04_i_aerocomac_q_f8(), model_data->l_04_i_aerocomac_q_f8);
+		assign_value_set(data.l_04_i_aerocomac_r_f8(), model_data->l_04_i_aerocomac_r_f8);
+		assign_value_set(data.l_04_i_aerocomac_qbar_f8(), model_data->l_04_i_aerocomac_qbar_f8);
+		assign_value_set(data.l_04_i_aerocomac_blcg_f8(), model_data->l_04_i_aerocomac_blcg_f8);
+		assign_value_set(data.l_04_i_aerocomac_bscg_f8(), model_data->l_04_i_aerocomac_bscg_f8);
+		assign_value_set(data.l_04_i_aerocomac_wlcg_f8(), model_data->l_04_i_aerocomac_wlcg_f8);
+		assign_value_set(data.l_04_i_aerocomac_ail_f8(), model_data->l_04_i_aerocomac_ail_f8);
+		assign_value_set(data.l_04_i_aerocomac_elv_f8(), model_data->l_04_i_aerocomac_elv_f8);
+		assign_value_set(data.l_04_i_aerocomac_rud_f8(), model_data->l_04_i_aerocomac_rud_f8);
+		assign_value_set(data.l_04_i_aerocomac_stab_f8(), model_data->l_04_i_aerocomac_stab_f8);
+		assign_value_set(data.l_04_i_aerocomac_gear_f8(), model_data->l_04_i_aerocomac_gear_f8);
+		assign_value_set(data.l_04_i_aerocomac_flap_f8(), model_data->l_04_i_aerocomac_flap_f8);
+		assign_value_set(data.l_04_i_aerocomac_slat_f8(), model_data->l_04_i_aerocomac_slat_f8);
+		assign_value_set(data.l_04_i_aerocomac_spl_f8(), model_data->l_04_i_aerocomac_spl_f8);
+		assign_value_set(data.l_04_i_aerocomac_tnet_f8(), model_data->l_04_i_aerocomac_tnet_f8);
+		assign_value_set(data.l_04_i_aerocomac_kice_f8(), model_data->l_04_i_aerocomac_kice_f8);
+		assign_value_set(data.l_04_i_aerocomac_alt_agl_f8(), model_data->l_04_i_aerocomac_alt_agl_f8);
+	}
+private:
+	XNSim::C909::ATA04::Aerodynamics_input data;
+	XNSim::C909::ATA04::Aerodynamics_input out_data;
+};
+}

Release/IDL/C909_V1/ATA04/Aerodynamics_output.cxx

@@ -0,0 +1,55 @@
+#include "Aerodynamics_output.hpp"
+namespace XNSim::C909::ATA04
+{
+Aerodynamics_output_Interface::Aerodynamics_output_Interface()
+{
+	MAP_DATA_FUNC(l_04_o_aerocomac_fxb_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_fyb_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_fzb_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_mxb_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_myb_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_mzb_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_cls_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_cl_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_cd_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_cm_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_cr_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_cy_f8);
+	MAP_DATA_FUNC(l_04_o_aerocomac_cn_f8);
+}
+Aerodynamics_output_Interface::~Aerodynamics_output_Interface()
+{
+}
+void Aerodynamics_output_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::Aerodynamics_outputPubSubType>("XNSim::C909::ATA04::Aerodynamics_output", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::Aerodynamics_outputPubSubType>("XNSim::C909::ATA04::Aerodynamics_output", modelId, std::bind(&Aerodynamics_output_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::Aerodynamics_outputPubSubType>("XNSim::C909::ATA04::Aerodynamics_output", modelId, std::bind(&Aerodynamics_output_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::Aerodynamics_outputPubSubType>("XNSim::C909::ATA04::Aerodynamics_output", modelId);
+	}
+}
+void Aerodynamics_output_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::Aerodynamics_output();
+}
+void Aerodynamics_output_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void Aerodynamics_output_Interface::inputDataListener(const XNSim::C909::ATA04::Aerodynamics_output &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/Aerodynamics_output.hpp

@@ -0,0 +1,60 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class Aerodynamics_output_Interface final : public XNDDSInterface
+{
+public:
+	Aerodynamics_output_Interface();
+	virtual ~Aerodynamics_output_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::Aerodynamics_output &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.l_04_o_aerocomac_fxb_f8(), model_data->l_04_o_aerocomac_fxb_f8);
+		assign_value_get(data.l_04_o_aerocomac_fyb_f8(), model_data->l_04_o_aerocomac_fyb_f8);
+		assign_value_get(data.l_04_o_aerocomac_fzb_f8(), model_data->l_04_o_aerocomac_fzb_f8);
+		assign_value_get(data.l_04_o_aerocomac_mxb_f8(), model_data->l_04_o_aerocomac_mxb_f8);
+		assign_value_get(data.l_04_o_aerocomac_myb_f8(), model_data->l_04_o_aerocomac_myb_f8);
+		assign_value_get(data.l_04_o_aerocomac_mzb_f8(), model_data->l_04_o_aerocomac_mzb_f8);
+		assign_value_get(data.l_04_o_aerocomac_cls_f8(), model_data->l_04_o_aerocomac_cls_f8);
+		assign_value_get(data.l_04_o_aerocomac_cl_f8(), model_data->l_04_o_aerocomac_cl_f8);
+		assign_value_get(data.l_04_o_aerocomac_cd_f8(), model_data->l_04_o_aerocomac_cd_f8);
+		assign_value_get(data.l_04_o_aerocomac_cm_f8(), model_data->l_04_o_aerocomac_cm_f8);
+		assign_value_get(data.l_04_o_aerocomac_cr_f8(), model_data->l_04_o_aerocomac_cr_f8);
+		assign_value_get(data.l_04_o_aerocomac_cy_f8(), model_data->l_04_o_aerocomac_cy_f8);
+		assign_value_get(data.l_04_o_aerocomac_cn_f8(), model_data->l_04_o_aerocomac_cn_f8);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.l_04_o_aerocomac_fxb_f8(), model_data->l_04_o_aerocomac_fxb_f8);
+		assign_value_set(data.l_04_o_aerocomac_fyb_f8(), model_data->l_04_o_aerocomac_fyb_f8);
+		assign_value_set(data.l_04_o_aerocomac_fzb_f8(), model_data->l_04_o_aerocomac_fzb_f8);
+		assign_value_set(data.l_04_o_aerocomac_mxb_f8(), model_data->l_04_o_aerocomac_mxb_f8);
+		assign_value_set(data.l_04_o_aerocomac_myb_f8(), model_data->l_04_o_aerocomac_myb_f8);
+		assign_value_set(data.l_04_o_aerocomac_mzb_f8(), model_data->l_04_o_aerocomac_mzb_f8);
+		assign_value_set(data.l_04_o_aerocomac_cls_f8(), model_data->l_04_o_aerocomac_cls_f8);
+		assign_value_set(data.l_04_o_aerocomac_cl_f8(), model_data->l_04_o_aerocomac_cl_f8);
+		assign_value_set(data.l_04_o_aerocomac_cd_f8(), model_data->l_04_o_aerocomac_cd_f8);
+		assign_value_set(data.l_04_o_aerocomac_cm_f8(), model_data->l_04_o_aerocomac_cm_f8);
+		assign_value_set(data.l_04_o_aerocomac_cr_f8(), model_data->l_04_o_aerocomac_cr_f8);
+		assign_value_set(data.l_04_o_aerocomac_cy_f8(), model_data->l_04_o_aerocomac_cy_f8);
+		assign_value_set(data.l_04_o_aerocomac_cn_f8(), model_data->l_04_o_aerocomac_cn_f8);
+	}
+private:
+	XNSim::C909::ATA04::Aerodynamics_output data;
+	XNSim::C909::ATA04::Aerodynamics_output out_data;
+};
+}

Release/IDL/C909_V1/ATA04/GroundHandling_heartbeat.cxx

@@ -0,0 +1,43 @@
+#include "GroundHandling_heartbeat.hpp"
+namespace XNSim::C909::ATA04
+{
+GroundHandling_heartbeat_Interface::GroundHandling_heartbeat_Interface()
+{
+	MAP_DATA_FUNC(groundhandling_model_heartbeat);
+}
+GroundHandling_heartbeat_Interface::~GroundHandling_heartbeat_Interface()
+{
+}
+void GroundHandling_heartbeat_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_heartbeatPubSubType>("XNSim::C909::ATA04::GroundHandling_heartbeat", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_heartbeatPubSubType>("XNSim::C909::ATA04::GroundHandling_heartbeat", modelId, std::bind(&GroundHandling_heartbeat_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_heartbeatPubSubType>("XNSim::C909::ATA04::GroundHandling_heartbeat", modelId, std::bind(&GroundHandling_heartbeat_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_heartbeatPubSubType>("XNSim::C909::ATA04::GroundHandling_heartbeat", modelId);
+	}
+}
+void GroundHandling_heartbeat_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::GroundHandling_heartbeat();
+}
+void GroundHandling_heartbeat_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void GroundHandling_heartbeat_Interface::inputDataListener(const XNSim::C909::ATA04::GroundHandling_heartbeat &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/GroundHandling_heartbeat.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class GroundHandling_heartbeat_Interface final : public XNDDSInterface
+{
+public:
+	GroundHandling_heartbeat_Interface();
+	virtual ~GroundHandling_heartbeat_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::GroundHandling_heartbeat &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.groundhandling_model_heartbeat(), model_data->groundhandling_model_heartbeat);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.groundhandling_model_heartbeat(), model_data->groundhandling_model_heartbeat);
+	}
+private:
+	XNSim::C909::ATA04::GroundHandling_heartbeat data;
+	XNSim::C909::ATA04::GroundHandling_heartbeat out_data;
+};
+}

Release/IDL/C909_V1/ATA04/GroundHandling_input.cxx

@@ -0,0 +1,81 @@
+#include "GroundHandling_input.hpp"
+namespace XNSim::C909::ATA04
+{
+GroundHandling_input_Interface::GroundHandling_input_Interface()
+{
+	MAP_DATA_FUNC(l_04_i_gdcomac_frz_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_chocks_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_alt_agl_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_frzflt_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_p_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_q_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_r_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_ug_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_vg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_wg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_blcg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_bscg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_wlcg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_pb_active_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_brake_torq_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_gear_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_gsteer_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_tire_pres_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_onjax_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_contdep_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_thetag_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_phig_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_rwyrgh_i2);
+	MAP_DATA_FUNC(l_04_i_gdcomac_rwyhdg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_reset_braketemp_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_reset_tirepress_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_temp_c_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_brake_temp_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_tire_tburst_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_tire_tflat_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_brk_reset_tpres_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_rcon_ci_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_pb_towforce_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_gsteer_state_i4);
+	MAP_DATA_FUNC(l_04_i_gdcomac_trim_active_l1);
+	MAP_DATA_FUNC(l_04_i_gdcomac_phi_deg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_theta_deg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_psi_deg_f8);
+	MAP_DATA_FUNC(l_04_i_gdcomac_resetint_l1);
+}
+GroundHandling_input_Interface::~GroundHandling_input_Interface()
+{
+}
+void GroundHandling_input_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_inputPubSubType>("XNSim::C909::ATA04::GroundHandling_input", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_inputPubSubType>("XNSim::C909::ATA04::GroundHandling_input", modelId, std::bind(&GroundHandling_input_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_inputPubSubType>("XNSim::C909::ATA04::GroundHandling_input", modelId, std::bind(&GroundHandling_input_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_inputPubSubType>("XNSim::C909::ATA04::GroundHandling_input", modelId);
+	}
+}
+void GroundHandling_input_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::GroundHandling_input();
+}
+void GroundHandling_input_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void GroundHandling_input_Interface::inputDataListener(const XNSim::C909::ATA04::GroundHandling_input &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/GroundHandling_input.hpp

@@ -0,0 +1,112 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class GroundHandling_input_Interface final : public XNDDSInterface
+{
+public:
+	GroundHandling_input_Interface();
+	virtual ~GroundHandling_input_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::GroundHandling_input &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.l_04_i_gdcomac_frz_l1(), model_data->l_04_i_gdcomac_frz_l1);
+		assign_value_get(data.l_04_i_gdcomac_chocks_l1(), model_data->l_04_i_gdcomac_chocks_l1);
+		assign_value_get(data.l_04_i_gdcomac_alt_agl_f8(), model_data->l_04_i_gdcomac_alt_agl_f8);
+		assign_value_get(data.l_04_i_gdcomac_frzflt_l1(), model_data->l_04_i_gdcomac_frzflt_l1);
+		assign_value_get(data.l_04_i_gdcomac_p_f8(), model_data->l_04_i_gdcomac_p_f8);
+		assign_value_get(data.l_04_i_gdcomac_q_f8(), model_data->l_04_i_gdcomac_q_f8);
+		assign_value_get(data.l_04_i_gdcomac_r_f8(), model_data->l_04_i_gdcomac_r_f8);
+		assign_value_get(data.l_04_i_gdcomac_ug_f8(), model_data->l_04_i_gdcomac_ug_f8);
+		assign_value_get(data.l_04_i_gdcomac_vg_f8(), model_data->l_04_i_gdcomac_vg_f8);
+		assign_value_get(data.l_04_i_gdcomac_wg_f8(), model_data->l_04_i_gdcomac_wg_f8);
+		assign_value_get(data.l_04_i_gdcomac_blcg_f8(), model_data->l_04_i_gdcomac_blcg_f8);
+		assign_value_get(data.l_04_i_gdcomac_bscg_f8(), model_data->l_04_i_gdcomac_bscg_f8);
+		assign_value_get(data.l_04_i_gdcomac_wlcg_f8(), model_data->l_04_i_gdcomac_wlcg_f8);
+		assign_value_get(data.l_04_i_gdcomac_pb_active_l1(), model_data->l_04_i_gdcomac_pb_active_l1);
+		assign_value_get(data.l_04_i_gdcomac_brake_torq_f8(), model_data->l_04_i_gdcomac_brake_torq_f8);
+		assign_value_get(data.l_04_i_gdcomac_gear_f8(), model_data->l_04_i_gdcomac_gear_f8);
+		assign_value_get(data.l_04_i_gdcomac_gsteer_f8(), model_data->l_04_i_gdcomac_gsteer_f8);
+		assign_value_get(data.l_04_i_gdcomac_tire_pres_f8(), model_data->l_04_i_gdcomac_tire_pres_f8);
+		assign_value_get(data.l_04_i_gdcomac_onjax_l1(), model_data->l_04_i_gdcomac_onjax_l1);
+		assign_value_get(data.l_04_i_gdcomac_contdep_f8(), model_data->l_04_i_gdcomac_contdep_f8);
+		assign_value_get(data.l_04_i_gdcomac_thetag_f8(), model_data->l_04_i_gdcomac_thetag_f8);
+		assign_value_get(data.l_04_i_gdcomac_phig_f8(), model_data->l_04_i_gdcomac_phig_f8);
+		assign_value_get(data.l_04_i_gdcomac_rwyrgh_i2(), model_data->l_04_i_gdcomac_rwyrgh_i2);
+		assign_value_get(data.l_04_i_gdcomac_rwyhdg_f8(), model_data->l_04_i_gdcomac_rwyhdg_f8);
+		assign_value_get(data.l_04_i_gdcomac_reset_braketemp_l1(), model_data->l_04_i_gdcomac_reset_braketemp_l1);
+		assign_value_get(data.l_04_i_gdcomac_reset_tirepress_l1(), model_data->l_04_i_gdcomac_reset_tirepress_l1);
+		assign_value_get(data.l_04_i_gdcomac_temp_c_f8(), model_data->l_04_i_gdcomac_temp_c_f8);
+		assign_value_get(data.l_04_i_gdcomac_brake_temp_f8(), model_data->l_04_i_gdcomac_brake_temp_f8);
+		assign_value_get(data.l_04_i_gdcomac_tire_tburst_l1(), model_data->l_04_i_gdcomac_tire_tburst_l1);
+		assign_value_get(data.l_04_i_gdcomac_tire_tflat_l1(), model_data->l_04_i_gdcomac_tire_tflat_l1);
+		assign_value_get(data.l_04_i_gdcomac_brk_reset_tpres_l1(), model_data->l_04_i_gdcomac_brk_reset_tpres_l1);
+		assign_value_get(data.l_04_i_gdcomac_rcon_ci_f8(), model_data->l_04_i_gdcomac_rcon_ci_f8);
+		assign_value_get(data.l_04_i_gdcomac_pb_towforce_f8(), model_data->l_04_i_gdcomac_pb_towforce_f8);
+		assign_value_get(data.l_04_i_gdcomac_gsteer_state_i4(), model_data->l_04_i_gdcomac_gsteer_state_i4);
+		assign_value_get(data.l_04_i_gdcomac_trim_active_l1(), model_data->l_04_i_gdcomac_trim_active_l1);
+		assign_value_get(data.l_04_i_gdcomac_phi_deg_f8(), model_data->l_04_i_gdcomac_phi_deg_f8);
+		assign_value_get(data.l_04_i_gdcomac_theta_deg_f8(), model_data->l_04_i_gdcomac_theta_deg_f8);
+		assign_value_get(data.l_04_i_gdcomac_psi_deg_f8(), model_data->l_04_i_gdcomac_psi_deg_f8);
+		assign_value_get(data.l_04_i_gdcomac_resetint_l1(), model_data->l_04_i_gdcomac_resetint_l1);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.l_04_i_gdcomac_frz_l1(), model_data->l_04_i_gdcomac_frz_l1);
+		assign_value_set(data.l_04_i_gdcomac_chocks_l1(), model_data->l_04_i_gdcomac_chocks_l1);
+		assign_value_set(data.l_04_i_gdcomac_alt_agl_f8(), model_data->l_04_i_gdcomac_alt_agl_f8);
+		assign_value_set(data.l_04_i_gdcomac_frzflt_l1(), model_data->l_04_i_gdcomac_frzflt_l1);
+		assign_value_set(data.l_04_i_gdcomac_p_f8(), model_data->l_04_i_gdcomac_p_f8);
+		assign_value_set(data.l_04_i_gdcomac_q_f8(), model_data->l_04_i_gdcomac_q_f8);
+		assign_value_set(data.l_04_i_gdcomac_r_f8(), model_data->l_04_i_gdcomac_r_f8);
+		assign_value_set(data.l_04_i_gdcomac_ug_f8(), model_data->l_04_i_gdcomac_ug_f8);
+		assign_value_set(data.l_04_i_gdcomac_vg_f8(), model_data->l_04_i_gdcomac_vg_f8);
+		assign_value_set(data.l_04_i_gdcomac_wg_f8(), model_data->l_04_i_gdcomac_wg_f8);
+		assign_value_set(data.l_04_i_gdcomac_blcg_f8(), model_data->l_04_i_gdcomac_blcg_f8);
+		assign_value_set(data.l_04_i_gdcomac_bscg_f8(), model_data->l_04_i_gdcomac_bscg_f8);
+		assign_value_set(data.l_04_i_gdcomac_wlcg_f8(), model_data->l_04_i_gdcomac_wlcg_f8);
+		assign_value_set(data.l_04_i_gdcomac_pb_active_l1(), model_data->l_04_i_gdcomac_pb_active_l1);
+		assign_value_set(data.l_04_i_gdcomac_brake_torq_f8(), model_data->l_04_i_gdcomac_brake_torq_f8);
+		assign_value_set(data.l_04_i_gdcomac_gear_f8(), model_data->l_04_i_gdcomac_gear_f8);
+		assign_value_set(data.l_04_i_gdcomac_gsteer_f8(), model_data->l_04_i_gdcomac_gsteer_f8);
+		assign_value_set(data.l_04_i_gdcomac_tire_pres_f8(), model_data->l_04_i_gdcomac_tire_pres_f8);
+		assign_value_set(data.l_04_i_gdcomac_onjax_l1(), model_data->l_04_i_gdcomac_onjax_l1);
+		assign_value_set(data.l_04_i_gdcomac_contdep_f8(), model_data->l_04_i_gdcomac_contdep_f8);
+		assign_value_set(data.l_04_i_gdcomac_thetag_f8(), model_data->l_04_i_gdcomac_thetag_f8);
+		assign_value_set(data.l_04_i_gdcomac_phig_f8(), model_data->l_04_i_gdcomac_phig_f8);
+		assign_value_set(data.l_04_i_gdcomac_rwyrgh_i2(), model_data->l_04_i_gdcomac_rwyrgh_i2);
+		assign_value_set(data.l_04_i_gdcomac_rwyhdg_f8(), model_data->l_04_i_gdcomac_rwyhdg_f8);
+		assign_value_set(data.l_04_i_gdcomac_reset_braketemp_l1(), model_data->l_04_i_gdcomac_reset_braketemp_l1);
+		assign_value_set(data.l_04_i_gdcomac_reset_tirepress_l1(), model_data->l_04_i_gdcomac_reset_tirepress_l1);
+		assign_value_set(data.l_04_i_gdcomac_temp_c_f8(), model_data->l_04_i_gdcomac_temp_c_f8);
+		assign_value_set(data.l_04_i_gdcomac_brake_temp_f8(), model_data->l_04_i_gdcomac_brake_temp_f8);
+		assign_value_set(data.l_04_i_gdcomac_tire_tburst_l1(), model_data->l_04_i_gdcomac_tire_tburst_l1);
+		assign_value_set(data.l_04_i_gdcomac_tire_tflat_l1(), model_data->l_04_i_gdcomac_tire_tflat_l1);
+		assign_value_set(data.l_04_i_gdcomac_brk_reset_tpres_l1(), model_data->l_04_i_gdcomac_brk_reset_tpres_l1);
+		assign_value_set(data.l_04_i_gdcomac_rcon_ci_f8(), model_data->l_04_i_gdcomac_rcon_ci_f8);
+		assign_value_set(data.l_04_i_gdcomac_pb_towforce_f8(), model_data->l_04_i_gdcomac_pb_towforce_f8);
+		assign_value_set(data.l_04_i_gdcomac_gsteer_state_i4(), model_data->l_04_i_gdcomac_gsteer_state_i4);
+		assign_value_set(data.l_04_i_gdcomac_trim_active_l1(), model_data->l_04_i_gdcomac_trim_active_l1);
+		assign_value_set(data.l_04_i_gdcomac_phi_deg_f8(), model_data->l_04_i_gdcomac_phi_deg_f8);
+		assign_value_set(data.l_04_i_gdcomac_theta_deg_f8(), model_data->l_04_i_gdcomac_theta_deg_f8);
+		assign_value_set(data.l_04_i_gdcomac_psi_deg_f8(), model_data->l_04_i_gdcomac_psi_deg_f8);
+		assign_value_set(data.l_04_i_gdcomac_resetint_l1(), model_data->l_04_i_gdcomac_resetint_l1);
+	}
+private:
+	XNSim::C909::ATA04::GroundHandling_input data;
+	XNSim::C909::ATA04::GroundHandling_input out_data;
+};
+}

Release/IDL/C909_V1/ATA04/GroundHandling_output.cxx

@@ -0,0 +1,76 @@
+#include "GroundHandling_output.hpp"
+namespace XNSim::C909::ATA04
+{
+GroundHandling_output_Interface::GroundHandling_output_Interface()
+{
+	MAP_DATA_FUNC(l_04_o_gdcomac_frz_l1);
+	MAP_DATA_FUNC(l_04_o_gdcomac_ac_on_ground_l1);
+	MAP_DATA_FUNC(l_04_o_gdcomac_ac_stationary_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_alt_tire_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_zcg_to_tire_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_fxb_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_fyb_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_fzb_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_mxb_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_myb_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_mzb_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_fygs_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_mzgs_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_mu_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_dstroke_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_sr_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_sy_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_sx_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_xft_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_yft_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_zft_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_distngrxcg_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_distmgrxcg_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_distmgrzcg_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_tire_vel_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_tire_burst_l1);
+	MAP_DATA_FUNC(l_04_o_gdcomac_tire_temp_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_wow_l1);
+	MAP_DATA_FUNC(l_04_o_gdcomac_utirew_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_vtirew_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_whl_omega_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_dstruc_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_wor_par_f8);
+	MAP_DATA_FUNC(l_04_o_gdcomac_nd_f8);
+}
+GroundHandling_output_Interface::~GroundHandling_output_Interface()
+{
+}
+void GroundHandling_output_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_outputPubSubType>("XNSim::C909::ATA04::GroundHandling_output", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_outputPubSubType>("XNSim::C909::ATA04::GroundHandling_output", modelId, std::bind(&GroundHandling_output_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_outputPubSubType>("XNSim::C909::ATA04::GroundHandling_output", modelId, std::bind(&GroundHandling_output_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_outputPubSubType>("XNSim::C909::ATA04::GroundHandling_output", modelId);
+	}
+}
+void GroundHandling_output_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::GroundHandling_output();
+}
+void GroundHandling_output_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void GroundHandling_output_Interface::inputDataListener(const XNSim::C909::ATA04::GroundHandling_output &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/GroundHandling_output.hpp

@@ -0,0 +1,102 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class GroundHandling_output_Interface final : public XNDDSInterface
+{
+public:
+	GroundHandling_output_Interface();
+	virtual ~GroundHandling_output_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::GroundHandling_output &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.l_04_o_gdcomac_frz_l1(), model_data->l_04_o_gdcomac_frz_l1);
+		assign_value_get(data.l_04_o_gdcomac_ac_on_ground_l1(), model_data->l_04_o_gdcomac_ac_on_ground_l1);
+		assign_value_get(data.l_04_o_gdcomac_ac_stationary_f8(), model_data->l_04_o_gdcomac_ac_stationary_f8);
+		assign_value_get(data.l_04_o_gdcomac_alt_tire_f8(), model_data->l_04_o_gdcomac_alt_tire_f8);
+		assign_value_get(data.l_04_o_gdcomac_zcg_to_tire_f8(), model_data->l_04_o_gdcomac_zcg_to_tire_f8);
+		assign_value_get(data.l_04_o_gdcomac_fxb_f8(), model_data->l_04_o_gdcomac_fxb_f8);
+		assign_value_get(data.l_04_o_gdcomac_fyb_f8(), model_data->l_04_o_gdcomac_fyb_f8);
+		assign_value_get(data.l_04_o_gdcomac_fzb_f8(), model_data->l_04_o_gdcomac_fzb_f8);
+		assign_value_get(data.l_04_o_gdcomac_mxb_f8(), model_data->l_04_o_gdcomac_mxb_f8);
+		assign_value_get(data.l_04_o_gdcomac_myb_f8(), model_data->l_04_o_gdcomac_myb_f8);
+		assign_value_get(data.l_04_o_gdcomac_mzb_f8(), model_data->l_04_o_gdcomac_mzb_f8);
+		assign_value_get(data.l_04_o_gdcomac_fygs_f8(), model_data->l_04_o_gdcomac_fygs_f8);
+		assign_value_get(data.l_04_o_gdcomac_mzgs_f8(), model_data->l_04_o_gdcomac_mzgs_f8);
+		assign_value_get(data.l_04_o_gdcomac_mu_f8(), model_data->l_04_o_gdcomac_mu_f8);
+		assign_value_get(data.l_04_o_gdcomac_dstroke_f8(), model_data->l_04_o_gdcomac_dstroke_f8);
+		assign_value_get(data.l_04_o_gdcomac_sr_f8(), model_data->l_04_o_gdcomac_sr_f8);
+		assign_value_get(data.l_04_o_gdcomac_sy_f8(), model_data->l_04_o_gdcomac_sy_f8);
+		assign_value_get(data.l_04_o_gdcomac_sx_f8(), model_data->l_04_o_gdcomac_sx_f8);
+		assign_value_get(data.l_04_o_gdcomac_xft_f8(), model_data->l_04_o_gdcomac_xft_f8);
+		assign_value_get(data.l_04_o_gdcomac_yft_f8(), model_data->l_04_o_gdcomac_yft_f8);
+		assign_value_get(data.l_04_o_gdcomac_zft_f8(), model_data->l_04_o_gdcomac_zft_f8);
+		assign_value_get(data.l_04_o_gdcomac_distngrxcg_f8(), model_data->l_04_o_gdcomac_distngrxcg_f8);
+		assign_value_get(data.l_04_o_gdcomac_distmgrxcg_f8(), model_data->l_04_o_gdcomac_distmgrxcg_f8);
+		assign_value_get(data.l_04_o_gdcomac_distmgrzcg_f8(), model_data->l_04_o_gdcomac_distmgrzcg_f8);
+		assign_value_get(data.l_04_o_gdcomac_tire_vel_f8(), model_data->l_04_o_gdcomac_tire_vel_f8);
+		assign_value_get(data.l_04_o_gdcomac_tire_burst_l1(), model_data->l_04_o_gdcomac_tire_burst_l1);
+		assign_value_get(data.l_04_o_gdcomac_tire_temp_f8(), model_data->l_04_o_gdcomac_tire_temp_f8);
+		assign_value_get(data.l_04_o_gdcomac_wow_l1(), model_data->l_04_o_gdcomac_wow_l1);
+		assign_value_get(data.l_04_o_gdcomac_utirew_f8(), model_data->l_04_o_gdcomac_utirew_f8);
+		assign_value_get(data.l_04_o_gdcomac_vtirew_f8(), model_data->l_04_o_gdcomac_vtirew_f8);
+		assign_value_get(data.l_04_o_gdcomac_whl_omega_f8(), model_data->l_04_o_gdcomac_whl_omega_f8);
+		assign_value_get(data.l_04_o_gdcomac_dstruc_f8(), model_data->l_04_o_gdcomac_dstruc_f8);
+		assign_value_get(data.l_04_o_gdcomac_wor_par_f8(), model_data->l_04_o_gdcomac_wor_par_f8);
+		assign_value_get(data.l_04_o_gdcomac_nd_f8(), model_data->l_04_o_gdcomac_nd_f8);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.l_04_o_gdcomac_frz_l1(), model_data->l_04_o_gdcomac_frz_l1);
+		assign_value_set(data.l_04_o_gdcomac_ac_on_ground_l1(), model_data->l_04_o_gdcomac_ac_on_ground_l1);
+		assign_value_set(data.l_04_o_gdcomac_ac_stationary_f8(), model_data->l_04_o_gdcomac_ac_stationary_f8);
+		assign_value_set(data.l_04_o_gdcomac_alt_tire_f8(), model_data->l_04_o_gdcomac_alt_tire_f8);
+		assign_value_set(data.l_04_o_gdcomac_zcg_to_tire_f8(), model_data->l_04_o_gdcomac_zcg_to_tire_f8);
+		assign_value_set(data.l_04_o_gdcomac_fxb_f8(), model_data->l_04_o_gdcomac_fxb_f8);
+		assign_value_set(data.l_04_o_gdcomac_fyb_f8(), model_data->l_04_o_gdcomac_fyb_f8);
+		assign_value_set(data.l_04_o_gdcomac_fzb_f8(), model_data->l_04_o_gdcomac_fzb_f8);
+		assign_value_set(data.l_04_o_gdcomac_mxb_f8(), model_data->l_04_o_gdcomac_mxb_f8);
+		assign_value_set(data.l_04_o_gdcomac_myb_f8(), model_data->l_04_o_gdcomac_myb_f8);
+		assign_value_set(data.l_04_o_gdcomac_mzb_f8(), model_data->l_04_o_gdcomac_mzb_f8);
+		assign_value_set(data.l_04_o_gdcomac_fygs_f8(), model_data->l_04_o_gdcomac_fygs_f8);
+		assign_value_set(data.l_04_o_gdcomac_mzgs_f8(), model_data->l_04_o_gdcomac_mzgs_f8);
+		assign_value_set(data.l_04_o_gdcomac_mu_f8(), model_data->l_04_o_gdcomac_mu_f8);
+		assign_value_set(data.l_04_o_gdcomac_dstroke_f8(), model_data->l_04_o_gdcomac_dstroke_f8);
+		assign_value_set(data.l_04_o_gdcomac_sr_f8(), model_data->l_04_o_gdcomac_sr_f8);
+		assign_value_set(data.l_04_o_gdcomac_sy_f8(), model_data->l_04_o_gdcomac_sy_f8);
+		assign_value_set(data.l_04_o_gdcomac_sx_f8(), model_data->l_04_o_gdcomac_sx_f8);
+		assign_value_set(data.l_04_o_gdcomac_xft_f8(), model_data->l_04_o_gdcomac_xft_f8);
+		assign_value_set(data.l_04_o_gdcomac_yft_f8(), model_data->l_04_o_gdcomac_yft_f8);
+		assign_value_set(data.l_04_o_gdcomac_zft_f8(), model_data->l_04_o_gdcomac_zft_f8);
+		assign_value_set(data.l_04_o_gdcomac_distngrxcg_f8(), model_data->l_04_o_gdcomac_distngrxcg_f8);
+		assign_value_set(data.l_04_o_gdcomac_distmgrxcg_f8(), model_data->l_04_o_gdcomac_distmgrxcg_f8);
+		assign_value_set(data.l_04_o_gdcomac_distmgrzcg_f8(), model_data->l_04_o_gdcomac_distmgrzcg_f8);
+		assign_value_set(data.l_04_o_gdcomac_tire_vel_f8(), model_data->l_04_o_gdcomac_tire_vel_f8);
+		assign_value_set(data.l_04_o_gdcomac_tire_burst_l1(), model_data->l_04_o_gdcomac_tire_burst_l1);
+		assign_value_set(data.l_04_o_gdcomac_tire_temp_f8(), model_data->l_04_o_gdcomac_tire_temp_f8);
+		assign_value_set(data.l_04_o_gdcomac_wow_l1(), model_data->l_04_o_gdcomac_wow_l1);
+		assign_value_set(data.l_04_o_gdcomac_utirew_f8(), model_data->l_04_o_gdcomac_utirew_f8);
+		assign_value_set(data.l_04_o_gdcomac_vtirew_f8(), model_data->l_04_o_gdcomac_vtirew_f8);
+		assign_value_set(data.l_04_o_gdcomac_whl_omega_f8(), model_data->l_04_o_gdcomac_whl_omega_f8);
+		assign_value_set(data.l_04_o_gdcomac_dstruc_f8(), model_data->l_04_o_gdcomac_dstruc_f8);
+		assign_value_set(data.l_04_o_gdcomac_wor_par_f8(), model_data->l_04_o_gdcomac_wor_par_f8);
+		assign_value_set(data.l_04_o_gdcomac_nd_f8(), model_data->l_04_o_gdcomac_nd_f8);
+	}
+private:
+	XNSim::C909::ATA04::GroundHandling_output data;
+	XNSim::C909::ATA04::GroundHandling_output out_data;
+};
+}

Release/IDL/C909_V1/ATA04/WeightBalance_heartbeat.cxx

@@ -0,0 +1,43 @@
+#include "WeightBalance_heartbeat.hpp"
+namespace XNSim::C909::ATA04
+{
+WeightBalance_heartbeat_Interface::WeightBalance_heartbeat_Interface()
+{
+	MAP_DATA_FUNC(weightbody_model_heartbeat);
+}
+WeightBalance_heartbeat_Interface::~WeightBalance_heartbeat_Interface()
+{
+}
+void WeightBalance_heartbeat_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::WeightBalance_heartbeatPubSubType>("XNSim::C909::ATA04::WeightBalance_heartbeat", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::WeightBalance_heartbeatPubSubType>("XNSim::C909::ATA04::WeightBalance_heartbeat", modelId, std::bind(&WeightBalance_heartbeat_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::WeightBalance_heartbeatPubSubType>("XNSim::C909::ATA04::WeightBalance_heartbeat", modelId, std::bind(&WeightBalance_heartbeat_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::WeightBalance_heartbeatPubSubType>("XNSim::C909::ATA04::WeightBalance_heartbeat", modelId);
+	}
+}
+void WeightBalance_heartbeat_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::WeightBalance_heartbeat();
+}
+void WeightBalance_heartbeat_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void WeightBalance_heartbeat_Interface::inputDataListener(const XNSim::C909::ATA04::WeightBalance_heartbeat &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/WeightBalance_heartbeat.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class WeightBalance_heartbeat_Interface final : public XNDDSInterface
+{
+public:
+	WeightBalance_heartbeat_Interface();
+	virtual ~WeightBalance_heartbeat_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::WeightBalance_heartbeat &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.weightbody_model_heartbeat(), model_data->weightbody_model_heartbeat);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.weightbody_model_heartbeat(), model_data->weightbody_model_heartbeat);
+	}
+private:
+	XNSim::C909::ATA04::WeightBalance_heartbeat data;
+	XNSim::C909::ATA04::WeightBalance_heartbeat out_data;
+};
+}

Release/IDL/C909_V1/ATA04/WeightBalance_input.cxx

@@ -0,0 +1,65 @@
+#include "WeightBalance_input.hpp"
+namespace XNSim::C909::ATA04
+{
+WeightBalance_input_Interface::WeightBalance_input_Interface()
+{
+	MAP_DATA_FUNC(l_04_i_wbcomac_theta_deg_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_gear_mode_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_acset_gw_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_acset_cg_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_acset_tankfuel_f4);
+	MAP_DATA_FUNC(l_04_i_wbcomac_acset_totfuel_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_acset_zfw_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_acset_zfwcg_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_eng_efsep_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_fuel_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_gear_avg_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_kice_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_bycglim_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_bygwlim_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_frz_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_zcgfrz_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_zcgfrz_grfx_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_ycgfrz_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_inertfrz_l1);
+	MAP_DATA_FUNC(l_04_i_wbcomac_potreq_gw_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_potreq_gwcg_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_phi_deg_f8);
+	MAP_DATA_FUNC(l_04_i_wbcomac_psi_deg_f8);
+}
+WeightBalance_input_Interface::~WeightBalance_input_Interface()
+{
+}
+void WeightBalance_input_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::WeightBalance_inputPubSubType>("XNSim::C909::ATA04::WeightBalance_input", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::WeightBalance_inputPubSubType>("XNSim::C909::ATA04::WeightBalance_input", modelId, std::bind(&WeightBalance_input_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::WeightBalance_inputPubSubType>("XNSim::C909::ATA04::WeightBalance_input", modelId, std::bind(&WeightBalance_input_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::WeightBalance_inputPubSubType>("XNSim::C909::ATA04::WeightBalance_input", modelId);
+	}
+}
+void WeightBalance_input_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::WeightBalance_input();
+}
+void WeightBalance_input_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void WeightBalance_input_Interface::inputDataListener(const XNSim::C909::ATA04::WeightBalance_input &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/WeightBalance_input.hpp

@@ -0,0 +1,80 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class WeightBalance_input_Interface final : public XNDDSInterface
+{
+public:
+	WeightBalance_input_Interface();
+	virtual ~WeightBalance_input_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::WeightBalance_input &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.l_04_i_wbcomac_theta_deg_f8(), model_data->l_04_i_wbcomac_theta_deg_f8);
+		assign_value_get(data.l_04_i_wbcomac_gear_mode_l1(), model_data->l_04_i_wbcomac_gear_mode_l1);
+		assign_value_get(data.l_04_i_wbcomac_acset_gw_f8(), model_data->l_04_i_wbcomac_acset_gw_f8);
+		assign_value_get(data.l_04_i_wbcomac_acset_cg_f8(), model_data->l_04_i_wbcomac_acset_cg_f8);
+		assign_value_get(data.l_04_i_wbcomac_acset_tankfuel_f4(), model_data->l_04_i_wbcomac_acset_tankfuel_f4);
+		assign_value_get(data.l_04_i_wbcomac_acset_totfuel_f8(), model_data->l_04_i_wbcomac_acset_totfuel_f8);
+		assign_value_get(data.l_04_i_wbcomac_acset_zfw_f8(), model_data->l_04_i_wbcomac_acset_zfw_f8);
+		assign_value_get(data.l_04_i_wbcomac_acset_zfwcg_f8(), model_data->l_04_i_wbcomac_acset_zfwcg_f8);
+		assign_value_get(data.l_04_i_wbcomac_eng_efsep_l1(), model_data->l_04_i_wbcomac_eng_efsep_l1);
+		assign_value_get(data.l_04_i_wbcomac_fuel_f8(), model_data->l_04_i_wbcomac_fuel_f8);
+		assign_value_get(data.l_04_i_wbcomac_gear_avg_f8(), model_data->l_04_i_wbcomac_gear_avg_f8);
+		assign_value_get(data.l_04_i_wbcomac_kice_f8(), model_data->l_04_i_wbcomac_kice_f8);
+		assign_value_get(data.l_04_i_wbcomac_bycglim_l1(), model_data->l_04_i_wbcomac_bycglim_l1);
+		assign_value_get(data.l_04_i_wbcomac_bygwlim_l1(), model_data->l_04_i_wbcomac_bygwlim_l1);
+		assign_value_get(data.l_04_i_wbcomac_frz_l1(), model_data->l_04_i_wbcomac_frz_l1);
+		assign_value_get(data.l_04_i_wbcomac_zcgfrz_l1(), model_data->l_04_i_wbcomac_zcgfrz_l1);
+		assign_value_get(data.l_04_i_wbcomac_zcgfrz_grfx_l1(), model_data->l_04_i_wbcomac_zcgfrz_grfx_l1);
+		assign_value_get(data.l_04_i_wbcomac_ycgfrz_l1(), model_data->l_04_i_wbcomac_ycgfrz_l1);
+		assign_value_get(data.l_04_i_wbcomac_inertfrz_l1(), model_data->l_04_i_wbcomac_inertfrz_l1);
+		assign_value_get(data.l_04_i_wbcomac_potreq_gw_f8(), model_data->l_04_i_wbcomac_potreq_gw_f8);
+		assign_value_get(data.l_04_i_wbcomac_potreq_gwcg_f8(), model_data->l_04_i_wbcomac_potreq_gwcg_f8);
+		assign_value_get(data.l_04_i_wbcomac_phi_deg_f8(), model_data->l_04_i_wbcomac_phi_deg_f8);
+		assign_value_get(data.l_04_i_wbcomac_psi_deg_f8(), model_data->l_04_i_wbcomac_psi_deg_f8);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.l_04_i_wbcomac_theta_deg_f8(), model_data->l_04_i_wbcomac_theta_deg_f8);
+		assign_value_set(data.l_04_i_wbcomac_gear_mode_l1(), model_data->l_04_i_wbcomac_gear_mode_l1);
+		assign_value_set(data.l_04_i_wbcomac_acset_gw_f8(), model_data->l_04_i_wbcomac_acset_gw_f8);
+		assign_value_set(data.l_04_i_wbcomac_acset_cg_f8(), model_data->l_04_i_wbcomac_acset_cg_f8);
+		assign_value_set(data.l_04_i_wbcomac_acset_tankfuel_f4(), model_data->l_04_i_wbcomac_acset_tankfuel_f4);
+		assign_value_set(data.l_04_i_wbcomac_acset_totfuel_f8(), model_data->l_04_i_wbcomac_acset_totfuel_f8);
+		assign_value_set(data.l_04_i_wbcomac_acset_zfw_f8(), model_data->l_04_i_wbcomac_acset_zfw_f8);
+		assign_value_set(data.l_04_i_wbcomac_acset_zfwcg_f8(), model_data->l_04_i_wbcomac_acset_zfwcg_f8);
+		assign_value_set(data.l_04_i_wbcomac_eng_efsep_l1(), model_data->l_04_i_wbcomac_eng_efsep_l1);
+		assign_value_set(data.l_04_i_wbcomac_fuel_f8(), model_data->l_04_i_wbcomac_fuel_f8);
+		assign_value_set(data.l_04_i_wbcomac_gear_avg_f8(), model_data->l_04_i_wbcomac_gear_avg_f8);
+		assign_value_set(data.l_04_i_wbcomac_kice_f8(), model_data->l_04_i_wbcomac_kice_f8);
+		assign_value_set(data.l_04_i_wbcomac_bycglim_l1(), model_data->l_04_i_wbcomac_bycglim_l1);
+		assign_value_set(data.l_04_i_wbcomac_bygwlim_l1(), model_data->l_04_i_wbcomac_bygwlim_l1);
+		assign_value_set(data.l_04_i_wbcomac_frz_l1(), model_data->l_04_i_wbcomac_frz_l1);
+		assign_value_set(data.l_04_i_wbcomac_zcgfrz_l1(), model_data->l_04_i_wbcomac_zcgfrz_l1);
+		assign_value_set(data.l_04_i_wbcomac_zcgfrz_grfx_l1(), model_data->l_04_i_wbcomac_zcgfrz_grfx_l1);
+		assign_value_set(data.l_04_i_wbcomac_ycgfrz_l1(), model_data->l_04_i_wbcomac_ycgfrz_l1);
+		assign_value_set(data.l_04_i_wbcomac_inertfrz_l1(), model_data->l_04_i_wbcomac_inertfrz_l1);
+		assign_value_set(data.l_04_i_wbcomac_potreq_gw_f8(), model_data->l_04_i_wbcomac_potreq_gw_f8);
+		assign_value_set(data.l_04_i_wbcomac_potreq_gwcg_f8(), model_data->l_04_i_wbcomac_potreq_gwcg_f8);
+		assign_value_set(data.l_04_i_wbcomac_phi_deg_f8(), model_data->l_04_i_wbcomac_phi_deg_f8);
+		assign_value_set(data.l_04_i_wbcomac_psi_deg_f8(), model_data->l_04_i_wbcomac_psi_deg_f8);
+	}
+private:
+	XNSim::C909::ATA04::WeightBalance_input data;
+	XNSim::C909::ATA04::WeightBalance_input out_data;
+};
+}

Release/IDL/C909_V1/ATA04/WeightBalance_output.cxx

@@ -0,0 +1,98 @@
+#include "WeightBalance_output.hpp"
+namespace XNSim::C909::ATA04
+{
+WeightBalance_output_Interface::WeightBalance_output_Interface()
+{
+	MAP_DATA_FUNC(l_04_o_wbcomac_frz_l1);
+	MAP_DATA_FUNC(l_04_o_wbcomac_zcgfrz_l1);
+	MAP_DATA_FUNC(l_04_o_wbcomac_zcgfrz_grfx_l1);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ycgfrz_l1);
+	MAP_DATA_FUNC(l_04_o_wbcomac_inertfrz_l1);
+	MAP_DATA_FUNC(l_04_o_wbcomac_gw_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_cg_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_blcg_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_bscg_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_wlcg_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_xcg_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ixx_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ixy_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ixz_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_iyy_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_iyz_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_izz_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_zfw_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_zfwcg_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_zfw_blcg_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_zfw_wlcg_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_fuel_cmd_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_fuel_mode_i4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_fuel_ixx_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_fuel_ixy_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_fuel_ixz_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_fuel_iyy_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_fuel_iyz_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_fuel_izz_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_l_wt_fuel_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_airframe_total_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_eng_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_eng_total_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_fuselage_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_stab_left_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_stab_right_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_stab_total_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_total_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_total_frac_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_vert_tail_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_wing_left_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_wing_right_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_ice_wing_total_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_init_l1);
+	MAP_DATA_FUNC(l_04_o_wbcomac_potmin_gw_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_potmax_gw_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_potmin_gwcg_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_potmax_gwcg_f8);
+	MAP_DATA_FUNC(l_04_o_wbcomac_min_cg_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_min_gw_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_min_zfw_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_min_zfwcg_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_max_cg_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_max_gw_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_max_zfw_f4);
+	MAP_DATA_FUNC(l_04_o_wbcomac_max_zfwcg_f4);
+}
+WeightBalance_output_Interface::~WeightBalance_output_Interface()
+{
+}
+void WeightBalance_output_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
+{
+	auto ddsManager = framework->GetDDSManager();
+	if (!ddsManager) {
+		LOG_ERROR("DDSManager is nullptr");
+		return;
+	}
+	if (DDS_type == 0) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::WeightBalance_outputPubSubType>("XNSim::C909::ATA04::WeightBalance_output", modelId);
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::WeightBalance_outputPubSubType>("XNSim::C909::ATA04::WeightBalance_output", modelId, std::bind(&WeightBalance_output_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 1) {
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::WeightBalance_outputPubSubType>("XNSim::C909::ATA04::WeightBalance_output", modelId, std::bind(&WeightBalance_output_Interface::inputDataListener, this, std::placeholders::_1));
+	}
+	else if (DDS_type == 2) {
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::WeightBalance_outputPubSubType>("XNSim::C909::ATA04::WeightBalance_output", modelId);
+	}
+}
+void WeightBalance_output_Interface::clearOutData()
+{
+	this->out_data = XNSim::C909::ATA04::WeightBalance_output();
+}
+void WeightBalance_output_Interface::sendOutData()
+{
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
+}
+void WeightBalance_output_Interface::inputDataListener(const XNSim::C909::ATA04::WeightBalance_output &input)
+{
+	this->data = input;
+}
+}

Release/IDL/C909_V1/ATA04/WeightBalance_output.hpp

@@ -0,0 +1,146 @@
+#pragma once
+#include "../C909_V1PubSubTypes.hpp"
+#include "XNCore/XNDDSInterface.h"
+namespace XNSim::C909::ATA04
+{
+class WeightBalance_output_Interface final : public XNDDSInterface
+{
+public:
+	WeightBalance_output_Interface();
+	virtual ~WeightBalance_output_Interface();
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
+	virtual void clearOutData() override;
+	virtual void sendOutData() override;
+	void inputDataListener(const XNSim::C909::ATA04::WeightBalance_output &input);
+	template <typename T>
+	void getData(T *model_data)
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		if(model_data == nullptr)
+			return;
+		assign_value_get(data.l_04_o_wbcomac_frz_l1(), model_data->l_04_o_wbcomac_frz_l1);
+		assign_value_get(data.l_04_o_wbcomac_zcgfrz_l1(), model_data->l_04_o_wbcomac_zcgfrz_l1);
+		assign_value_get(data.l_04_o_wbcomac_zcgfrz_grfx_l1(), model_data->l_04_o_wbcomac_zcgfrz_grfx_l1);
+		assign_value_get(data.l_04_o_wbcomac_ycgfrz_l1(), model_data->l_04_o_wbcomac_ycgfrz_l1);
+		assign_value_get(data.l_04_o_wbcomac_inertfrz_l1(), model_data->l_04_o_wbcomac_inertfrz_l1);
+		assign_value_get(data.l_04_o_wbcomac_gw_f4(), model_data->l_04_o_wbcomac_gw_f4);
+		assign_value_get(data.l_04_o_wbcomac_cg_f4(), model_data->l_04_o_wbcomac_cg_f4);
+		assign_value_get(data.l_04_o_wbcomac_blcg_f8(), model_data->l_04_o_wbcomac_blcg_f8);
+		assign_value_get(data.l_04_o_wbcomac_bscg_f8(), model_data->l_04_o_wbcomac_bscg_f8);
+		assign_value_get(data.l_04_o_wbcomac_wlcg_f8(), model_data->l_04_o_wbcomac_wlcg_f8);
+		assign_value_get(data.l_04_o_wbcomac_xcg_f8(), model_data->l_04_o_wbcomac_xcg_f8);
+		assign_value_get(data.l_04_o_wbcomac_ixx_f8(), model_data->l_04_o_wbcomac_ixx_f8);
+		assign_value_get(data.l_04_o_wbcomac_ixy_f8(), model_data->l_04_o_wbcomac_ixy_f8);
+		assign_value_get(data.l_04_o_wbcomac_ixz_f8(), model_data->l_04_o_wbcomac_ixz_f8);
+		assign_value_get(data.l_04_o_wbcomac_iyy_f8(), model_data->l_04_o_wbcomac_iyy_f8);
+		assign_value_get(data.l_04_o_wbcomac_iyz_f8(), model_data->l_04_o_wbcomac_iyz_f8);
+		assign_value_get(data.l_04_o_wbcomac_izz_f8(), model_data->l_04_o_wbcomac_izz_f8);
+		assign_value_get(data.l_04_o_wbcomac_zfw_f4(), model_data->l_04_o_wbcomac_zfw_f4);
+		assign_value_get(data.l_04_o_wbcomac_zfwcg_f4(), model_data->l_04_o_wbcomac_zfwcg_f4);
+		assign_value_get(data.l_04_o_wbcomac_zfw_blcg_f4(), model_data->l_04_o_wbcomac_zfw_blcg_f4);
+		assign_value_get(data.l_04_o_wbcomac_zfw_wlcg_f4(), model_data->l_04_o_wbcomac_zfw_wlcg_f4);
+		assign_value_get(data.l_04_o_wbcomac_fuel_cmd_f8(), model_data->l_04_o_wbcomac_fuel_cmd_f8);
+		assign_value_get(data.l_04_o_wbcomac_fuel_mode_i4(), model_data->l_04_o_wbcomac_fuel_mode_i4);
+		assign_value_get(data.l_04_o_wbcomac_fuel_ixx_f8(), model_data->l_04_o_wbcomac_fuel_ixx_f8);
+		assign_value_get(data.l_04_o_wbcomac_fuel_ixy_f8(), model_data->l_04_o_wbcomac_fuel_ixy_f8);
+		assign_value_get(data.l_04_o_wbcomac_fuel_ixz_f8(), model_data->l_04_o_wbcomac_fuel_ixz_f8);
+		assign_value_get(data.l_04_o_wbcomac_fuel_iyy_f8(), model_data->l_04_o_wbcomac_fuel_iyy_f8);
+		assign_value_get(data.l_04_o_wbcomac_fuel_iyz_f8(), model_data->l_04_o_wbcomac_fuel_iyz_f8);
+		assign_value_get(data.l_04_o_wbcomac_fuel_izz_f8(), model_data->l_04_o_wbcomac_fuel_izz_f8);
+		assign_value_get(data.l_04_o_wbcomac_l_wt_fuel_f8(), model_data->l_04_o_wbcomac_l_wt_fuel_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_airframe_total_f8(), model_data->l_04_o_wbcomac_ice_airframe_total_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_eng_f8(), model_data->l_04_o_wbcomac_ice_eng_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_eng_total_f8(), model_data->l_04_o_wbcomac_ice_eng_total_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_fuselage_f8(), model_data->l_04_o_wbcomac_ice_fuselage_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_stab_left_f8(), model_data->l_04_o_wbcomac_ice_stab_left_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_stab_right_f8(), model_data->l_04_o_wbcomac_ice_stab_right_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_stab_total_f8(), model_data->l_04_o_wbcomac_ice_stab_total_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_total_f8(), model_data->l_04_o_wbcomac_ice_total_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_total_frac_f8(), model_data->l_04_o_wbcomac_ice_total_frac_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_vert_tail_f8(), model_data->l_04_o_wbcomac_ice_vert_tail_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_wing_left_f8(), model_data->l_04_o_wbcomac_ice_wing_left_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_wing_right_f8(), model_data->l_04_o_wbcomac_ice_wing_right_f8);
+		assign_value_get(data.l_04_o_wbcomac_ice_wing_total_f8(), model_data->l_04_o_wbcomac_ice_wing_total_f8);
+		assign_value_get(data.l_04_o_wbcomac_init_l1(), model_data->l_04_o_wbcomac_init_l1);
+		assign_value_get(data.l_04_o_wbcomac_potmin_gw_f8(), model_data->l_04_o_wbcomac_potmin_gw_f8);
+		assign_value_get(data.l_04_o_wbcomac_potmax_gw_f8(), model_data->l_04_o_wbcomac_potmax_gw_f8);
+		assign_value_get(data.l_04_o_wbcomac_potmin_gwcg_f8(), model_data->l_04_o_wbcomac_potmin_gwcg_f8);
+		assign_value_get(data.l_04_o_wbcomac_potmax_gwcg_f8(), model_data->l_04_o_wbcomac_potmax_gwcg_f8);
+		assign_value_get(data.l_04_o_wbcomac_min_cg_f4(), model_data->l_04_o_wbcomac_min_cg_f4);
+		assign_value_get(data.l_04_o_wbcomac_min_gw_f4(), model_data->l_04_o_wbcomac_min_gw_f4);
+		assign_value_get(data.l_04_o_wbcomac_min_zfw_f4(), model_data->l_04_o_wbcomac_min_zfw_f4);
+		assign_value_get(data.l_04_o_wbcomac_min_zfwcg_f4(), model_data->l_04_o_wbcomac_min_zfwcg_f4);
+		assign_value_get(data.l_04_o_wbcomac_max_cg_f4(), model_data->l_04_o_wbcomac_max_cg_f4);
+		assign_value_get(data.l_04_o_wbcomac_max_gw_f4(), model_data->l_04_o_wbcomac_max_gw_f4);
+		assign_value_get(data.l_04_o_wbcomac_max_zfw_f4(), model_data->l_04_o_wbcomac_max_zfw_f4);
+		assign_value_get(data.l_04_o_wbcomac_max_zfwcg_f4(), model_data->l_04_o_wbcomac_max_zfwcg_f4);
+	}
+	template <typename T>
+	void setData(T *model_data)
+	{
+		if(model_data == nullptr)
+			return;
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		assign_value_set(data.l_04_o_wbcomac_frz_l1(), model_data->l_04_o_wbcomac_frz_l1);
+		assign_value_set(data.l_04_o_wbcomac_zcgfrz_l1(), model_data->l_04_o_wbcomac_zcgfrz_l1);
+		assign_value_set(data.l_04_o_wbcomac_zcgfrz_grfx_l1(), model_data->l_04_o_wbcomac_zcgfrz_grfx_l1);
+		assign_value_set(data.l_04_o_wbcomac_ycgfrz_l1(), model_data->l_04_o_wbcomac_ycgfrz_l1);
+		assign_value_set(data.l_04_o_wbcomac_inertfrz_l1(), model_data->l_04_o_wbcomac_inertfrz_l1);
+		assign_value_set(data.l_04_o_wbcomac_gw_f4(), model_data->l_04_o_wbcomac_gw_f4);
+		assign_value_set(data.l_04_o_wbcomac_cg_f4(), model_data->l_04_o_wbcomac_cg_f4);
+		assign_value_set(data.l_04_o_wbcomac_blcg_f8(), model_data->l_04_o_wbcomac_blcg_f8);
+		assign_value_set(data.l_04_o_wbcomac_bscg_f8(), model_data->l_04_o_wbcomac_bscg_f8);
+		assign_value_set(data.l_04_o_wbcomac_wlcg_f8(), model_data->l_04_o_wbcomac_wlcg_f8);
+		assign_value_set(data.l_04_o_wbcomac_xcg_f8(), model_data->l_04_o_wbcomac_xcg_f8);
+		assign_value_set(data.l_04_o_wbcomac_ixx_f8(), model_data->l_04_o_wbcomac_ixx_f8);
+		assign_value_set(data.l_04_o_wbcomac_ixy_f8(), model_data->l_04_o_wbcomac_ixy_f8);
+		assign_value_set(data.l_04_o_wbcomac_ixz_f8(), model_data->l_04_o_wbcomac_ixz_f8);
+		assign_value_set(data.l_04_o_wbcomac_iyy_f8(), model_data->l_04_o_wbcomac_iyy_f8);
+		assign_value_set(data.l_04_o_wbcomac_iyz_f8(), model_data->l_04_o_wbcomac_iyz_f8);
+		assign_value_set(data.l_04_o_wbcomac_izz_f8(), model_data->l_04_o_wbcomac_izz_f8);
+		assign_value_set(data.l_04_o_wbcomac_zfw_f4(), model_data->l_04_o_wbcomac_zfw_f4);
+		assign_value_set(data.l_04_o_wbcomac_zfwcg_f4(), model_data->l_04_o_wbcomac_zfwcg_f4);
+		assign_value_set(data.l_04_o_wbcomac_zfw_blcg_f4(), model_data->l_04_o_wbcomac_zfw_blcg_f4);
+		assign_value_set(data.l_04_o_wbcomac_zfw_wlcg_f4(), model_data->l_04_o_wbcomac_zfw_wlcg_f4);
+		assign_value_set(data.l_04_o_wbcomac_fuel_cmd_f8(), model_data->l_04_o_wbcomac_fuel_cmd_f8);
+		assign_value_set(data.l_04_o_wbcomac_fuel_mode_i4(), model_data->l_04_o_wbcomac_fuel_mode_i4);
+		assign_value_set(data.l_04_o_wbcomac_fuel_ixx_f8(), model_data->l_04_o_wbcomac_fuel_ixx_f8);
+		assign_value_set(data.l_04_o_wbcomac_fuel_ixy_f8(), model_data->l_04_o_wbcomac_fuel_ixy_f8);
+		assign_value_set(data.l_04_o_wbcomac_fuel_ixz_f8(), model_data->l_04_o_wbcomac_fuel_ixz_f8);
+		assign_value_set(data.l_04_o_wbcomac_fuel_iyy_f8(), model_data->l_04_o_wbcomac_fuel_iyy_f8);
+		assign_value_set(data.l_04_o_wbcomac_fuel_iyz_f8(), model_data->l_04_o_wbcomac_fuel_iyz_f8);
+		assign_value_set(data.l_04_o_wbcomac_fuel_izz_f8(), model_data->l_04_o_wbcomac_fuel_izz_f8);
+		assign_value_set(data.l_04_o_wbcomac_l_wt_fuel_f8(), model_data->l_04_o_wbcomac_l_wt_fuel_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_airframe_total_f8(), model_data->l_04_o_wbcomac_ice_airframe_total_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_eng_f8(), model_data->l_04_o_wbcomac_ice_eng_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_eng_total_f8(), model_data->l_04_o_wbcomac_ice_eng_total_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_fuselage_f8(), model_data->l_04_o_wbcomac_ice_fuselage_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_stab_left_f8(), model_data->l_04_o_wbcomac_ice_stab_left_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_stab_right_f8(), model_data->l_04_o_wbcomac_ice_stab_right_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_stab_total_f8(), model_data->l_04_o_wbcomac_ice_stab_total_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_total_f8(), model_data->l_04_o_wbcomac_ice_total_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_total_frac_f8(), model_data->l_04_o_wbcomac_ice_total_frac_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_vert_tail_f8(), model_data->l_04_o_wbcomac_ice_vert_tail_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_wing_left_f8(), model_data->l_04_o_wbcomac_ice_wing_left_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_wing_right_f8(), model_data->l_04_o_wbcomac_ice_wing_right_f8);
+		assign_value_set(data.l_04_o_wbcomac_ice_wing_total_f8(), model_data->l_04_o_wbcomac_ice_wing_total_f8);
+		assign_value_set(data.l_04_o_wbcomac_init_l1(), model_data->l_04_o_wbcomac_init_l1);
+		assign_value_set(data.l_04_o_wbcomac_potmin_gw_f8(), model_data->l_04_o_wbcomac_potmin_gw_f8);
+		assign_value_set(data.l_04_o_wbcomac_potmax_gw_f8(), model_data->l_04_o_wbcomac_potmax_gw_f8);
+		assign_value_set(data.l_04_o_wbcomac_potmin_gwcg_f8(), model_data->l_04_o_wbcomac_potmin_gwcg_f8);
+		assign_value_set(data.l_04_o_wbcomac_potmax_gwcg_f8(), model_data->l_04_o_wbcomac_potmax_gwcg_f8);
+		assign_value_set(data.l_04_o_wbcomac_min_cg_f4(), model_data->l_04_o_wbcomac_min_cg_f4);
+		assign_value_set(data.l_04_o_wbcomac_min_gw_f4(), model_data->l_04_o_wbcomac_min_gw_f4);
+		assign_value_set(data.l_04_o_wbcomac_min_zfw_f4(), model_data->l_04_o_wbcomac_min_zfw_f4);
+		assign_value_set(data.l_04_o_wbcomac_min_zfwcg_f4(), model_data->l_04_o_wbcomac_min_zfwcg_f4);
+		assign_value_set(data.l_04_o_wbcomac_max_cg_f4(), model_data->l_04_o_wbcomac_max_cg_f4);
+		assign_value_set(data.l_04_o_wbcomac_max_gw_f4(), model_data->l_04_o_wbcomac_max_gw_f4);
+		assign_value_set(data.l_04_o_wbcomac_max_zfw_f4(), model_data->l_04_o_wbcomac_max_zfw_f4);
+		assign_value_set(data.l_04_o_wbcomac_max_zfwcg_f4(), model_data->l_04_o_wbcomac_max_zfwcg_f4);
+	}
+private:
+	XNSim::C909::ATA04::WeightBalance_output data;
+	XNSim::C909::ATA04::WeightBalance_output out_data;
+};
+}

Release/IDL/C909_V1/C909_V1.idl

@@ -0,0 +1,231 @@
+module XNSim
+{
+	module C909
+	{
+		module ATA04
+		{
+			struct Aerodynamics_input
+			{
+				@optional double l_04_i_aerocomac_alpha_f8;
+				@optional double l_04_i_aerocomac_alpdot_f8;
+				@optional double l_04_i_aerocomac_beta_f8;
+				@optional double l_04_i_aerocomac_press_alt_f8;
+				@optional double l_04_i_aerocomac_tas_f8;
+				@optional double l_04_i_aerocomac_mach_f8;
+				@optional double l_04_i_aerocomac_nx_f8;
+				@optional double l_04_i_aerocomac_ny_f8;
+				@optional double l_04_i_aerocomac_nz_f8;
+				@optional double l_04_i_aerocomac_p_f8;
+				@optional double l_04_i_aerocomac_q_f8;
+				@optional double l_04_i_aerocomac_r_f8;
+				@optional double l_04_i_aerocomac_qbar_f8;
+				@optional double l_04_i_aerocomac_blcg_f8;
+				@optional double l_04_i_aerocomac_bscg_f8;
+				@optional double l_04_i_aerocomac_wlcg_f8;
+				@optional double l_04_i_aerocomac_ail_f8[10];
+				@optional double l_04_i_aerocomac_elv_f8[4];
+				@optional double l_04_i_aerocomac_rud_f8[2];
+				@optional double l_04_i_aerocomac_stab_f8;
+				@optional double l_04_i_aerocomac_gear_f8[7];
+				@optional double l_04_i_aerocomac_flap_f8[10];
+				@optional double l_04_i_aerocomac_slat_f8[20];
+				@optional double l_04_i_aerocomac_spl_f8[20];
+				@optional double l_04_i_aerocomac_tnet_f8[4];
+				@optional double l_04_i_aerocomac_kice_f8[20];
+				@optional double l_04_i_aerocomac_alt_agl_f8;
+			};
+			struct GroundHandling_input
+			{
+				@optional char l_04_i_gdcomac_frz_l1;
+				@optional char l_04_i_gdcomac_chocks_l1;
+				@optional double l_04_i_gdcomac_alt_agl_f8;
+				@optional char l_04_i_gdcomac_frzflt_l1;
+				@optional double l_04_i_gdcomac_p_f8;
+				@optional double l_04_i_gdcomac_q_f8;
+				@optional double l_04_i_gdcomac_r_f8;
+				@optional double l_04_i_gdcomac_ug_f8;
+				@optional double l_04_i_gdcomac_vg_f8;
+				@optional double l_04_i_gdcomac_wg_f8;
+				@optional double l_04_i_gdcomac_blcg_f8;
+				@optional double l_04_i_gdcomac_bscg_f8;
+				@optional double l_04_i_gdcomac_wlcg_f8;
+				@optional char l_04_i_gdcomac_pb_active_l1;
+				@optional double l_04_i_gdcomac_brake_torq_f8[3][2];
+				@optional double l_04_i_gdcomac_gear_f8[3];
+				@optional double l_04_i_gdcomac_gsteer_f8[3];
+				@optional double l_04_i_gdcomac_tire_pres_f8[3][2];
+				@optional char l_04_i_gdcomac_onjax_l1;
+				@optional double l_04_i_gdcomac_contdep_f8[7];
+				@optional double l_04_i_gdcomac_thetag_f8;
+				@optional double l_04_i_gdcomac_phig_f8;
+				@optional long l_04_i_gdcomac_rwyrgh_i2;
+				@optional double l_04_i_gdcomac_rwyhdg_f8;
+				@optional char l_04_i_gdcomac_reset_braketemp_l1;
+				@optional char l_04_i_gdcomac_reset_tirepress_l1;
+				@optional double l_04_i_gdcomac_temp_c_f8;
+				@optional double l_04_i_gdcomac_brake_temp_f8[3][2];
+				@optional char l_04_i_gdcomac_tire_tburst_l1[3][2];
+				@optional char l_04_i_gdcomac_tire_tflat_l1[3][2];
+				@optional char l_04_i_gdcomac_brk_reset_tpres_l1;
+				@optional double l_04_i_gdcomac_rcon_ci_f8[14];
+				@optional double l_04_i_gdcomac_pb_towforce_f8;
+				@optional long l_04_i_gdcomac_gsteer_state_i4;
+				@optional char l_04_i_gdcomac_trim_active_l1;
+				@optional double l_04_i_gdcomac_phi_deg_f8;
+				@optional double l_04_i_gdcomac_theta_deg_f8;
+				@optional double l_04_i_gdcomac_psi_deg_f8;
+				@optional char l_04_i_gdcomac_resetint_l1;
+			};
+			struct GroundHandling_output
+			{
+				@optional char l_04_o_gdcomac_frz_l1;
+				@optional char l_04_o_gdcomac_ac_on_ground_l1;
+				@optional double l_04_o_gdcomac_ac_stationary_f8;
+				@optional double l_04_o_gdcomac_alt_tire_f8;
+				@optional double l_04_o_gdcomac_zcg_to_tire_f8;
+				@optional double l_04_o_gdcomac_fxb_f8;
+				@optional double l_04_o_gdcomac_fyb_f8;
+				@optional double l_04_o_gdcomac_fzb_f8;
+				@optional double l_04_o_gdcomac_mxb_f8;
+				@optional double l_04_o_gdcomac_myb_f8;
+				@optional double l_04_o_gdcomac_mzb_f8;
+				@optional double l_04_o_gdcomac_fygs_f8[3];
+				@optional double l_04_o_gdcomac_mzgs_f8[3];
+				@optional double l_04_o_gdcomac_mu_f8[3];
+				@optional double l_04_o_gdcomac_dstroke_f8[3];
+				@optional double l_04_o_gdcomac_sr_f8[3][2];
+				@optional double l_04_o_gdcomac_sy_f8[3][2];
+				@optional double l_04_o_gdcomac_sx_f8[3][2];
+				@optional double l_04_o_gdcomac_xft_f8[3];
+				@optional double l_04_o_gdcomac_yft_f8[3];
+				@optional double l_04_o_gdcomac_zft_f8[3];
+				@optional double l_04_o_gdcomac_distngrxcg_f8;
+				@optional double l_04_o_gdcomac_distmgrxcg_f8;
+				@optional double l_04_o_gdcomac_distmgrzcg_f8;
+				@optional double l_04_o_gdcomac_tire_vel_f8[3][2];
+				@optional char l_04_o_gdcomac_tire_burst_l1[3][2];
+				@optional double l_04_o_gdcomac_tire_temp_f8[3][2];
+				@optional char l_04_o_gdcomac_wow_l1;
+				@optional double l_04_o_gdcomac_utirew_f8[3][2];
+				@optional double l_04_o_gdcomac_vtirew_f8[3][2];
+				@optional double l_04_o_gdcomac_whl_omega_f8[3][2];
+				@optional double l_04_o_gdcomac_dstruc_f8[6];
+				@optional double l_04_o_gdcomac_wor_par_f8[3];
+				@optional double l_04_o_gdcomac_nd_f8[3];
+			};
+			struct Aerodynamics_output
+			{
+				@optional double l_04_o_aerocomac_fxb_f8;
+				@optional double l_04_o_aerocomac_fyb_f8;
+				@optional double l_04_o_aerocomac_fzb_f8;
+				@optional double l_04_o_aerocomac_mxb_f8;
+				@optional double l_04_o_aerocomac_myb_f8;
+				@optional double l_04_o_aerocomac_mzb_f8;
+				@optional double l_04_o_aerocomac_cls_f8;
+				@optional double l_04_o_aerocomac_cl_f8;
+				@optional double l_04_o_aerocomac_cd_f8;
+				@optional double l_04_o_aerocomac_cm_f8;
+				@optional double l_04_o_aerocomac_cr_f8;
+				@optional double l_04_o_aerocomac_cy_f8;
+				@optional double l_04_o_aerocomac_cn_f8;
+			};
+			struct WeightBalance_input
+			{
+				@optional double l_04_i_wbcomac_theta_deg_f8;
+				@optional char l_04_i_wbcomac_gear_mode_l1;
+				@optional double l_04_i_wbcomac_acset_gw_f8;
+				@optional double l_04_i_wbcomac_acset_cg_f8;
+				@optional float l_04_i_wbcomac_acset_tankfuel_f4[20];
+				@optional double l_04_i_wbcomac_acset_totfuel_f8;
+				@optional double l_04_i_wbcomac_acset_zfw_f8;
+				@optional double l_04_i_wbcomac_acset_zfwcg_f8;
+				@optional char l_04_i_wbcomac_eng_efsep_l1[4];
+				@optional double l_04_i_wbcomac_fuel_f8[20];
+				@optional double l_04_i_wbcomac_gear_avg_f8;
+				@optional double l_04_i_wbcomac_kice_f8[20];
+				@optional char l_04_i_wbcomac_bycglim_l1;
+				@optional char l_04_i_wbcomac_bygwlim_l1;
+				@optional char l_04_i_wbcomac_frz_l1;
+				@optional char l_04_i_wbcomac_zcgfrz_l1;
+				@optional char l_04_i_wbcomac_zcgfrz_grfx_l1;
+				@optional char l_04_i_wbcomac_ycgfrz_l1;
+				@optional char l_04_i_wbcomac_inertfrz_l1;
+				@optional double l_04_i_wbcomac_potreq_gw_f8;
+				@optional double l_04_i_wbcomac_potreq_gwcg_f8;
+				@optional double l_04_i_wbcomac_phi_deg_f8;
+				@optional double l_04_i_wbcomac_psi_deg_f8;
+			};
+			struct WeightBalance_output
+			{
+				@optional char l_04_o_wbcomac_frz_l1;
+				@optional char l_04_o_wbcomac_zcgfrz_l1;
+				@optional char l_04_o_wbcomac_zcgfrz_grfx_l1;
+				@optional char l_04_o_wbcomac_ycgfrz_l1;
+				@optional char l_04_o_wbcomac_inertfrz_l1;
+				@optional float l_04_o_wbcomac_gw_f4;
+				@optional float l_04_o_wbcomac_cg_f4;
+				@optional double l_04_o_wbcomac_blcg_f8;
+				@optional double l_04_o_wbcomac_bscg_f8;
+				@optional double l_04_o_wbcomac_wlcg_f8;
+				@optional double l_04_o_wbcomac_xcg_f8;
+				@optional double l_04_o_wbcomac_ixx_f8;
+				@optional double l_04_o_wbcomac_ixy_f8;
+				@optional double l_04_o_wbcomac_ixz_f8;
+				@optional double l_04_o_wbcomac_iyy_f8;
+				@optional double l_04_o_wbcomac_iyz_f8;
+				@optional double l_04_o_wbcomac_izz_f8;
+				@optional float l_04_o_wbcomac_zfw_f4;
+				@optional float l_04_o_wbcomac_zfwcg_f4;
+				@optional float l_04_o_wbcomac_zfw_blcg_f4;
+				@optional float l_04_o_wbcomac_zfw_wlcg_f4;
+				@optional double l_04_o_wbcomac_fuel_cmd_f8[20];
+				@optional long l_04_o_wbcomac_fuel_mode_i4;
+				@optional double l_04_o_wbcomac_fuel_ixx_f8;
+				@optional double l_04_o_wbcomac_fuel_ixy_f8;
+				@optional double l_04_o_wbcomac_fuel_ixz_f8;
+				@optional double l_04_o_wbcomac_fuel_iyy_f8;
+				@optional double l_04_o_wbcomac_fuel_iyz_f8;
+				@optional double l_04_o_wbcomac_fuel_izz_f8;
+				@optional double l_04_o_wbcomac_l_wt_fuel_f8;
+				@optional double l_04_o_wbcomac_ice_airframe_total_f8;
+				@optional double l_04_o_wbcomac_ice_eng_f8[4];
+				@optional double l_04_o_wbcomac_ice_eng_total_f8;
+				@optional double l_04_o_wbcomac_ice_fuselage_f8;
+				@optional double l_04_o_wbcomac_ice_stab_left_f8;
+				@optional double l_04_o_wbcomac_ice_stab_right_f8;
+				@optional double l_04_o_wbcomac_ice_stab_total_f8;
+				@optional double l_04_o_wbcomac_ice_total_f8;
+				@optional double l_04_o_wbcomac_ice_total_frac_f8;
+				@optional double l_04_o_wbcomac_ice_vert_tail_f8;
+				@optional double l_04_o_wbcomac_ice_wing_left_f8;
+				@optional double l_04_o_wbcomac_ice_wing_right_f8;
+				@optional double l_04_o_wbcomac_ice_wing_total_f8;
+				@optional char l_04_o_wbcomac_init_l1;
+				@optional double l_04_o_wbcomac_potmin_gw_f8;
+				@optional double l_04_o_wbcomac_potmax_gw_f8;
+				@optional double l_04_o_wbcomac_potmin_gwcg_f8;
+				@optional double l_04_o_wbcomac_potmax_gwcg_f8;
+				@optional float l_04_o_wbcomac_min_cg_f4;
+				@optional float l_04_o_wbcomac_min_gw_f4;
+				@optional float l_04_o_wbcomac_min_zfw_f4;
+				@optional float l_04_o_wbcomac_min_zfwcg_f4;
+				@optional float l_04_o_wbcomac_max_cg_f4;
+				@optional float l_04_o_wbcomac_max_gw_f4;
+				@optional float l_04_o_wbcomac_max_zfw_f4;
+				@optional float l_04_o_wbcomac_max_zfwcg_f4;
+			};
+			struct GroundHandling_heartbeat
+			{
+				@optional long groundhandling_model_heartbeat;
+			};
+			struct WeightBalance_heartbeat
+			{
+				@optional long weightbody_model_heartbeat;
+			};
+			struct Aerodynamics_heartbeat
+			{
+				@optional long aero_model_heartbeat;
+			};
+		};
+	};
+};

Release/IDL/C909_V1/C909_V1CdrAux.hpp

@@ -0,0 +1,102 @@
+// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*!
+ * @file C909_V1CdrAux.hpp
+ * This source file contains some definitions of CDR related functions.
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#ifndef FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1CDRAUX_HPP
+#define FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1CDRAUX_HPP
+
+#include "C909_V1.hpp"
+
+constexpr uint32_t XNSim_C909_ATA04_GroundHandling_input_max_cdr_typesize {1037UL};
+constexpr uint32_t XNSim_C909_ATA04_GroundHandling_input_max_key_cdr_typesize {0UL};
+
+constexpr uint32_t XNSim_C909_ATA04_GroundHandling_heartbeat_max_cdr_typesize {12UL};
+constexpr uint32_t XNSim_C909_ATA04_GroundHandling_heartbeat_max_key_cdr_typesize {0UL};
+
+constexpr uint32_t XNSim_C909_ATA04_Aerodynamics_output_max_cdr_typesize {312UL};
+constexpr uint32_t XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize {0UL};
+
+constexpr uint32_t XNSim_C909_ATA04_WeightBalance_output_max_cdr_typesize {1184UL};
+constexpr uint32_t XNSim_C909_ATA04_WeightBalance_output_max_key_cdr_typesize {0UL};
+
+constexpr uint32_t XNSim_C909_ATA04_WeightBalance_heartbeat_max_cdr_typesize {12UL};
+constexpr uint32_t XNSim_C909_ATA04_WeightBalance_heartbeat_max_key_cdr_typesize {0UL};
+
+constexpr uint32_t XNSim_C909_ATA04_GroundHandling_output_max_cdr_typesize {1264UL};
+constexpr uint32_t XNSim_C909_ATA04_GroundHandling_output_max_key_cdr_typesize {0UL};
+
+constexpr uint32_t XNSim_C909_ATA04_WeightBalance_input_max_cdr_typesize {784UL};
+constexpr uint32_t XNSim_C909_ATA04_WeightBalance_input_max_key_cdr_typesize {0UL};
+
+constexpr uint32_t XNSim_C909_ATA04_Aerodynamics_input_max_cdr_typesize {1352UL};
+constexpr uint32_t XNSim_C909_ATA04_Aerodynamics_input_max_key_cdr_typesize {0UL};
+
+constexpr uint32_t XNSim_C909_ATA04_Aerodynamics_heartbeat_max_cdr_typesize {12UL};
+constexpr uint32_t XNSim_C909_ATA04_Aerodynamics_heartbeat_max_key_cdr_typesize {0UL};
+
+
+namespace eprosima {
+namespace fastcdr {
+
+class Cdr;
+class CdrSizeCalculator;
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::Aerodynamics_input& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::GroundHandling_input& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::GroundHandling_output& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::Aerodynamics_output& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::WeightBalance_input& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::WeightBalance_output& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::GroundHandling_heartbeat& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::WeightBalance_heartbeat& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const XNSim::C909::ATA04::Aerodynamics_heartbeat& data);
+
+
+} // namespace fastcdr
+} // namespace eprosima
+
+#endif // FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1CDRAUX_HPP
+

Release/IDL/C909_V1/C909_V1PubSubTypes.hpp

@@ -0,0 +1,780 @@
+// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*!
+ * @file C909_V1PubSubTypes.hpp
+ * This header file contains the declaration of the serialization functions.
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+
+#ifndef FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1_PUBSUBTYPES_HPP
+#define FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1_PUBSUBTYPES_HPP
+
+#include <fastdds/dds/core/policy/QosPolicies.hpp>
+#include <fastdds/dds/topic/TopicDataType.hpp>
+#include <fastdds/rtps/common/InstanceHandle.hpp>
+#include <fastdds/rtps/common/SerializedPayload.hpp>
+#include <fastdds/utils/md5.hpp>
+
+#include "C909_V1.hpp"
+
+
+#if !defined(FASTDDS_GEN_API_VER) || (FASTDDS_GEN_API_VER != 3)
+#error \
+    Generated C909_V1 is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen.
+#endif  // FASTDDS_GEN_API_VER
+
+namespace XNSim
+{
+    namespace C909
+    {
+        namespace ATA04
+        {
+
+            /*!
+             * @brief This class represents the TopicDataType of the type Aerodynamics_input defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class Aerodynamics_inputPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef Aerodynamics_input type;
+
+                eProsima_user_DllExport Aerodynamics_inputPubSubType();
+
+                eProsima_user_DllExport ~Aerodynamics_inputPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+
+            /*!
+             * @brief This class represents the TopicDataType of the type GroundHandling_input defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class GroundHandling_inputPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef GroundHandling_input type;
+
+                eProsima_user_DllExport GroundHandling_inputPubSubType();
+
+                eProsima_user_DllExport ~GroundHandling_inputPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+
+            /*!
+             * @brief This class represents the TopicDataType of the type GroundHandling_output defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class GroundHandling_outputPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef GroundHandling_output type;
+
+                eProsima_user_DllExport GroundHandling_outputPubSubType();
+
+                eProsima_user_DllExport ~GroundHandling_outputPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+
+            /*!
+             * @brief This class represents the TopicDataType of the type Aerodynamics_output defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class Aerodynamics_outputPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef Aerodynamics_output type;
+
+                eProsima_user_DllExport Aerodynamics_outputPubSubType();
+
+                eProsima_user_DllExport ~Aerodynamics_outputPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+
+            /*!
+             * @brief This class represents the TopicDataType of the type WeightBalance_input defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class WeightBalance_inputPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef WeightBalance_input type;
+
+                eProsima_user_DllExport WeightBalance_inputPubSubType();
+
+                eProsima_user_DllExport ~WeightBalance_inputPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+
+            /*!
+             * @brief This class represents the TopicDataType of the type WeightBalance_output defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class WeightBalance_outputPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef WeightBalance_output type;
+
+                eProsima_user_DllExport WeightBalance_outputPubSubType();
+
+                eProsima_user_DllExport ~WeightBalance_outputPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+
+            /*!
+             * @brief This class represents the TopicDataType of the type GroundHandling_heartbeat defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class GroundHandling_heartbeatPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef GroundHandling_heartbeat type;
+
+                eProsima_user_DllExport GroundHandling_heartbeatPubSubType();
+
+                eProsima_user_DllExport ~GroundHandling_heartbeatPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+
+            /*!
+             * @brief This class represents the TopicDataType of the type WeightBalance_heartbeat defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class WeightBalance_heartbeatPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef WeightBalance_heartbeat type;
+
+                eProsima_user_DllExport WeightBalance_heartbeatPubSubType();
+
+                eProsima_user_DllExport ~WeightBalance_heartbeatPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+
+            /*!
+             * @brief This class represents the TopicDataType of the type Aerodynamics_heartbeat defined by the user in the IDL file.
+             * @ingroup C909_V1
+             */
+            class Aerodynamics_heartbeatPubSubType : public eprosima::fastdds::dds::TopicDataType
+            {
+            public:
+
+                typedef Aerodynamics_heartbeat type;
+
+                eProsima_user_DllExport Aerodynamics_heartbeatPubSubType();
+
+                eProsima_user_DllExport ~Aerodynamics_heartbeatPubSubType() override;
+
+                eProsima_user_DllExport bool serialize(
+                        const void* const data,
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool deserialize(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        void* data) override;
+
+                eProsima_user_DllExport uint32_t calculate_serialized_size(
+                        const void* const data,
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport bool compute_key(
+                        const void* const data,
+                        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+                        bool force_md5 = false) override;
+
+                eProsima_user_DllExport void* create_data() override;
+
+                eProsima_user_DllExport void delete_data(
+                        void* data) override;
+
+                //Register TypeObject representation in Fast DDS TypeObjectRegistry
+                eProsima_user_DllExport void register_type_object_representation() override;
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+                eProsima_user_DllExport inline bool is_bounded() const override
+                {
+                    return true;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+                eProsima_user_DllExport inline bool is_plain(
+                        eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+                {
+                    static_cast<void>(data_representation);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+            #ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+                eProsima_user_DllExport inline bool construct_sample(
+                        void* memory) const override
+                {
+                    static_cast<void>(memory);
+                    return false;
+                }
+
+            #endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+            private:
+
+                eprosima::fastdds::MD5 md5_;
+                unsigned char* key_buffer_;
+
+            };
+        } // namespace ATA04
+    } // namespace C909
+} // namespace XNSim
+
+#endif // FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1_PUBSUBTYPES_HPP
+

Release/IDL/C909_V1/C909_V1TypeObjectSupport.hpp

@@ -0,0 +1,169 @@
+// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*!
+ * @file C909_V1TypeObjectSupport.hpp
+ * Header file containing the API required to register the TypeObject representation of the described types in the IDL file
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#ifndef FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1_TYPE_OBJECT_SUPPORT_HPP
+#define FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1_TYPE_OBJECT_SUPPORT_HPP
+
+#include <fastdds/dds/xtypes/type_representation/TypeObject.hpp>
+
+
+#if defined(_WIN32)
+#if defined(EPROSIMA_USER_DLL_EXPORT)
+#define eProsima_user_DllExport __declspec( dllexport )
+#else
+#define eProsima_user_DllExport
+#endif  // EPROSIMA_USER_DLL_EXPORT
+#else
+#define eProsima_user_DllExport
+#endif  // _WIN32
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
+
+namespace XNSim {
+namespace C909 {
+namespace ATA04 {
+/**
+ * @brief Register Aerodynamics_input related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_Aerodynamics_input_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register GroundHandling_input related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_GroundHandling_input_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register GroundHandling_output related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_GroundHandling_output_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register Aerodynamics_output related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_Aerodynamics_output_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register WeightBalance_input related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_WeightBalance_input_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register WeightBalance_output related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_WeightBalance_output_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register GroundHandling_heartbeat related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_GroundHandling_heartbeat_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register WeightBalance_heartbeat related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_WeightBalance_heartbeat_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register Aerodynamics_heartbeat related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_Aerodynamics_heartbeat_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+} // namespace ATA04
+
+} // namespace C909
+
+} // namespace XNSim
+
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
+
+#endif // FAST_DDS_GENERATED__XNSIM_C909_ATA04_C909_V1_TYPE_OBJECT_SUPPORT_HPP

Release/IDL/C909_V1/CMakeLists.txt

@@ -0,0 +1,59 @@
+cmake_minimum_required(VERSION 3.16)
+project(C909_V1_Interface LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+if(DEFINED ENV{XNCore})
+	set(XNCore_PATH $ENV{XNCore})
+else()
+	message(FATAL_ERROR "Environment variable XNCore is not set.")
+endif()
+include_directories(${XNCore_PATH}/include)
+if(NOT fastcdr_FOUND)
+	find_package(fastcdr 2 REQUIRED)
+endif()
+if(NOT fastdds_FOUND)
+	find_package(fastdds 3 REQUIRED)
+endif()
+find_package(OpenSSL REQUIRED)
+add_library(C909_V1_Interface SHARED
+    C909_V1.hpp
+    C909_V1CdrAux.hpp
+    C909_V1CdrAux.ipp
+    C909_V1PubSubTypes.hpp
+    C909_V1PubSubTypes.cxx
+    C909_V1TypeObjectSupport.hpp
+    C909_V1TypeObjectSupport.cxx
+    ATA04/Aerodynamics_input.hpp
+    ATA04/Aerodynamics_input.cxx
+    ATA04/GroundHandling_input.hpp
+    ATA04/GroundHandling_input.cxx
+    ATA04/GroundHandling_output.hpp
+    ATA04/GroundHandling_output.cxx
+    ATA04/Aerodynamics_output.hpp
+    ATA04/Aerodynamics_output.cxx
+    ATA04/WeightBalance_input.hpp
+    ATA04/WeightBalance_input.cxx
+    ATA04/WeightBalance_output.hpp
+    ATA04/WeightBalance_output.cxx
+    ATA04/GroundHandling_heartbeat.hpp
+    ATA04/GroundHandling_heartbeat.cxx
+    ATA04/WeightBalance_heartbeat.hpp
+    ATA04/WeightBalance_heartbeat.cxx
+    ATA04/Aerodynamics_heartbeat.hpp
+    ATA04/Aerodynamics_heartbeat.cxx
+)
+target_link_libraries(C909_V1_Interface PRIVATE
+     fastcdr fastdds OpenSSL::SSL OpenSSL::Crypto
+     ${XNCore_PATH}/lib/libXNCore.so
+)
+target_compile_definitions(C909_V1_Interface PRIVATE C909_V1_INTERFACE_LIBRARY)
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+	set(CMAKE_INSTALL_PREFIX "${XNCore_PATH}" CACHE PATH "Install path prefix" FORCE)
+endif()
+include(GNUInstallDirs)
+install(TARGETS C909_V1_Interface
+    RUNTIME DESTINATION .
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION .
+)

Release/IDL/XNAerodynamics.idl

@@ -1,56 +0,0 @@
-module XNSim
-{
-	module ATA04
-	{
-		struct Aerodynamics_input
-		{
-			@optional double l_04_i_aerocomac_alpha_f8;
-			@optional double l_04_i_aerocomac_alpdot_f8;
-			@optional double l_04_i_aerocomac_beta_f8;
-			@optional double l_04_i_aerocomac_press_alt_f8;
-			@optional double l_04_i_aerocomac_tas_f8;
-			@optional double l_04_i_aerocomac_mach_f8;
-			@optional double l_04_i_aerocomac_nx_f8;
-			@optional double l_04_i_aerocomac_ny_f8;
-			@optional double l_04_i_aerocomac_nz_f8;
-			@optional double l_04_i_aerocomac_p_f8;
-			@optional double l_04_i_aerocomac_q_f8;
-			@optional double l_04_i_aerocomac_r_f8;
-			@optional double l_04_i_aerocomac_qbar_f8;
-			@optional double l_04_i_aerocomac_blcg_f8;
-			@optional double l_04_i_aerocomac_bscg_f8;
-			@optional double l_04_i_aerocomac_wlcg_f8;
-			@optional double l_04_i_aerocomac_ail_f8[10];
-			@optional double l_04_i_aerocomac_elv_f8[4];
-			@optional double l_04_i_aerocomac_rud_f8[2];
-			@optional double l_04_i_aerocomac_stab_f8;
-			@optional double l_04_i_aerocomac_gear_f8[7];
-			@optional double l_04_i_aerocomac_flap_f8[10];
-			@optional double l_04_i_aerocomac_slat_f8[20];
-			@optional double l_04_i_aerocomac_spl_f8[20];
-			@optional double l_04_i_aerocomac_tnet_f8[4];
-			@optional double l_04_i_aerocomac_kice_f8[20];
-			@optional double l_04_i_aerocomac_alt_agl_f8;
-		};
-		struct Aerodynamics_output
-		{
-			@optional double l_04_o_aerocomac_fxb_f8;
-			@optional double l_04_o_aerocomac_fyb_f8;
-			@optional double l_04_o_aerocomac_fzb_f8;
-			@optional double l_04_o_aerocomac_mxb_f8;
-			@optional double l_04_o_aerocomac_myb_f8;
-			@optional double l_04_o_aerocomac_mzb_f8;
-			@optional double l_04_o_aerocomac_cls_f8;
-			@optional double l_04_o_aerocomac_cl_f8;
-			@optional double l_04_o_aerocomac_cd_f8;
-			@optional double l_04_o_aerocomac_cm_f8;
-			@optional double l_04_o_aerocomac_cr_f8;
-			@optional double l_04_o_aerocomac_cy_f8;
-			@optional double l_04_o_aerocomac_cn_f8;
-		};
-		struct Aerodynamics_heartbeat
-		{
-			long aero_model_heartbeat;
-		};
-	};
-};

Release/IDL/XNGroundHandling.idl

@@ -1,90 +0,0 @@
-module XNSim
-{
-	module ATA04
-	{
-		struct GroundHandling_input
-		{
-			@optional char l_04_i_gdcomac_frz_l1;
-			@optional char l_04_i_gdcomac_chocks_l1;
-			@optional double l_04_i_gdcomac_alt_agl_f8;
-			@optional char l_04_i_gdcomac_frzflt_l1;
-			@optional double l_04_i_gdcomac_p_f8;
-			@optional double l_04_i_gdcomac_q_f8;
-			@optional double l_04_i_gdcomac_r_f8;
-			@optional double l_04_i_gdcomac_ug_f8;
-			@optional double l_04_i_gdcomac_vg_f8;
-			@optional double l_04_i_gdcomac_wg_f8;
-			@optional double l_04_i_gdcomac_blcg_f8;
-			@optional double l_04_i_gdcomac_bscg_f8;
-			@optional double l_04_i_gdcomac_wlcg_f8;
-			@optional char l_04_i_gdcomac_pb_active_l1;
-			@optional double l_04_i_gdcomac_brake_torq_f8[3][2];
-			@optional double l_04_i_gdcomac_gear_f8[3];
-			@optional double l_04_i_gdcomac_gsteer_f8[10];
-			@optional double l_04_i_gdcomac_tire_pres_f8[3][2];
-			@optional char l_04_i_gdcomac_onjax_l1;
-			@optional double l_04_i_gdcomac_contdep_f8[7];
-			@optional double l_04_i_gdcomac_thetag_f8;
-			@optional double l_04_i_gdcomac_phig_f8;
-			@optional long l_04_i_gdcomac_rwyrgh_i2;
-			@optional double l_04_i_gdcomac_rwyhdg_f8;
-			@optional char l_04_i_gdcomac_reset_braketemp_l1;
-			@optional char l_04_i_gdcomac_reset_tirepress_l1;
-			@optional double l_04_i_gdcomac_temp_c_f8;
-			@optional double l_04_i_gdcomac_brake_temp_f8[3][2];
-			@optional char l_04_i_gdcomac_tire_tburst_l1[3][2];
-			@optional char l_04_i_gdcomac_tire_tflat_l1[3][2];
-			@optional char l_04_i_gdcomac_brk_reset_tpres_l1;
-			@optional double l_04_i_gdcomac_rcon_ci_f8[14];
-			@optional double l_04_i_gdcomac_pb_towforce_f8;
-			@optional long l_04_i_gdcomac_gsteer_state_i4;
-			@optional char l_04_i_gdcomac_trim_active_l1;
-			@optional double l_04_i_gdcomac_phi_deg_f8;
-			@optional double l_04_i_gdcomac_theta_deg_f8;
-			@optional double l_04_i_gdcomac_psi_deg_f8;
-			@optional char l_04_i_gdcomac_resetint_l1;
-		};
-		struct GroundHandling_output
-		{
-			@optional char l_04_o_gdcomac_frz_l1;
-			@optional char l_04_o_gdcomac_ac_on_ground_l1;
-			@optional double l_04_o_gdcomac_ac_stationary_f8;
-			@optional double l_04_o_gdcomac_alt_tire_f8;
-			@optional double l_04_o_gdcomac_zcg_to_tire_f8;
-			@optional double l_04_o_gdcomac_fxb_f8;
-			@optional double l_04_o_gdcomac_fyb_f8;
-			@optional double l_04_o_gdcomac_fzb_f8;
-			@optional double l_04_o_gdcomac_mxb_f8;
-			@optional double l_04_o_gdcomac_myb_f8;
-			@optional double l_04_o_gdcomac_mzb_f8;
-			@optional double l_04_o_gdcomac_fygs_f8[3];
-			@optional double l_04_o_gdcomac_mzgs_f8[3];
-			@optional double l_04_o_gdcomac_mu_f8[3];
-			@optional double l_04_o_gdcomac_dstroke_f8[3];
-			@optional double l_04_o_gdcomac_sr_f8[3][2];
-			@optional double l_04_o_gdcomac_sy_f8[3][2];
-			@optional double l_04_o_gdcomac_sx_f8[3][2];
-			@optional double l_04_o_gdcomac_xft_f8[3];
-			@optional double l_04_o_gdcomac_yft_f8[3];
-			@optional double l_04_o_gdcomac_zft_f8[3];
-			@optional double l_04_o_gdcomac_distngrxcg_f8;
-			@optional double l_04_o_gdcomac_distmgrxcg_f8;
-			@optional double l_04_o_gdcomac_distmgrzcg_f8;
-			@optional double l_04_o_gdcomac_tire_vel_f8[3][2];
-			@optional char l_04_o_gdcomac_tire_burst_l1[3][2];
-			@optional double l_04_o_gdcomac_tire_temp_f8[3][2];
-			@optional char l_04_o_gdcomac_wow_l1;
-			@optional double l_04_o_gdcomac_utirew_f8[3][2];
-			@optional double l_04_o_gdcomac_vtirew_f8[3][2];
-			@optional double l_04_o_gdcomac_whl_omega_f8[3][2];
-			@optional double l_04_o_gdcomac_dstruc_f8[6];
-			@optional double l_04_o_gdcomac_wor_par_f8[3];
-			@optional double l_04_o_gdcomac_nd_f8[3];
-			@optional double l_04_o_gdcomac_vczt_f8[3][2];
-		};
-		struct GroundHandling_heartbeat
-		{
-			long groundhandling_model_heartbeat;
-		};
-	};
-};

Release/IDL/XNWeightBalance.idl

@@ -1,95 +0,0 @@
-module XNSim
-{
-	module ATA04
-	{
-		struct WeightBalance_input
-		{
-			@optional double l_04_i_wbcomac_theta_deg_f8;
-			@optional char l_04_i_wbcomac_gear_mode_l1;
-			@optional double l_04_i_wbcomac_acset_gw_f8;
-			@optional double l_04_i_wbcomac_acset_cg_f8;
-			@optional float l_04_i_wbcomac_acset_tankfuel_f4[20];
-			@optional double l_04_i_wbcomac_acset_totfuel_f8;
-			@optional double l_04_i_wbcomac_acset_zfw_f8;
-			@optional double l_04_i_wbcomac_acset_zfwcg_f8;
-			@optional char l_04_i_wbcomac_eng_efsep_l1[4];
-			@optional double l_04_i_wbcomac_fuel_f8[20];
-			@optional double l_04_i_wbcomac_gear_avg_f8;
-			@optional double l_04_i_wbcomac_kice_f8[20];
-			@optional char l_04_i_wbcomac_bycglim_l1;
-			@optional char l_04_i_wbcomac_bygwlim_l1;
-			@optional char l_04_i_wbcomac_frz_l1;
-			@optional char l_04_i_wbcomac_zcgfrz_l1;
-			@optional char l_04_i_wbcomac_zcgfrz_grfx_l1;
-			@optional char l_04_i_wbcomac_ycgfrz_l1;
-			@optional char l_04_i_wbcomac_inertfrz_l1;
-			@optional double l_04_i_wbcomac_potreq_gw_f8;
-			@optional double l_04_i_wbcomac_potreq_gwcg_f8;
-			@optional double l_04_i_wbcomac_phi_deg_f8;
-			@optional double l_04_i_wbcomac_psi_deg_f8;
-		};
-		struct WeightBalance_output
-		{
-			@optional char l_04_o_wbcomac_frz_l1;
-			@optional char l_04_o_wbcomac_zcgfrz_l1;
-			@optional char l_04_o_wbcomac_zcgfrz_grfx_l1;
-			@optional char l_04_o_wbcomac_ycgfrz_l1;
-			@optional char l_04_o_wbcomac_inertfrz_l1;
-			@optional float l_04_o_wbcomac_gw_f4;
-			@optional float l_04_o_wbcomac_cg_f4;
-			@optional double l_04_o_wbcomac_blcg_f8;
-			@optional double l_04_o_wbcomac_bscg_f8;
-			@optional double l_04_o_wbcomac_wlcg_f8;
-			@optional double l_04_o_wbcomac_xcg_f8;
-			@optional double l_04_o_wbcomac_ixx_f8;
-			@optional double l_04_o_wbcomac_ixy_f8;
-			@optional double l_04_o_wbcomac_ixz_f8;
-			@optional double l_04_o_wbcomac_iyy_f8;
-			@optional double l_04_o_wbcomac_iyz_f8;
-			@optional double l_04_o_wbcomac_izz_f8;
-			@optional float l_04_o_wbcomac_zfw_f4;
-			@optional float l_04_o_wbcomac_zfwcg_f4;
-			@optional float l_04_o_wbcomac_zfw_blcg_f4;
-			@optional float l_04_o_wbcomac_zfw_wlcg_f4;
-			@optional double l_04_o_wbcomac_fuel_cmd_f8[20];
-			@optional long l_04_o_wbcomac_fuel_mode_i4;
-			@optional double l_04_o_wbcomac_fuel_ixx_f8;
-			@optional double l_04_o_wbcomac_fuel_ixy_f8;
-			@optional double l_04_o_wbcomac_fuel_ixz_f8;
-			@optional double l_04_o_wbcomac_fuel_iyy_f8;
-			@optional double l_04_o_wbcomac_fuel_iyz_f8;
-			@optional double l_04_o_wbcomac_fuel_izz_f8;
-			@optional double l_04_o_wbcomac_l_wt_fuel_f8;
-			@optional double l_04_o_wbcomac_ice_airframe_total_f8;
-			@optional double l_04_o_wbcomac_ice_eng_f8[4];
-			@optional double l_04_o_wbcomac_ice_eng_total_f8;
-			@optional double l_04_o_wbcomac_ice_fuselage_f8;
-			@optional double l_04_o_wbcomac_ice_stab_left_f8;
-			@optional double l_04_o_wbcomac_ice_stab_right_f8;
-			@optional double l_04_o_wbcomac_ice_stab_total_f8;
-			@optional double l_04_o_wbcomac_ice_total_f8;
-			@optional double l_04_o_wbcomac_ice_total_frac_f8;
-			@optional double l_04_o_wbcomac_ice_vert_tail_f8;
-			@optional double l_04_o_wbcomac_ice_wing_left_f8;
-			@optional double l_04_o_wbcomac_ice_wing_right_f8;
-			@optional double l_04_o_wbcomac_ice_wing_total_f8;
-			@optional char l_04_o_wbcomac_init_l1;
-			@optional double l_04_o_wbcomac_potmin_gw_f8;
-			@optional double l_04_o_wbcomac_potmax_gw_f8;
-			@optional double l_04_o_wbcomac_potmin_gwcg_f8;
-			@optional double l_04_o_wbcomac_potmax_gwcg_f8;
-			@optional float l_04_o_wbcomac_min_cg_f4;
-			@optional float l_04_o_wbcomac_min_gw_f4;
-			@optional float l_04_o_wbcomac_min_zfw_f4;
-			@optional float l_04_o_wbcomac_min_zfwcg_f4;
-			@optional float l_04_o_wbcomac_max_cg_f4;
-			@optional float l_04_o_wbcomac_max_gw_f4;
-			@optional float l_04_o_wbcomac_max_zfw_f4;
-			@optional float l_04_o_wbcomac_max_zfwcg_f4;
-		};
-		struct WeightBalance_heartbeat
-		{
-			long weightbody_model_heartbeat;
-		};
-	};
-};

Release/Models/XNAerodynamics.idl

@@ -1,56 +0,0 @@
-module XNSim
-{
-	module ATA04
-	{
-		struct Aerodynamics_input
-		{
-			@optional double l_04_i_aerocomac_alpha_f8;
-			@optional double l_04_i_aerocomac_alpdot_f8;
-			@optional double l_04_i_aerocomac_beta_f8;
-			@optional double l_04_i_aerocomac_press_alt_f8;
-			@optional double l_04_i_aerocomac_tas_f8;
-			@optional double l_04_i_aerocomac_mach_f8;
-			@optional double l_04_i_aerocomac_nx_f8;
-			@optional double l_04_i_aerocomac_ny_f8;
-			@optional double l_04_i_aerocomac_nz_f8;
-			@optional double l_04_i_aerocomac_p_f8;
-			@optional double l_04_i_aerocomac_q_f8;
-			@optional double l_04_i_aerocomac_r_f8;
-			@optional double l_04_i_aerocomac_qbar_f8;
-			@optional double l_04_i_aerocomac_blcg_f8;
-			@optional double l_04_i_aerocomac_bscg_f8;
-			@optional double l_04_i_aerocomac_wlcg_f8;
-			@optional double l_04_i_aerocomac_ail_f8[10];
-			@optional double l_04_i_aerocomac_elv_f8[4];
-			@optional double l_04_i_aerocomac_rud_f8[2];
-			@optional double l_04_i_aerocomac_stab_f8;
-			@optional double l_04_i_aerocomac_gear_f8[7];
-			@optional double l_04_i_aerocomac_flap_f8[10];
-			@optional double l_04_i_aerocomac_slat_f8[20];
-			@optional double l_04_i_aerocomac_spl_f8[20];
-			@optional double l_04_i_aerocomac_tnet_f8[4];
-			@optional double l_04_i_aerocomac_kice_f8[20];
-			@optional double l_04_i_aerocomac_alt_agl_f8;
-		};
-		struct Aerodynamics_output
-		{
-			@optional double l_04_o_aerocomac_fxb_f8;
-			@optional double l_04_o_aerocomac_fyb_f8;
-			@optional double l_04_o_aerocomac_fzb_f8;
-			@optional double l_04_o_aerocomac_mxb_f8;
-			@optional double l_04_o_aerocomac_myb_f8;
-			@optional double l_04_o_aerocomac_mzb_f8;
-			@optional double l_04_o_aerocomac_cls_f8;
-			@optional double l_04_o_aerocomac_cl_f8;
-			@optional double l_04_o_aerocomac_cd_f8;
-			@optional double l_04_o_aerocomac_cm_f8;
-			@optional double l_04_o_aerocomac_cr_f8;
-			@optional double l_04_o_aerocomac_cy_f8;
-			@optional double l_04_o_aerocomac_cn_f8;
-		};
-		struct Aerodynamics_heartbeat
-		{
-			long aero_model_heartbeat;
-		};
-	};
-};

Release/Models/XNGroundHandling.idl

@@ -1,90 +0,0 @@
-module XNSim
-{
-	module ATA04
-	{
-		struct GroundHandling_input
-		{
-			@optional char l_04_i_gdcomac_frz_l1;
-			@optional char l_04_i_gdcomac_chocks_l1;
-			@optional double l_04_i_gdcomac_alt_agl_f8;
-			@optional char l_04_i_gdcomac_frzflt_l1;
-			@optional double l_04_i_gdcomac_p_f8;
-			@optional double l_04_i_gdcomac_q_f8;
-			@optional double l_04_i_gdcomac_r_f8;
-			@optional double l_04_i_gdcomac_ug_f8;
-			@optional double l_04_i_gdcomac_vg_f8;
-			@optional double l_04_i_gdcomac_wg_f8;
-			@optional double l_04_i_gdcomac_blcg_f8;
-			@optional double l_04_i_gdcomac_bscg_f8;
-			@optional double l_04_i_gdcomac_wlcg_f8;
-			@optional char l_04_i_gdcomac_pb_active_l1;
-			@optional double l_04_i_gdcomac_brake_torq_f8[3][2];
-			@optional double l_04_i_gdcomac_gear_f8[3];
-			@optional double l_04_i_gdcomac_gsteer_f8[10];
-			@optional double l_04_i_gdcomac_tire_pres_f8[3][2];
-			@optional char l_04_i_gdcomac_onjax_l1;
-			@optional double l_04_i_gdcomac_contdep_f8[7];
-			@optional double l_04_i_gdcomac_thetag_f8;
-			@optional double l_04_i_gdcomac_phig_f8;
-			@optional long l_04_i_gdcomac_rwyrgh_i2;
-			@optional double l_04_i_gdcomac_rwyhdg_f8;
-			@optional char l_04_i_gdcomac_reset_braketemp_l1;
-			@optional char l_04_i_gdcomac_reset_tirepress_l1;
-			@optional double l_04_i_gdcomac_temp_c_f8;
-			@optional double l_04_i_gdcomac_brake_temp_f8[3][2];
-			@optional char l_04_i_gdcomac_tire_tburst_l1[3][2];
-			@optional char l_04_i_gdcomac_tire_tflat_l1[3][2];
-			@optional char l_04_i_gdcomac_brk_reset_tpres_l1;
-			@optional double l_04_i_gdcomac_rcon_ci_f8[14];
-			@optional double l_04_i_gdcomac_pb_towforce_f8;
-			@optional long l_04_i_gdcomac_gsteer_state_i4;
-			@optional char l_04_i_gdcomac_trim_active_l1;
-			@optional double l_04_i_gdcomac_phi_deg_f8;
-			@optional double l_04_i_gdcomac_theta_deg_f8;
-			@optional double l_04_i_gdcomac_psi_deg_f8;
-			@optional char l_04_i_gdcomac_resetint_l1;
-		};
-		struct GroundHandling_output
-		{
-			@optional char l_04_o_gdcomac_frz_l1;
-			@optional char l_04_o_gdcomac_ac_on_ground_l1;
-			@optional double l_04_o_gdcomac_ac_stationary_f8;
-			@optional double l_04_o_gdcomac_alt_tire_f8;
-			@optional double l_04_o_gdcomac_zcg_to_tire_f8;
-			@optional double l_04_o_gdcomac_fxb_f8;
-			@optional double l_04_o_gdcomac_fyb_f8;
-			@optional double l_04_o_gdcomac_fzb_f8;
-			@optional double l_04_o_gdcomac_mxb_f8;
-			@optional double l_04_o_gdcomac_myb_f8;
-			@optional double l_04_o_gdcomac_mzb_f8;
-			@optional double l_04_o_gdcomac_fygs_f8[3];
-			@optional double l_04_o_gdcomac_mzgs_f8[3];
-			@optional double l_04_o_gdcomac_mu_f8[3];
-			@optional double l_04_o_gdcomac_dstroke_f8[3];
-			@optional double l_04_o_gdcomac_sr_f8[3][2];
-			@optional double l_04_o_gdcomac_sy_f8[3][2];
-			@optional double l_04_o_gdcomac_sx_f8[3][2];
-			@optional double l_04_o_gdcomac_xft_f8[3];
-			@optional double l_04_o_gdcomac_yft_f8[3];
-			@optional double l_04_o_gdcomac_zft_f8[3];
-			@optional double l_04_o_gdcomac_distngrxcg_f8;
-			@optional double l_04_o_gdcomac_distmgrxcg_f8;
-			@optional double l_04_o_gdcomac_distmgrzcg_f8;
-			@optional double l_04_o_gdcomac_tire_vel_f8[3][2];
-			@optional char l_04_o_gdcomac_tire_burst_l1[3][2];
-			@optional double l_04_o_gdcomac_tire_temp_f8[3][2];
-			@optional char l_04_o_gdcomac_wow_l1;
-			@optional double l_04_o_gdcomac_utirew_f8[3][2];
-			@optional double l_04_o_gdcomac_vtirew_f8[3][2];
-			@optional double l_04_o_gdcomac_whl_omega_f8[3][2];
-			@optional double l_04_o_gdcomac_dstruc_f8[6];
-			@optional double l_04_o_gdcomac_wor_par_f8[3];
-			@optional double l_04_o_gdcomac_nd_f8[3];
-			@optional double l_04_o_gdcomac_vczt_f8[3][2];
-		};
-		struct GroundHandling_heartbeat
-		{
-			long groundhandling_model_heartbeat;
-		};
-	};
-};

Release/Models/XNGroundHandling.mcfg

@@ -8,6 +8,6 @@
     <ChangeTime>2025-02-19 16:22:19</ChangeTime>
     <Node>0-0</Node>
     <Priority>99</Priority>
-    <MathLib>ATA04_SACSCGroundHandling_2.0.27.1H_20241106/libSACSCGroundHandling.so</MathLib>
+    <MathLib>ATA04_SACSCGroundHandling_2.0.143.1H_20250506/libSACSCGroundHandling.so.2.0.143.1H</MathLib>
     <CommandList/>
 </Model>

Release/Models/XNWeightBalance.idl

@@ -1,95 +0,0 @@
-module XNSim
-{
-	module ATA04
-	{
-		struct WeightBalance_input
-		{
-			@optional double l_04_i_wbcomac_theta_deg_f8;
-			@optional char l_04_i_wbcomac_gear_mode_l1;
-			@optional double l_04_i_wbcomac_acset_gw_f8;
-			@optional double l_04_i_wbcomac_acset_cg_f8;
-			@optional float l_04_i_wbcomac_acset_tankfuel_f4[20];
-			@optional double l_04_i_wbcomac_acset_totfuel_f8;
-			@optional double l_04_i_wbcomac_acset_zfw_f8;
-			@optional double l_04_i_wbcomac_acset_zfwcg_f8;
-			@optional char l_04_i_wbcomac_eng_efsep_l1[4];
-			@optional double l_04_i_wbcomac_fuel_f8[20];
-			@optional double l_04_i_wbcomac_gear_avg_f8;
-			@optional double l_04_i_wbcomac_kice_f8[20];
-			@optional char l_04_i_wbcomac_bycglim_l1;
-			@optional char l_04_i_wbcomac_bygwlim_l1;
-			@optional char l_04_i_wbcomac_frz_l1;
-			@optional char l_04_i_wbcomac_zcgfrz_l1;
-			@optional char l_04_i_wbcomac_zcgfrz_grfx_l1;
-			@optional char l_04_i_wbcomac_ycgfrz_l1;
-			@optional char l_04_i_wbcomac_inertfrz_l1;
-			@optional double l_04_i_wbcomac_potreq_gw_f8;
-			@optional double l_04_i_wbcomac_potreq_gwcg_f8;
-			@optional double l_04_i_wbcomac_phi_deg_f8;
-			@optional double l_04_i_wbcomac_psi_deg_f8;
-		};
-		struct WeightBalance_output
-		{
-			@optional char l_04_o_wbcomac_frz_l1;
-			@optional char l_04_o_wbcomac_zcgfrz_l1;
-			@optional char l_04_o_wbcomac_zcgfrz_grfx_l1;
-			@optional char l_04_o_wbcomac_ycgfrz_l1;
-			@optional char l_04_o_wbcomac_inertfrz_l1;
-			@optional float l_04_o_wbcomac_gw_f4;
-			@optional float l_04_o_wbcomac_cg_f4;
-			@optional double l_04_o_wbcomac_blcg_f8;
-			@optional double l_04_o_wbcomac_bscg_f8;
-			@optional double l_04_o_wbcomac_wlcg_f8;
-			@optional double l_04_o_wbcomac_xcg_f8;
-			@optional double l_04_o_wbcomac_ixx_f8;
-			@optional double l_04_o_wbcomac_ixy_f8;
-			@optional double l_04_o_wbcomac_ixz_f8;
-			@optional double l_04_o_wbcomac_iyy_f8;
-			@optional double l_04_o_wbcomac_iyz_f8;
-			@optional double l_04_o_wbcomac_izz_f8;
-			@optional float l_04_o_wbcomac_zfw_f4;
-			@optional float l_04_o_wbcomac_zfwcg_f4;
-			@optional float l_04_o_wbcomac_zfw_blcg_f4;
-			@optional float l_04_o_wbcomac_zfw_wlcg_f4;
-			@optional double l_04_o_wbcomac_fuel_cmd_f8[20];
-			@optional long l_04_o_wbcomac_fuel_mode_i4;
-			@optional double l_04_o_wbcomac_fuel_ixx_f8;
-			@optional double l_04_o_wbcomac_fuel_ixy_f8;
-			@optional double l_04_o_wbcomac_fuel_ixz_f8;
-			@optional double l_04_o_wbcomac_fuel_iyy_f8;
-			@optional double l_04_o_wbcomac_fuel_iyz_f8;
-			@optional double l_04_o_wbcomac_fuel_izz_f8;
-			@optional double l_04_o_wbcomac_l_wt_fuel_f8;
-			@optional double l_04_o_wbcomac_ice_airframe_total_f8;
-			@optional double l_04_o_wbcomac_ice_eng_f8[4];
-			@optional double l_04_o_wbcomac_ice_eng_total_f8;
-			@optional double l_04_o_wbcomac_ice_fuselage_f8;
-			@optional double l_04_o_wbcomac_ice_stab_left_f8;
-			@optional double l_04_o_wbcomac_ice_stab_right_f8;
-			@optional double l_04_o_wbcomac_ice_stab_total_f8;
-			@optional double l_04_o_wbcomac_ice_total_f8;
-			@optional double l_04_o_wbcomac_ice_total_frac_f8;
-			@optional double l_04_o_wbcomac_ice_vert_tail_f8;
-			@optional double l_04_o_wbcomac_ice_wing_left_f8;
-			@optional double l_04_o_wbcomac_ice_wing_right_f8;
-			@optional double l_04_o_wbcomac_ice_wing_total_f8;
-			@optional char l_04_o_wbcomac_init_l1;
-			@optional double l_04_o_wbcomac_potmin_gw_f8;
-			@optional double l_04_o_wbcomac_potmax_gw_f8;
-			@optional double l_04_o_wbcomac_potmin_gwcg_f8;
-			@optional double l_04_o_wbcomac_potmax_gwcg_f8;
-			@optional float l_04_o_wbcomac_min_cg_f4;
-			@optional float l_04_o_wbcomac_min_gw_f4;
-			@optional float l_04_o_wbcomac_min_zfw_f4;
-			@optional float l_04_o_wbcomac_min_zfwcg_f4;
-			@optional float l_04_o_wbcomac_max_cg_f4;
-			@optional float l_04_o_wbcomac_max_gw_f4;
-			@optional float l_04_o_wbcomac_max_zfw_f4;
-			@optional float l_04_o_wbcomac_max_zfwcg_f4;
-		};
-		struct WeightBalance_heartbeat
-		{
-			long weightbody_model_heartbeat;
-		};
-	};
-};

Release/Models/asdasdf.mcfg

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?><Model>
-	<Name>asdf</Name>
-	<Description>模型描述</Description>
-	<Author>用户</Author>
-	<Version>1.0.0</Version>
-	<CreateTime>2025-04-23 15:43:50</CreateTime>
-	<ChangeTime>2025-04-23 15:43:50</ChangeTime>
-	<Node>0-0</Node>
-	<Priority>99</Priority>
-	<MathLib/>
-	<CommandList><Command Name="asdf" Call="asdf" Description="asdf"/></CommandList>
-</Model>

Release/Models/asdf.mcfg

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?><Model>
-	<Name>asdf</Name>
-	<Description>模型描述</Description>
-	<Author>用户</Author>
-	<Version>1.0.0</Version>
-	<CreateTime>2025-04-23 15:43:50</CreateTime>
-	<ChangeTime>2025-04-23 15:43:50</ChangeTime>
-	<Node>0-0</Node>
-	<Priority>99</Priority>
-	<MathLib/>
-	<CommandList><Command Name="sdf" Call="asdf" Description="adsf"/></CommandList>
-</Model>

Release/Models/asdfasd.mcfg

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?><Model>
-	<Name>asdf</Name>
-	<Description>模型描述</Description>
-	<Author>用户</Author>
-	<Version>1.0.0</Version>
-	<CreateTime>2025-04-23 15:43:50</CreateTime>
-	<ChangeTime>2025-04-23 15:43:50</ChangeTime>
-	<Node>0-0</Node>
-	<Priority>99</Priority>
-	<MathLib/>
-	<CommandList/>
-</Model>

Release/Scenario/OnlyFlightModel.xml

@@ -1,13 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
   <Scenario>
-            	<Environment OSName="Debian" Version="11" RTXVersion="preempt-rt" CPUAffinity="0,1" BaseFrequency="120" WorkPath="/home/jin/MyCode/XNSim/Release/" ModelsPath="Models/" ServicesPath="Services/" DomainID="10"/>
+            	<Environment OSName="Debian" Version="11" RTXVersion="preempt-rt" CPUAffinity="0,1" WorkPath="/home/jin/MyCode/XNSim/Release/" ModelsPath="Models/" ServicesPath="Services/" DomainID="10"/>
             	<ConsoleOutput Debug="1" Info="1" Error="1" Warning="1"/>
             	<Log Debug="0" Info="1" Error="1" Warning="1"/>
-                <ModelGroup Name="本体模型组" FreqGroup="0" Priority="99" CPUAff="0">
+                <ModelGroup Name="本体模型组" Freq="120" Priority="99" CPUAff="0">
                   		<Model Name="ATA04气动模型" ClassName="XNAerodynamics"/>
                   		<Model Name="ATA04地面操纵模型" ClassName="XNGroundHandling"/>
                   		<Model Name="ATA04质量模型" ClassName="XNWeightBalance"/>
-                  		<!--Model Name="ATA04数据处理模型" ClassName="XNATA04DataProcessor"/-->
+                  		<Model Name="ATA04数据处理模型" ClassName="XNATA04DataProcessor"/>
             	</ModelGroup>
             	<ServicesList>
                   		<Service Name="UDP通信服务" ClassName="XNUDPService"/>

Release/Scenario/test.sce

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Scenario>
-	<Environment
-	OSName="Debian"
-	Version="11"
-	RTXVersion="preempt-rt"
-	CPUAffinity="0,1"
-	BaseFrequency="120"
-	WorkPath="/home/jin/Myprj/XNSim/Release/"
-	ModelsPath="Models/"
-	ServicesPath="Services/"
-	DomainID="10"
-	/>
-	<ConsoleOutput Debug="1" Info="1" Error="1" Warning="1" />
-	<Log Debug="0" Info="1" Error="1" Warning="1" />
-    <ModelGroup Name="本体模型组" FreqGroup="0" Priority="99" CPUAff="0">
-		<Model Name="ATA04气动模型" ClassName="XNAerodynamics" />
-		<Model Name="ATA04地面操纵模型" ClassName="XNGroundHandling" />
-		<Model Name="ATA04质量模型" ClassName="XNWeightBalance" />
-		<Model Name="ATA04数据处理模型" ClassName="XNATA04DataProcessor" />
-	</ModelGroup>
-	<ServicesList>
-		<Service Name="UDP通信服务" ClassName="XNUDPService" />
-	</ServicesList>
-</Scenario>

Release/Scenario/test.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Scenario>
-    <Environment
-        OSName="Debian"
-        Version="11"
-        RTXVersion="preempt-rt"
-        CPUAffinity="0,1"
-        BaseFrequency="120"
-        WorkPath="/home/jin/Myprj/XNSim/Release/"
-        ModelsPath="Models/"
-        ServicesPath="Services/"
-        DomainID="10"
-    />
-    <ConsoleOutput Debug="1" Info="1" Error="1" Warning="1" />
-    <Log Debug="0" Info="1" Error="1" Warning="1" />
-    <ModelGroup Name="新模型组" FreqGroup="0" Priority="99" CPUAff="0">
-        <!-- 这里添加模型 -->
-    </ModelGroup>
-    <ServicesList>
-        <!-- 这里添加服务 -->
-    </ServicesList>
-</Scenario>

Release/Scenario/testGRD.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+  <Scenario>
+            	<Environment OSName="Debian" Version="11" RTXVersion="preempt-rt" CPUAffinity="0,1" WorkPath="/home/jin/MyCode/XNSim/Release/" ModelsPath="Models/" ServicesPath="Services/" DomainID="10"/>
+            	<ConsoleOutput Debug="1" Info="1" Error="1" Warning="1"/>
+            	<Log Debug="0" Info="1" Error="1" Warning="1"/>
+                <ModelGroup Name="本体模型组" Freq="120" Priority="99" CPUAff="0">
+                  	<Model Name="ATA04地面操纵模型" ClassName="XNGroundHandling"/>
+                  	<Model Name="ATA04数据处理模型" ClassName="XNATA04DataProcessor"/>
+            	</ModelGroup>
+            	<ServicesList>
+                  		<Service Name="UDP通信服务" ClassName="XNUDPService"/>
+            	</ServicesList>
+      </Scenario>

Release/include/DataModels/libSACSCGroundHandling_V2.0.143.1H/std_04_dll.h

@@ -0,0 +1,593 @@
+#ifndef CMCLIB_H
+#define CMCLIB_H
+
+#include <string>
+
+typedef struct ComacDataStructure_S {
+	int aero_model_heartbeat;
+	int weightbody_model_heartbeat;
+	int groundhandling_model_heartbeat;
+
+	double yitim;
+
+	struct input_aero_S*  input_aero;
+	struct output_aero_S* output_aero;
+
+	struct input_weight_S*  input_weight;
+	struct output_weight_S* output_weight;
+
+	struct input_ground_S*  input_ground;
+	struct output_ground_S* output_ground;
+};
+
+struct input_weight_S {
+	double l_04_i_wbcomac_theta_deg_f8;
+	double l_04_i_wbcomac_phi_deg_f8;
+	double l_04_i_wbcomac_psi_deg_f8;
+
+	unsigned char l_04_i_wbcomac_gear_mode_l1;
+
+	double l_04_i_wbcomac_acset_gw_f8;
+	double l_04_i_wbcomac_acset_cg_f8;
+
+	// [0]: left wing tank
+	// [1]: right wing tan
+	// [2]: center tank
+	float* l_04_i_wbcomac_acset_tankfuel_f4;
+	double l_04_i_wbcomac_acset_totfuel_f8;
+
+	double l_04_i_wbcomac_acset_zfw_f8;
+	double l_04_i_wbcomac_acset_zfwcg_f8;
+
+	// [0]: Engine #1
+	// [1]: Engine #2
+	unsigned char* l_04_i_wbcomac_eng_efsep_l1;
+
+	// [0]: left wing tank
+	// [1]: right wing tan
+	// [2]: center tank
+	double* l_04_i_wbcomac_fuel_f8;
+
+	double l_04_i_wbcomac_gear_avg_f8;
+
+	// [0]: outboard left wing
+	// [1]: inboard left wing
+	// [2]: root left wing
+	// [3]: root right wing
+	// [4]: inboard right wing
+	// [5]: outboard right wing
+	// [6]: fuselage icing
+	// [7]: left horizontal tail
+	// [8]: right horizontal tail
+	// [9]: vertical tail
+	// [10]: engine 1
+	// [11]: engine 2
+	double* l_04_i_wbcomac_kice_f8;
+
+	unsigned char l_04_i_wbcomac_bycglim_l1;
+	unsigned char l_04_i_wbcomac_bygwlim_l1;
+
+	unsigned char l_04_i_wbcomac_frz_l1;
+	unsigned char l_04_i_wbcomac_zcgfrz_l1;
+	unsigned char l_04_i_wbcomac_zcgfrz_grfx_l1;
+	unsigned char l_04_i_wbcomac_ycgfrz_l1;
+	unsigned char l_04_i_wbcomac_inertfrz_l1;
+
+	double l_04_i_wbcomac_potreq_gw_f8;
+	double l_04_i_wbcomac_potreq_gwcg_f8;
+};
+
+struct output_weight_S {
+
+	float l_04_o_wbcomac_gw_f4;
+	float l_04_o_wbcomac_cg_f4;
+
+	double l_04_o_wbcomac_xcg_f8;
+
+	double l_04_o_wbcomac_blcg_f8;
+	double l_04_o_wbcomac_bscg_f8;
+	double l_04_o_wbcomac_wlcg_f8;
+
+	double l_04_o_wbcomac_ixx_f8;
+	double l_04_o_wbcomac_ixy_f8;
+	double l_04_o_wbcomac_ixz_f8;
+	double l_04_o_wbcomac_iyy_f8;
+	double l_04_o_wbcomac_iyz_f8;
+	double l_04_o_wbcomac_izz_f8;
+
+	float l_04_o_wbcomac_zfw_f4;
+	float l_04_o_wbcomac_zfwcg_f4;
+	float l_04_o_wbcomac_zfw_blcg_f4;
+	float l_04_o_wbcomac_zfw_wlcg_f4;
+
+	// [0]: left wing tank   (if mode is 2)
+	// [1]: right wing tank  (if mode is 2)
+	// [2]: center tank      (if mode is 2) 
+	double* l_04_o_wbcomac_fuel_cmd_f8;
+
+	// 0 = backdrive inactive, 1 = total fuel backdrive, 2 = individual fuel tank backdrive
+	int l_04_o_wbcomac_fuel_mode_i4;
+
+	double l_04_o_wbcomac_fuel_ixx_f8;
+	double l_04_o_wbcomac_fuel_ixy_f8;
+	double l_04_o_wbcomac_fuel_ixz_f8;
+	double l_04_o_wbcomac_fuel_iyy_f8;
+	double l_04_o_wbcomac_fuel_iyz_f8;
+	double l_04_o_wbcomac_fuel_izz_f8;
+
+	double l_04_o_wbcomac_l_wt_fuel_f8;
+	double l_04_o_wbcomac_ice_airframe_total_f8;
+
+	// [0]: Engine #1
+	// [1]: Engine #2
+	double* l_04_o_wbcomac_ice_eng_f8;
+	double l_04_o_wbcomac_ice_eng_total_f8;
+
+	double l_04_o_wbcomac_ice_fuselage_f8;
+	double l_04_o_wbcomac_ice_stab_left_f8;
+	double l_04_o_wbcomac_ice_stab_right_f8;
+	double l_04_o_wbcomac_ice_stab_total_f8;
+	double l_04_o_wbcomac_ice_total_f8;
+	double l_04_o_wbcomac_ice_total_frac_f8;
+	double l_04_o_wbcomac_ice_vert_tail_f8;
+	double l_04_o_wbcomac_ice_wing_left_f8;
+	double l_04_o_wbcomac_ice_wing_right_f8;
+	double l_04_o_wbcomac_ice_wing_total_f8;
+
+	unsigned char l_04_o_wbcomac_frz_l1;
+	unsigned char l_04_o_wbcomac_zcgfrz_l1;
+	unsigned char l_04_o_wbcomac_zcgfrz_grfx_l1;
+	unsigned char l_04_o_wbcomac_ycgfrz_l1;
+	unsigned char l_04_o_wbcomac_inertfrz_l1;
+
+	unsigned char l_04_o_wbcomac_init_l1;
+
+	float l_04_o_wbcomac_min_gw_f4;
+	float l_04_o_wbcomac_max_gw_f4;
+
+	float l_04_o_wbcomac_min_cg_f4;    // 0 = Leading Edge MAC, 1 = Trailing Edge MAC
+	float l_04_o_wbcomac_max_cg_f4;    // 0 = Leading Edge MAC, 1 = Trailing Edge MAC
+
+	float l_04_o_wbcomac_min_zfw_f4;    // 0 = Leading Edge MAC, 1 = Trailing Edge MAC
+	float l_04_o_wbcomac_max_zfw_f4;    // 0 = Leading Edge MAC, 1 = Trailing Edge MAC
+
+	float l_04_o_wbcomac_min_zfwcg_f4;
+	float l_04_o_wbcomac_max_zfwcg_f4;
+
+	double l_04_o_wbcomac_potmin_gw_f8;  // 0 = Leading Edge MAC, 1 = Trailing Edge MAC  
+	double l_04_o_wbcomac_potmax_gw_f8;  // 0 = Leading Edge MAC, 1 = Trailing Edge MAC  
+
+	double l_04_o_wbcomac_potmin_gwcg_f8;
+	double l_04_o_wbcomac_potmax_gwcg_f8;
+};
+
+struct input_ground_S {
+
+	unsigned char l_04_i_gdcomac_frz_l1;
+
+	unsigned char l_04_i_gdcomac_chocks_l1; // 1 = A/C on chocks
+
+	double l_04_i_gdcomac_alt_agl_f8;
+
+	unsigned char l_04_i_gdcomac_frzflt_l1;
+
+	double l_04_i_gdcomac_p_f8;
+	double l_04_i_gdcomac_q_f8;
+	double l_04_i_gdcomac_r_f8;
+
+	double l_04_i_gdcomac_ug_f8;
+	double l_04_i_gdcomac_vg_f8;
+	double l_04_i_gdcomac_wg_f8;
+
+	double l_04_i_gdcomac_blcg_f8;
+	double l_04_i_gdcomac_bscg_f8;
+	double l_04_i_gdcomac_wlcg_f8;
+
+	unsigned char l_04_i_gdcomac_pb_active_l1;
+	double l_04_i_gdcomac_pb_towforce_f8; // "PUSHBACK TOW FORCE"
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_i_gdcomac_brake_torq_f8;
+
+	// [0] : Nose gear,
+	// [1] : Left gear,
+	// [2] : Right gear
+	double* l_04_i_gdcomac_gear_f8; // 1 = Gear down / 0 = Gear up
+
+	// [0] : Nose gear,
+	// [1] : Left gear,
+	// [2] : Right gear
+	double* l_04_i_gdcomac_gsteer_f8; // Positive: turn right
+
+	// [0][0] : Nose gear, Tire left
+	// [0][1] : Nose gear, Tire right
+	// [1][0] : Left gear, Tire left
+	// [1][1] : Left gear, Tire right
+	// [2][0] : Right gear, Tire left
+	// [2][1] : Right gear, Tire right
+	double** l_04_i_gdcomac_tire_pres_f8;
+
+	unsigned char  l_04_i_gdcomac_onjax_l1; // Positive: turn right
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_i_gdcomac_contdep_f8; // Will be provided according to contamination type.
+
+	double l_04_i_gdcomac_thetag_f8;
+	double l_04_i_gdcomac_phig_f8;
+
+	int l_04_i_gdcomac_rwyrgh_i2;// 4 Levels of Roughness. From MIN to MAX.
+	double l_04_i_gdcomac_rwyhdg_f8;// North-South axis
+
+	unsigned char  l_04_i_gdcomac_reset_braketemp_l1;
+	unsigned char  l_04_i_gdcomac_reset_tirepress_l1;
+
+	double l_04_i_gdcomac_temp_c_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_i_gdcomac_brake_temp_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	unsigned char** l_04_i_gdcomac_tire_tburst_l1; // 1 =  Tire is burst
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	unsigned char** l_04_i_gdcomac_tire_tflat_l1;  // 1 =  Tire is flat 
+
+	unsigned char  l_04_i_gdcomac_brk_reset_tpres_l1;  // Reset the tire pressure to the value set from flight control. 
+
+	//  [0]: Dried 
+	//  [1]: Wet 
+	//  [2]: Flooded 
+	//  [3]: Wet with rubber
+	//  [4]: Flooded with ru
+	//  [5]: Melting Slush 
+	//  [6]: Freezing Slush 
+	//  [7]: Wet Snow
+	//  [8]: Dry Snow
+	//  [9]: Wet Ice
+	//  [10]: Cold Ice
+	//  [11]: Thin Dust/Dirs
+	//  [12]: Thick Dust/Dir
+	//  [13]: White Strip
+	double* l_04_i_gdcomac_rcon_ci_f8;
+
+	int l_04_i_gdcomac_gsteer_state_i4; // 0 = Engaged, 2 = Castoring
+
+	unsigned char l_04_i_gdcomac_trim_active_l1;
+
+	double l_04_i_gdcomac_theta_deg_f8;
+	double l_04_i_gdcomac_phi_deg_f8;
+	double l_04_i_gdcomac_psi_deg_f8;
+
+	unsigned char l_04_i_gdcomac_resetint_l1; // when this is true, the ground model should return the default values of the ground parameters
+
+	unsigned char l_04_i_gdcomac_eom_wgfrz_l1;
+	unsigned char l_04_i_gdcomac_eom_vgfrz_l1;
+	unsigned char l_04_i_gdcomac_eom_ugfrz_l1;
+	unsigned char l_04_i_gdcomac_eom_pfrz_l1;
+	unsigned char l_04_i_gdcomac_eom_qfrz_l1;
+	unsigned char l_04_i_gdcomac_eom_rfrz_l1;
+	unsigned char l_04_i_gdcomac_eom_hfrz_l1;
+	unsigned char l_04_i_gdcomac_eom_phifrz_l1;
+	unsigned char l_04_i_gdcomac_eom_thefrz_l1;
+	unsigned char l_04_i_gdcomac_eom_psifrz_l1;
+};
+
+struct output_ground_S {
+
+	unsigned char l_04_o_gdcomac_frz_l1;
+
+	unsigned char l_04_o_gdcomac_ac_on_ground_l1;   // 1 = A/C is on ground
+	double        l_04_o_gdcomac_ac_stationary_f8;  // 1 = A/C is moving / 0 = A/C is stationary
+
+	double l_04_o_gdcomac_alt_tire_f8;
+	double l_04_o_gdcomac_zcg_to_tire_f8;
+
+	double l_04_o_gdcomac_fxb_f8;
+	double l_04_o_gdcomac_fyb_f8;
+	double l_04_o_gdcomac_fzb_f8;
+
+	double l_04_o_gdcomac_mxb_f8;
+	double l_04_o_gdcomac_myb_f8;
+	double l_04_o_gdcomac_mzb_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_fygs_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_mzgs_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_mu_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_dstroke_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_sr_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_sy_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_sx_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_xft_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_yft_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_zft_f8;
+
+	double l_04_o_gdcomac_distngrxcg_f8;
+	double l_04_o_gdcomac_distmgrxcg_f8;
+	double l_04_o_gdcomac_distmgrzcg_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_tire_vel_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_tire_temp_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	unsigned char** l_04_o_gdcomac_tire_burst_l1;
+
+	unsigned char l_04_o_gdcomac_wow_l1;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_utirew_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_vtirew_f8;
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_whl_omega_f8;
+
+	// [0] = Nose 
+	// [1] = Left wing
+	// [2] = Right wing
+	// [3] = Left Body
+	// [4] = Right Body
+	// [5] = Tail
+	double*  l_04_o_gdcomac_dstruc_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_nd_f8;
+
+	// [0]: Nose gear
+	// [1]: Left gear
+	// [2]: Right gea
+	double* l_04_o_gdcomac_wor_par_f8; // Only [0]: Nose gear can have yaw / is driven
+
+	// [0][0]: Nose gear, Tire left
+	// [0][1]: Nose gear, Tire right
+	// [1][0]: Left gear, Tire left
+	// [1][1]: Left gear, Tire right
+	// [2][0]: Right gear, Tire left
+	// [2][1]: Right gear, Tire right
+	double** l_04_o_gdcomac_vczt_f8;
+
+	unsigned char l_04_o_gdcomac_eom_wgfrz_l1;  // DISABLE INTEG. OF Z BODY VELOCI
+	unsigned char l_04_o_gdcomac_eom_vgfrz_l1;  // DISABLE INTEG. OF Y BODY VELOCI
+	unsigned char l_04_o_gdcomac_eom_ugfrz_l1;  // DISABLE INTEG. OF X BODY VELOCI
+	unsigned char l_04_o_gdcomac_eom_pfrz_l1;   // DISABLE INTEG. OF BODY AXIS ROL
+	unsigned char l_04_o_gdcomac_eom_qfrz_l1;   // DISABLE INTEG. OF BODY AXIS PIT
+	unsigned char l_04_o_gdcomac_eom_rfrz_l1;   // DISABLE INTEG. OF BODY AXIS YAW
+	unsigned char l_04_o_gdcomac_eom_hfrz_l1;   // DISABLE INTEG. OF ALTITUDE ABOV
+	unsigned char l_04_o_gdcomac_eom_phifrz_l1; // DISABLE INTEG. OF ROLL ANGLE
+	unsigned char l_04_o_gdcomac_eom_thefrz_l1; // DISABLE INTEG. OF PITCH ANGLE
+	unsigned char l_04_o_gdcomac_eom_psifrz_l1; // DISABLE INTEG. OF YAW ANGLE
+};
+
+
+struct output_aero_S {
+	double  l_04_o_aerocomac_fxb_f8;
+	double  l_04_o_aerocomac_fyb_f8;
+	double  l_04_o_aerocomac_fzb_f8;
+
+	double  l_04_o_aerocomac_mxb_f8;
+	double  l_04_o_aerocomac_myb_f8;
+	double  l_04_o_aerocomac_mzb_f8;
+
+	double  l_04_o_aerocomac_cls_f8;
+
+	double  l_04_o_aerocomac_cl_f8;
+	double  l_04_o_aerocomac_cd_f8;
+	double  l_04_o_aerocomac_cm_f8;
+
+	double  l_04_o_aerocomac_cr_f8;
+	double  l_04_o_aerocomac_cy_f8;
+	double  l_04_o_aerocomac_cn_f8;
+};
+
+struct input_aero_S {
+
+	// double l_04_i_aerocomac_uprt_swvtx_p_f8; // UPRT Simplified wake vortex rotational wind (Roll)
+	// double l_04_i_aerocomac_uprt_swvtx_q_f8; // UPRT Simplified wake vortex rotational wind (Pitch)
+
+	double l_04_i_aerocomac_alpha_f8;
+	double l_04_i_aerocomac_alpdot_f8;
+	double l_04_i_aerocomac_beta_f8;
+
+	double l_04_i_aerocomac_press_alt_f8;
+
+	double l_04_i_aerocomac_tas_f8;
+	double l_04_i_aerocomac_mach_f8;
+
+	double l_04_i_aerocomac_nx_f8;
+	double l_04_i_aerocomac_ny_f8;
+	double l_04_i_aerocomac_nz_f8;
+
+	double l_04_i_aerocomac_p_f8;
+	double l_04_i_aerocomac_q_f8;
+	double l_04_i_aerocomac_r_f8;
+
+	double l_04_i_aerocomac_qbar_f8;
+
+	double l_04_i_aerocomac_blcg_f8;
+	double l_04_i_aerocomac_bscg_f8;
+	double l_04_i_aerocomac_wlcg_f8;
+
+	double l_04_i_aerocomac_stab_f8;
+
+	// [0] : left aileron
+	// [1] : right aileron
+	double* l_04_i_aerocomac_ail_f8;
+
+	// [0] : left elevator
+	// [1] : right elevator
+	double* l_04_i_aerocomac_elv_f8;
+
+	// [0] : rudder
+	// [1] : not use
+	double* l_04_i_aerocomac_rud_f8;   // Size = 2
+
+	// [0] : Nose Gear
+	// [1] : Left Main Gear
+	// [2] : Right Main Gear
+	double* l_04_i_aerocomac_gear_f8;   // Index 1 : Nose Gear
+
+	// [0] : left wing flap
+	// [1] : right wing flap
+	double* l_04_i_aerocomac_flap_f8;
+
+	// [0] : left wing slat
+	// [1] : right wing slat
+	double* l_04_i_aerocomac_slat_f8;
+
+	// Spoiler 1 (deg +ve TED) // Index 1 to 8 : from left outboard spoiler to right outboard spoiler
+	// Spoiler 2 (deg +ve TED) // Index 1 to 8 : from left outboard spoiler to right outboard spoiler
+	// Spoiler 3 (deg +ve TED) // Index 1 to 8 : from left outboard spoiler to right outboard spoiler
+	// Spoiler 4 (deg +ve TED) // Index 1 to 8 : from left outboard spoiler to right outboard spoiler
+	// Spoiler 5 (deg +ve TED) // Index 1 to 8 : from left outboard spoiler to right outboard spoiler
+	// Spoiler 6 (deg +ve TED) // Index 1 to 8 : from left outboard spoiler to right outboard spoiler
+	// Spoiler 7 (deg +ve TED) // Index 1 to 8 : from left outboard spoiler to right outboard spoiler
+	// Spoiler 8 (deg +ve TED) // Index 1 to 8 : from left outboard spoiler to right outboard spoiler
+	double* l_04_i_aerocomac_spl_f8;
+
+	// [0] : engine #1
+	// [1] : engine #2
+	double* l_04_i_aerocomac_tnet_f8;
+
+	// [0]: outboard left wing
+	// [1]: inboard left wing
+	// [2]: root left wing
+	// [3]: root right wing
+	// [4]: inboard right wing
+	// [5]: outboard right wing
+	// [6]: fuselage icing
+	// [7]: left horizontal tail
+	// [8]: right horizontal tail
+	// [9]: vertical tail
+	// [10]: engine 1
+	// [11]: engine 2
+	double* l_04_i_aerocomac_kice_f8;
+	double l_04_i_aerocomac_alt_agl_f8;
+};
+
+void comacAeroModelPreProcess(ComacDataStructure_S* ComacDataStructure);
+void comacAeroModelPostProcess(ComacDataStructure_S* ComacDataStructure);
+
+void comacWeightModelPreProcess(ComacDataStructure_S* ComacDataStructure);
+void comacWeightModelPostProcess(ComacDataStructure_S* ComacDataStructure);
+
+void comacGroundModelPreProcess(ComacDataStructure_S* ComacDataStructure);
+void comacGroundModelPostProcess(ComacDataStructure_S* ComacDataStructure);
+
+ComacDataStructure_S* allocateComacDataStructure_S(double yitim_, int cnf_numgear_i4, int cnf_numtire_i4);
+
+void init_input_weight_S(input_weight_S* ptr);
+void init_output_weight_S(output_weight_S* ptr);
+
+void init_input_ground_S(input_ground_S* ptr, int ngear, int ntiregear);
+void init_output_ground_S(output_ground_S* ptr, int ngear, int ntiregear);
+
+void init_input_aero_S(input_aero_S* ptr, int ngear);
+void init_output_aero_S(output_aero_S* ptr);
+
+
+#endif //CMCLIB_H

Release/include/XNCore/XNBaseFrameObject.h

@@ -12,34 +12,29 @@
 
 #include "XNObject.h"
 
-class XNBaseFrameObjectPrivate;
+struct XNBaseFrameObjectPrivate;
 
 /**
  * @brief 框架对象基类
  */
 class XNCORE_EXPORT XNBaseFrameObject : public XNObject
 {
-	/**
-	 * @brief 宏定义，用于支持Qt的元对象系统
-	 */
-	Q_OBJECT
-
 	/**
 	 * @brief 宏定义，用于禁用拷贝构造函数
 	 */
-	Q_DISABLE_COPY(XNBaseFrameObject)
+	XN_METATYPE(XNBaseFrameObject, XNObject)
 
 	/**
 	 * @brief 宏定义，用于声明私有数据成员
 	 */
-	Q_DECLARE_PRIVATE(XNBaseFrameObject);
+	XN_DECLARE_PRIVATE(XNBaseFrameObject)
 
 public:
 	/**
 	 * @brief 构造函数
 	 * @param parent 父对象
 	 */
-	XNBaseFrameObject(QObject *parent = nullptr);
+	XNBaseFrameObject();
 
 	/**
 	 * @brief 析构函数
@@ -52,44 +47,34 @@ protected:
 	 * @param dd 私有数据成员
 	 * @param parent 父对象
 	 */
-	XNBaseFrameObject(XNBaseFrameObjectPrivate &dd, QObject *parent = nullptr);
-
-signals:
-	/**
-	 * @brief 初始化
-	 */
-	void Initialize();
-
-	/**
-	 * @brief 初始化失败
-	 */
-	void InitializeFailed();
-
-	/**
-	 * @brief 准备执行
-	 */
-	void PrepareForExecute();
-
-	/**
-	 * @brief 准备执行失败
-	 */
-	void PrepareForExecuteFailed();
-
-public slots:
-	/**
-	 * @brief 初始化
-	 */
-	virtual void OnInitialize() = 0;
-
-	/**
-	 * @brief 准备执行
-	 */
-	virtual void OnPrepareForExecute() = 0;
+	XNBaseFrameObject(PrivateType *p);
 
 public:
+	/**
+	 * @brief 初始化
+	 */
+	virtual bool Initialize() = 0;
+
+	/**
+	 * @brief 准备执行
+	 */
+	virtual bool PrepareForExecute() = 0;
+
 	/**
 	 * @brief 获取框架对象状态
 	 * @return 框架对象状态
 	 */
 	XNFrameObjectStatus GetFrameObjectStatus();
+
+	/**
+	 * @brief 获取框架对象
+	 * @return 框架对象
+	 */
+	XNFrameworkPtr GetFramework();
+
+	/**
+	 * @brief 设置框架对象
+	 * @param framework 框架对象
+	 */
+	void SetFramework(XNFrameworkPtr framework);
 };

Release/include/XNCore/XNBaseFrameObject_p.h

@@ -16,22 +16,13 @@
 /**
  * @brief 框架对象基类的私有数据成员
  */
-class XNBaseFrameObjectPrivate : public XNObjectPrivate
-{
-public:
-	/**
-	 * @brief 构造函数
-	 * @param q 框架对象基类指针
-	 */
-	explicit XNBaseFrameObjectPrivate(XNBaseFrameObject *q) : XNObjectPrivate(q) {}
-
-	/**
-	 * @brief 宏定义，用于声明公有数据成员
-	 */
-	Q_DECLARE_PUBLIC(XNBaseFrameObject)
-
+struct XNBaseFrameObjectPrivate : public XNObjectPrivate {
 	/**
 	 * @brief 框架对象状态
 	 */
 	XNFrameObjectStatus _status = XNFrameObjectStatus::NotReady;
+	/**
+	 * @brief 框架对象
+	 */
+	XNFrameworkPtr _framework;
 };

Release/include/XNCore/XNByteArray.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+#include <cstring>
+
+/**
+ * @brief 自定义字节数组容器类
+ * @details 提供类似QByteArray的功能，用于处理二进制数据
+ */
+class XNByteArray
+{
+public:
+	XNByteArray() = default;
+	explicit XNByteArray(size_t size) : data_(size) {}
+
+	/**
+	 * @brief 从原始数据构造
+	 * @param buffer 原始数据缓冲区
+	 * @param size 数据大小
+	 */
+	XNByteArray(const uint8_t *buffer, size_t size) : data_(buffer, buffer + size) {}
+
+	/**
+	 * @brief 获取数据指针
+	 * @return 数据指针
+	 */
+	uint8_t *data() { return data_.data(); }
+
+	/**
+	 * @brief 获取常量数据指针
+	 * @return 常量数据指针
+	 */
+	const uint8_t *data() const { return data_.data(); }
+
+	/**
+	 * @brief 获取数据大小
+	 * @return 数据大小
+	 */
+	size_t size() const { return data_.size(); }
+
+	/**
+	 * @brief 调整大小
+	 * @param size 新大小
+	 */
+	void resize(size_t size) { data_.resize(size); }
+
+	/**
+	 * @brief 清空数据
+	 */
+	void clear() { data_.clear(); }
+
+	/**
+	 * @brief 追加数据
+	 * @param buffer 要追加的数据
+	 * @param size 数据大小
+	 */
+	void append(const uint8_t *buffer, size_t size)
+	{
+		size_t oldSize = data_.size();
+		data_.resize(oldSize + size);
+		std::memcpy(data_.data() + oldSize, buffer, size);
+	}
+
+	/**
+	 * @brief 追加另一个XNByteArray
+	 * @param other 要追加的XNByteArray
+	 */
+	void append(const XNByteArray &other) { append(other.data(), other.size()); }
+
+	/**
+	 * @brief 获取指定位置的字节
+	 * @param index 索引
+	 * @return 字节值
+	 */
+	uint8_t &operator[](size_t index) { return data_[index]; }
+
+	/**
+	 * @brief 获取指定位置的字节（常量版本）
+	 * @param index 索引
+	 * @return 字节值
+	 */
+	const uint8_t &operator[](size_t index) const { return data_[index]; }
+
+	/**
+	 * @brief 检查是否为空
+	 * @return 是否为空
+	 */
+	bool isEmpty() const { return data_.empty(); }
+
+	/**
+	 * @brief 预分配空间
+	 * @param size 要预分配的大小
+	 */
+	void reserve(size_t size) { data_.reserve(size); }
+
+private:
+	std::vector<uint8_t> data_;
+};

Release/include/XNCore/XNCore_global.h

@@ -1,14 +1,13 @@
-#ifndef XNCORE_GLOBAL_H
-#define XNCORE_GLOBAL_H
-
-#include <QtCore/qglobal.h>
+#pragma once
 
 #if defined(XNCORE_LIBRARY)
-#	define XNCORE_EXPORT Q_DECL_EXPORT
+#	define XNCORE_EXPORT __attribute__((visibility("default")))
 #else
-#	define XNCORE_EXPORT Q_DECL_IMPORT
+#	define XNCORE_EXPORT __attribute__((visibility("default")))
 #endif
 
+#define FORCEINLINE __attribute__((always_inline))
+
 #ifdef __linux__
 #	include <pthread.h>
 #	include <sched.h>
@@ -20,8 +19,38 @@
 #	include <memory>
 #	include <errno.h>
 #	include <unistd.h>
+#	include <limits.h>
+#	include <functional>
+#	include <map>
+#	include <unordered_map>
+#	include <vector>
+#	include <set>
+#	include <any>
+#	include <string>
+#	include <thread>
+#	include <mutex>
+#	include <condition_variable>
+#	include <queue>
+#	include <tinyxml2.h>
+#	include <chrono>
+#	include <iomanip>
+#	include <sstream>
+#	include <dlfcn.h>
+#	include <filesystem>
+#	include <array>
+#	include <cstring>
+#	include <iostream>
 #endif
 
+#include <fastdds/dds/domain/DomainParticipant.hpp>
+#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/publisher/DataWriter.hpp>
+#include <fastdds/dds/publisher/Publisher.hpp>
+#include <fastdds/dds/subscriber/DataReader.hpp>
+#include <fastdds/dds/subscriber/Subscriber.hpp>
+#include <fastdds/dds/topic/TypeSupport.hpp>
+#include <fastdds/dds/subscriber/DataReaderListener.hpp>
+#include <fastcdr/xcdr/optional.hpp>
 #define FAST_DDS_MACRO eprosima::fastdds::dds
 
 /**
@@ -40,6 +69,9 @@ using XNCallBack = std::function<void()>;
 //DDS回调函数类型别名
 using XNDDSCallBack = std::function<void(void *)>;
 
+//事件回调函数类型别名
+using XNEventCallback = std::function<void(const std::any &)>;
+
 /**
  * @brief 	纳秒睡眠相关时间结构体
  * @details 用于线程睡眠时间控制
@@ -54,6 +86,17 @@ struct PERIOD_INFO {
 	 */
 	long period_ns;
 };
+/**
+ * @brief 系统时间点类型别名
+ */
+using XNTimePoint = std::chrono::system_clock::time_point;
+
+/**
+	 * @brief 将ISO格式的时间字符串转换为系统时间点
+	 * @param timeStr ISO格式的时间字符串 (YYYY-MM-DDTHH:mm:ss)
+	 * @return 系统时间点
+	 */
+extern "C" XNTimePoint XNCORE_EXPORT parseISOTime(const std::string &timeStr);
 
 /**
  * @brief 系统运行状态枚举类
@@ -155,10 +198,63 @@ enum class XNFrameObjectStatus {
 	Unknown
 };
 
-#define XN_DLL_INITIALIZE(ClassName)                                                               \
-	extern "C" void Initial##ClassName()                                                           \
-	{                                                                                              \
-		qRegisterMetaType<ClassName>(#ClassName);                                                  \
-	}
+template <class ToType, class FromType>
+FORCEINLINE ToType XNStaticCastHelper(const FromType &from)
+{
+	return std::static_pointer_cast<typename ToType::element_type>(from);
+}
 
-#endif // XNCORE_GLOBAL_H
+template <class ToType, class FromType>
+FORCEINLINE ToType XNCastHelper(const FromType &from)
+{
+	return std::dynamic_pointer_cast<typename ToType::element_type>(from);
+}
+
+#define XN_CAST(from, to) XNStaticCastHelper<to>(from)
+
+#define XN_THISPTR std::static_pointer_cast<ThisType>(shared_from_this())
+
+#define XNCLASS_PTR_DECLARE(a)                                                                     \
+	using a##Ptr	 = std::shared_ptr<class a>;                                                   \
+	using a##WPtr	 = std::weak_ptr<class a>;                                                     \
+	using a##UPtr	 = std::unique_ptr<class a>;                                                   \
+	using a##ConsPtr = std::shared_ptr<const class a>;
+
+#define XNSTRUCT_PTR_DECLARE(a)                                                                    \
+	using a##Ptr	 = std::shared_ptr<struct a>;                                                  \
+	using a##WPtr	 = std::weak_ptr<struct a>;                                                    \
+	using a##UPtr	 = std::unique_ptr<struct a>;                                                  \
+	using a##ConsPtr = std::shared_ptr<const struct a>;
+
+#define XN_NOCOPYABLE(Class)                                                                       \
+public:                                                                                            \
+	using NoCopyable = Class;                                                                      \
+                                                                                                   \
+private:                                                                                           \
+	Class(const Class &)			= delete;                                                      \
+	Class &operator=(const Class &) = delete;
+
+#define XN_DECLARE_PRIVATE(Class)                                                                  \
+	XN_NOCOPYABLE(Class)                                                                           \
+protected:                                                                                         \
+	friend class Class##Private;                                                                   \
+	inline Class##Private *GetPP() const                                                           \
+	{                                                                                              \
+		return reinterpret_cast<Class##Private *>(_Private_Ptr);                                   \
+	}                                                                                              \
+	using PrivateType = Class##Private;
+
+#define T_D() PrivateType *const d = GetPP()
+
+struct XNNullClass {
+};
+
+#define XN_METATYPE_P(cls)                                                                         \
+public:                                                                                            \
+	using ThisType	= cls;                                                                         \
+	using SuperType = XNNullClass;
+
+#define XN_METATYPE(cls, sup)                                                                      \
+public:                                                                                            \
+	using ThisType	= cls;                                                                         \
+	using SuperType = sup;

Release/include/XNCore/XNDDSInterface.h

@@ -1,188 +1,339 @@
 #pragma once
 
-#include "XNObject.h"
-#include <fastcdr/xcdr/optional.hpp>
-template <typename T>
-struct is_std_array : std::false_type {
-};
+#include "XNFramework.h"
+#include "XNDDSManager.h"
+#include "XNByteArray.h"
+#include "XNTypeTraits.h"
+#include <stdexcept>
 
-template <typename T, std::size_t N>
-struct is_std_array<std::array<T, N>> : std::true_type {
-};
+// 定义UDP包的最大大小
+constexpr size_t MAX_UDP_PACKET_SIZE = 40000;
 
-// 变量模板简化使用
-template <typename T>
-inline constexpr bool is_std_array_v = is_std_array<T>::value;
-
-class XNDDSInterface : public XNObject
+class XNDDSInterface
 {
-	Q_OBJECT
 public:
-	explicit XNDDSInterface(QObject *parent = nullptr) : XNObject(parent) {}
-	virtual ~XNDDSInterface() {}
+	XNDDSInterface()		  = default;
+	virtual ~XNDDSInterface() = default;
 
-	template <typename T>
-	QByteArray getQByteArray(eprosima::fastcdr::optional<T> data)
-	{
-		QByteArray value;
-		// 如果T是普通类型，将data中的数据转换为QByteArray
-		if constexpr (std::is_arithmetic_v<T>) {
-			QDataStream dataStream(&value, QIODevice::WriteOnly);
-			dataStream.setByteOrder(QDataStream::LittleEndian);
-			if (data) {
-				dataStream << data.value();
-			} else {
-				dataStream << (T)0;
-			}
-		}
-		// 如果T是std::array，则需要根据T的类型和大小，生成一个std::array<T, N>的QByteArray
-		else if constexpr (is_std_array_v<T>) {
-			if (data) {
-				value = getQByteArrayFromStdArray(data.value());
-			} else {
-				T zero = {};
-				value  = getQByteArrayFromStdArray(zero);
-			}
-		}
-		return value;
-	}
+public:
+	/**
+	 * @brief 初始化
+	 * @param framework: 框架
+	 */
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelID, uint32_t DDS_type) = 0;
 
-	template <typename T, std::size_t N>
-	QByteArray getQByteArrayFromStdArray(std::array<T, N> data)
-	{
-		QByteArray value;
-		QDataStream dataStream(&value, QIODevice::WriteOnly);
-		dataStream.setByteOrder(QDataStream::LittleEndian);
-		for (std::size_t i = 0; i < N; ++i) {
-			if constexpr (std::is_arithmetic_v<T>) {
-				dataStream << data[i];
-			} else {
-				dataStream << getQByteArrayFromStdArray(data[i]);
-			}
-		}
-		return value;
-	}
+	/**
+	 * @brief 获取该接口的UDP包
+	 * @return 字节数组
+	 */
+	XNByteArray getUDPPackage();
 
-	QByteArray getUDPPackage()
-	{
-		QByteArray package;
-		QByteArray header = this->header.mid(0, 5);
-		package.append(header);
-		for (auto func : getByteArrayFunction) {
-			package.append(func());
-		}
-		package[4] = package.size();
-		return package;
-	}
+	/**
+	 * @brief 通过UDP包设置数据
+	 * @param package: UDP包
+	 */
+	void setDataByUDPPackage(const XNByteArray &package);
 
-	template <typename T>
-	QString getQString(eprosima::fastcdr::optional<T> data)
-	{
-		if constexpr (std::is_arithmetic_v<T>) {
-			if (data) {
-				return QString::number(data.value());
-			} else {
-				return QString::number(0);
-			}
-		} else if constexpr (std::is_same_v<T, std::string>) {
-			if (data) {
-				return getQStringFromStdArray(data.value());
-			} else {
-				T zero = {};
-				return getQStringFromStdArray(zero);
-			}
-		}
-		return QString();
-	}
+	/**
+	 * @brief 批量获取指定变量的数据
+	 * @param varNames: 变量名列表
+	 * @return: 变量名到数据的映射
+	 */
+	std::unordered_map<std::string, std::string> getStringData(std::vector<std::string> varNames);
 
-	template <typename T, std::size_t N>
-	QString getQStringFromStdArray(std::array<T, N> data)
-	{
-		QStringList list;
-		for (std::size_t i = 0; i < N; ++i) {
-			if constexpr (std::is_arithmetic_v<T>) {
-				list.append(QString::number(data[i]));
-			} else {
-				list.append(getQStringFromStdArray(data[i]));
-			}
-		}
-		return list.join(",");
-	}
-
-	QString getData(const QString &varName)
-	{
-		int index1			= -1;
-		int index2			= -1;
-		QString trueVarName = varName;
-		// 检查变量名中是否存在数组标记
-		if (varName.contains('[')) {
-			// 解析数组索引
-			int startPos = varName.indexOf('[');
-			int midPos	 = varName.indexOf("][");
-			int endPos	 = varName.lastIndexOf(']');
-
-			// 如果是二维数组 (格式: name[index1][index2])
-			if (midPos != -1) {
-				bool ok1 = false, ok2 = false;
-				index1 = varName.mid(startPos + 1, midPos - startPos - 1).toInt(&ok1);
-				index2 = varName.mid(midPos + 2, endPos - midPos - 2).toInt(&ok2);
-
-				if (!ok1 || !ok2) {
-					qWarning() << "无法解析数组索引:" << varName;
-					index1 = 0;
-					index2 = 0;
-				}
-			}
-			// 如果是一维数组 (格式: name[index1])
-			else if (startPos != -1 && endPos != -1) {
-				bool ok = false;
-				index1	= varName.mid(startPos + 1, endPos - startPos - 1).toInt(&ok);
-
-				if (!ok) {
-					qWarning() << "无法解析数组索引:" << varName;
-					index1 = 0;
-				}
-			}
-			trueVarName = varName.left(startPos);
-		}
-		auto it = getDataFunction.find(trueVarName);
-		if (it == getDataFunction.end()) {
-			return QString(); // 返回空字符串表示未找到
-		}
-		if (index1 < 0) {
-			QMutexLocker locker(&mutex);
-			return it.value()();
-		} else if (index2 < 0) {
-			QMutexLocker locker(&mutex);
-			QStringList list = it.value()().split(",");
-			if (index1 >= list.size()) {
-				qWarning() << "数组索引超出范围:" << varName;
-				return QString();
-			}
-			return list[index1];
-		} else {
-			QMutexLocker locker(&mutex);
-			QStringList list = it.value()().split(",");
-			if (index1 >= list.size()) {
-				qWarning() << "数组索引超出范围:" << varName;
-				return QString();
-			}
-			QStringList list2 = list[index1].split(" ");
-			if (index2 >= list2.size()) {
-				qWarning() << "数组索引超出范围:" << varName;
-				return QString();
-			}
-			return list2[index2];
-		}
-	}
+	/**
+	 * @brief 批量设置指定变量的数据
+	 * @param data: 变量名到数据的映射
+	 */
+	void setDataByString(std::unordered_map<std::string, std::string> data);
 
 protected:
-	QHash<QString, std::function<QString()>> getDataFunction;
-	QVector<std::function<QByteArray()>> getByteArrayFunction;
-	QMutex mutex;
-	QByteArray header;
+	/**
+	 * @brief 获取指定变量的字节数据，用于网络通信
+	 * @param data: 数据
+	 * @return 字节数组
+	 */
+	template <typename T>
+	XNByteArray getByteArray(eprosima::fastcdr::optional<T> data)
+	{
+		XNByteArray result(getTypeSize<T>());
+
+		if constexpr (std::is_arithmetic_v<T>) {
+			if (data) {
+				std::memcpy(result.data(), &data.value(), sizeof(T));
+			} else {
+				T zero = 0;
+				std::memcpy(result.data(), &zero, sizeof(T));
+			}
+		} else if constexpr (is_std_array_v<T>) {
+			if (data) {
+				return getByteArrayFromStdArray(data.value());
+			} else {
+				T zero = {};
+				return getByteArrayFromStdArray(zero);
+			}
+		} else {
+			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
+						  "Type must be arithmetic or std::array");
+		}
+
+		return result;
+	}
+
+	/**
+	 * @brief 设置指定变量的字节数据，用于网络通信
+	 * @param data: 数据
+	 * @param byteArray: 字节数组
+	 */
+	template <typename T>
+	void setByteArray(eprosima::fastcdr::optional<T> &data, const XNByteArray &byteArray,
+					  uint32_t &pos)
+	{
+		uint32_t thisSize = getTypeSize<T>();
+		XNByteArray thisArray(thisSize);
+		if (pos + thisSize > byteArray.size()) {
+			return;
+		}
+		std::memcpy(thisArray.data(), byteArray.data() + pos, thisSize);
+		pos += thisSize;
+
+		if constexpr (std::is_arithmetic_v<T>) {
+			T temp;
+			std::memcpy(&temp, thisArray.data(), sizeof(T));
+			data = temp;
+		} else if constexpr (is_std_array_v<T>) {
+			if (!data) {
+				data = T{};
+			}
+			setByteArrayFromStdArray(data.value(), thisArray);
+		} else {
+			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
+						  "Type must be arithmetic or std::array");
+		}
+	}
+
+	/**
+	 * @brief 获取指定数组变量的字节数据，用于网络通信
+	 * @param data: 数据
+	 * @return 字节数组
+	 */
+	template <typename T, std::size_t N>
+	XNByteArray getByteArrayFromStdArray(const std::array<T, N> &data)
+	{
+		XNByteArray result(getTypeSize<T>() * N);
+
+		for (std::size_t i = 0; i < N; ++i) {
+			if constexpr (std::is_arithmetic_v<T>) {
+				std::memcpy(result.data() + i * getTypeSize<T>(), &data[i], getTypeSize<T>());
+			} else {
+				XNByteArray subArray = getByteArrayFromStdArray(data[i]);
+				std::memcpy(result.data() + i * getTypeSize<T>(), subArray.data(),
+							getTypeSize<T>());
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * @brief 设置指定数组变量的字节数据，用于网络通信
+	 * @param data: 数据
+	 * @param byteArray: 字节数组
+	 */
+	template <typename T, std::size_t N>
+	void setByteArrayFromStdArray(std::array<T, N> &data, const XNByteArray &byteArray)
+	{
+		if (byteArray.size() < getTypeSize<T>() * N)
+			return;
+
+		for (std::size_t i = 0; i < N; ++i) {
+			if constexpr (std::is_arithmetic_v<T>) {
+				std::memcpy(&data[i], byteArray.data() + i * getTypeSize<T>(), getTypeSize<T>());
+			} else {
+				XNByteArray subArray(byteArray.data() + i * getTypeSize<T>(), getTypeSize<T>());
+				setByteArrayFromStdArray(data[i], subArray);
+			}
+		}
+	}
+
+	/**
+	 * @brief 获取指定变量的字符串数据，用于JSON前端
+	 * @param data: 数据
+	 * @return: 数据（字符串格式）
+	 */
+	template <typename T>
+	std::string getString(eprosima::fastcdr::optional<T> data)
+	{
+		if constexpr (std::is_arithmetic_v<T>) {
+			if (data) {
+				return std::to_string(data.value());
+			} else {
+				return std::to_string(0);
+			}
+		} else if constexpr (is_std_array_v<T>) {
+			if (data) {
+				return getStringFromStdArray(data.value());
+			} else {
+				T zero = {};
+				return getStringFromStdArray(zero);
+			}
+		}
+		return std::string();
+	}
+
+	/**
+	 * @brief 通过字符串数据设置指定变量，用于JSON前端
+	 * @param data: 数据
+	 * @param value: 字符串数据
+	 */
+	template <typename T>
+	void setDataFromString(eprosima::fastcdr::optional<T> &data, const std::string &value)
+	{
+		if constexpr (std::is_arithmetic_v<T>) {
+			if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+				data = std::stod(value);
+			} else {
+				data = std::stoll(value);
+			}
+		} else if constexpr (is_std_array_v<T>) {
+			// 解析输入字符串
+			std::stringstream ss(value);
+			std::string item;
+			std::vector<std::string> items;
+			while (std::getline(ss, item, ',')) {
+				items.push_back(item);
+			}
+			T temp;
+			setStdArrayFromString(temp, items, 0);
+			data = temp;
+		}
+	}
+
+	/**
+	 * @brief 获取指定数组变量的字符串数据，用于JSON前端
+	 * @param data: 数据
+	 * @return: 数据（字符串格式）
+	 */
+	template <typename T, std::size_t N>
+	std::string getStringFromStdArray(std::array<T, N> data)
+	{
+		std::stringstream ss;
+		for (std::size_t i = 0; i < N; ++i) {
+			if (i > 0)
+				ss << ",";
+			if constexpr (std::is_arithmetic_v<T>) {
+				ss << data[i];
+			} else {
+				ss << getStringFromStdArray(data[i]);
+			}
+		}
+		return ss.str();
+	}
+
+	/**
+	 * @brief 通过字符串数据设置指定数组变量，用于JSON前端
+	 * @param data: 数据
+	 * @param value: 字符串数据，格式为"数字,数字,..."
+	 * @param start_pos: 当前数组在输入字符串中的起始位置
+	 * @return 处理完当前数组后，下一个数组的起始位置
+	 * @throw std::runtime_error: 当输入数据格式不正确时抛出异常
+	 */
+	template <typename T, std::size_t N>
+	size_t setStdArrayFromString(std::array<T, N> &data, const std::vector<std::string> &value,
+								 size_t start_pos = 0)
+	{
+		// 递归处理每个元素
+		for (std::size_t i = 0; i < N; ++i) {
+			try {
+				if constexpr (std::is_arithmetic_v<T>) {
+					// 对于基本类型，直接转换
+					if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+						data[i] = static_cast<T>(std::stod(value[start_pos + i]));
+					} else {
+						data[i] = static_cast<T>(std::stoll(value[start_pos + i]));
+					}
+				} else if constexpr (is_std_array_v<T>) {
+					// 对于嵌套数组，递归处理
+					start_pos = setStdArrayFromString(data[i], value, start_pos + i);
+				} else {
+					static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
+								  "Type must be arithmetic or std::array");
+				}
+			} catch (const std::exception &e) {
+				throw std::runtime_error("Error parsing element " + std::to_string(i) + ": "
+										 + e.what());
+			}
+		}
+		return start_pos + N;
+	}
+
+	template <typename T1, typename T2>
+	void assign_value_get(eprosima::fastcdr::optional<T1> &data, T2 &model_data)
+	{
+		if (data) {
+			auto temp = data.value();
+			if constexpr (std::is_arithmetic_v<T1>) {
+				model_data = temp;
+			} else if constexpr (is_std_array_v<T1>) {
+				size_t arraySize = array_size_v<T1>;
+				for (size_t i = 0; i < arraySize; ++i) {
+					auto temp2 = temp[i];
+					if constexpr (std::is_arithmetic_v<T2>) {
+						model_data[i] = temp2;
+					} else if constexpr (is_std_array_v<T2>) {
+						size_t arraySize2 = array_size_v<T2>;
+						for (size_t j = 0; j < arraySize2; ++j) {
+							model_data[i][j] = temp2[j];
+						}
+					}
+				}
+			}
+		}
+	}
+
+	template <typename T1, typename T2>
+	void assign_value_set(eprosima::fastcdr::optional<T1> &data, T2 &model_data)
+	{
+		if constexpr (std::is_arithmetic_v<T1>) {
+			data = model_data;
+		} else if constexpr (is_std_array_v<T1>) {
+			T1 temp;
+			size_t arraySize = array_size_v<T1>;
+			for (size_t i = 0; i < arraySize; ++i) {
+				if constexpr (std::is_arithmetic_v<typename T1::value_type>) {
+					temp[i] = model_data[i];
+				} else if constexpr (is_std_array_v<typename T1::value_type>) {
+					size_t arraySize2 = array_size_v<typename T1::value_type>;
+					for (size_t j = 0; j < arraySize2; ++j) {
+						temp[i][j] = model_data[i][j];
+					}
+				}
+			}
+			data = temp;
+		}
+	}
+
+	virtual void clearOutData() {}
+	virtual void sendOutData() {}
+
+protected:
+	std::unordered_map<std::string, std::function<std::string()>> getDataFunction;
+	std::unordered_map<std::string, std::function<void(std::string)>> setDataFunction;
+	std::vector<std::function<XNByteArray(void)>> getByteArrayFunction;
+	std::vector<std::function<void(XNByteArray, uint32_t &)>> setByteArrayFunction;
+	std::mutex dataMutex;
+	std::mutex outDataMutex;
+	uint8_t header[8]{0}; // 固定大小的头部
+	size_t headerSize = 8;
+	FAST_DDS_MACRO::DataWriter *dataWriter;
 };
 
-#define MAP_GET_DATA_FUNC(NAME)                                                                    \
-	getDataFunction[#NAME] = [this]() { return getQString(data.NAME()); };                         \
-	getByteArrayFunction.push_back([this]() { return getQByteArray(data.NAME()); })
+#define MAP_DATA_FUNC(NAME)                                                                        \
+	getDataFunction[#NAME] = [this]() { return getString(data.NAME()); };                          \
+	setDataFunction[#NAME] = [this](std::string value) {                                           \
+		setDataFromString(out_data.NAME(), value);                                                 \
+	};                                                                                             \
+	getByteArrayFunction.push_back([this]() { return getByteArray(data.NAME()); });                \
+	setByteArrayFunction.push_back([this](XNByteArray byteArray, uint32_t &pos) {                  \
+		setByteArray(out_data.NAME(), byteArray, pos);                                             \
+	});

Release/include/XNCore/XNDDSManager.h

@@ -1,14 +1,6 @@
 #pragma once
 #include "XNBaseFrameObject.h"
-
-#include <fastdds/dds/domain/DomainParticipant.hpp>
-#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
-#include <fastdds/dds/publisher/DataWriter.hpp>
-#include <fastdds/dds/publisher/Publisher.hpp>
-#include <fastdds/dds/subscriber/DataReader.hpp>
-#include <fastdds/dds/subscriber/Subscriber.hpp>
-#include <fastdds/dds/topic/TypeSupport.hpp>
-#include <fastdds/dds/subscriber/DataReaderListener.hpp>
+#include "XNBaseFrameObject_p.h"
 
 struct PublisherInfo {
 	FAST_DDS_MACRO::Publisher *publisher;
@@ -22,8 +14,8 @@ struct SubscriberInfo {
 
 struct TopicInfo {
 	FAST_DDS_MACRO::Topic *topic;
-	QMap<quint32, PublisherInfo> publishers_;
-	QMap<quint32, SubscriberInfo> subscribers_;
+	std::map<uint32_t, PublisherInfo> publishers_;
+	std::map<uint32_t, SubscriberInfo> subscribers_;
 };
 
 template <typename T>
@@ -46,50 +38,54 @@ private:
 	std::function<void(const T &)> callback_;
 };
 
-class XNDDSManagerPrivate;
+struct XNDDSManagerPrivate : public XNBaseFrameObjectPrivate {
+	FAST_DDS_MACRO::DomainParticipant *participant_;
+	std::map<std::string, TopicInfo> topics_;
+	std::mutex mutex_;
+};
 
 class XNDDSManager : public XNBaseFrameObject
 {
-	Q_OBJECT
-	Q_DECLARE_PRIVATE(XNDDSManager)
-	Q_DISABLE_COPY(XNDDSManager)
+	XN_METATYPE(XNDDSManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNDDSManager)
 public:
-	explicit XNDDSManager(QObject *parent = nullptr);
+	XNDDSManager();
 	~XNDDSManager();
 
 protected:
-	XNDDSManager(XNDDSManagerPrivate &dd, QObject *parent = nullptr);
+	XNDDSManager(PrivateType *p);
 
-public slots:
-	virtual void OnInitialize() override;
+public:
+	virtual bool Initialize() override;
 
-	virtual void OnPrepareForExecute() override;
+	virtual bool PrepareForExecute() override;
 
-	void SetDomainID(quint32 domainID);
+	void SetDomainID(uint32_t domainID);
 
 public:
 	template <typename T>
-	FAST_DDS_MACRO::DataWriter *RegisterPublisher(const QString &topicName, quint32 publisherID)
+	FAST_DDS_MACRO::DataWriter *RegisterPublisher(const std::string &topicName,
+												  uint32_t publisherID)
 	{
-		std::lock_guard<std::mutex> lock(mutex_);
-		if (!topics_.contains(topicName)) {
-			topics_[topicName] = TopicInfo();
-			TopicInfo &tmp	   = topics_[topicName];
+		T_D();
+		std::lock_guard<std::mutex> lock(d->mutex_);
+		if (d->topics_.find(topicName) == d->topics_.end()) {
+			d->topics_[topicName] = TopicInfo();
+			TopicInfo &tmp		  = d->topics_[topicName];
 			FAST_DDS_MACRO::TypeSupport typeSupport(new T());
-			typeSupport.register_type(participant_);
-			tmp.topic =
-				participant_->create_topic(topicName.toStdString(), typeSupport.get_type_name(),
-										   FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
+			typeSupport.register_type(d->participant_);
+			tmp.topic = d->participant_->create_topic(topicName, typeSupport.get_type_name(),
+													  FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
 			if (tmp.topic == nullptr) {
 				LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
-				topics_.remove(topicName);
+				d->topics_.erase(topicName);
 				return nullptr;
 			}
 		}
-		TopicInfo &tmp				 = topics_[topicName];
+		TopicInfo &tmp				 = d->topics_[topicName];
 		tmp.publishers_[publisherID] = PublisherInfo();
 		tmp.publishers_[publisherID].publisher =
-			participant_->create_publisher(FAST_DDS_MACRO::PUBLISHER_QOS_DEFAULT, nullptr);
+			d->participant_->create_publisher(FAST_DDS_MACRO::PUBLISHER_QOS_DEFAULT, nullptr);
 		if (tmp.publishers_[publisherID].publisher == nullptr) {
 			LOG_ERROR("0x2131 Create Publisher %1 for Topic %2 Failed!", publisherID, topicName);
 			return nullptr;
@@ -119,29 +115,28 @@ public:
 	}
 
 	template <typename T>
-	void RegisterSubscriber(const QString &topicName, quint32 subscriberID,
+	void RegisterSubscriber(const std::string &topicName, uint32_t subscriberID,
 							std::function<void(const typename T::type &)> fun)
 	{
-		Q_D(XNDDSManager);
-		std::lock_guard<std::mutex> lock(mutex_);
-		if (!topics_.contains(topicName)) {
-			topics_[topicName] = TopicInfo();
-			TopicInfo &tmp	   = topics_[topicName];
+		T_D();
+		std::lock_guard<std::mutex> lock(d->mutex_);
+		if (d->topics_.find(topicName) == d->topics_.end()) {
+			d->topics_[topicName] = TopicInfo();
+			TopicInfo &tmp		  = d->topics_[topicName];
 			FAST_DDS_MACRO::TypeSupport typeSupport(new T());
-			typeSupport.register_type(participant_);
-			tmp.topic =
-				participant_->create_topic(topicName.toStdString(), typeSupport.get_type_name(),
-										   FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
+			typeSupport.register_type(d->participant_);
+			tmp.topic = d->participant_->create_topic(topicName, typeSupport.get_type_name(),
+													  FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
 			if (tmp.topic == nullptr) {
 				LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
-				topics_.remove(topicName);
+				d->topics_.erase(topicName);
 				return;
 			}
 		}
-		TopicInfo &tmp				   = topics_[topicName];
+		TopicInfo &tmp				   = d->topics_[topicName];
 		tmp.subscribers_[subscriberID] = SubscriberInfo();
 		tmp.subscribers_[subscriberID].subscriber =
-			participant_->create_subscriber(FAST_DDS_MACRO::SUBSCRIBER_QOS_DEFAULT, nullptr);
+			d->participant_->create_subscriber(FAST_DDS_MACRO::SUBSCRIBER_QOS_DEFAULT, nullptr);
 		if (tmp.subscribers_[subscriberID].subscriber == nullptr) {
 			LOG_ERROR("0x2135 Create Subscriber %1 for Topic %2 Failed!", subscriberID, topicName);
 		}
@@ -157,9 +152,4 @@ public:
 		}
 		LOG_INFO("0x2137 Create Subscriber %1 for Topic %2 Success!", subscriberID, topicName);
 	}
-
-private:
-	FAST_DDS_MACRO::DomainParticipant *participant_;
-	QMap<QString, TopicInfo> topics_;
-	std::mutex mutex_;
 };

Release/include/XNCore/XNEventManager.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "XNBaseFrameObject.h"
-#include <QVariant>
+
 // 事件优先级定义
 namespace XNEvent
 {
@@ -11,19 +11,18 @@ enum class Priority {
 	Low		 = 3  // 低优先级
 };
 }
+
 // 前向声明私有类
-class XNEventManagerPrivate;
+struct XNEventManagerPrivate;
 
 // 事件管理器类，继承自XNBaseFrameObject
 class XNEventManager : public XNBaseFrameObject
 {
-	Q_OBJECT							  // 启用Qt的元对象系统
-		Q_DECLARE_PRIVATE(XNEventManager) // 声明私有实现类
-		Q_DISABLE_COPY(XNEventManager)	  // 禁用拷贝构造和赋值操作
-
-		public :
-		// 构造函数，创建事件管理器实例
-		explicit XNEventManager(QObject *parent = nullptr);
+	XN_METATYPE(XNEventManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNEventManager)
+public:
+	// 构造函数，创建事件管理器实例
+	XNEventManager();
 	// 析构函数
 	~XNEventManager();
 
@@ -34,21 +33,20 @@ class XNEventManager : public XNBaseFrameObject
 	// @param async: 是否异步处理该事件
 	// @param priority: 事件优先级
 	// @return: 返回处理器ID，失败返回-1
-	int RegisterEventHandler(const QString &eventName,
-							 std::function<void(const QVariant &)> callback, quint32 objectId,
-							 bool async					= false,
+	int RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
+							 uint32_t objectId, bool async = false,
 							 XNEvent::Priority priority = XNEvent::Priority::Normal);
 	// 移除事件处理器
 	// @param eventName: 事件名称
 	// @param handlerId: 处理器ID
 	// @return: 移除是否成功
-	bool RemoveEventHandler(const QString &eventName, int handlerId);
+	bool RemoveEventHandler(const std::string &eventName, int handlerId);
 	// 触发指定事件
 	// @param eventName: 要触发的事件名称
 	// @param eventData: 事件携带的数据
 	// @param forceAsync: 强制异步处理
 	// @param priority: 事件优先级
-	void TriggerEvent(const QString &eventName, const QVariant &eventData = QVariant(),
+	void TriggerEvent(const std::string &eventName, const std::any &eventData = std::any(),
 					  bool forceAsync			 = false,
 					  XNEvent::Priority priority = XNEvent::Priority::Normal);
 
@@ -64,17 +62,16 @@ class XNEventManager : public XNBaseFrameObject
 	// 设置实时线程池参数
 	void SetRTThreadPoolConfig(int maxThreads, int minPriority, int maxPriority);
 
+	// 事件处理完成回调
+	void EventProcessed(const std::string &eventName, bool success);
+
 protected:
 	// 保护构造函数，用于继承实现
-	XNEventManager(XNEventManagerPrivate &dd, QObject *parent = nullptr);
+	XNEventManager(PrivateType *p);
 
-public slots:
+public:
 	// 初始化事件管理器
-	virtual void OnInitialize() override;
+	virtual bool Initialize() override;
 	// 准备执行
-	virtual void OnPrepareForExecute() override;
-
-signals:
-	// 事件处理完成信号
-	void EventProcessed(const QString &eventName, bool success);
+	virtual bool PrepareForExecute() override;
 };

Release/include/XNCore/XNEventManager_p.h

@@ -1,9 +1,6 @@
 #pragma once
 #include "XNBaseFrameObject_p.h"
 #include "XNEventManager.h"
-#include <QMap>
-#include <QMutex>
-#include <QThreadPool>
 #include <functional>
 #include <sys/types.h>
 #include <bits/pthreadtypes.h>
@@ -12,78 +9,130 @@
 #include <queue>
 #include <mutex>
 #include <condition_variable>
+#include <string>
+#include <any>
+#include <map>
+#include <list>
 
 // 事件处理器信息结构
 struct EventHandlerInfo {
-	std::function<void(const QVariant &)> callback; // 回调函数
-	quint32 objectId;								// 对象ID
-	int localId;									// 本地ID
+	std::function<void(const std::any &)> callback; // 回调函数
+	uint32_t objectId;								// 对象ID
+	uint32_t localId;								// 本地ID
 	bool isAsync;									// 是否异步处理
 	XNEvent::Priority priority;						// 事件优先级
-	int threadPriority;								// 线程优先级
+	uint32_t threadPriority;						// 线程优先级
 
 	// 获取全局处理器ID
-	int GetHandlerId() const { return (objectId << 16) | (localId & 0xFFFF); }
+	uint32_t GetHandlerId() const { return (objectId << 16) | (localId & 0xFFFF); }
 
 	// 从全局处理器ID中提取对象ID
-	static quint32 GetObjectId(int handlerId) { return handlerId >> 16; }
+	static uint32_t GetObjectId(uint32_t handlerId) { return handlerId >> 16; }
 
 	// 从全局处理器ID中提取本地ID
-	static int GetLocalId(int handlerId) { return handlerId & 0xFFFF; }
+	static uint32_t GetLocalId(uint32_t handlerId) { return handlerId & 0xFFFF; }
 };
 
 // 事件任务基类
-class BaseEventTask : public QRunnable
+class BaseEventTask
 {
 public:
-	BaseEventTask(const QString &name, const QVariant &data,
-				  std::function<void(const QVariant &)> callback, XNEventManager *manager)
+	/**
+	 * @brief 构造函数
+	 * @param name 事件名称
+	 * @param data 事件数据
+	 * @param callback 回调函数
+	 * @param manager 事件管理器指针
+	 */
+	BaseEventTask(const std::string &name, const std::any &data,
+				  std::function<void(const std::any &)> callback, XNEventManager *manager)
 		: eventName(name), eventData(data), eventCallback(callback), eventManager(manager)
 	{
-		setAutoDelete(true);
 	}
 	virtual ~BaseEventTask() = default;
 
+	/**
+	 * @brief 执行任务
+	 */
+	virtual void execute() = 0;
+
 protected:
-	QString eventName;
-	QVariant eventData;
-	std::function<void(const QVariant &)> eventCallback;
+	std::string eventName;
+	std::any eventData;
+	std::function<void(const std::any &)> eventCallback;
 	XNEventManager *eventManager;
 };
 
-// 实时事件任务
-class RTEventTask
+// 异步事件任务
+class AsyncEventTask : public BaseEventTask
 {
 public:
-	RTEventTask(const QString &name, const QVariant &data,
-				std::function<void(const QVariant &)> callback, XNEventManager *manager)
-		: eventName(name), eventData(data), eventCallback(callback), eventManager(manager)
+	/**
+	 * @brief 构造函数
+	 * @param name 事件名称
+	 * @param data 事件数据
+	 * @param callback 回调函数
+	 * @param manager 事件管理器指针
+	 */
+	AsyncEventTask(const std::string &name, const std::any &data,
+				   std::function<void(const std::any &)> callback, XNEventManager *manager)
+		: BaseEventTask(name, data, callback, manager)
 	{
 	}
 
-	void execute()
+	/**
+	 * @brief 执行任务
+	 */
+	void execute() override
 	{
 		try {
 			eventCallback(eventData);
 			if (eventManager) {
-				QMetaObject::invokeMethod(eventManager, "EventProcessed", Qt::QueuedConnection,
-										  Q_ARG(QString, eventName), Q_ARG(bool, true));
+				eventManager->EventProcessed(eventName, true);
 			}
 		} catch (const std::exception &e) {
-			LOG_ERROR(
-				QString("RT event handler exception for %1: %2").arg(eventName).arg(e.what()));
+			LOG_ERROR("Async event handler exception for " + eventName + ": " + e.what());
 			if (eventManager) {
-				QMetaObject::invokeMethod(eventManager, "EventProcessed", Qt::QueuedConnection,
-										  Q_ARG(QString, eventName), Q_ARG(bool, false));
+				eventManager->EventProcessed(eventName, false);
 			}
 		}
 	}
+};
 
-private:
-	QString eventName;
-	QVariant eventData;
-	std::function<void(const QVariant &)> eventCallback;
-	XNEventManager *eventManager;
+// 实时事件任务
+class RTEventTask : public BaseEventTask
+{
+public:
+	/**
+	 * @brief 构造函数
+	 * @param name 事件名称
+	 * @param data 事件数据
+	 * @param callback 回调函数
+	 * @param manager 事件管理器指针
+	 */
+	RTEventTask(const std::string &name, const std::any &data,
+				std::function<void(const std::any &)> callback, XNEventManager *manager)
+		: BaseEventTask(name, data, callback, manager)
+	{
+	}
+
+	/**
+	 * @brief 执行任务
+	 */
+	void execute() override
+	{
+		try {
+			eventCallback(eventData);
+			if (eventManager) {
+				eventManager->EventProcessed(eventName, true);
+			}
+		} catch (const std::exception &e) {
+			LOG_ERROR("RT event handler exception for " + eventName + ": " + e.what());
+			if (eventManager) {
+				eventManager->EventProcessed(eventName, false);
+			}
+		}
+	}
 };
 
 // 实时线程管理器
@@ -167,35 +216,27 @@ private:
 };
 
 // 事件管理器的私有实现类
-class XNEventManagerPrivate : public XNBaseFrameObjectPrivate
-{
-public:
-	// 声明公共接口类
-	Q_DECLARE_PUBLIC(XNEventManager)
-
-	// 构造函数，初始化私有实现
-	explicit XNEventManagerPrivate(XNEventManager *q) : XNBaseFrameObjectPrivate(q) {}
-
+struct XNEventManagerPrivate : public XNBaseFrameObjectPrivate {
 	// 存储事件及其对应的处理器信息列表
 	// key: 事件名称
 	// value: 该事件对应的所有处理器信息列表
-	QMap<QString, QList<EventHandlerInfo>> eventHandlers;
+	std::map<std::string, std::list<EventHandlerInfo>> eventHandlers;
 
 	// 处理器ID到事件名称的反向映射，用于快速查找
-	QMap<int, QString> handlerToEvent;
+	std::map<int, std::string> handlerToEvent;
 
 	// 本地ID计数器
 	int localIdCounter = 0;
 
 	// 互斥锁，用于保护事件处理器表的线程安全访问
-	QMutex eventMutex;
+	std::mutex eventMutex;
 
-	// 线程池，用于异步执行事件处理器
-	QThreadPool threadPool;
-
-	// 实时线程池
-	QThreadPool rtThreadPool;
+	// 线程池相关
+	std::vector<std::thread> workerThreads;
+	std::queue<BaseEventTask *> taskQueue;
+	std::mutex taskMutex;
+	std::condition_variable taskCond;
+	bool running = true;
 
 	RTThreadManager rtManager;
-	QThreadPool normalThreadPool; // 用于非实时任务
 };

Release/include/XNCore/XNFramework.h

@@ -12,195 +12,157 @@
 
 #include "XNObject.h"
 
-class XNFrameworkPrivate;
+struct XNFrameworkPrivate;
 
 /**
  * @brief 框架类
  */
 class XNCORE_EXPORT XNFramework : public XNObject
 {
-	/**
-	 * @brief 宏定义，用于支持Qt的元对象系统
-	 */
-	Q_OBJECT
-
 	/**
 	 * @brief 宏定义，用于禁用拷贝构造函数
 	 */
-	Q_DISABLE_COPY(XNFramework)
+	XN_METATYPE(XNFramework, XNObject)
 
 	/**
 	 * @brief 宏定义，用于声明私有数据成员
 	 */
-	Q_DECLARE_PRIVATE(XNFramework);
-
-	/**
-	 * @brief 宏定义，用于声明属性workPath
-	 */
-	Q_PROPERTY(QString workPath READ GetWorkPath WRITE SetWorkPath)
-
-	/**
-	 * @brief 宏定义，用于声明属性modelPath
-	 */
-	Q_PROPERTY(QString modelPath READ GetModelPath WRITE SetModelPath)
-
-	/**
-	 * @brief 宏定义，用于声明属性cpuAffinity
-	 */
-	Q_PROPERTY(quint32 cpuAffinity READ GetCpuAffinity WRITE SetCpuAffinity)
-
+	XN_DECLARE_PRIVATE(XNFramework)
 public:
 	/**
 	 * @brief 构造函数
 	 * @param parent 父对象
 	 */
-	explicit XNFramework(QObject *parent = nullptr);
+	XNFramework();
 
 	/**
 	 * @brief 析构函数
 	 */
 	virtual ~XNFramework();
 
+protected:
+	/**
+	 * @brief 构造函数
+	 * @param p 私有数据成员
+	 */
+	XNFramework(PrivateType *p);
+
+public:
+	/**
+	 * @brief 获取DDS管理器
+	 * @return DDS管理器
+	 */
+	XNDDSManagerPtr GetDDSManager();
+
+	/**
+	 * @brief 获取事件管理器
+	 * @return 事件管理器
+	 */
+	XNEventManagerPtr GetEventManager();
+
+	/**
+	 * @brief 获取模型管理器
+	 * @return 模型管理器
+	 */
+	XNModelManagerPtr GetModelManager();
+
+	/**
+	 * @brief 获取场景管理器
+	 * @return 场景管理器
+	 */
+	XNScenarioManagerPtr GetScenarioManager();
+
+	/**
+	 * @brief 获取服务管理器
+	 * @return 服务管理器
+	 */
+	XNServiceManagerPtr GetServiceManager();
+
+	/**
+	 * @brief 获取线程管理器
+	 * @return 线程管理器
+	 */
+	XNThreadManagerPtr GetThreadManager();
+
+	/**
+	 * @brief 获取时间管理器
+	 * @return 时间管理器
+	 */
+	XNTimeManagerPtr GetTimeManager();
+
 	/**
 	 * @brief 获取工作路径
 	 * @return 工作路径
 	 */
-	QString GetWorkPath();
+	std::string GetWorkPath();
+
+	/**
+	 * @brief 设置工作路径
+	 * @param workPath 工作路径
+	 */
+	void SetWorkPath(const std::string &workPath);
 
 	/**
 	 * @brief 获取模型库路径
 	 * @return 模型库路径
 	 */
-	QString GetModelPath();
+	std::string GetModelPath();
+
+	/**
+	 * @brief 设置模型库路径
+	 * @param modelPath 模型库路径
+	 */
+	void SetModelPath(const std::string &modelPath);
 
 	/**
 	 * @brief 获取服务库路径
 	 * @return 服务库路径
 	 */
-	QString GetServicePath();
+	std::string GetServicePath();
+
+	/**
+	 * @brief 设置服务库路径
+	 * @param servicePath 服务库路径
+	 */
+	void SetServicePath(const std::string &servicePath);
 
 	/**
 	 * @brief 获取CPU亲和性
 	 * @return CPU亲和性
 	 */
-	quint32 GetCpuAffinity();
+	uint32_t GetCpuAffinity();
+
+	/**
+	 * @brief 设置CPU亲和性
+	 * @param cpuAffinity CPU亲和性
+	 */
+	void SetCpuAffinity(uint32_t cpuAffinity);
 
 	/**
 	 * @brief 设置场景XML
 	 * @param scenarioXml 场景XML
 	 */
-	void SetScenarioXml(const QString &scenarioXml);
-
-signals:
-	/**
-	 * @brief 初始化
-	 */
-	void Initialize();
-
-	/**
-	 * @brief 初始化成功
-	 */
-	void InitializeSuccess(bool isSuccess);
+	void SetScenarioXml(const std::string &scenarioXml);
 
 	/**
 	 * @brief 准备执行
+	 * @return true:	准备成功
+	 * @return false:	准备失败
 	 */
-	void PrepareForExecute();
-
-	/**
-	 * @brief 准备执行成功
-	 */
-	void PrepareForExecuteSuccess(bool isSuccess);
-
-	/**
-	 * @brief 分析场景XML
-	 * @param scenarioXml 场景XML
-	 */
-	void AnalyzeScenarioXml(const QString &scenarioXml);
+	bool PrepareForExecute();
 
 	/**
 	 * @brief 仿真控制
 	 * @param objectId 对象ID
 	 * @param cmd 命令
 	 */
-	void SimControl(quint32 objectId, SimControlCmd cmd);
-
-public slots:
-	/**
-	 * @brief 设置工作路径
-	 * @param workPath 工作路径
-	 */
-	void SetWorkPath(const QString &workPath);
-
-	/**
-	 * @brief 设置模型库路径
-	 * @param modelPath 模型库路径
-	 */
-	void SetModelPath(const QString &modelPath);
-
-	/**
-	 * @brief 设置服务库路径
-	 * @param servicePath 服务库路径
-	 */
-	void SetServicePath(const QString &servicePath);
-
-	/**
-	 * @brief 设置CPU亲和性
-	 * @param cpuAffinity CPU亲和性
-	 */
-	void SetCpuAffinity(quint32 cpuAffinity);
+	void SimControl(uint32_t objectId, SimControlCmd cmd);
 
 	/**
 	 * @brief 初始化
+	 * @param initialType 初始化类型
+	 * @return true:	初始化成功
+	 * @return false:	初始化失败
 	 */
-	void OnInitialize();
-
-	/**
-	 * @brief 初始化成功
-	 */
-	void OnInitializeSuccess();
-
-	/**
-	 * @brief 初始化失败
-	 */
-	void OnInitializeFailed();
-
-	/**
-	 * @brief 解析配置文件成功
-	 */
-	void OnAnalyzeScenarioXmlSuccess();
-
-	/**
-	 * @brief 解析配置文件失败
-	 */
-	void OnAnalyzeScenarioXmlFailed();
-
-	/**
-	 * @brief 准备执行
-	 */
-	void OnPrepareForExecute();
-
-	/**
-	 * @brief 准备执行成功
-	 */
-	void OnPrepareForExecuteSuccess();
-
-	/**
-	 * @brief 准备执行失败
-	 */
-	void OnPrepareForExecuteFailed();
-
-	/**
-	 * @brief 仿真控制
-	 * @param cmd 命令
-	 */
-	void OnSimControl(quint32 objectId, SimControlCmd cmd);
-
-protected:
-	/**
-	 * @brief 构造函数
-	 * @param dd 私有数据成员
-	 * @param parent 父对象
-	 */
-	XNFramework(XNFrameworkPrivate &dd, QObject *parent = nullptr);
+	bool Initialize(uint32_t initialType);
 };

Release/include/XNCore/XNFramework_p.h

@@ -16,43 +16,65 @@
 /**
  * @brief 框架类的私有数据成员
  */
-class XNFrameworkPrivate : public XNObjectPrivate
-{
-public:
-	/**
-	 * @brief 构造函数
-	 * @param q 框架类指针
-	 */
-	explicit XNFrameworkPrivate(XNFramework *q) : XNObjectPrivate(q) {}
+struct XNFrameworkPrivate : public XNObjectPrivate {
 
 	/**
-	 * @brief 宏定义，用于声明公有数据成员
+	 * @brief DDS管理器
 	 */
-	Q_DECLARE_PUBLIC(XNFramework)
+	XNDDSManagerPtr ddsManager;
+
+	/**
+	 * @brief 事件管理器
+	 */
+	XNEventManagerPtr eventManager;
+
+	/**
+	 * @brief 模型管理器
+	 */
+	XNModelManagerPtr modelManager;
+
+	/**
+	 * @brief 场景管理器
+	 */
+	XNScenarioManagerPtr scenarioManager;
+
+	/**
+	 * @brief 服务管理器
+	 */
+	XNServiceManagerPtr serviceManager;
+
+	/**
+	 * @brief 线程管理器
+	 */
+	XNThreadManagerPtr threadManager;
+
+	/**
+	 * @brief 时间管理器
+	 */
+	XNTimeManagerPtr timeManager;
 
-private:
 	/**
 	 * @brief 工作路径
 	 */
-	QString workPath;
+	std::string workPath;
 
 	/**
 	 * @brief 模型路径
 	 */
-	QString modelPath;
+	std::string modelPath;
 
 	/**
 	 * @brief 服务路径
 	 */
-	QString servicePath;
+	std::string servicePath;
 
 	/**
 	 * @brief CPU亲和性
 	 */
-	quint32 uCpuAffinity;
+	uint32_t uCpuAffinity;
 
 	/**
 	 * @brief 场景XML
 	 */
-	QString scenarioXml;
+	std::string scenarioXml;
 };

Release/include/XNCore/XNLogger.h

@@ -9,13 +9,15 @@
  * 
  */
 #pragma once
-#include <QString>
-#include <QMutex>
-#include <QFile>
-#include <QTextStream>
-#include <QDateTime>
-#include <QDir>
+#include <string>
+#include <mutex>
+#include <fstream>
+#include <chrono>
+#include <filesystem>
 #include <type_traits>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
 
 /**
  * @brief 日志类
@@ -34,7 +36,6 @@ public:
 	 */
 	static XNLogger &instance()
 	{
-		// 懒汉式单例，C++11 及以上版本的标准保证了局部静态变量的初始化是线程安全的
 		static XNLogger instance;
 		return instance;
 	}
@@ -44,7 +45,7 @@ public:
 	 * @param level 日志等级
 	 * @param message 日志消息
 	 */
-	void log(LogLevel level, const QString &message);
+	void log(LogLevel level, const std::string &message);
 
 	/**
 	 * @brief 启用控制台输出
@@ -64,7 +65,7 @@ private:
 	/**
 	 * @brief 构造函数
 	 */
-	XNLogger(); // 默认构造函数
+	XNLogger();
 
 	/**
 	 * @brief 析构函数
@@ -74,17 +75,17 @@ private:
 	/**
 	 * @brief 禁止拷贝构造
 	 */
-	XNLogger(const XNLogger &) = delete; // 禁止拷贝构造
+	XNLogger(const XNLogger &) = delete;
 
 	/**
 	 * @brief 禁止赋值
 	 */
-	XNLogger &operator=(const XNLogger &) = delete; // 禁止赋值
+	XNLogger &operator=(const XNLogger &) = delete;
 
 	/**
 	 * @brief 日志文件路径
 	 */
-	QString logFilePath;
+	std::string logFilePath;
 
 	/**
 	 * @brief 控制台输出控制
@@ -99,44 +100,50 @@ private:
 	/**
 	 * @brief 日志文件
 	 */
-	QFile logFile;
+	std::ofstream logFile;
 
 	/**
 	 * @brief 互斥锁
 	 */
-	QMutex mutex;
+	std::mutex mutex;
 
 	/**
 	 * @brief 日志等级转换为字符串
 	 * @param level 日志等级
 	 * @return 日志等级字符串
 	 */
-	QString logLevelToString(LogLevel level) const;
+	std::string logLevelToString(LogLevel level) const;
+
+	/**
+	 * @brief 获取当前时间字符串
+	 * @return 格式化的时间字符串
+	 */
+	std::string getCurrentTimeString() const;
 
 	/**
 	 * @brief 控制台输出字体恢复颜色常量
 	 */
-	const QString COLOR_RESET = "\033[0m";
+	const std::string COLOR_RESET = "\033[0m";
 
 	/**
 	 * @brief 调试颜色常量
 	 */
-	const QString COLOR_DEBUG = "\033[34m"; // 蓝色
+	const std::string COLOR_DEBUG = "\033[34m"; // 蓝色
 
 	/**
 	 * @brief 信息颜色常量	
 	 */
-	const QString COLOR_INFO = "\033[32m"; // 绿色
+	const std::string COLOR_INFO = "\033[32m"; // 绿色
 
 	/**
 	 * @brief 警告颜色常量
 	 */
-	const QString COLOR_WARNING = "\033[33m"; // 黄色
+	const std::string COLOR_WARNING = "\033[33m"; // 黄色
 
 	/**
 	 * @brief 错误颜色常量
 	 */
-	const QString COLOR_ERROR = "\033[31m"; // 红色
+	const std::string COLOR_ERROR = "\033[31m"; // 红色
 };
 
 /**
@@ -154,9 +161,9 @@ public:
 	 */
 	template <typename... Args>
 	inline static typename std::enable_if<(sizeof...(Args) > 0), void>::type
-	log(XNLogger::LogLevel level, const QString &message, Args... args)
+	log(XNLogger::LogLevel level, const std::string &message, Args... args)
 	{
-		QString formattedMessage = formatMessage(message, args...);
+		std::string formattedMessage = formatMessage(message, args...);
 		XNLogger::instance().log(level, formattedMessage);
 	}
 
@@ -165,7 +172,7 @@ public:
 	 * @param level 日志等级
 	 * @param message 日志消息
 	 */
-	inline static void log(XNLogger::LogLevel level, const QString &message)
+	inline static void log(XNLogger::LogLevel level, const std::string &message)
 	{
 		XNLogger::instance().log(level, message);
 	}
@@ -173,27 +180,44 @@ public:
 private:
 	// 辅助函数，用于格式化消息
 	template <typename T>
-	static QString convertToString(const T &arg)
+	static std::string convertToString(const T &arg)
 	{
 		if constexpr (std::is_arithmetic<T>::value) {
-			return QString::number(arg); // 处理数值类型
+			return std::to_string(arg); // 处理数值类型
 		} else {
-			return arg;
+			return std::string(arg);
 		}
 	}
 
 	// 递归变参函数，用于处理多个参数
 	template <typename T, typename... Args>
-	static QString formatMessage(const QString &message, T arg, Args... args)
+	static std::string formatMessage(const std::string &message, T arg, Args... args)
 	{
-		return formatMessage(message.arg(convertToString(arg)), args...); // 递归调用
+		// 查找下一个参数占位符
+		std::string result = message;
+		size_t paramIndex  = 0;
+		size_t pos		   = 0;
+
+		// 找到当前参数对应的占位符
+		while (true) {
+			std::string placeholder = "%" + std::to_string(paramIndex + 1);
+			pos						= result.find(placeholder);
+			if (pos != std::string::npos) {
+				// 替换占位符，使用placeholder的长度
+				result.replace(pos, placeholder.length(), convertToString(arg));
+				break;
+			}
+			paramIndex++;
+			if (paramIndex > 100) { // 防止无限循环
+				return result;
+			}
+		}
+
+		return formatMessage(result, args...);
 	}
 
 	// 基础情况
-	static QString formatMessage(const QString &message)
-	{
-		return message; // 处理没有参数的情况
-	}
+	static std::string formatMessage(const std::string &message) { return message; }
 };
 
 /**

Release/include/XNCore/XNModelManager.h

@@ -12,7 +12,9 @@
 #include "XNBaseFrameObject.h"
 
 class XNModelObject;
-class XNModelManagerPrivate;
+XNCLASS_PTR_DECLARE(XNModelObject)
+
+struct XNModelManagerPrivate;
 
 /**
  * @brief 模型管理器类
@@ -20,18 +22,14 @@ class XNModelManagerPrivate;
  */
 class XNModelManager : public XNBaseFrameObject
 {
-	/**
-	 * @brief 使用禁止复制类宏定义自身禁止复制
-	 */
-	Q_OBJECT
-	Q_DECLARE_PRIVATE(XNModelManager)
-	Q_DISABLE_COPY(XNModelManager)
+	XN_METATYPE(XNModelManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNModelManager)
 
 public:
 	/**
 	 * @brief 模型管理器类默认构造函数
 	 */
-	explicit XNModelManager(QObject *parent = nullptr);
+	XNModelManager();
 
 	/**
 	 * @brief 模型管理器类默认析构函数
@@ -44,20 +42,20 @@ protected:
 	 * @param p:私有结构体指针
 	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
 	 */
-	XNModelManager(XNModelManagerPrivate &dd, QObject *parent = nullptr);
+	XNModelManager(PrivateType *p);
 
-public slots:
+public:
 	/**
 	 * @brief 系统开始运行前的最后准备工作
 	 * @details	系统运行前模型管理器做最后处理的接口
 	 */
-	virtual void OnPrepareForExecute() override;
+	virtual bool PrepareForExecute() override;
 
 	/**
 	 * @brief 初始化模型管理器
 	 * @details	模型管理器的初始化接口
 	 */
-	virtual void OnInitialize() override;
+	virtual bool Initialize() override;
 
 	/**
 	 * @brief 加载模型
@@ -65,31 +63,23 @@ public slots:
 	 * @param className:	QString类型，模型类名
 	 * @details	加载模型
 	 */
-	void OnLoadModel(const QString &modelPath, const QString &className);
+	void LoadModel(const std::string &modelPath, const std::string &className, uint32_t initialType,
+				   uint32_t threadID);
 
-	/**
-	 * @brief 设置仿真系统运行基频
-	 * @param dBaseFreq:	double类型，频率值，单位Hz
-	 * @details 仿真系统所有线程以此基频的 1 或 1/2 或 1/4 或 1/8 或 1/16 或 1/32 倍运行
-	 */
-	void OnSetBaseFreq(const double &dBaseFreq);
-
-public:
 	/**
 	 * @brief 注册模型信息
 	 * @return UINT32:	模型的全局唯一ID
 	 * @details	模型通过此接口注册自身，并获取自身全局唯一ID
 	 */
-	quint32 RegisterModel();
+	uint32_t RegisterModel();
 
 	/**
 	 * @brief 获取模型指针
 	 * @param modelID:	UINT32类型，模型全局唯一ID
 	 * @return XNModelObjectPtr:	模型基类指针
 	 */
-	XNModelObject *GetModel(quint32 modelID);
+	XNModelObjectPtr GetModel(uint32_t modelID);
 
-public slots:
 	/**
 	 * @brief 注册模型函数
 	 * @param ModelID:	UINT32类型，模型全局唯一ID
@@ -98,22 +88,6 @@ public slots:
 	 * @param RunPos:	UINT32类型，提交的函数运行节点号，<2^(freqGroup)
 	 * @param RunPriorty:	UINT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
 	 */
-	void OnRegisterFunction(quint32 id, XNCallBack fun, quint32 freqGroup, quint32 RunPos,
-							quint32 RunPriorty);
-
-signals:
-	/**
-	 * @brief 注册函数信号
-	 * @param id:	UINT32类型，模型全局唯一ID
-	 * @param fun:	函数指针
-	 * @param freqGroup:	UINT32类型，提交的函数运行频率组，0为基频，1为半频，2为1/4频，3为1/8频，4为1/16频，5为1/32频
-	 * @param RunPos:	UINT32类型，提交的函数运行节点号，<2^(freqGroup)
-	 * @param RunPriorty:	UINT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
-	 */
-	void RegisterFunction(quint32 id, XNCallBack fun, quint32 freqGroup, quint32 RunPos,
-						  quint32 RunPriorty);
-
-	void InitializeSuccess();
-
-	void PrepareForExecuteSuccess();
+	void RegisterFunction(uint32_t id, XNCallBack fun, uint32_t threadID, uint32_t freqGroup,
+						  uint32_t RunPos, uint32_t RunPriorty);
 };

Release/include/XNCore/XNModelManager_p.h

@@ -1,25 +1,17 @@
 #pragma once
 
 #include "XNBaseFrameObject_p.h"
-#include <QVector>
-#include <QHash>
-
-class XNModelManagerPrivate : public XNBaseFrameObjectPrivate
-{
-public:
-	Q_DECLARE_PUBLIC(XNModelManager)
-
-	explicit XNModelManagerPrivate(XNModelManager *q) : XNBaseFrameObjectPrivate(q) {}
 
+struct XNModelManagerPrivate : public XNBaseFrameObjectPrivate {
+	XNFrameworkPtr framework;
 	/**
 	 * @brief 模型ID库
 	 * @details 所有模型已用ID的存储库
 	 */
-	QVector<bool> ModelIDAssigned;
-
+	std::vector<bool> ModelIDAssigned;
 	/**
-	 * @brief 仿真系统运行基频
-	 * @details 仿真系统所有线程以此基频的 1 或 1/2 或 1/4 或 1/8 或 1/16 或 1/32 倍运行
+	 * @brief 模型ID与模型指针的映射表
+	 * @details 所有模型ID与模型指针的映射表
 	 */
-	double dBaseFreq;
+	std::map<uint32_t, XNModelObjectPtr> ModelMap;
 };

Release/include/XNCore/XNModelObject.h

@@ -12,7 +12,7 @@
 #include "XNObject.h"
 #include "XNEventManager.h"
 
-class XNModelObjectPrivate;
+struct XNModelObjectPrivate;
 
 /**
  * @brief 模型基类
@@ -20,22 +20,14 @@ class XNModelObjectPrivate;
  */
 class XNModelObject : public XNObject
 {
-	Q_OBJECT
-	Q_DISABLE_COPY(XNModelObject)
-	Q_DECLARE_PRIVATE(XNModelObject)
-
-	Q_PROPERTY(QString description READ GetDescription WRITE SetDescription)
-	Q_PROPERTY(QString author READ GetAuthor WRITE SetAuthor)
-	Q_PROPERTY(QString xmlPath READ GetXmlPath WRITE SetXmlPath)
-	Q_PROPERTY(QDateTime createTime READ GetCreateTime WRITE SetCreateTime)
-	Q_PROPERTY(QDateTime changeTime READ GetChangeTime WRITE SetChangeTime)
-	Q_PROPERTY(QString version READ GetVersion WRITE SetVersion)
+	XN_METATYPE(XNModelObject, XNObject)
+	XN_DECLARE_PRIVATE(XNModelObject)
 
 public:
 	/**
 	 * @brief 模型基类默认构造函数
 	 */
-	XNModelObject(QObject *parent = nullptr);
+	XNModelObject();
 
 	/**
 	 * @brief 模型基类默认析构函数
@@ -45,89 +37,137 @@ public:
 protected:
 	/**
 	 * @brief 模型基类带参构造函数
-	 * @param dd:XNModelObjectPrivate类型，私有结构体指针
-	 * @param parent:QObject类型，父对象指针
+	 * @param p:XNModelObjectPrivate类型，私有结构体指针
 	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
 	 */
-	XNModelObject(XNModelObjectPrivate &dd, QObject *parent = nullptr);
+	XNModelObject(PrivateType *p);
+
+public:
+	void SetFramework(XNFrameworkPtr framework);
+
+protected:
+	XNFrameworkPtr GetFramework() const;
 
 public:
 	/**
 	 * @brief 获取模型描述
 	 * @return const QString&:模型描述
 	 */
-	const QString &GetDescription();
+	const std::string &GetDescription();
 
 	/**
 	 * @brief 设置模型描述
 	 * @param sDescription:QString类型，模型描述
 	 */
-	void SetDescription(const QString &sDescription);
+	void SetDescription(const std::string &sDescription);
 
 	/**
 	 * @brief 获取作者
 	 * @return const QString&:	作者
 	 */
-	const QString &GetAuthor();
+	const std::string &GetAuthor();
 
 	/**
 	 * @brief 设置作者
 	 * @param sAuthor:	QString类型，作者
 	 */
-	void SetAuthor(const QString &sAuthor);
+	void SetAuthor(const std::string &sAuthor);
 
 	/**
 	 * @brief 获取模型配置文件路径
 	 * @return const QString&:	模型配置文件路径
 	 */
-	const QString &GetXmlPath();
+	const std::string &GetXmlPath();
 
 	/**
 	 * @brief 设置模型配置文件路径
 	 * @param sXmlPath:QString类型，模型配置文件路径
 	 */
-	void SetXmlPath(const QString &sXmlPath);
+	void SetXmlPath(const std::string &sXmlPath);
 
 	/**
 	 * @brief 获取模型创建时间
-	 * @return const QDateTime&:模型创建时间
+	 * @return const XNTimePoint&:模型创建时间
 	 */
-	const QDateTime &GetCreateTime();
+	const XNTimePoint &GetCreateTime();
 
 	/**
 	 * @brief 设置模型创建时间
-	 * @param cTime:	QDateTime类型，模型创建时间
+	 * @param cTime:	XNTimePoint类型，模型创建时间
 	 */
-	void SetCreateTime(const QDateTime &cTime);
+	void SetCreateTime(const XNTimePoint &cTime);
 
 	/**
 	 * @brief 获取模型修改时间
-	 * @return const QDateTime&:模型修改时间
+	 * @return const XNTimePoint&:模型修改时间
 	 */
-	const QDateTime &GetChangeTime();
+	const XNTimePoint &GetChangeTime();
 
 	/**
 	 * @brief 设置模型修改时间
-	 * @param cTime:	QDateTime类型，模型修改时间
+	 * @param cTime:	XNTimePoint类型，模型修改时间
 	 */
-	void SetChangeTime(const QDateTime &cTime);
+	void SetChangeTime(const XNTimePoint &cTime);
 
 	/**
 	 * @brief 获取模型版本号
 	 * @return const XNString&:	模型版本号
 	 */
-	const QString &GetVersion();
-	/**
-	 * @brief 设置模型版本号
-	 * @param sVersion:	QString类型，模型版本号
-	 */
-	void SetVersion(const QString &sVersion);
+	const std::string &GetVersion();
 
 	/**
-	 * @brief 设置仿真系统运行基频
-	 * @param dBaseFreq:	double类型，频率值，单位Hz
+	 * @brief 设置模型版本号
+	 * @param sVersion:	std::string类型，模型版本号
 	 */
-	void SetBaseFreq(const double &dBaseFreq);
+	void SetVersion(const std::string &sVersion);
+
+	/**
+	 * @brief 获取模型运行频率组
+	 * @return uint32_t:	模型运行频率组
+	 */
+	uint32_t GetRunFreq() const;
+
+	/**
+	 * @brief 设置模型运行频率组
+	 * @param runFreq:	uint32_t类型，模型运行频率组
+	 */
+	void SetRunFreq(uint32_t runFreq);
+
+	/**
+	 * @brief 获取模型运行节点
+	 * @return uint32_t:	模型运行节点
+	 */
+	uint32_t GetRunNode() const;
+
+	/**
+	 * @brief 设置模型运行节点
+	 * @param runNode:	uint32_t类型，模型运行节点
+	 */
+	void SetRunNode(uint32_t runNode);
+
+	/**
+	 * @brief 获取模型运行优先级
+	 * @return uint32_t:	模型运行优先级
+	 */
+	uint32_t GetRunPriority() const;
+
+	/**
+	 * @brief 设置模型运行优先级
+	 * @param runPriority:	uint32_t类型，模型运行优先级
+	 */
+	void SetRunPriority(uint32_t runPriority);
+
+	/**
+	 * @brief 获取模型设置频率
+	 * @return double:	模型设置频率
+	 */
+	double GetSetFreq() const;
+
+	/**
+	 * @brief 设置模型设置频率
+	 * @param setFreq:	double类型，模型设置频率
+	 */
+	void SetSetFreq(double setFreq);
 
 	/**
 	 * @brief 单步执行函数
@@ -142,8 +182,8 @@ public:
 	 * @param async: 是否异步处理
 	 * @return: 返回处理器ID，失败返回-1
 	 */
-	int RegisterEventHandler(const QString &eventName,
-							 std::function<void(const QVariant &)> callback, bool async = false,
+	int RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
+							 bool async					= false,
 							 XNEvent::Priority priority = XNEvent::Priority::Normal);
 
 	/**
@@ -152,7 +192,7 @@ public:
 	 * @param eventData: 事件携带的数据
 	 * @param forceAsync: 强制异步处理
 	 */
-	void TriggerEvent(const QString &eventName, const QVariant &eventData = QVariant(),
+	void TriggerEvent(const std::string &eventName, const std::any &eventData = std::any(),
 					  bool forceAsync			 = false,
 					  XNEvent::Priority priority = XNEvent::Priority::Normal);
 
@@ -162,8 +202,7 @@ public:
 	 * @param callback: 事件处理回调函数
 	 * @return: 返回处理器ID，失败返回-1
 	 */
-	int RegisterRTEventHandler(const QString &eventName,
-							   std::function<void(const QVariant &)> callback)
+	int RegisterRTEventHandler(const std::string &eventName, XNEventCallback callback)
 	{
 		return RegisterEventHandler(eventName, callback, true, XNEvent::Priority::RealTime);
 	}
@@ -173,64 +212,37 @@ public:
 	 * @param eventName: 要触发的事件名称
 	 * @param eventData: 事件携带的数据
 	 */
-	void TriggerRTEvent(const QString &eventName, const QVariant &eventData = QVariant())
+	void TriggerRTEvent(const std::string &eventName, const std::any &eventData = std::any())
 	{
 		TriggerEvent(eventName, eventData, true, XNEvent::Priority::RealTime);
 	}
 
-signals:
-	/**
-	 * @brief 			注册周期性执行的函数
-	 * @param id:		quint32类型，模型ID
-	 * @param fun:		QFunctionPointer类型，需要提交的函数的包装
-	 * @param freqGroup:UINT32类型，提交的函数运行频率组，0为基频，1为半频，2为1/4频，3为1/8频，4为1/16频，5为1/32频
-	 * @param RunPos:	UINT32类型，提交的函数运行节点号，<2^(freqGroup)
-	 * @param RunPriorty:INT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
-	 * @details 向线程管理器添加要周期性执行的函数
-	 */
-	void RegisterFunction(quint32 id, XNCallBack fun, quint32 freqGroup, quint32 RunPos,
-						  quint32 RunPriorty);
+	void SetInitializeType(uint32_t initialType);
+
+	void SetThreadID(uint32_t threadID);
+
+	uint32_t GetThreadID() const;
 
-public slots:
 	/**
 	 * @brief 初始化函数
 	 * @details
 	 * 模型的初始化函数接口，子类继承时要调用父类初始化接口，或在此函数中使用AddMyFunction方法注册需要被线程调用的函数
 	 */
-	virtual void OnInitialize();
+	virtual void Initialize();
 
 	/**
 	 * @brief 仿真系统运行前做最后处理
 	 * @details	系统运行前模型做最后处理的接口
 	 */
-	virtual void OnPrepareForExecute();
+	virtual void PrepareForExecute();
 
 public:
 	virtual void RegisterDDSParticipant();
 };
 
-#define XN_DECLARE_DDS()                                                                           \
-public:                                                                                            \
-	virtual void RegisterDDSParticipant() override;
-
-#define XN_REGISTER_PARTICIPANT_BEGIN(class)                                                       \
-	void class ::RegisterDDSParticipant()                                                          \
+#define XN_MODEL_INITIALIZE(ClassName)                                                             \
+	extern "C" XNModelObjectPtr Initial##ClassName()                                               \
 	{                                                                                              \
-		XNModelObject::RegisterDDSParticipant();                                                   \
-		Q_D(class);                                                                                \
-		XNModelManager *modelManager = qobject_cast<XNModelManager *>(parent());                   \
-		if (modelManager == nullptr)                                                               \
-			return;                                                                                \
-		XNDDSManager *ddsManager = modelManager->parent()->findChild<XNDDSManager *>();            \
-		if (ddsManager == nullptr)                                                                 \
-			return;                                                                                \
-		quint32 MyID = getUniqueId();
-
-#define XN_PUBLISHTOPIC(topic)                                                                     \
-	d->_dataWriters[#topic] = ddsManager->RegisterPublisher<topic##PubSubType>(#topic, MyID);
-
-#define XN_SUBSCRIBETOPIC(topic, fun)                                                              \
-	ddsManager->RegisterSubscriber<topic##PubSubType>(                                             \
-		#topic, MyID, std::bind(fun, this, std::placeholders::_1));
-
-#define XN_REGISTER_PARTICIPANT_END(class) }
+		ClassName##Ptr obj = std::make_shared<ClassName>();                                        \
+		return obj;                                                                                \
+	}

Release/include/XNCore/XNModelObject_p.h

@@ -10,62 +10,49 @@
  */
 #pragma once
 #include "XNObject_p.h"
-#include <QLibrary>
-#include <QFunctionPointer>
-#include <QHash>
-#include <fastdds/dds/publisher/DataWriter.hpp>
 
 /**
  * @brief 模型基类私有结构体
  */
-class XNModelObjectPrivate : public XNObjectPrivate
-{
-public:
-	Q_DECLARE_PUBLIC(XNModelObject)
-
-	/**
-	 * @brief 构造函数
-	 * @param q 模型基类指针
-	 */
-	explicit XNModelObjectPrivate(XNModelObject *q) : XNObjectPrivate(q) {}
-
+struct XNModelObjectPrivate : public XNObjectPrivate {
+	XNFrameworkPtr _framework;
 	/**
 	 * @brief 模型描述
 	 */
-	QString _sDescription;
+	std::string _sDescription;
 	/**
 	 * @brief 模型作者
 	 */
-	QString _sAuthor;
+	std::string _sAuthor;
 	/**
 	 * @brief 模型配置文件路径
 	 */
-	QString _sXmlPath;
+	std::string _sXmlPath;
 	/**
 	 * @brief 数据包模型动态库路径
 	 */
-	QString _sLibPath;
+	std::string _sLibPath;
 	/**
 	 * @brief 模型创建时间
 	 */
-	QDateTime _cCreatTime;
+	XNTimePoint _cCreatTime;
 	/**
 	 * @brief 模型修改时间
 	 */
-	QDateTime _cChangeTime;
+	XNTimePoint _cChangeTime;
 	/**
 	 * @brief 模型版本号
 	 */
-	QString _sVersion;
+	std::string _sVersion;
 	/**
 	 * @brief 数据包模型动态库句柄
 	 */
-	QLibrary *_dynamicLib = nullptr;
+	void *_dynamicLib = nullptr;
 
 	/**
 	 * @brief 发布者信息
 	 */
-	QHash<QString, FAST_DDS_MACRO::DataWriter *> _dataWriters;
+	FAST_DDS_MACRO::DataWriter *_dataWriter;
 
 	/**
 	 * @brief 模型运行时间
@@ -75,25 +62,35 @@ public:
 	/**
 	 * @brief 模型运行次数
 	 */
-	quint64 _runCnt;
+	uint64_t _runCnt;
 
 	/**
 	 * @brief 模型运行频率
 	 */
-	quint32 _runFreq;
+	uint32_t _runFreq;
 
 	/**
 	 * @brief 模型运行节点
 	 */
-	quint32 _runNode;
+	uint32_t _runNode;
 
 	/**
 	 * @brief 模型运行优先级
 	 */
-	quint32 _runPriority;
+	uint32_t _runPriority;
 
 	/**
 	 * @brief 模型设置频率
 	 */
 	double _setFreq;
+
+	/**
+	 * @brief 模型初始化类型
+	 */
+	uint32_t _initialType;
+
+	/**
+	 * @brief 模型线程ID
+	 */
+	uint32_t _threadID;
 };

Release/include/XNCore/XNObject.h

@@ -10,75 +10,83 @@
  */
 #pragma once
 
-#include <QObject>
-#include <QVariant>
-#include <QtXml/QDomDocument>
-
 #include "XNCore_global.h"
 #include "XNLogger.h"
 
-class XNObjectPrivate;
+struct XNObjectPrivate;
 
 /**
  * @brief 基础对象类
  */
-class XNCORE_EXPORT XNObject : public QObject
+class XNCORE_EXPORT XNObject : public std::enable_shared_from_this<XNObject>
 {
+	XN_METATYPE_P(XNObject)
+	XN_NOCOPYABLE(XNObject)
+protected:
+	using PrivateType = XNObjectPrivate;
 	/**
-	 * @brief 宏定义，用于支持Qt的元对象系统	
+	 * @brief 私有数据成员
 	 */
-	Q_OBJECT
-
-	/**
-	 * @brief 宏定义，用于禁用拷贝构造函数	
-	 */
-	Q_DISABLE_COPY(XNObject)
-
-	/**
-	 * @brief 宏定义，用于声明私有数据成员
-	 */
-	Q_DECLARE_PRIVATE(XNObject)
-
-	/**
-	 * @brief 宏定义，用于声明属性uniqueId
-	 */
-	Q_PROPERTY(quint32 UniqueId READ getUniqueId WRITE setUniqueId)
+	PrivateType *_Private_Ptr;
 
 public:
 	/**
 	 * @brief 构造函数
-	 * @param parent 父对象
 	 */
-	explicit XNObject(QObject *parent = nullptr);
+	XNObject();
 
 	/**
 	 * @brief 析构函数
 	 */
 	virtual ~XNObject();
 
+protected:
+	/**
+	 * @brief 构造函数
+	 * @param p 私有数据成员
+	 */
+	XNObject(PrivateType *p);
+
+public:
 	/**
 	 * @brief 获取唯一ID
 	 * @return 唯一ID
 	 */
-	quint32 getUniqueId();
+	uint32_t GetUniqueId();
 
 	/**
 	 * @brief 设置唯一ID
 	 * @param uniqueId 唯一ID
 	 */
-	void setUniqueId(const quint32 &uniqueId);
+	void SetUniqueId(const uint32_t &uniqueId);
 
-protected:
 	/**
-	 * @brief 构造函数
-	 * @param dd 私有数据成员
-	 * @param parent 父对象
+	 * @brief 获取对象名称
+	 * @return 对象名称
 	 */
-	XNObject(XNObjectPrivate &dd, QObject *parent = nullptr);
+	const std::string &GetObjectName();
 
-protected:
 	/**
-	 * @brief 私有数据成员
+	 * @brief 设置对象名称
+	 * @param name 对象名称
 	 */
-	XNObjectPrivate *d_ptr;
+	void SetObjectName(const std::string &name);
 };
+
+class XNFramework;
+class XNDDSManager;
+class XNEventManager;
+class XNModelManager;
+class XNScenarioManager;
+class XNServiceManager;
+class XNThreadManager;
+class XNTimeManager;
+
+XNCLASS_PTR_DECLARE(XNFramework)
+XNCLASS_PTR_DECLARE(XNDDSManager)
+XNCLASS_PTR_DECLARE(XNEventManager)
+XNCLASS_PTR_DECLARE(XNModelManager)
+XNCLASS_PTR_DECLARE(XNScenarioManager)
+XNCLASS_PTR_DECLARE(XNServiceManager)
+XNCLASS_PTR_DECLARE(XNThreadManager)
+XNCLASS_PTR_DECLARE(XNTimeManager)

Release/include/XNCore/XNObject_p.h

@@ -15,28 +15,20 @@
 /**
  * @brief 基础对象类的私有数据成员
  */
-class XNObjectPrivate
-{
-public:
-	/**
-	 * @brief 宏定义，用于声明公有数据成员	
-	 */
-	Q_DECLARE_PUBLIC(XNObject)
-
-	/**
-	 * @brief 构造函数
-	 * @param q 基础对象类指针
-	 */
-	explicit XNObjectPrivate(XNObject *q) : q_ptr(q) {}
-
+struct XNObjectPrivate {
+	virtual ~XNObjectPrivate();
 	/**
 	 * @brief 基础对象类指针
 	 */
-	XNObject *q_ptr;
+	XNObject *_Public_Ptr;
 
-private:
 	/**
 	 * @brief 唯一ID
 	 */
-	quint32 uUniqueID;
+	uint32_t uUniqueID;
+
+	/**
+	 * @brief 对象名称
+	 */
+	std::string sObjectName;
 };

Release/include/XNCore/XNScenarioManager.h

@@ -11,7 +11,7 @@
 #pragma once
 #include "XNBaseFrameObject.h"
 
-class XNScenarioManagerPrivate;
+struct XNScenarioManagerPrivate;
 
 /**
  * @brief 运行环境描述管理器类
@@ -19,14 +19,13 @@ class XNScenarioManagerPrivate;
  */
 class XNScenarioManager : public XNBaseFrameObject
 {
-	Q_OBJECT
-	Q_DECLARE_PRIVATE(XNScenarioManager)
-	Q_DISABLE_COPY(XNScenarioManager)
+	XN_METATYPE(XNScenarioManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNScenarioManager)
 public:
 	/**
 	 * @brief 运行环境描述管理器类默认构造函数
 	 */
-	explicit XNScenarioManager(QObject *parent = nullptr);
+	XNScenarioManager();
 
 	/**
 	 * @brief 运行环境描述管理器类析构函数
@@ -39,110 +38,42 @@ protected:
 	 * @param p:私有结构体指针
 	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
 	 */
-	XNScenarioManager(XNScenarioManagerPrivate &dd, QObject *parent = nullptr);
+	XNScenarioManager(PrivateType *p);
 
 public:
 	/**
 	 * @brief 获取运行环境名称
 	 * @return const XNString&:	运行环境名称
 	 */
-	const QString &GetSimName();
+	const std::string &GetSimName();
 
 	/**
 	 * @brief 设置运行环境名称
 	 * @param simName:	XNString类型，运行环境名称
 	 */
-	void SetSimName(QString &simName);
+	void SetSimName(const std::string &simName);
 
-	/**
-	 * @brief 获取运行环境开始时间
-	 * @return const XNTime&:	运行环境开始时间
-	 */
-	const QDateTime &GetSimStartTime();
-
-	/**
-	 * @brief 设置运行环境开始时间
-	 * @param startTime:	QDateTime类型，运行环境开始时间
-	 */
-	void SetSimStartTime(QDateTime &startTime);
-
-signals:
-	/**
-	 * @brief 信号，用于通知线程管理器添加线程
-	 */
-	void AddThreadPool(QString name, FreqLevel freq, quint32 priority, quint32 CPUAff,
-					   double RunInter);
-
-	/**
-	 * @brief 信号，用于通知模型管理器加载模型
-	 */
-	void LoadModel(const QString &modelPath, const QString &className);
-
-	/**
-	 * @brief 信号，用于通知服务管理器加载服务
-	 */
-	void LoadService(const QString &servicePath, const QString &className);
-
-	/**
-	 * @brief 信号，用于通知框架设置工作路径
-	 */
-	void SetWorkPath(const QString &workPath);
-
-	/**
-	 * @brief 信号，用于通知框架设置模型库路径
-	 */
-	void SetModelPath(const QString &modelPath);
-
-	/**
-	 * @brief 信号，用于通知框架设置服务库路径
-	 */
-	void SetServicePath(const QString &servicePath);
-
-	/**
-	 * @brief 信号，用于通知框架设置CPU亲和性
-	 */
-	void SetCpuAffinity(quint32 cpuAffinity);
-
-	/**
-	 * @brief 设置基础运行频率
-	 * @param freq:	基础运行频率，单位Hz
-	 */
-	void SetBaseFreq(const double &freq);
-
-	/**
-	 * @brief 设置DDS域ID
-	 * @param domainID:	DDS域ID
-	 */
-	void SetDomainID(quint32 domainID);
-
-	/**
-	 * @brief 解析配置文件成功
-	 */
-	void AnalyzeScenarioXmlSuccess();
-
-	/**
-	 * @brief 解析配置文件失败
-	 */
-	void AnalyzeScenarioXmlFailed();
-
-public slots:
+public:
 	/**
 	 * @brief 初始化运行环境描述管理器
 	 * @return true:	初始化成功
 	 * @return false:	初始化失败
 	 * @details	运行环境描述管理器的初始化接口函数
 	 */
-	virtual void OnInitialize() override;
+	virtual bool Initialize() override;
 
 	/**
 	 * @brief 仿真运行前最后处理
 	 * @note  运行环境描述管理器在系统运行开始前的准备工作
 	 */
-	virtual void OnPrepareForExecute() override;
+	virtual bool PrepareForExecute() override;
 
 	/**
 	 * @brief 运行环境配置文件解析
-	 * @param XmlPath:	QString类型，运行环境配置文件解析路径
+	 * @param XmlPath:	std::string类型，运行环境配置文件解析路径
+	 * @param initialType:	uint32_t类型，初始化类型
+	 * @return true:	解析成功
+	 * @return false:	解析失败
 	 */
-	virtual void AnalysisScenarioXml(const QString &XmlPath);
+	virtual bool AnalysisScenarioXml(const std::string &XmlPath, uint32_t initialType);
 };

Release/include/XNCore/XNScenarioManager_p.h

@@ -14,19 +14,9 @@
 /**
  * @brief 运行环境描述管理器类私有结构体
  */
-class XNScenarioManagerPrivate : public XNBaseFrameObjectPrivate
-{
-
-public:
-	Q_DECLARE_PUBLIC(XNScenarioManager)
-	explicit XNScenarioManagerPrivate(XNScenarioManager *q) : XNBaseFrameObjectPrivate(q) {}
+struct XNScenarioManagerPrivate : public XNBaseFrameObjectPrivate {
 	/**
 	 * @brief 运行环境名称
 	 */
-	QString _ScenarioName;
-
-	/**
-	 * @brief 运行环境开始时间
-	 */
-	QDateTime _SimStartTime;
+	std::string _ScenarioName;
 };

Release/include/XNCore/XNServiceManager.h

@@ -3,26 +3,35 @@
 
 // 添加前向声明
 class XNServiceObject;
-class XNServiceManagerPrivate;
+XNCLASS_PTR_DECLARE(XNServiceObject)
+
+struct XNServiceManagerPrivate;
 
 class XNServiceManager : public XNBaseFrameObject
 {
-	Q_OBJECT
-	Q_DECLARE_PRIVATE(XNServiceManager)
-	Q_DISABLE_COPY(XNServiceManager)
+	XN_METATYPE(XNServiceManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNServiceManager)
 public:
-	explicit XNServiceManager(QObject *parent = nullptr);
+	/**
+	 * @brief 服务管理器类默认构造函数
+	 */
+	XNServiceManager();
+
+	/**
+	 * @brief 服务管理器类析构函数
+	 */
 	virtual ~XNServiceManager();
 
 protected:
-	XNServiceManager(XNServiceManagerPrivate &dd, QObject *parent = nullptr);
-
-public slots:
-	virtual void OnInitialize() override;
-	virtual void OnPrepareForExecute() override;
-	void OnLoadService(const QString &servicePath, const QString &serviceName);
+	XNServiceManager(PrivateType *p);
 
 public:
-	XNServiceObject *GetService(quint32 serviceID);
-	quint32 RegisterService();
+	virtual bool Initialize() override;
+	virtual bool PrepareForExecute() override;
+	void LoadService(const std::string &servicePath, const std::string &serviceName,
+					 uint32_t initialType);
+
+public:
+	XNServiceObjectPtr GetService(uint32_t serviceID);
+	uint32_t RegisterService();
 };

Release/include/XNCore/XNServiceManager_p.h

@@ -1,16 +1,16 @@
 #pragma once
 #include "XNBaseFrameObject_p.h"
 
-class XNServiceManagerPrivate : public XNBaseFrameObjectPrivate
-{
-public:
-	Q_DECLARE_PUBLIC(XNServiceManager)
-
-	explicit XNServiceManagerPrivate(XNServiceManager *q) : XNBaseFrameObjectPrivate(q) {}
-
+struct XNServiceManagerPrivate : public XNBaseFrameObjectPrivate {
 	/**
 	 * @brief 服务ID库
 	 * @details 所有服务已用ID的存储库
 	 */
-	QVector<bool> ServiceIDAssigned;
+	std::vector<bool> ServiceIDAssigned;
+
+	/**
+	 * @brief 服务列表
+	 * @details 所有服务的存储库
+	 */
+	std::map<uint32_t, XNServiceObjectPtr> ServiceList;
 };

Release/include/XNCore/XNServiceObject.h

@@ -3,90 +3,64 @@
 #include "XNObject.h"
 #include "XNServiceManager.h"
 #include "XNEventManager.h"
-
-class XNServiceObjectPrivate;
+struct XNServiceObjectPrivate;
 
 class XNServiceObject : public XNObject
 {
-	Q_OBJECT
-	Q_DECLARE_PRIVATE(XNServiceObject)
-	Q_DISABLE_COPY(XNServiceObject)
-
-	Q_PROPERTY(QString description READ GetDescription WRITE SetDescription)
-	Q_PROPERTY(QString author READ GetAuthor WRITE SetAuthor)
-	Q_PROPERTY(QString xmlPath READ GetXmlPath WRITE SetXmlPath)
-	Q_PROPERTY(QDateTime createTime READ GetCreateTime WRITE SetCreateTime)
-	Q_PROPERTY(QDateTime changeTime READ GetChangeTime WRITE SetChangeTime)
-	Q_PROPERTY(QString version READ GetVersion WRITE SetVersion)
-
+	XN_METATYPE(XNServiceObject, XNObject)
+	XN_DECLARE_PRIVATE(XNServiceObject)
 public:
-	explicit XNServiceObject(QObject *parent = nullptr);
+	XNServiceObject();
 	virtual ~XNServiceObject();
 
 protected:
-	explicit XNServiceObject(XNServiceObjectPrivate &dd, QObject *parent = nullptr);
+	XNServiceObject(PrivateType *p);
 
 public:
-	const QString &GetVersion();
-	const QString &GetDescription();
-	const QString &GetAuthor();
-	const QString &GetXmlPath();
-	const QDateTime &GetCreateTime();
-	const QDateTime &GetChangeTime();
+	const std::string &GetVersion();
+	const std::string &GetDescription();
+	const std::string &GetAuthor();
+	const std::string &GetXmlPath();
+	const XNTimePoint &GetCreateTime();
+	const XNTimePoint &GetChangeTime();
 
-	void SetVersion(const QString &version);
-	void SetDescription(const QString &description);
-	void SetAuthor(const QString &author);
-	void SetXmlPath(const QString &xmlPath);
-	void SetCreateTime(const QDateTime &createTime);
-	void SetChangeTime(const QDateTime &changeTime);
+	void SetVersion(const std::string &version);
+	void SetDescription(const std::string &description);
+	void SetAuthor(const std::string &author);
+	void SetXmlPath(const std::string &xmlPath);
+	void SetCreateTime(const XNTimePoint &createTime);
+	void SetChangeTime(const XNTimePoint &changeTime);
 
-	int RegisterEventHandler(const QString &eventName,
-							 std::function<void(const QVariant &)> callback, bool async = false,
+	int RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
+							 bool async					= false,
 							 XNEvent::Priority priority = XNEvent::Priority::Normal);
 
-	void TriggerEvent(const QString &eventName, const QVariant &eventData = QVariant(),
+	void TriggerEvent(const std::string &eventName, const std::any &eventData = std::any(),
 					  bool forceAsync			 = false,
 					  XNEvent::Priority priority = XNEvent::Priority::Normal);
 
-	int RegisterRTEventHandler(const QString &eventName,
-							   std::function<void(const QVariant &)> callback);
+	int RegisterRTEventHandler(const std::string &eventName, XNEventCallback callback);
 
-	void TriggerRTEvent(const QString &eventName, const QVariant &eventData = QVariant());
+	void TriggerRTEvent(const std::string &eventName, const std::any &eventData = std::any());
 
-public slots:
-	virtual void OnInitialize();
-	virtual void OnPrepareForExecute();
+	void SetInitializeType(uint32_t initialType);
+
+	virtual void Initialize();
+	virtual void PrepareForExecute();
 
-public:
 	virtual void RegisterDDSParticipant();
 
-private:
-	XNEventManager *GetEventManager() const;
+	void SetFramework(XNFrameworkPtr framework);
+
+protected:
+	XNFrameworkPtr GetFramework() const;
 };
 
-#define XN_DECLARE_DDS_SERVICE()                                                                   \
-public:                                                                                            \
-	virtual void RegisterDDSParticipant() override;
+XNCLASS_PTR_DECLARE(XNServiceObject)
 
-#define XN_REGISTER_SERVICE_BEGIN_SERVICE(class)                                                   \
-	void class ::RegisterDDSParticipant()                                                          \
+#define XN_SERVICE_INITIALIZE(ClassName)                                                           \
+	extern "C" XNServiceObjectPtr Initial##ClassName()                                             \
 	{                                                                                              \
-		XNServiceObject::RegisterDDSParticipant();                                                 \
-		Q_D(class);                                                                                \
-		XNServiceManager *serviceManager = qobject_cast<XNServiceManager *>(parent());             \
-		if (serviceManager == nullptr)                                                             \
-			return;                                                                                \
-		XNDDSManager *ddsManager = serviceManager->parent()->findChild<XNDDSManager *>();          \
-		if (ddsManager == nullptr)                                                                 \
-			return;                                                                                \
-		quint32 MyID = getUniqueId();
-
-#define XN_PUBLISHTOPIC_SERVICE(topic)                                                             \
-	d->_dataWriters[#topic] = ddsManager->RegisterPublisher<topic##PubSubType>(#topic, MyID);
-
-#define XN_SUBSCRIBETOPIC_SERVICE(topic, fun)                                                      \
-	ddsManager->RegisterSubscriber<topic##PubSubType>(                                             \
-		#topic, MyID, std::bind(fun, this, std::placeholders::_1));
-
-#define XN_REGISTER_SERVICE_END_SERVICE(class) }
+		ClassName##Ptr obj = std::make_shared<ClassName>();                                        \
+		return obj;                                                                                \
+	}

Release/include/XNCore/XNServiceObject_p.h

@@ -1,21 +1,14 @@
 #pragma once
 #include "XNObject_p.h"
-#include <QHash>
-#include <fastdds/dds/publisher/DataWriter.hpp>
-#include "XNEventManager.h"
-class XNServiceObjectPrivate : public XNObjectPrivate
-{
-public:
-	Q_DECLARE_PUBLIC(XNServiceObject)
-	explicit XNServiceObjectPrivate(XNServiceObject *q) : XNObjectPrivate(q) {}
 
-	QString _sDescription;
-	QString _sAuthor;
-	QString _sXmlPath;
-	QDateTime _cCreateTime;
-	QDateTime _cChangeTime;
-	QString _sVersion;
-	QHash<QString, FAST_DDS_MACRO::DataWriter *> _dataWriters;
-
-	XNEventManager *pEventManager;
+struct XNServiceObjectPrivate : public XNObjectPrivate {
+	std::string _sDescription;
+	std::string _sAuthor;
+	std::string _sXmlPath;
+	XNTimePoint _cCreateTime;
+	XNTimePoint _cChangeTime;
+	std::string _sVersion;
+	std::unordered_map<std::string, FAST_DDS_MACRO::DataWriter *> _dataWriters;
+	XNFrameworkPtr pFramework;
+	uint32_t _initialType;
 };

Release/include/XNCore/XNThread.h

@@ -9,36 +9,43 @@
  *
  */
 #pragma once
-#include <QObject>
-#include <QThread>
-#include "XNCore_global.h"
+#include "XNObject.h"
 
-class XNThreadPrivate;
+struct XNThreadPrivate;
 
 /**
  * @brief 调度线程类
  * @details 调度所有模型提交的周期性执行函数
  */
-class XNCORE_EXPORT XNThread : public QObject
+class XNCORE_EXPORT XNThread : public XNObject
 {
-	Q_OBJECT
-	Q_DISABLE_COPY(XNThread)
-	Q_DECLARE_PRIVATE(XNThread)
+	XN_METATYPE(XNThread, XNObject)
+	XN_DECLARE_PRIVATE(XNThread)
 
 public:
-	explicit XNThread(QObject *parent = nullptr);
-	XNThread(QObject *parent = nullptr, QString name = "", FreqLevel freq = FreqLevel::BaseFreq,
-			 quint32 priority = 99, quint32 CPUAff = 0, double RunInter = BASE_RUN_INTER);
+	XNThread() = delete;
 
-protected:
-	XNThreadPrivate *d_ptr;
-
-public:
 	/**
 	 * @brief 默认析构函数
 	 */
 	virtual ~XNThread();
 
+	explicit XNThread(std::string name = "", double freq = BASE_RUN_FREQ, uint32_t priority = 99,
+					  uint32_t CPUAff = 0);
+
+public:
+	/**
+	 * @brief 获取框架对象
+	 * @return 框架对象
+	 */
+	XNFrameworkPtr GetFramework();
+
+	/**
+	 * @brief 设置框架对象
+	 * @param framework 框架对象
+	 */
+	void SetFramework(XNFrameworkPtr framework);
+
 	/**
 	 * @brief 线程初始化
 	 * @return true:	初始化成功
@@ -46,26 +53,19 @@ public:
 	 */
 	bool Initialize();
 
-public slots:
 	/**
 	 * @brief 仿真控制
 	 * @param objectId:	对象ID
 	 * @param cmd:	仿真控制命令
 	 */
-	void OnSimControl(quint32 objectId, SimControlCmd cmd);
+	void SimControl(uint32_t objectId, SimControlCmd cmd);
 
 	/**
 	 * @brief 设置线程运行的开始时间
 	 * @param simTime:	timespec结构体类型，用于线程纳秒睡眠计算的开始时间
 	 * @details 通过设置统一的开始时间，使个线程能同步执行
 	 */
-	void OnSetStartTime(const timespec &simTime);
-
-	/**
-	 * @brief 设置线程运行间隔
-	 * @param dRunInter:	double类型，线程运行间隔，单位纳秒
-	 */
-	void SetRunInter(const double &dRunInter);
+	void SetStartTime(const timespec &simTime);
 
 	/**
 	 * @brief 加入线程
@@ -78,19 +78,73 @@ public slots:
 	 */
 	void Detach();
 
-public:
 	/**
 	 * @brief 获取线程ID
 	 * @return const quint32&:	线程ID
 	 */
-	const quint32 &GetThreadID();
+	const uint32_t &GetThreadID();
 
 	/**
 	 * @brief 设置线程ID
 	 * @param threadID:	线程ID
 	 */
-	void SetThreadID(const quint32 &threadID);
+	void SetThreadID(const uint32_t &threadID);
 
+	/**
+	 * @brief 获取运行状态
+	 * @return RunStatus:	运行状态枚举
+	 */
+	RunStatus GetRunStatus();
+
+	/**
+	 * @brief 获取线程运行频率
+	 * @return const double&:线程运行频率
+	 */
+	const double &GetRunFrequecy();
+
+	/**
+	 * @brief 设置线程运行频率
+	 * @param eRunFrequecy:	double类型，线程运行频率
+	 */
+	void SetRunFrequecy(const double &dRunFrequecy);
+
+	/**
+	 * @brief 获取线程运行优先级
+	 * @return const UINT32&:运行优先级，0～99，99最高
+	 */
+	const uint32_t &GetRunPriority();
+
+	/**
+	 * @brief 设置线程运行优先级
+	 * @param uRunPriority:	UINT32类型，运行优先级，0～99，99最高
+	 */
+	void SetRunPriority(const uint32_t &uRunPriority);
+
+	/**
+	 * @brief 设置线程CPU亲和性掩码
+	 * @return const UINT32&:	CPU亲和性掩码，按位表示某CPU核是否使用，从低到高，0表示不使用，1表示使用。
+	 * 							例如：0x00000003表示使用0,1号CPU
+	 */
+	const uint32_t &GetCPUAffinity();
+
+	/**
+	 * @brief 获取线程CPU亲和性掩码
+	 * @param uCPUAffinity:	UINT32类型，CPU亲和性掩码，按位表示某CPU核是否使用，从低到高，0表示不使用，1表示使用。
+	 * 						例如：0x00000003表示使用0,1号CPU
+	 */
+	void SetCPUAffinity(const uint32_t &uCPUAffinity);
+
+	/**
+	 * @brief 向线程添加周期性函数
+	 * @param fun:XNCallBack函数包装器类型，需要提交的函数的包装
+	 * @param freq:FreqLevel类型，提交的函数运行频率组
+	 * @param pos:UINT32类型，提交的函数运行节点号
+	 * @param priorty:UINT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
+	 * @details 根据运行频率组和节点号向调度线程任务表中添加周期性函数
+	 */
+	void AddFunction(XNCallBack fun, FreqLevel freq, uint32_t pos, uint32_t priorty);
+
+private:
 	/**
 	 * @brief 控制线程开始
 	 * @return true:	线程启动成功
@@ -120,61 +174,6 @@ public:
 	 */
 	void Stop(bool force = false);
 
-	/**
-	 * @brief 获取运行状态
-	 * @return RunStatus:	运行状态枚举
-	 */
-	RunStatus GetRunStatus();
-
-	/**
-	 * @brief 获取线程运行频率族
-	 * @return const FreqLevel&:线程运行频率族
-	 */
-	const FreqLevel &GetRunFrequecy();
-
-	/**
-	 * @brief 设置线程运行频率族
-	 * @param eRunFrequecy:	FreqLevel枚举类，线程运行频率族
-	 */
-	void SetRunFrequecy(const FreqLevel &eRunFrequecy);
-
-	/**
-	 * @brief 获取线程运行优先级
-	 * @return const UINT32&:运行优先级，0～99，99最高
-	 */
-	const quint32 &GetRunPriority();
-
-	/**
-	 * @brief 设置线程运行优先级
-	 * @param uRunPriority:	UINT32类型，运行优先级，0～99，99最高
-	 */
-	void SetRunPriority(const quint32 &uRunPriority);
-
-	/**
-	 * @brief 设置线程CPU亲和性掩码
-	 * @return const UINT32&:	CPU亲和性掩码，按位表示某CPU核是否使用，从低到高，0表示不使用，1表示使用。
-	 * 							例如：0x00000003表示使用0,1号CPU
-	 */
-	const quint32 &GetCPUAffinity();
-
-	/**
-	 * @brief 获取线程CPU亲和性掩码
-	 * @param uCPUAffinity:	UINT32类型，CPU亲和性掩码，按位表示某CPU核是否使用，从低到高，0表示不使用，1表示使用。
-	 * 						例如：0x00000003表示使用0,1号CPU
-	 */
-	void SetCPUAffinity(const quint32 &uCPUAffinity);
-
-	/**
-	 * @brief 向线程添加周期性函数
-	 * @param fun:XNCallBack函数包装器类型，需要提交的函数的包装
-	 * @param freq:FreqLevel类型，提交的函数运行频率组
-	 * @param pos:UINT32类型，提交的函数运行节点号
-	 * @param priorty:UINT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
-	 * @details 根据运行频率组和节点号向调度线程任务表中添加周期性函数
-	 */
-	void AddFunction(XNCallBack fun, FreqLevel freq, quint32 pos, quint32 priorty);
-
-private:
 	/**
 	 * @brief 执行线程CPU亲和性设置
 	 * @return true:	设置线程CPU亲和性成功
@@ -189,8 +188,10 @@ private:
 	 */
 	static void *ThreadFunction(void *args);
 
-	/**
-	 * @brief 初始化周期性函数表
-	 */
-	void InitialFunPool();
-};
+	// /**
+	//  * @brief 初始化周期性函数表
+	//  */
+	//void InitialFunPool();
+};
+
+XNCLASS_PTR_DECLARE(XNThread)

Release/include/XNCore/XNThreadManager.h

@@ -11,7 +11,7 @@
 #pragma once
 #include "XNBaseFrameObject.h"
 
-class XNThreadManagerPrivate;
+struct XNThreadManagerPrivate;
 
 /**
  * @brief 线程管理器类
@@ -19,15 +19,14 @@ class XNThreadManagerPrivate;
  */
 class XNThreadManager : public XNBaseFrameObject
 {
-	Q_OBJECT
-	Q_DECLARE_PRIVATE(XNThreadManager)
-	Q_DISABLE_COPY(XNThreadManager)
+	XN_METATYPE(XNThreadManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNThreadManager)
 
 public:
 	/**
 	 * @brief 线程管理器类默认构造函数
 	 */
-	explicit XNThreadManager(QObject *parent = nullptr);
+	XNThreadManager();
 
 	/**
 	 * @brief 线程管理器类析构函数
@@ -41,53 +40,32 @@ protected:
 	 * @param parent:QObject类型，父对象指针
 	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
 	 */
-	XNThreadManager(XNThreadManagerPrivate &dd, QObject *parent = nullptr);
+	XNThreadManager(PrivateType *p);
 
-signals:
-	/**
-	 * @brief 设置仿真开始时间信号
-	 * @param simTime:	timespec结构体类型，用于线程纳秒睡眠计算的开始时间
-	 * @details 通过设置统一的开始时间，使个线程能同步执行
-	 */
-	void SetStartTime(const timespec &simTime);
-
-	/**
-	 * @brief 设置线程运行间隔信号
-	 * @param dRunInter:	double类型，线程运行间隔，单位纳秒
-	 */
-	void SetRunInter(const double &dRunInter);
-
-	/**
-	 * @brief 仿真控制信号
-	 * @param objectId:	对象ID
-	 * @param cmd:	仿真控制命令
-	 */
-	void SimControl(quint32 objectId, SimControlCmd cmd);
-
-public slots:
+public:
 	/**
 	 * @brief 开始控制
 	 * @details 控制线程管理器开始运行接口
 	 */
-	void OnStart();
+	void Start();
 
 	/**
 	 * @brief 停止控制
 	 * @details 控制线程管理器停止运行接口
 	 */
-	void OnAbort();
+	void Abort();
 
 	/**
 	 * @brief 暂停控制
 	 * @details 控制线程管理器暂停运行接口
 	 */
-	void OnPause();
+	void Pause();
 
 	/**
 	 * @brief 继续控制
 	 * @details 控制线程管理器继续运行接口
 	 */
-	void OnContinue();
+	void Continue();
 
 	/**
 	 * @brief 初始化线程管理器
@@ -95,29 +73,37 @@ public slots:
 	 * @return false:	初始化失败
 	 * @details	线程管理器的初始化接口函数
 	 */
-	virtual void OnInitialize() override;
+	virtual bool Initialize() override;
 
 	/**
 	 * @brief 仿真运行前最后处理
 	 * @note  线程管理器在所有线程开始执行前的准备工作
 	 */
-	virtual void OnPrepareForExecute() override;
+	virtual bool PrepareForExecute() override;
+
+	/**
+	 * @brief 设置线程频率
+	 * @param threadID:	UINT32类型，线程ID
+	 * @param freq:	double类型，线程频率
+	 * @details 设置线程频率接口
+	 */
+	void SetThreadFreqByID(uint32_t threadID, double freq);
+
+	/**
+	 * @brief 获取线程频率
+	 * @param threadID:	UINT32类型，线程ID
+	 * @return double:	线程频率
+	 * @details 获取线程频率接口
+	 */
+	double GetThreadFreqByID(uint32_t threadID);
 
 	/**
 	 * @brief 仿真控制
 	 * @param objectId:	对象ID
 	 * @param cmd:	仿真控制命令
 	 */
-	void OnSimControl(quint32 objectId, SimControlCmd cmd);
+	void SimControl(uint32_t objectId, SimControlCmd cmd);
 
-	/**
-	 * @brief 设置仿真系统运行基频
-	 * @param dBaseFreq:	double类型，频率值，单位Hz
-	 * @details 仿真系统所有线程以此基频的 1 或 1/2 或 1/4 或 1/8 或 1/16 或 1/32 倍运行
-	 */
-	void OnSetBaseFreq(const double &dBaseFreq);
-
-public:
 	/**
 	 * @brief 获取运行状态
 	 * @return RunStatus:	枚举类，线程运行状态
@@ -125,50 +111,29 @@ public:
 	 */
 	RunStatus GetStatus();
 
-	/**
-	 * @brief 获得仿真系统运行基频
-	 * @return const double&:	频率值，单位Hz
-	 */
-	const double &GetBaseFreq();
-
-	/**
-	 * @brief 获得仿真系统运行基础间隔
-	 * @return const double&:	运行周期值，单位纳秒
-	 * @details 模型基础运行间隔由基频计算获得
-	 */
-	const double &GetBaseInter();
-
-	/**
-	 * @brief 通过运行间隔设置基频
-	 * @param dBaseInter:double类型，运行周期值，单位纳秒
-	 * @details 使用运行间隔计算得到基频并设置
-	 */
-	void SetBaseFreqByInter(const double &dBaseInter);
-
 	/**
 	 * @brief 获取线程数量
 	 * @return quint32:	线程数量
 	 */
-	quint32 GetThreadCount();
+	uint32_t GetThreadCount();
 
-public slots:
 	/**
 	 * @brief 添加一个线程
 	 * @param name:	XNString类型，线程名称
-	 * @param freq:	FreqLevel枚举类型，线程运行频率组
+	 * @param freq:	double类型，线程运行频率，单位Hz
 	 * @param priority:	UINT32类型，线程运行优先级，99～0，优先级数值越大，优先级越高
 	 * @param CPUAff:	UINT32类型，线程的CPU亲和性掩码，按位表示某CPU核是否使用，从低到高，0表示不使用，1表示使用。
 	 * 					例如：0x00000003表示使用0,1号CPU
-	 * @param RunInter: double类型，线程的运行周期，单位纳秒
 	 * @details 按照设置的参数创建线程
 	 */
-	virtual void OnAddThreadPool(QString name, FreqLevel freq, quint32 priority, quint32 CPUAff,
-								 double RunInter);
+	virtual uint32_t AddThreadPool(std::string name, double freq, uint32_t priority,
+								   uint32_t CPUAff);
 
 	/**
 	 * @brief 向线程中添加周期性函数
 	 * @param id:	UINT32类型，模型全局唯一ID
 	 * @param fun:	XNCallBack函数包装器类型，需要提交的函数的包装
+	 * @param threadID:	UINT32类型，线程ID
 	 * @param freqGroup:	UINT32类型，提交的函数运行频率组，0为基频，1为半频，2为1/4频，3为1/8频，4为1/16频，5为1/32频
 	 * @param RunPos:	UINT32类型，提交的函数运行节点号，<2^(freqGroup)
 	 * @param RunPriorty:	UINT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
@@ -176,8 +141,8 @@ public slots:
 	 * @return false:	添加失败
 	 * @details	根据运行频率组和节点号向对应的线程中添加周期性函数
 	 */
-	void OnRegisterFunction(quint32 id, XNCallBack fun, quint32 freqGroup, quint32 RunPos,
-							quint32 RunPriorty);
+	void RegisterFunction(uint32_t id, XNCallBack fun, uint32_t threadID, uint32_t freqGroup,
+						  uint32_t RunPos, uint32_t RunPriorty);
 
 private:
 	/**
@@ -187,7 +152,7 @@ private:
 	 * @return true:提交的函数频率与节点号符合规则
 	 * @return false:提交的函数频率与节点号不符合规则
 	 */
-	bool IsFunParamRight(quint32 ModelID, quint32 freqGroup, quint32 RunPos);
+	bool IsFunParamRight(uint32_t ModelID, uint32_t freqGroup, uint32_t RunPos);
 
-	quint32 AllocateThreadID();
+	uint32_t AllocateThreadID();
 };

Release/include/XNCore/XNThreadManager_p.h

@@ -20,55 +20,46 @@ struct funInfo {
 	 * @brief 周期性函数包装器
 	 */
 	XNCallBack fun;
+	/**
+	 * @brief 线程ID
+	 */
+	uint32_t threadID;
 	/**
 	 * @brief 运行频率组
 	 */
-	quint32 freqGroup;
+	uint32_t freqGroup;
 	/**
 	 * @brief 运行节点
 	 */
-	quint32 RunPos;
+	uint32_t RunPos;
 	/**
 	 * @brief 运行优先级
 	 */
-	quint32 RunPriority;
+	uint32_t RunPriority;
 };
 /**
  * @brief 声明周期性函数存储结构体的智能指针
  */
-using funInfoPtr = QSharedPointer<funInfo>;
+using funInfoPtr = std::shared_ptr<funInfo>;
 
 /**
  * @brief 线程管理器类私有结构体
  */
-class XNThreadManagerPrivate : public XNBaseFrameObjectPrivate
-{
-public:
-	XNThreadManagerPrivate(XNThreadManager *q) : XNBaseFrameObjectPrivate(q) {}
-	Q_DECLARE_PUBLIC(XNThreadManager)
-private:
+struct XNThreadManagerPrivate : public XNBaseFrameObjectPrivate {
 	/**
 	 * @brief 所有线程运行状态
 	 */
 	RunStatus _eRunStatus;
+	/**
+	 * @brief 线程列表
+	 */
+	std::map<uint32_t, XNThreadPtr> threadList;
 	/**
 	 * @brief 周期性函数存储列表
 	 */
-	QMap<quint32, std::vector<funInfoPtr> > funList;
-	/**
-	 * @brief 基础运行频率
-	 */
-	double dRunFreq = BASE_RUN_FREQ;
-	/**
-	 * @brief 基础运行间隔
-	 */
-	double dRunInter = BASE_RUN_INTER;
+	std::map<uint32_t, std::vector<funInfoPtr> > funList;
 	/**
 	 * @brief 线程ID
 	 */
-	QSet<quint32> threadIDMap;
-	/**
-	 * @brief 线程数量
-	 */
-	quint32 threadCount = 0;
+	std::set<uint32_t> threadIDMap;
 };

Release/include/XNCore/XNThread_p.h

@@ -0,0 +1,76 @@
+#pragma once
+#include "XNObject_p.h"
+/**
+ * @brief 线程类私有结构体
+ */
+struct XNThreadPrivate : public XNObjectPrivate {
+	/**
+	 * @brief 框架对象
+	 */
+	XNFrameworkPtr _framework;
+	/**
+	 * @brief 线程运行优先级
+	 */
+	uint32_t _uPriority = 0;
+	/**
+	 * @brief 线程CPU亲和性掩码
+	 * @details	按位表示某CPU核是否使用，从低到高，0表示不使用，1表示使用。例如：0x00000003表示使用0,1号CPU
+	 */
+	uint32_t _uAffinity = 0;
+	/**
+	 * @brief 线程运行频率
+	 */
+	double _setFreq = BASE_RUN_FREQ;
+	/**
+	 * @brief 线程调度任务表
+	 */
+	std::vector<std::map<uint32_t, std::vector<XNCallBack> > > _funVec;
+	/**
+	 * @brief pthread线程调度参数
+	 */
+	sched_param param;
+	/**
+	 * @brief pthread线程属性
+	 */
+	pthread_attr_t attr;
+	/**
+	 * @brief pthread线程
+	 */
+	pthread_t thread;
+	/**
+	 * @brief 线程睡眠时间控制
+	 */
+	PERIOD_INFO pinfo;
+	/**
+	 * @brief 线程控制锁
+	 */
+	pthread_mutex_t _mtx = PTHREAD_MUTEX_INITIALIZER;
+	/**
+	 * @brief 线程控制条件变量
+	 */
+	pthread_cond_t _cond = PTHREAD_COND_INITIALIZER;
+	/**
+	 * @brief 线程运行状态
+	 */
+	RunStatus _eRunStatus = RunStatus::NotStart;
+	/**
+	 * @brief 线程执行进度
+	 */
+	uint32_t _RunPosition = 0;
+	/**
+	 * @brief 线程执行计数
+	 */
+	int count = 0;
+	/**
+	 * @brief 线程执行时间统计
+	 */
+	timespec _lastRunTime;
+	/**
+	 * @brief 线程运行状态主题写入器
+	 */
+	FAST_DDS_MACRO::DataWriter *writer;
+	/**
+	 * @brief 线程ID
+	 */
+	uint32_t _threadID = 0;
+};

Release/include/XNCore/XNTimeManager.h

@@ -10,9 +10,9 @@
  */
 #pragma once
 #include "XNBaseFrameObject.h"
-#include <QDateTime>
+#include <chrono>
 
-class XNTimeManagerPrivate;
+struct XNTimeManagerPrivate;
 
 /**
  * @brief 时间管理器类
@@ -20,16 +20,14 @@ class XNTimeManagerPrivate;
  */
 class XNCORE_EXPORT XNTimeManager : public XNBaseFrameObject
 {
-	Q_OBJECT
-	Q_DISABLE_COPY(XNTimeManager);
-	Q_DECLARE_PRIVATE(XNTimeManager);
+	XN_METATYPE(XNTimeManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNTimeManager)
 
 public:
 	/**
 	 * @brief 构造函数
-	 * @param parent: 父对象
 	 */
-	explicit XNTimeManager(QObject *parent = nullptr);
+	XNTimeManager();
 
 	/**
 	 * @brief 析构函数
@@ -39,63 +37,46 @@ public:
 protected:
 	/**
 	 * @brief 构造函数
-	 * @param dd: 私有数据成员
-	 * @param parent: 父对象
+	 * @param p: 私有数据成员
 	 */
-	XNTimeManager(XNTimeManagerPrivate &dd, QObject *parent = nullptr);
+	XNTimeManager(PrivateType *p);
 
 public:
 	/**
 	 * @brief 获取当前仿真时间
-	 * @return QDateTime:	当前仿真时间
+	 * @return std::chrono::system_clock::time_point: 当前仿真时间
 	 */
-	QDateTime GetSimTime();
+	XNTimePoint GetSimTime();
 
-signals:
-	/**
-	 * @brief 设置仿真开始时间信号
-	 * @param simTime:	timespec结构体类型，用于线程纳秒睡眠计算的开始时间
-	 * @details 通过设置统一的开始时间，使个线程能同步执行
-	 */
-	void SetStartTime(const timespec &simTime);
-
-	/**
-	 * @brief 仿真控制信号
-	 * @param objectId:	对象ID
-	 * @param cmd:	仿真控制命令
-	 */
-	void SimControl(quint32 objectId, SimControlCmd cmd);
-
-public slots:
 	/**
 	 * @brief 设置仿真开始时间
-	 * @param simTime:	timespec类型，仿真开始时间
+	 * @param simTime: timespec类型，仿真开始时间
 	 */
-	void OnSetStartTime(const timespec &simTime);
+	void SetStartTime(const timespec &simTime);
 
 	/**
 	 * @brief 开始控制
 	 * @details 控制时间管理器线程开始运行接口
 	 */
-	void OnStart();
+	void Start();
 
 	/**
 	 * @brief 停止控制
 	 * @details 控制时间管理器线程停止运行接口
 	 */
-	void OnAbort();
+	void Abort();
 
 	/**
 	 * @brief 暂停控制
 	 * @details 控制时间管理器线程暂停运行接口
 	 */
-	void OnPause();
+	void Pause();
 
 	/**
 	 * @brief 继续控制
 	 * @details 控制时间管理器线程继续运行接口
 	 */
-	void OnContinue();
+	void Continue();
 
 	/**
 	 * @brief 初始化时间管理器
@@ -103,22 +84,21 @@ public slots:
 	 * @return false:	初始化失败
 	 * @details	时间管理器的初始化接口函数
 	 */
-	virtual void OnInitialize() override;
+	virtual bool Initialize() override;
 
 	/**
 	 * @brief 仿真运行前最后处理
 	 * @note  时间管理器在开始执行前的准备工作
 	 */
-	virtual void OnPrepareForExecute() override;
+	virtual bool PrepareForExecute() override;
 
 	/**
 	 * @brief 仿真控制
 	 * @param objectId:	对象ID
 	 * @param cmd:	仿真控制命令
 	 */
-	void OnSimControl(quint32 objectId, SimControlCmd cmd);
+	void SimControl(uint32_t objectId, SimControlCmd cmd);
 
-public:
 	/**
 	 * @brief 获取运行状态
 	 * @return RunStatus:	枚举类，时间管理器线程运行状态

Release/include/XNCore/XNTimeManager_p.h

@@ -11,21 +11,12 @@
 #pragma once
 #include "XNBaseFrameObject_p.h"
 #include "XNThread.h"
+#include <chrono>
 
 /**
  * @brief 时间管理器类私有结构体
  */
-class XNTimeManagerPrivate : public XNBaseFrameObjectPrivate
-{
-public:
-	Q_DECLARE_PUBLIC(XNTimeManager)
-
-	explicit XNTimeManagerPrivate(XNTimeManager *q) : XNBaseFrameObjectPrivate(q)
-	{
-		_eRunStatus = RunStatus::NotStart;
-	}
-
-private:
+struct XNTimeManagerPrivate : public XNBaseFrameObjectPrivate {
 	/*
 	 * @brief 仿真运行状态
 	 */
@@ -33,11 +24,11 @@ private:
 	/**
 	 * @brief 仿真开始时间
 	 */
-	QDateTime _SimStartTime;
+	std::chrono::system_clock::time_point _SimStartTime;
 	/**
 	 * @brief 当前仿真时间
 	 */
-	QDateTime _SimTime;
+	std::chrono::system_clock::time_point _SimTime;
 	/**
 	 * @brief 时间管理器线程智能指针
 	 */

Release/include/XNCore/XNTypeTraits.h

@@ -0,0 +1,45 @@
+#pragma once
+#include <array>
+#include <type_traits>
+#include <cstddef>
+
+template <typename T>
+struct is_std_array : std::false_type {
+};
+
+template <typename T, std::size_t N>
+struct is_std_array<std::array<T, N>> : std::true_type {
+};
+
+// 变量模板简化使用
+template <typename T>
+inline constexpr bool is_std_array_v = is_std_array<T>::value;
+
+/**
+ * @brief 获取类型的数组大小
+ * @tparam T 要检查的类型
+ * @return 如果是std::array，返回其大小；否则返回1
+ */
+template <typename T>
+struct array_size : std::integral_constant<std::size_t, 1> {
+};
+
+template <typename T, std::size_t N>
+struct array_size<std::array<T, N>> : std::integral_constant<std::size_t, N> {
+};
+
+// 变量模板简化使用
+template <typename T>
+inline constexpr std::size_t array_size_v = array_size<T>::value;
+
+// 获取类型大小的辅助函数
+template <typename T>
+constexpr size_t getTypeSize()
+{
+	if constexpr (is_std_array_v<T>) {
+		// 对于std::array，计算所有元素的总大小
+		return getTypeSize<typename T::value_type>() * array_size_v<T>;
+	} else {
+		return sizeof(T);
+	}
+}

XNCore/.vscode/settings.json

@@ -75,6 +75,12 @@
 		"complex": "cpp",
 		"set": "cpp",
 		"regex": "cpp",
-		"qlibrary": "cpp"
+		"qlibrary": "cpp",
+		"csignal": "cpp",
+		"any": "cpp",
+		"unordered_set": "cpp",
+		"fstream": "cpp",
+		"forward_list": "cpp",
+		"valarray": "cpp"
 	}
 }

XNCore/CMakeLists.txt

@@ -2,11 +2,9 @@ cmake_minimum_required(VERSION 3.16)
 
 project(XNCore LANGUAGES CXX)
 
-set(CMAKE_AUTOUIC ON)
-set(CMAKE_AUTOMOC ON)
-set(CMAKE_AUTORCC ON)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 if(NOT fastcdr_FOUND)
     find_package(fastcdr 2 REQUIRED)
@@ -18,13 +16,14 @@ endif()
 
 file(GLOB DDS_XNIDL_SOURCES_CXX "XNIDL/*.cxx")
 
-find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core Xml Network)
-find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core Xml Network)
 find_package(Threads REQUIRED)
 find_package(OpenSSL REQUIRED)
 
 add_library(XNCore SHARED
   XNCore_global.h
+  XNCore_Function.cpp
+  XNTypeTraits.h
+  XNByteArray.h
   XNObject.h
   XNObject.cpp
   XNObject_p.h
@@ -41,6 +40,7 @@ add_library(XNCore SHARED
   XNTimeManager.cpp
   XNThread.h
   XNThread.cpp
+  XNThread_p.h
   XNThreadManager.h
   XNThreadManager_p.h
   XNThreadManager.cpp
@@ -54,7 +54,6 @@ add_library(XNCore SHARED
   XNScenarioManager_p.h
   XNScenarioManager.cpp
   XNDDSManager.h
-  XNDDSManager_p.h
   XNDDSManager.cpp
   XNServiceManager.h
   XNServiceManager_p.h
@@ -66,19 +65,18 @@ add_library(XNCore SHARED
   XNServiceObject_p.h
   XNServiceObject.cpp
   XNDDSInterface.h
+  XNDDSInterface.cpp
   ${DDS_XNIDL_SOURCES_CXX}
 )
 
 target_link_libraries(XNCore PRIVATE
 	${CMAKE_THREAD_LIBS_INIT}
-	Qt${QT_VERSION_MAJOR}::Core
-	Qt${QT_VERSION_MAJOR}::Xml
-	Qt${QT_VERSION_MAJOR}::Network
 	fastcdr
 	fastdds
 	pthread
 	OpenSSL::SSL
 	OpenSSL::Crypto
+    dl
 )
 
 target_compile_definitions(XNCore PRIVATE XNCORE_LIBRARY)

XNCore/XNBaseFrameObject.cpp

@@ -1,8 +1,7 @@
 #include "XNBaseFrameObject.h"
 #include "XNBaseFrameObject_p.h"
 
-XNBaseFrameObject::XNBaseFrameObject(QObject *parent)
-	: XNObject(*new XNBaseFrameObjectPrivate(this), parent)
+XNBaseFrameObject::XNBaseFrameObject() : XNObject(new XNBaseFrameObjectPrivate())
 {
 }
 
@@ -10,13 +9,24 @@ XNBaseFrameObject::~XNBaseFrameObject()
 {
 }
 
-XNBaseFrameObject::XNBaseFrameObject(XNBaseFrameObjectPrivate &dd, QObject *parent)
-	: XNObject(dd, parent)
+XNBaseFrameObject::XNBaseFrameObject(PrivateType *p) : XNObject(p)
 {
 }
 
 XNFrameObjectStatus XNBaseFrameObject::GetFrameObjectStatus()
 {
-	Q_D(XNBaseFrameObject);
+	T_D();
 	return d->_status;
 }
+
+XNFrameworkPtr XNBaseFrameObject::GetFramework()
+{
+	T_D();
+	return d->_framework;
+}
+
+void XNBaseFrameObject::SetFramework(XNFrameworkPtr framework)
+{
+	T_D();
+	d->_framework = framework;
+}

XNCore/XNBaseFrameObject.h

@@ -12,34 +12,29 @@
 
 #include "XNObject.h"
 
-class XNBaseFrameObjectPrivate;
+struct XNBaseFrameObjectPrivate;
 
 /**
  * @brief 框架对象基类
  */
 class XNCORE_EXPORT XNBaseFrameObject : public XNObject
 {
-	/**
-	 * @brief 宏定义，用于支持Qt的元对象系统
-	 */
-	Q_OBJECT
-
 	/**
 	 * @brief 宏定义，用于禁用拷贝构造函数
 	 */
-	Q_DISABLE_COPY(XNBaseFrameObject)
+	XN_METATYPE(XNBaseFrameObject, XNObject)
 
 	/**
 	 * @brief 宏定义，用于声明私有数据成员
 	 */
-	Q_DECLARE_PRIVATE(XNBaseFrameObject);
+	XN_DECLARE_PRIVATE(XNBaseFrameObject)
 
 public:
 	/**
 	 * @brief 构造函数
 	 * @param parent 父对象
 	 */
-	XNBaseFrameObject(QObject *parent = nullptr);
+	XNBaseFrameObject();
 
 	/**
 	 * @brief 析构函数
@@ -52,44 +47,34 @@ protected:
 	 * @param dd 私有数据成员
 	 * @param parent 父对象
 	 */
-	XNBaseFrameObject(XNBaseFrameObjectPrivate &dd, QObject *parent = nullptr);
-
-signals:
-	/**
-	 * @brief 初始化
-	 */
-	void Initialize();
-
-	/**
-	 * @brief 初始化失败
-	 */
-	void InitializeFailed();
-
-	/**
-	 * @brief 准备执行
-	 */
-	void PrepareForExecute();
-
-	/**
-	 * @brief 准备执行失败
-	 */
-	void PrepareForExecuteFailed();
-
-public slots:
-	/**
-	 * @brief 初始化
-	 */
-	virtual void OnInitialize() = 0;
-
-	/**
-	 * @brief 准备执行
-	 */
-	virtual void OnPrepareForExecute() = 0;
+	XNBaseFrameObject(PrivateType *p);
 
 public:
+	/**
+	 * @brief 初始化
+	 */
+	virtual bool Initialize() = 0;
+
+	/**
+	 * @brief 准备执行
+	 */
+	virtual bool PrepareForExecute() = 0;
+
 	/**
 	 * @brief 获取框架对象状态
 	 * @return 框架对象状态
 	 */
 	XNFrameObjectStatus GetFrameObjectStatus();
+
+	/**
+	 * @brief 获取框架对象
+	 * @return 框架对象
+	 */
+	XNFrameworkPtr GetFramework();
+
+	/**
+	 * @brief 设置框架对象
+	 * @param framework 框架对象
+	 */
+	void SetFramework(XNFrameworkPtr framework);
 };

XNCore/XNBaseFrameObject_p.h

@@ -16,22 +16,13 @@
 /**
  * @brief 框架对象基类的私有数据成员
  */
-class XNBaseFrameObjectPrivate : public XNObjectPrivate
-{
-public:
-	/**
-	 * @brief 构造函数
-	 * @param q 框架对象基类指针
-	 */
-	explicit XNBaseFrameObjectPrivate(XNBaseFrameObject *q) : XNObjectPrivate(q) {}
-
-	/**
-	 * @brief 宏定义，用于声明公有数据成员
-	 */
-	Q_DECLARE_PUBLIC(XNBaseFrameObject)
-
+struct XNBaseFrameObjectPrivate : public XNObjectPrivate {
 	/**
 	 * @brief 框架对象状态
 	 */
 	XNFrameObjectStatus _status = XNFrameObjectStatus::NotReady;
+	/**
+	 * @brief 框架对象
+	 */
+	XNFrameworkPtr _framework;
 };

XNCore/XNByteArray.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+#include <cstring>
+
+/**
+ * @brief 自定义字节数组容器类
+ * @details 提供类似QByteArray的功能，用于处理二进制数据
+ */
+class XNByteArray
+{
+public:
+	XNByteArray() = default;
+	explicit XNByteArray(size_t size) : data_(size) {}
+
+	/**
+	 * @brief 从原始数据构造
+	 * @param buffer 原始数据缓冲区
+	 * @param size 数据大小
+	 */
+	XNByteArray(const uint8_t *buffer, size_t size) : data_(buffer, buffer + size) {}
+
+	/**
+	 * @brief 获取数据指针
+	 * @return 数据指针
+	 */
+	uint8_t *data() { return data_.data(); }
+
+	/**
+	 * @brief 获取常量数据指针
+	 * @return 常量数据指针
+	 */
+	const uint8_t *data() const { return data_.data(); }
+
+	/**
+	 * @brief 获取数据大小
+	 * @return 数据大小
+	 */
+	size_t size() const { return data_.size(); }
+
+	/**
+	 * @brief 调整大小
+	 * @param size 新大小
+	 */
+	void resize(size_t size) { data_.resize(size); }
+
+	/**
+	 * @brief 清空数据
+	 */
+	void clear() { data_.clear(); }
+
+	/**
+	 * @brief 追加数据
+	 * @param buffer 要追加的数据
+	 * @param size 数据大小
+	 */
+	void append(const uint8_t *buffer, size_t size)
+	{
+		size_t oldSize = data_.size();
+		data_.resize(oldSize + size);
+		std::memcpy(data_.data() + oldSize, buffer, size);
+	}
+
+	/**
+	 * @brief 追加另一个XNByteArray
+	 * @param other 要追加的XNByteArray
+	 */
+	void append(const XNByteArray &other) { append(other.data(), other.size()); }
+
+	/**
+	 * @brief 获取指定位置的字节
+	 * @param index 索引
+	 * @return 字节值
+	 */
+	uint8_t &operator[](size_t index) { return data_[index]; }
+
+	/**
+	 * @brief 获取指定位置的字节（常量版本）
+	 * @param index 索引
+	 * @return 字节值
+	 */
+	const uint8_t &operator[](size_t index) const { return data_[index]; }
+
+	/**
+	 * @brief 检查是否为空
+	 * @return 是否为空
+	 */
+	bool isEmpty() const { return data_.empty(); }
+
+	/**
+	 * @brief 预分配空间
+	 * @param size 要预分配的大小
+	 */
+	void reserve(size_t size) { data_.reserve(size); }
+
+private:
+	std::vector<uint8_t> data_;
+};

XNCore/XNCore_Function.cpp

@@ -0,0 +1,10 @@
+#include "XNCore_global.h"
+
+XNTimePoint parseISOTime(const std::string &timeStr)
+{
+	std::tm tm = {};
+	std::istringstream ss(timeStr);
+	ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
+	auto tp = std::chrono::system_clock::from_time_t(std::mktime(&tm));
+	return tp;
+}

XNCore/XNCore_global.h

@@ -1,14 +1,13 @@
-#ifndef XNCORE_GLOBAL_H
-#define XNCORE_GLOBAL_H
-
-#include <QtCore/qglobal.h>
+#pragma once
 
 #if defined(XNCORE_LIBRARY)
-#	define XNCORE_EXPORT Q_DECL_EXPORT
+#	define XNCORE_EXPORT __attribute__((visibility("default")))
 #else
-#	define XNCORE_EXPORT Q_DECL_IMPORT
+#	define XNCORE_EXPORT __attribute__((visibility("default")))
 #endif
 
+#define FORCEINLINE __attribute__((always_inline))
+
 #ifdef __linux__
 #	include <pthread.h>
 #	include <sched.h>
@@ -20,8 +19,38 @@
 #	include <memory>
 #	include <errno.h>
 #	include <unistd.h>
+#	include <limits.h>
+#	include <functional>
+#	include <map>
+#	include <unordered_map>
+#	include <vector>
+#	include <set>
+#	include <any>
+#	include <string>
+#	include <thread>
+#	include <mutex>
+#	include <condition_variable>
+#	include <queue>
+#	include <tinyxml2.h>
+#	include <chrono>
+#	include <iomanip>
+#	include <sstream>
+#	include <dlfcn.h>
+#	include <filesystem>
+#	include <array>
+#	include <cstring>
+#	include <iostream>
 #endif
 
+#include <fastdds/dds/domain/DomainParticipant.hpp>
+#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/publisher/DataWriter.hpp>
+#include <fastdds/dds/publisher/Publisher.hpp>
+#include <fastdds/dds/subscriber/DataReader.hpp>
+#include <fastdds/dds/subscriber/Subscriber.hpp>
+#include <fastdds/dds/topic/TypeSupport.hpp>
+#include <fastdds/dds/subscriber/DataReaderListener.hpp>
+#include <fastcdr/xcdr/optional.hpp>
 #define FAST_DDS_MACRO eprosima::fastdds::dds
 
 /**
@@ -40,6 +69,9 @@ using XNCallBack = std::function<void()>;
 //DDS回调函数类型别名
 using XNDDSCallBack = std::function<void(void *)>;
 
+//事件回调函数类型别名
+using XNEventCallback = std::function<void(const std::any &)>;
+
 /**
  * @brief 	纳秒睡眠相关时间结构体
  * @details 用于线程睡眠时间控制
@@ -54,6 +86,17 @@ struct PERIOD_INFO {
 	 */
 	long period_ns;
 };
+/**
+ * @brief 系统时间点类型别名
+ */
+using XNTimePoint = std::chrono::system_clock::time_point;
+
+/**
+	 * @brief 将ISO格式的时间字符串转换为系统时间点
+	 * @param timeStr ISO格式的时间字符串 (YYYY-MM-DDTHH:mm:ss)
+	 * @return 系统时间点
+	 */
+extern "C" XNTimePoint XNCORE_EXPORT parseISOTime(const std::string &timeStr);
 
 /**
  * @brief 系统运行状态枚举类
@@ -155,10 +198,63 @@ enum class XNFrameObjectStatus {
 	Unknown
 };
 
-#define XN_DLL_INITIALIZE(ClassName)                                                               \
-	extern "C" void Initial##ClassName()                                                           \
-	{                                                                                              \
-		qRegisterMetaType<ClassName>(#ClassName);                                                  \
-	}
+template <class ToType, class FromType>
+FORCEINLINE ToType XNStaticCastHelper(const FromType &from)
+{
+	return std::static_pointer_cast<typename ToType::element_type>(from);
+}
 
-#endif // XNCORE_GLOBAL_H
+template <class ToType, class FromType>
+FORCEINLINE ToType XNCastHelper(const FromType &from)
+{
+	return std::dynamic_pointer_cast<typename ToType::element_type>(from);
+}
+
+#define XN_CAST(from, to) XNStaticCastHelper<to>(from)
+
+#define XN_THISPTR std::static_pointer_cast<ThisType>(shared_from_this())
+
+#define XNCLASS_PTR_DECLARE(a)                                                                     \
+	using a##Ptr	 = std::shared_ptr<class a>;                                                   \
+	using a##WPtr	 = std::weak_ptr<class a>;                                                     \
+	using a##UPtr	 = std::unique_ptr<class a>;                                                   \
+	using a##ConsPtr = std::shared_ptr<const class a>;
+
+#define XNSTRUCT_PTR_DECLARE(a)                                                                    \
+	using a##Ptr	 = std::shared_ptr<struct a>;                                                  \
+	using a##WPtr	 = std::weak_ptr<struct a>;                                                    \
+	using a##UPtr	 = std::unique_ptr<struct a>;                                                  \
+	using a##ConsPtr = std::shared_ptr<const struct a>;
+
+#define XN_NOCOPYABLE(Class)                                                                       \
+public:                                                                                            \
+	using NoCopyable = Class;                                                                      \
+                                                                                                   \
+private:                                                                                           \
+	Class(const Class &)			= delete;                                                      \
+	Class &operator=(const Class &) = delete;
+
+#define XN_DECLARE_PRIVATE(Class)                                                                  \
+	XN_NOCOPYABLE(Class)                                                                           \
+protected:                                                                                         \
+	friend class Class##Private;                                                                   \
+	inline Class##Private *GetPP() const                                                           \
+	{                                                                                              \
+		return reinterpret_cast<Class##Private *>(_Private_Ptr);                                   \
+	}                                                                                              \
+	using PrivateType = Class##Private;
+
+#define T_D() PrivateType *const d = GetPP()
+
+struct XNNullClass {
+};
+
+#define XN_METATYPE_P(cls)                                                                         \
+public:                                                                                            \
+	using ThisType	= cls;                                                                         \
+	using SuperType = XNNullClass;
+
+#define XN_METATYPE(cls, sup)                                                                      \
+public:                                                                                            \
+	using ThisType	= cls;                                                                         \
+	using SuperType = sup;

XNCore/XNDDSInterface.cpp

@@ -0,0 +1,97 @@
+#include "XNDDSInterface.h"
+#include "XNObject_p.h"
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+XNByteArray XNDDSInterface::getUDPPackage()
+{
+	XNByteArray result;
+
+	size_t currentPos = 0;
+
+	// 复制头部
+	result.append(header, headerSize);
+	currentPos = headerSize;
+
+	// 复制数据
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		for (auto func : getByteArrayFunction) {
+			XNByteArray byteArray = func();
+			size_t byteArraySize  = byteArray.size();
+			if (currentPos + byteArraySize <= MAX_UDP_PACKET_SIZE) {
+				result.append(byteArray);
+				currentPos += byteArraySize; // 使用实际返回的字节数组大小
+			} else {
+				break; // 超出最大包大小
+			}
+		}
+	}
+
+	// 更新包大小
+	if (currentPos >= 8 && currentPos < MAX_UDP_PACKET_SIZE) {
+		result[6] = static_cast<uint8_t>((currentPos >> 8) & 0xFF);
+		result[7] = static_cast<uint8_t>(currentPos & 0xFF);
+	}
+
+	return result;
+}
+
+void XNDDSInterface::setDataByUDPPackage(const XNByteArray &package)
+{
+	if (package.size() < headerSize) {
+		return;
+	}
+
+	// 获取包大小
+	uint16_t packageSize = (package[6] << 8) | package[7];
+	if (packageSize > MAX_UDP_PACKET_SIZE) {
+		return;
+	}
+
+	uint32_t currentPos = 8;
+
+	// 设置数据
+	{
+		std::lock_guard<std::mutex> lock(outDataMutex);
+		clearOutData();
+		for (auto &func : setByteArrayFunction) {
+			func(package, currentPos);
+		}
+	}
+	sendOutData();
+}
+
+std::unordered_map<std::string, std::string>
+XNDDSInterface::getStringData(std::vector<std::string> varNames)
+{
+	std::unordered_map<std::string, std::string> result;
+
+	{
+		std::lock_guard<std::mutex> lock(dataMutex);
+		for (const auto &varName : varNames) {
+			auto it = getDataFunction.find(varName);
+			if (it == getDataFunction.end()) {
+				continue;
+			}
+			result[varName] = it->second();
+		}
+	}
+
+	return result;
+}
+
+void XNDDSInterface::setDataByString(std::unordered_map<std::string, std::string> data)
+{
+	std::lock_guard<std::mutex> lock(outDataMutex);
+	clearOutData();
+	for (const auto &[varName, value] : data) {
+		auto it = setDataFunction.find(varName);
+		if (it == setDataFunction.end()) {
+			continue;
+		}
+		it->second(value);
+	}
+	sendOutData();
+}

XNCore/XNDDSInterface.h

@@ -1,188 +1,339 @@
 #pragma once
 
-#include "XNObject.h"
-#include <fastcdr/xcdr/optional.hpp>
-template <typename T>
-struct is_std_array : std::false_type {
-};
+#include "XNFramework.h"
+#include "XNDDSManager.h"
+#include "XNByteArray.h"
+#include "XNTypeTraits.h"
+#include <stdexcept>
 
-template <typename T, std::size_t N>
-struct is_std_array<std::array<T, N>> : std::true_type {
-};
+// 定义UDP包的最大大小
+constexpr size_t MAX_UDP_PACKET_SIZE = 40000;
 
-// 变量模板简化使用
-template <typename T>
-inline constexpr bool is_std_array_v = is_std_array<T>::value;
-
-class XNDDSInterface : public XNObject
+class XNDDSInterface
 {
-	Q_OBJECT
 public:
-	explicit XNDDSInterface(QObject *parent = nullptr) : XNObject(parent) {}
-	virtual ~XNDDSInterface() {}
+	XNDDSInterface()		  = default;
+	virtual ~XNDDSInterface() = default;
 
-	template <typename T>
-	QByteArray getQByteArray(eprosima::fastcdr::optional<T> data)
-	{
-		QByteArray value;
-		// 如果T是普通类型，将data中的数据转换为QByteArray
-		if constexpr (std::is_arithmetic_v<T>) {
-			QDataStream dataStream(&value, QIODevice::WriteOnly);
-			dataStream.setByteOrder(QDataStream::LittleEndian);
-			if (data) {
-				dataStream << data.value();
-			} else {
-				dataStream << (T)0;
-			}
-		}
-		// 如果T是std::array，则需要根据T的类型和大小，生成一个std::array<T, N>的QByteArray
-		else if constexpr (is_std_array_v<T>) {
-			if (data) {
-				value = getQByteArrayFromStdArray(data.value());
-			} else {
-				T zero = {};
-				value  = getQByteArrayFromStdArray(zero);
-			}
-		}
-		return value;
-	}
+public:
+	/**
+	 * @brief 初始化
+	 * @param framework: 框架
+	 */
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelID, uint32_t DDS_type) = 0;
 
-	template <typename T, std::size_t N>
-	QByteArray getQByteArrayFromStdArray(std::array<T, N> data)
-	{
-		QByteArray value;
-		QDataStream dataStream(&value, QIODevice::WriteOnly);
-		dataStream.setByteOrder(QDataStream::LittleEndian);
-		for (std::size_t i = 0; i < N; ++i) {
-			if constexpr (std::is_arithmetic_v<T>) {
-				dataStream << data[i];
-			} else {
-				dataStream << getQByteArrayFromStdArray(data[i]);
-			}
-		}
-		return value;
-	}
+	/**
+	 * @brief 获取该接口的UDP包
+	 * @return 字节数组
+	 */
+	XNByteArray getUDPPackage();
 
-	QByteArray getUDPPackage()
-	{
-		QByteArray package;
-		QByteArray header = this->header.mid(0, 5);
-		package.append(header);
-		for (auto func : getByteArrayFunction) {
-			package.append(func());
-		}
-		package[4] = package.size();
-		return package;
-	}
+	/**
+	 * @brief 通过UDP包设置数据
+	 * @param package: UDP包
+	 */
+	void setDataByUDPPackage(const XNByteArray &package);
 
-	template <typename T>
-	QString getQString(eprosima::fastcdr::optional<T> data)
-	{
-		if constexpr (std::is_arithmetic_v<T>) {
-			if (data) {
-				return QString::number(data.value());
-			} else {
-				return QString::number(0);
-			}
-		} else if constexpr (std::is_same_v<T, std::string>) {
-			if (data) {
-				return getQStringFromStdArray(data.value());
-			} else {
-				T zero = {};
-				return getQStringFromStdArray(zero);
-			}
-		}
-		return QString();
-	}
+	/**
+	 * @brief 批量获取指定变量的数据
+	 * @param varNames: 变量名列表
+	 * @return: 变量名到数据的映射
+	 */
+	std::unordered_map<std::string, std::string> getStringData(std::vector<std::string> varNames);
 
-	template <typename T, std::size_t N>
-	QString getQStringFromStdArray(std::array<T, N> data)
-	{
-		QStringList list;
-		for (std::size_t i = 0; i < N; ++i) {
-			if constexpr (std::is_arithmetic_v<T>) {
-				list.append(QString::number(data[i]));
-			} else {
-				list.append(getQStringFromStdArray(data[i]));
-			}
-		}
-		return list.join(",");
-	}
-
-	QString getData(const QString &varName)
-	{
-		int index1			= -1;
-		int index2			= -1;
-		QString trueVarName = varName;
-		// 检查变量名中是否存在数组标记
-		if (varName.contains('[')) {
-			// 解析数组索引
-			int startPos = varName.indexOf('[');
-			int midPos	 = varName.indexOf("][");
-			int endPos	 = varName.lastIndexOf(']');
-
-			// 如果是二维数组 (格式: name[index1][index2])
-			if (midPos != -1) {
-				bool ok1 = false, ok2 = false;
-				index1 = varName.mid(startPos + 1, midPos - startPos - 1).toInt(&ok1);
-				index2 = varName.mid(midPos + 2, endPos - midPos - 2).toInt(&ok2);
-
-				if (!ok1 || !ok2) {
-					qWarning() << "无法解析数组索引:" << varName;
-					index1 = 0;
-					index2 = 0;
-				}
-			}
-			// 如果是一维数组 (格式: name[index1])
-			else if (startPos != -1 && endPos != -1) {
-				bool ok = false;
-				index1	= varName.mid(startPos + 1, endPos - startPos - 1).toInt(&ok);
-
-				if (!ok) {
-					qWarning() << "无法解析数组索引:" << varName;
-					index1 = 0;
-				}
-			}
-			trueVarName = varName.left(startPos);
-		}
-		auto it = getDataFunction.find(trueVarName);
-		if (it == getDataFunction.end()) {
-			return QString(); // 返回空字符串表示未找到
-		}
-		if (index1 < 0) {
-			QMutexLocker locker(&mutex);
-			return it.value()();
-		} else if (index2 < 0) {
-			QMutexLocker locker(&mutex);
-			QStringList list = it.value()().split(",");
-			if (index1 >= list.size()) {
-				qWarning() << "数组索引超出范围:" << varName;
-				return QString();
-			}
-			return list[index1];
-		} else {
-			QMutexLocker locker(&mutex);
-			QStringList list = it.value()().split(",");
-			if (index1 >= list.size()) {
-				qWarning() << "数组索引超出范围:" << varName;
-				return QString();
-			}
-			QStringList list2 = list[index1].split(" ");
-			if (index2 >= list2.size()) {
-				qWarning() << "数组索引超出范围:" << varName;
-				return QString();
-			}
-			return list2[index2];
-		}
-	}
+	/**
+	 * @brief 批量设置指定变量的数据
+	 * @param data: 变量名到数据的映射
+	 */
+	void setDataByString(std::unordered_map<std::string, std::string> data);
 
 protected:
-	QHash<QString, std::function<QString()>> getDataFunction;
-	QVector<std::function<QByteArray()>> getByteArrayFunction;
-	QMutex mutex;
-	QByteArray header;
+	/**
+	 * @brief 获取指定变量的字节数据，用于网络通信
+	 * @param data: 数据
+	 * @return 字节数组
+	 */
+	template <typename T>
+	XNByteArray getByteArray(eprosima::fastcdr::optional<T> data)
+	{
+		XNByteArray result(getTypeSize<T>());
+
+		if constexpr (std::is_arithmetic_v<T>) {
+			if (data) {
+				std::memcpy(result.data(), &data.value(), sizeof(T));
+			} else {
+				T zero = 0;
+				std::memcpy(result.data(), &zero, sizeof(T));
+			}
+		} else if constexpr (is_std_array_v<T>) {
+			if (data) {
+				return getByteArrayFromStdArray(data.value());
+			} else {
+				T zero = {};
+				return getByteArrayFromStdArray(zero);
+			}
+		} else {
+			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
+						  "Type must be arithmetic or std::array");
+		}
+
+		return result;
+	}
+
+	/**
+	 * @brief 设置指定变量的字节数据，用于网络通信
+	 * @param data: 数据
+	 * @param byteArray: 字节数组
+	 */
+	template <typename T>
+	void setByteArray(eprosima::fastcdr::optional<T> &data, const XNByteArray &byteArray,
+					  uint32_t &pos)
+	{
+		uint32_t thisSize = getTypeSize<T>();
+		XNByteArray thisArray(thisSize);
+		if (pos + thisSize > byteArray.size()) {
+			return;
+		}
+		std::memcpy(thisArray.data(), byteArray.data() + pos, thisSize);
+		pos += thisSize;
+
+		if constexpr (std::is_arithmetic_v<T>) {
+			T temp;
+			std::memcpy(&temp, thisArray.data(), sizeof(T));
+			data = temp;
+		} else if constexpr (is_std_array_v<T>) {
+			if (!data) {
+				data = T{};
+			}
+			setByteArrayFromStdArray(data.value(), thisArray);
+		} else {
+			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
+						  "Type must be arithmetic or std::array");
+		}
+	}
+
+	/**
+	 * @brief 获取指定数组变量的字节数据，用于网络通信
+	 * @param data: 数据
+	 * @return 字节数组
+	 */
+	template <typename T, std::size_t N>
+	XNByteArray getByteArrayFromStdArray(const std::array<T, N> &data)
+	{
+		XNByteArray result(getTypeSize<T>() * N);
+
+		for (std::size_t i = 0; i < N; ++i) {
+			if constexpr (std::is_arithmetic_v<T>) {
+				std::memcpy(result.data() + i * getTypeSize<T>(), &data[i], getTypeSize<T>());
+			} else {
+				XNByteArray subArray = getByteArrayFromStdArray(data[i]);
+				std::memcpy(result.data() + i * getTypeSize<T>(), subArray.data(),
+							getTypeSize<T>());
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * @brief 设置指定数组变量的字节数据，用于网络通信
+	 * @param data: 数据
+	 * @param byteArray: 字节数组
+	 */
+	template <typename T, std::size_t N>
+	void setByteArrayFromStdArray(std::array<T, N> &data, const XNByteArray &byteArray)
+	{
+		if (byteArray.size() < getTypeSize<T>() * N)
+			return;
+
+		for (std::size_t i = 0; i < N; ++i) {
+			if constexpr (std::is_arithmetic_v<T>) {
+				std::memcpy(&data[i], byteArray.data() + i * getTypeSize<T>(), getTypeSize<T>());
+			} else {
+				XNByteArray subArray(byteArray.data() + i * getTypeSize<T>(), getTypeSize<T>());
+				setByteArrayFromStdArray(data[i], subArray);
+			}
+		}
+	}
+
+	/**
+	 * @brief 获取指定变量的字符串数据，用于JSON前端
+	 * @param data: 数据
+	 * @return: 数据（字符串格式）
+	 */
+	template <typename T>
+	std::string getString(eprosima::fastcdr::optional<T> data)
+	{
+		if constexpr (std::is_arithmetic_v<T>) {
+			if (data) {
+				return std::to_string(data.value());
+			} else {
+				return std::to_string(0);
+			}
+		} else if constexpr (is_std_array_v<T>) {
+			if (data) {
+				return getStringFromStdArray(data.value());
+			} else {
+				T zero = {};
+				return getStringFromStdArray(zero);
+			}
+		}
+		return std::string();
+	}
+
+	/**
+	 * @brief 通过字符串数据设置指定变量，用于JSON前端
+	 * @param data: 数据
+	 * @param value: 字符串数据
+	 */
+	template <typename T>
+	void setDataFromString(eprosima::fastcdr::optional<T> &data, const std::string &value)
+	{
+		if constexpr (std::is_arithmetic_v<T>) {
+			if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+				data = std::stod(value);
+			} else {
+				data = std::stoll(value);
+			}
+		} else if constexpr (is_std_array_v<T>) {
+			// 解析输入字符串
+			std::stringstream ss(value);
+			std::string item;
+			std::vector<std::string> items;
+			while (std::getline(ss, item, ',')) {
+				items.push_back(item);
+			}
+			T temp;
+			setStdArrayFromString(temp, items, 0);
+			data = temp;
+		}
+	}
+
+	/**
+	 * @brief 获取指定数组变量的字符串数据，用于JSON前端
+	 * @param data: 数据
+	 * @return: 数据（字符串格式）
+	 */
+	template <typename T, std::size_t N>
+	std::string getStringFromStdArray(std::array<T, N> data)
+	{
+		std::stringstream ss;
+		for (std::size_t i = 0; i < N; ++i) {
+			if (i > 0)
+				ss << ",";
+			if constexpr (std::is_arithmetic_v<T>) {
+				ss << data[i];
+			} else {
+				ss << getStringFromStdArray(data[i]);
+			}
+		}
+		return ss.str();
+	}
+
+	/**
+	 * @brief 通过字符串数据设置指定数组变量，用于JSON前端
+	 * @param data: 数据
+	 * @param value: 字符串数据，格式为"数字,数字,..."
+	 * @param start_pos: 当前数组在输入字符串中的起始位置
+	 * @return 处理完当前数组后，下一个数组的起始位置
+	 * @throw std::runtime_error: 当输入数据格式不正确时抛出异常
+	 */
+	template <typename T, std::size_t N>
+	size_t setStdArrayFromString(std::array<T, N> &data, const std::vector<std::string> &value,
+								 size_t start_pos = 0)
+	{
+		// 递归处理每个元素
+		for (std::size_t i = 0; i < N; ++i) {
+			try {
+				if constexpr (std::is_arithmetic_v<T>) {
+					// 对于基本类型，直接转换
+					if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+						data[i] = static_cast<T>(std::stod(value[start_pos + i]));
+					} else {
+						data[i] = static_cast<T>(std::stoll(value[start_pos + i]));
+					}
+				} else if constexpr (is_std_array_v<T>) {
+					// 对于嵌套数组，递归处理
+					start_pos = setStdArrayFromString(data[i], value, start_pos + i);
+				} else {
+					static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
+								  "Type must be arithmetic or std::array");
+				}
+			} catch (const std::exception &e) {
+				throw std::runtime_error("Error parsing element " + std::to_string(i) + ": "
+										 + e.what());
+			}
+		}
+		return start_pos + N;
+	}
+
+	template <typename T1, typename T2>
+	void assign_value_get(eprosima::fastcdr::optional<T1> &data, T2 &model_data)
+	{
+		if (data) {
+			auto temp = data.value();
+			if constexpr (std::is_arithmetic_v<T1>) {
+				model_data = temp;
+			} else if constexpr (is_std_array_v<T1>) {
+				size_t arraySize = array_size_v<T1>;
+				for (size_t i = 0; i < arraySize; ++i) {
+					auto temp2 = temp[i];
+					if constexpr (std::is_arithmetic_v<T2>) {
+						model_data[i] = temp2;
+					} else if constexpr (is_std_array_v<T2>) {
+						size_t arraySize2 = array_size_v<T2>;
+						for (size_t j = 0; j < arraySize2; ++j) {
+							model_data[i][j] = temp2[j];
+						}
+					}
+				}
+			}
+		}
+	}
+
+	template <typename T1, typename T2>
+	void assign_value_set(eprosima::fastcdr::optional<T1> &data, T2 &model_data)
+	{
+		if constexpr (std::is_arithmetic_v<T1>) {
+			data = model_data;
+		} else if constexpr (is_std_array_v<T1>) {
+			T1 temp;
+			size_t arraySize = array_size_v<T1>;
+			for (size_t i = 0; i < arraySize; ++i) {
+				if constexpr (std::is_arithmetic_v<typename T1::value_type>) {
+					temp[i] = model_data[i];
+				} else if constexpr (is_std_array_v<typename T1::value_type>) {
+					size_t arraySize2 = array_size_v<typename T1::value_type>;
+					for (size_t j = 0; j < arraySize2; ++j) {
+						temp[i][j] = model_data[i][j];
+					}
+				}
+			}
+			data = temp;
+		}
+	}
+
+	virtual void clearOutData() {}
+	virtual void sendOutData() {}
+
+protected:
+	std::unordered_map<std::string, std::function<std::string()>> getDataFunction;
+	std::unordered_map<std::string, std::function<void(std::string)>> setDataFunction;
+	std::vector<std::function<XNByteArray(void)>> getByteArrayFunction;
+	std::vector<std::function<void(XNByteArray, uint32_t &)>> setByteArrayFunction;
+	std::mutex dataMutex;
+	std::mutex outDataMutex;
+	uint8_t header[8]{0}; // 固定大小的头部
+	size_t headerSize = 8;
+	FAST_DDS_MACRO::DataWriter *dataWriter;
 };
 
-#define MAP_GET_DATA_FUNC(NAME)                                                                    \
-	getDataFunction[#NAME] = [this]() { return getQString(data.NAME()); };                         \
-	getByteArrayFunction.push_back([this]() { return getQByteArray(data.NAME()); })
+#define MAP_DATA_FUNC(NAME)                                                                        \
+	getDataFunction[#NAME] = [this]() { return getString(data.NAME()); };                          \
+	setDataFunction[#NAME] = [this](std::string value) {                                           \
+		setDataFromString(out_data.NAME(), value);                                                 \
+	};                                                                                             \
+	getByteArrayFunction.push_back([this]() { return getByteArray(data.NAME()); });                \
+	setByteArrayFunction.push_back([this](XNByteArray byteArray, uint32_t &pos) {                  \
+		setByteArray(out_data.NAME(), byteArray, pos);                                             \
+	});

XNCore/XNDDSManager.cpp

@@ -1,45 +1,45 @@
 #include "XNDDSManager.h"
-#include "XNDDSManager_p.h"
 
-XNDDSManager::XNDDSManager(QObject *parent)
-	: XNBaseFrameObject(*new XNDDSManagerPrivate(this), parent)
+XNDDSManager::XNDDSManager() : XNBaseFrameObject(new XNDDSManagerPrivate())
 {
-	setUniqueId(8);
-	setObjectName("XNDDSManager");
+	SetUniqueId(8);
+	SetObjectName("XNDDSManager");
 }
 
 XNDDSManager::~XNDDSManager()
 {
 }
 
-XNDDSManager::XNDDSManager(XNDDSManagerPrivate &dd, QObject *parent) : XNBaseFrameObject(dd, parent)
+XNDDSManager::XNDDSManager(PrivateType *p) : XNBaseFrameObject(p)
 {
 }
 
-void XNDDSManager::OnInitialize()
+bool XNDDSManager::Initialize()
 {
-	Q_D(XNDDSManager);
+	T_D();
+	d->_status		= XNFrameObjectStatus::Initialized;
+	d->participant_ = nullptr;
+	d->topics_.clear();
 	LOG_INFO("XNDDSManager Initialize Success!");
-	d->_status = XNFrameObjectStatus::Initialized;
-	emit Initialize();
+	return true;
 }
 
-void XNDDSManager::OnPrepareForExecute()
+bool XNDDSManager::PrepareForExecute()
 {
-	Q_D(XNDDSManager);
+	T_D();
 	d->_status = XNFrameObjectStatus::Ready;
 	LOG_INFO("XNDDSManager is prepared!");
-	emit PrepareForExecute();
+	return true;
 }
 
-void XNDDSManager::SetDomainID(quint32 domainID)
+void XNDDSManager::SetDomainID(uint32_t domainID)
 {
-	Q_D(XNDDSManager);
+	T_D();
 	FAST_DDS_MACRO::DomainParticipantQos participantQos;
 	participantQos.name("XNDDSManager");
-	participant_ = FAST_DDS_MACRO::DomainParticipantFactory::get_instance()->create_participant(
+	d->participant_ = FAST_DDS_MACRO::DomainParticipantFactory::get_instance()->create_participant(
 		domainID, participantQos);
-	if (participant_ == nullptr) {
+	if (d->participant_ == nullptr) {
 		LOG_ERROR("0x2130 Create DomainParticipant Failed!");
 	}
 }

XNCore/XNDDSManager.h

@@ -1,14 +1,6 @@
 #pragma once
 #include "XNBaseFrameObject.h"
-
-#include <fastdds/dds/domain/DomainParticipant.hpp>
-#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
-#include <fastdds/dds/publisher/DataWriter.hpp>
-#include <fastdds/dds/publisher/Publisher.hpp>
-#include <fastdds/dds/subscriber/DataReader.hpp>
-#include <fastdds/dds/subscriber/Subscriber.hpp>
-#include <fastdds/dds/topic/TypeSupport.hpp>
-#include <fastdds/dds/subscriber/DataReaderListener.hpp>
+#include "XNBaseFrameObject_p.h"
 
 struct PublisherInfo {
 	FAST_DDS_MACRO::Publisher *publisher;
@@ -22,8 +14,8 @@ struct SubscriberInfo {
 
 struct TopicInfo {
 	FAST_DDS_MACRO::Topic *topic;
-	QMap<quint32, PublisherInfo> publishers_;
-	QMap<quint32, SubscriberInfo> subscribers_;
+	std::map<uint32_t, PublisherInfo> publishers_;
+	std::map<uint32_t, SubscriberInfo> subscribers_;
 };
 
 template <typename T>
@@ -46,50 +38,54 @@ private:
 	std::function<void(const T &)> callback_;
 };
 
-class XNDDSManagerPrivate;
+struct XNDDSManagerPrivate : public XNBaseFrameObjectPrivate {
+	FAST_DDS_MACRO::DomainParticipant *participant_;
+	std::map<std::string, TopicInfo> topics_;
+	std::mutex mutex_;
+};
 
 class XNDDSManager : public XNBaseFrameObject
 {
-	Q_OBJECT
-	Q_DECLARE_PRIVATE(XNDDSManager)
-	Q_DISABLE_COPY(XNDDSManager)
+	XN_METATYPE(XNDDSManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNDDSManager)
 public:
-	explicit XNDDSManager(QObject *parent = nullptr);
+	XNDDSManager();
 	~XNDDSManager();
 
 protected:
-	XNDDSManager(XNDDSManagerPrivate &dd, QObject *parent = nullptr);
+	XNDDSManager(PrivateType *p);
 
-public slots:
-	virtual void OnInitialize() override;
+public:
+	virtual bool Initialize() override;
 
-	virtual void OnPrepareForExecute() override;
+	virtual bool PrepareForExecute() override;
 
-	void SetDomainID(quint32 domainID);
+	void SetDomainID(uint32_t domainID);
 
 public:
 	template <typename T>
-	FAST_DDS_MACRO::DataWriter *RegisterPublisher(const QString &topicName, quint32 publisherID)
+	FAST_DDS_MACRO::DataWriter *RegisterPublisher(const std::string &topicName,
+												  uint32_t publisherID)
 	{
-		std::lock_guard<std::mutex> lock(mutex_);
-		if (!topics_.contains(topicName)) {
-			topics_[topicName] = TopicInfo();
-			TopicInfo &tmp	   = topics_[topicName];
+		T_D();
+		std::lock_guard<std::mutex> lock(d->mutex_);
+		if (d->topics_.find(topicName) == d->topics_.end()) {
+			d->topics_[topicName] = TopicInfo();
+			TopicInfo &tmp		  = d->topics_[topicName];
 			FAST_DDS_MACRO::TypeSupport typeSupport(new T());
-			typeSupport.register_type(participant_);
-			tmp.topic =
-				participant_->create_topic(topicName.toStdString(), typeSupport.get_type_name(),
-										   FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
+			typeSupport.register_type(d->participant_);
+			tmp.topic = d->participant_->create_topic(topicName, typeSupport.get_type_name(),
+													  FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
 			if (tmp.topic == nullptr) {
 				LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
-				topics_.remove(topicName);
+				d->topics_.erase(topicName);
 				return nullptr;
 			}
 		}
-		TopicInfo &tmp				 = topics_[topicName];
+		TopicInfo &tmp				 = d->topics_[topicName];
 		tmp.publishers_[publisherID] = PublisherInfo();
 		tmp.publishers_[publisherID].publisher =
-			participant_->create_publisher(FAST_DDS_MACRO::PUBLISHER_QOS_DEFAULT, nullptr);
+			d->participant_->create_publisher(FAST_DDS_MACRO::PUBLISHER_QOS_DEFAULT, nullptr);
 		if (tmp.publishers_[publisherID].publisher == nullptr) {
 			LOG_ERROR("0x2131 Create Publisher %1 for Topic %2 Failed!", publisherID, topicName);
 			return nullptr;
@@ -119,29 +115,28 @@ public:
 	}
 
 	template <typename T>
-	void RegisterSubscriber(const QString &topicName, quint32 subscriberID,
+	void RegisterSubscriber(const std::string &topicName, uint32_t subscriberID,
 							std::function<void(const typename T::type &)> fun)
 	{
-		Q_D(XNDDSManager);
-		std::lock_guard<std::mutex> lock(mutex_);
-		if (!topics_.contains(topicName)) {
-			topics_[topicName] = TopicInfo();
-			TopicInfo &tmp	   = topics_[topicName];
+		T_D();
+		std::lock_guard<std::mutex> lock(d->mutex_);
+		if (d->topics_.find(topicName) == d->topics_.end()) {
+			d->topics_[topicName] = TopicInfo();
+			TopicInfo &tmp		  = d->topics_[topicName];
 			FAST_DDS_MACRO::TypeSupport typeSupport(new T());
-			typeSupport.register_type(participant_);
-			tmp.topic =
-				participant_->create_topic(topicName.toStdString(), typeSupport.get_type_name(),
-										   FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
+			typeSupport.register_type(d->participant_);
+			tmp.topic = d->participant_->create_topic(topicName, typeSupport.get_type_name(),
+													  FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
 			if (tmp.topic == nullptr) {
 				LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
-				topics_.remove(topicName);
+				d->topics_.erase(topicName);
 				return;
 			}
 		}
-		TopicInfo &tmp				   = topics_[topicName];
+		TopicInfo &tmp				   = d->topics_[topicName];
 		tmp.subscribers_[subscriberID] = SubscriberInfo();
 		tmp.subscribers_[subscriberID].subscriber =
-			participant_->create_subscriber(FAST_DDS_MACRO::SUBSCRIBER_QOS_DEFAULT, nullptr);
+			d->participant_->create_subscriber(FAST_DDS_MACRO::SUBSCRIBER_QOS_DEFAULT, nullptr);
 		if (tmp.subscribers_[subscriberID].subscriber == nullptr) {
 			LOG_ERROR("0x2135 Create Subscriber %1 for Topic %2 Failed!", subscriberID, topicName);
 		}
@@ -157,9 +152,4 @@ public:
 		}
 		LOG_INFO("0x2137 Create Subscriber %1 for Topic %2 Success!", subscriberID, topicName);
 	}
-
-private:
-	FAST_DDS_MACRO::DomainParticipant *participant_;
-	QMap<QString, TopicInfo> topics_;
-	std::mutex mutex_;
 };

XNCore/XNDDSManager_p.h

@@ -1,15 +0,0 @@
-#pragma once
-#include "XNBaseFrameObject_p.h"
-
-#include <mutex>
-#include <fastdds/dds/domain/DomainParticipant.hpp>
-
-struct TopicInfo;
-
-class XNDDSManagerPrivate : public XNBaseFrameObjectPrivate
-{
-public:
-	Q_DECLARE_PUBLIC(XNDDSManager)
-
-	explicit XNDDSManagerPrivate(XNDDSManager *q) : XNBaseFrameObjectPrivate(q) {}
-};

XNCore/XNEventManager.cpp

@@ -1,76 +1,47 @@
 #include "XNEventManager.h"
 #include "XNEventManager_p.h"
 #include "XNFramework.h"
+#include <thread>
+#include <algorithm>
 
 // 构造函数
-XNEventManager::XNEventManager(QObject *parent)
-	: XNBaseFrameObject(*new XNEventManagerPrivate(this), parent)
+XNEventManager::XNEventManager() : XNBaseFrameObject(new XNEventManagerPrivate())
 {
 	// 设置唯一标识符
-	setUniqueId(7);
+	SetUniqueId(7);
 	// 设置对象名称
-	setObjectName("XNEventManager");
+	SetObjectName("XNEventManager");
 }
 
 // 析构函数
 XNEventManager::~XNEventManager()
 {
+	T_D();
+	d->running = false;
+	d->taskCond.notify_all();
+	for (auto &thread : d->workerThreads) {
+		if (thread.joinable()) {
+			thread.join();
+		}
+	}
 }
 
 // 保护构造函数实现
-XNEventManager::XNEventManager(XNEventManagerPrivate &dd, QObject *parent)
-	: XNBaseFrameObject(dd, parent)
+XNEventManager::XNEventManager(PrivateType *p) : XNBaseFrameObject(p)
 {
 }
 
-// 添加一个用于异步执行的任务类
-class EventTask : public QRunnable
-{
-public:
-	EventTask(const QString &name, const QVariant &data,
-			  std::function<void(const QVariant &)> callback, XNEventManager *manager)
-		: eventName(name), eventData(data), eventCallback(callback), eventManager(manager)
-	{
-		setAutoDelete(true);
-	}
-
-	void run() override
-	{
-		try {
-			eventCallback(eventData);
-			if (eventManager) {
-				QMetaObject::invokeMethod(eventManager, "EventProcessed", Qt::QueuedConnection,
-										  Q_ARG(QString, eventName), Q_ARG(bool, true));
-			}
-		} catch (const std::exception &e) {
-			LOG_ERROR(
-				QString("Async event handler exception for %1: %2").arg(eventName).arg(e.what()));
-			if (eventManager) {
-				QMetaObject::invokeMethod(eventManager, "EventProcessed", Qt::QueuedConnection,
-										  Q_ARG(QString, eventName), Q_ARG(bool, false));
-			}
-		}
-	}
-
-private:
-	QString eventName;
-	QVariant eventData;
-	std::function<void(const QVariant &)> eventCallback;
-	XNEventManager *eventManager;
-};
-
 // 修改注册事件处理器的实现
-int XNEventManager::RegisterEventHandler(const QString &eventName,
-										 std::function<void(const QVariant &)> callback,
-										 quint32 objectId, bool async, XNEvent::Priority priority)
+int XNEventManager::RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
+										 uint32_t objectId, bool async, XNEvent::Priority priority)
 {
-	Q_D(XNEventManager);
-	if (eventName.isEmpty() || !callback) {
+	T_D();
+	if (eventName.empty() || !callback) {
 		LOG_WARNING("Invalid event name or callback!");
 		return -1;
 	}
 
-	QMutexLocker locker(&d->eventMutex);
+	std::lock_guard<std::mutex> locker(d->eventMutex);
 
 	// 生成新的本地ID
 	d->localIdCounter = (d->localIdCounter + 1) & 0xFFFF;
@@ -88,94 +59,94 @@ int XNEventManager::RegisterEventHandler(const QString &eventName,
 	int handlerId = handlerInfo.GetHandlerId();
 
 	// 添加处理器信息到事件列表
-	d->eventHandlers[eventName].append(handlerInfo);
+	d->eventHandlers[eventName].push_back(handlerInfo);
 	// 添加反向映射
 	d->handlerToEvent[handlerId] = eventName;
 
-	LOG_INFO(
-		QString("Registered %1 event handler for event: %2, handler ID: %3 (object: %4, local: %5)")
-			.arg(async ? "async" : "sync")
-			.arg(eventName)
-			.arg(handlerId)
-			.arg(objectId)
-			.arg(d->localIdCounter));
+	LOG_INFO("Registered " + std::string(async ? "async" : "sync") + " event handler for event: "
+			 + eventName + ", handler ID: " + std::to_string(handlerId) + " (object: "
+			 + std::to_string(objectId) + ", local: " + std::to_string(d->localIdCounter) + ")");
 	return handlerId;
 }
 
 // 修改移除事件处理器的实现
-bool XNEventManager::RemoveEventHandler(const QString &eventName, int handlerId)
+bool XNEventManager::RemoveEventHandler(const std::string &eventName, int handlerId)
 {
-	Q_D(XNEventManager);
-	QMutexLocker locker(&d->eventMutex);
+	T_D();
+	std::lock_guard<std::mutex> locker(d->eventMutex);
 
 	// 如果指定了事件名称，先验证事件是否存在
-	if (!eventName.isEmpty()) {
-		if (!d->eventHandlers.contains(eventName)) {
-			LOG_WARNING(QString("Event %1 not found!").arg(eventName));
+	if (!eventName.empty()) {
+		auto it = d->eventHandlers.find(eventName);
+		if (it == d->eventHandlers.end()) {
+			LOG_WARNING("Event " + eventName + " not found!");
 			return false;
 		}
 
 		// 查找并移除指定的处理器
-		auto &handlers = d->eventHandlers[eventName];
-		for (auto it = handlers.begin(); it != handlers.end(); ++it) {
-			if (it->GetHandlerId() == handlerId) {
-				handlers.erase(it);
-				d->handlerToEvent.remove(handlerId);
-				LOG_INFO(
-					QString("Removed handler ID %1 from event: %2").arg(handlerId).arg(eventName));
+		auto &handlers = it->second;
+		auto handlerIt = std::find_if(
+			handlers.begin(), handlers.end(),
+			[handlerId](const EventHandlerInfo &info) { return info.GetHandlerId() == handlerId; });
 
-				// 如果事件没有处理器了，移除整个事件
-				if (handlers.isEmpty()) {
-					d->eventHandlers.remove(eventName);
-				}
-				return true;
+		if (handlerIt != handlers.end()) {
+			handlers.erase(handlerIt);
+			d->handlerToEvent.erase(handlerId);
+			LOG_INFO("Removed handler ID " + std::to_string(handlerId)
+					 + " from event: " + eventName);
+
+			// 如果事件没有处理器了，移除整个事件
+			if (handlers.empty()) {
+				d->eventHandlers.erase(it);
 			}
+			return true;
 		}
-		LOG_WARNING(QString("Handler ID %1 not found in event: %2").arg(handlerId).arg(eventName));
+		LOG_WARNING("Handler ID " + std::to_string(handlerId)
+					+ " not found in event: " + eventName);
 		return false;
 	}
 
 	// 如果没有指定事件名称，使用反向映射查找
 	auto eventIt = d->handlerToEvent.find(handlerId);
 	if (eventIt != d->handlerToEvent.end()) {
-		QString eventToRemove = eventIt.value();
-		auto &handlers		  = d->eventHandlers[eventToRemove];
+		std::string eventToRemove = eventIt->second;
+		auto &handlers			  = d->eventHandlers[eventToRemove];
 
-		for (auto it = handlers.begin(); it != handlers.end(); ++it) {
-			if (it->GetHandlerId() == handlerId) {
-				handlers.erase(it);
-				d->handlerToEvent.remove(handlerId);
-				LOG_INFO(QString("Removed handler ID %1 from event: %2")
-							 .arg(handlerId)
-							 .arg(eventToRemove));
+		auto handlerIt = std::find_if(
+			handlers.begin(), handlers.end(),
+			[handlerId](const EventHandlerInfo &info) { return info.GetHandlerId() == handlerId; });
 
-				// 如果事件没有处理器了，移除整个事件
-				if (handlers.isEmpty()) {
-					d->eventHandlers.remove(eventToRemove);
-				}
-				return true;
+		if (handlerIt != handlers.end()) {
+			handlers.erase(handlerIt);
+			d->handlerToEvent.erase(handlerId);
+			LOG_INFO("Removed handler ID " + std::to_string(handlerId)
+					 + " from event: " + eventToRemove);
+
+			// 如果事件没有处理器了，移除整个事件
+			if (handlers.empty()) {
+				d->eventHandlers.erase(eventToRemove);
 			}
+			return true;
 		}
 	}
 
-	LOG_WARNING(QString("Handler ID %1 not found!").arg(handlerId));
+	LOG_WARNING("Handler ID " + std::to_string(handlerId) + " not found!");
 	return false;
 }
 
 // 修改触发事件的实现
-void XNEventManager::TriggerEvent(const QString &eventName, const QVariant &eventData,
+void XNEventManager::TriggerEvent(const std::string &eventName, const std::any &eventData,
 								  bool forceAsync, XNEvent::Priority priority)
 {
-	Q_D(XNEventManager);
-
-	QList<EventHandlerInfo> handlers;
+	T_D();
+	std::list<EventHandlerInfo> handlers;
 	{
-		QMutexLocker locker(&d->eventMutex);
-		if (!d->eventHandlers.contains(eventName)) {
-			//LOG_WARNING(QString("No handlers registered for event: %1").arg(eventName));
+		std::lock_guard<std::mutex> locker(d->eventMutex);
+		auto it = d->eventHandlers.find(eventName);
+		if (it == d->eventHandlers.end()) {
 			return;
 		}
-		handlers = d->eventHandlers[eventName];
+		handlers = it->second;
 	}
 
 	for (const auto &handler : handlers) {
@@ -186,54 +157,85 @@ void XNEventManager::TriggerEvent(const QString &eventName, const QVariant &even
 				d->rtManager.addTask(task);
 			} else {
 				// 普通异步任务使用线程池
-				d->normalThreadPool.start(
-					new EventTask(eventName, eventData, handler.callback, this));
+				std::lock_guard<std::mutex> lock(d->taskMutex);
+				d->taskQueue.push(new AsyncEventTask(eventName, eventData, handler.callback, this));
+				d->taskCond.notify_one();
 			}
 		} else {
 			// 同步执行
 			try {
 				handler.callback(eventData);
-				emit EventProcessed(eventName, true);
+				EventProcessed(eventName, true);
 			} catch (const std::exception &e) {
-				LOG_ERROR(QString("Exception in handler %1 for event %2: %3")
-							  .arg(handler.GetHandlerId())
-							  .arg(eventName)
-							  .arg(e.what()));
-				emit EventProcessed(eventName, false);
+				LOG_ERROR("Exception in handler " + std::to_string(handler.GetHandlerId())
+						  + " for event " + eventName + ": " + e.what());
+				EventProcessed(eventName, false);
 			}
 		}
 	}
-
-	//LOG_INFO(QString("Triggered event: %1 with %2 handlers").arg(eventName).arg(handlers.size()));
 }
 
 void XNEventManager::SetMaxThreadCount(int count)
 {
-	Q_D(XNEventManager);
-	d->threadPool.setMaxThreadCount(count);
-	LOG_INFO(QString("Set thread pool max thread count to %1").arg(count));
+	T_D();
+	std::lock_guard<std::mutex> lock(d->taskMutex);
+	// 停止现有线程
+	d->running = false;
+	d->taskCond.notify_all();
+	for (auto &thread : d->workerThreads) {
+		if (thread.joinable()) {
+			thread.join();
+		}
+	}
+	d->workerThreads.clear();
+
+	// 创建新线程
+	d->running = true;
+	for (int i = 0; i < count; ++i) {
+		d->workerThreads.emplace_back([this, d]() {
+			while (d->running) {
+				BaseEventTask *task = nullptr;
+				{
+					std::unique_lock<std::mutex> lock(d->taskMutex);
+					d->taskCond.wait(lock,
+									 [this, d] { return !d->taskQueue.empty() || !d->running; });
+					if (!d->running) {
+						break;
+					}
+					task = d->taskQueue.front();
+					d->taskQueue.pop();
+				}
+				if (task) {
+					task->execute();
+					delete task;
+				}
+			}
+		});
+	}
+	LOG_INFO("Set thread pool max thread count to " + std::to_string(count));
 }
 
 int XNEventManager::GetMaxThreadCount() const
 {
-	Q_D(const XNEventManager);
-	return d->threadPool.maxThreadCount();
+	T_D();
+	std::lock_guard<std::mutex> lock(d->taskMutex);
+	return d->workerThreads.size();
 }
 
 void XNEventManager::WaitForAsyncEvents()
 {
-	Q_D(XNEventManager);
-	d->threadPool.waitForDone();
+	T_D();
+	std::unique_lock<std::mutex> lock(d->taskMutex);
+	d->taskCond.wait(lock, [this, d] { return d->taskQueue.empty(); });
 	LOG_INFO("All async events have been processed");
 }
 
 // 初始化事件管理器
-void XNEventManager::OnInitialize()
+bool XNEventManager::Initialize()
 {
-	Q_D(XNEventManager);
-
+	T_D();
 	// 配置普通线程池
-	d->threadPool.setMaxThreadCount(QThread::idealThreadCount());
+	SetMaxThreadCount(std::thread::hardware_concurrency());
 
 	// 配置实时线程池
 	SetRTThreadPoolConfig(2,								   // 最大线程数
@@ -242,32 +244,30 @@ void XNEventManager::OnInitialize()
 
 	LOG_INFO("XNEventManager Initialize Success!");
 	d->_status = XNFrameObjectStatus::Initialized;
-	emit Initialize();
+	return true;
 }
 
 // 准备执行
-void XNEventManager::OnPrepareForExecute()
+bool XNEventManager::PrepareForExecute()
 {
-	Q_D(XNEventManager);
-	// 设置状态为就绪
+	T_D();
 	d->_status = XNFrameObjectStatus::Ready;
 	LOG_INFO("XNEventManager is prepared!");
-	// 发送准备完成信号
-	emit PrepareForExecute();
+	return true;
 }
 
 void XNEventManager::SetRTThreadPoolConfig(int maxThreads, int minPriority, int maxPriority)
 {
-	Q_D(XNEventManager);
+	T_D();
 	d->rtManager.stop();
 
-	XNFramework *framework = qobject_cast<XNFramework *>(parent());
-	if (framework == nullptr) {
+	XNFrameworkPtr framework = GetFramework();
+	if (!framework) {
 		LOG_WARNING("XNFramework is nullptr!");
 		return;
 	}
 
-	quint32 cpuAffinity = framework->GetCpuAffinity();
+	uint32_t cpuAffinity = framework->GetCpuAffinity();
 
 	// 找到最后一个可用的CPU
 	int lastCpu = -1;
@@ -281,8 +281,15 @@ void XNEventManager::SetRTThreadPoolConfig(int maxThreads, int minPriority, int
 		LOG_WARNING("No available CPU found in affinity mask, using default CPU 1");
 		lastCpu = 1;
 	} else {
-		LOG_INFO(QString("RT thread bound to CPU %1").arg(lastCpu));
+		LOG_INFO("RT thread bound to CPU " + std::to_string(lastCpu));
 	}
 
 	d->rtManager.start(maxThreads, maxPriority, lastCpu);
 }
+
+void XNEventManager::EventProcessed(const std::string &eventName, bool success)
+{
+	T_D();
+	// 这里可以添加事件处理完成的回调逻辑
+	//LOG_INFO("Event " + eventName + " processed " + (success ? "successfully" : "with error"));
+}

XNCore/XNEventManager.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "XNBaseFrameObject.h"
-#include <QVariant>
+
 // 事件优先级定义
 namespace XNEvent
 {
@@ -11,19 +11,18 @@ enum class Priority {
 	Low		 = 3  // 低优先级
 };
 }
+
 // 前向声明私有类
-class XNEventManagerPrivate;
+struct XNEventManagerPrivate;
 
 // 事件管理器类，继承自XNBaseFrameObject
 class XNEventManager : public XNBaseFrameObject
 {
-	Q_OBJECT							  // 启用Qt的元对象系统
-		Q_DECLARE_PRIVATE(XNEventManager) // 声明私有实现类
-		Q_DISABLE_COPY(XNEventManager)	  // 禁用拷贝构造和赋值操作
-
-		public :
-		// 构造函数，创建事件管理器实例
-		explicit XNEventManager(QObject *parent = nullptr);
+	XN_METATYPE(XNEventManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNEventManager)
+public:
+	// 构造函数，创建事件管理器实例
+	XNEventManager();
 	// 析构函数
 	~XNEventManager();
 
@@ -34,21 +33,20 @@ class XNEventManager : public XNBaseFrameObject
 	// @param async: 是否异步处理该事件
 	// @param priority: 事件优先级
 	// @return: 返回处理器ID，失败返回-1
-	int RegisterEventHandler(const QString &eventName,
-							 std::function<void(const QVariant &)> callback, quint32 objectId,
-							 bool async					= false,
+	int RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
+							 uint32_t objectId, bool async = false,
 							 XNEvent::Priority priority = XNEvent::Priority::Normal);
 	// 移除事件处理器
 	// @param eventName: 事件名称
 	// @param handlerId: 处理器ID
 	// @return: 移除是否成功
-	bool RemoveEventHandler(const QString &eventName, int handlerId);
+	bool RemoveEventHandler(const std::string &eventName, int handlerId);
 	// 触发指定事件
 	// @param eventName: 要触发的事件名称
 	// @param eventData: 事件携带的数据
 	// @param forceAsync: 强制异步处理
 	// @param priority: 事件优先级
-	void TriggerEvent(const QString &eventName, const QVariant &eventData = QVariant(),
+	void TriggerEvent(const std::string &eventName, const std::any &eventData = std::any(),
 					  bool forceAsync			 = false,
 					  XNEvent::Priority priority = XNEvent::Priority::Normal);
 
@@ -64,17 +62,16 @@ class XNEventManager : public XNBaseFrameObject
 	// 设置实时线程池参数
 	void SetRTThreadPoolConfig(int maxThreads, int minPriority, int maxPriority);
 
+	// 事件处理完成回调
+	void EventProcessed(const std::string &eventName, bool success);
+
 protected:
 	// 保护构造函数，用于继承实现
-	XNEventManager(XNEventManagerPrivate &dd, QObject *parent = nullptr);
+	XNEventManager(PrivateType *p);
 
-public slots:
+public:
 	// 初始化事件管理器
-	virtual void OnInitialize() override;
+	virtual bool Initialize() override;
 	// 准备执行
-	virtual void OnPrepareForExecute() override;
-
-signals:
-	// 事件处理完成信号
-	void EventProcessed(const QString &eventName, bool success);
+	virtual bool PrepareForExecute() override;
 };

XNCore/XNEventManager_p.h

@@ -1,9 +1,6 @@
 #pragma once
 #include "XNBaseFrameObject_p.h"
 #include "XNEventManager.h"
-#include <QMap>
-#include <QMutex>
-#include <QThreadPool>
 #include <functional>
 #include <sys/types.h>
 #include <bits/pthreadtypes.h>
@@ -12,78 +9,130 @@
 #include <queue>
 #include <mutex>
 #include <condition_variable>
+#include <string>
+#include <any>
+#include <map>
+#include <list>
 
 // 事件处理器信息结构
 struct EventHandlerInfo {
-	std::function<void(const QVariant &)> callback; // 回调函数
-	quint32 objectId;								// 对象ID
-	int localId;									// 本地ID
+	std::function<void(const std::any &)> callback; // 回调函数
+	uint32_t objectId;								// 对象ID
+	uint32_t localId;								// 本地ID
 	bool isAsync;									// 是否异步处理
 	XNEvent::Priority priority;						// 事件优先级
-	int threadPriority;								// 线程优先级
+	uint32_t threadPriority;						// 线程优先级
 
 	// 获取全局处理器ID
-	int GetHandlerId() const { return (objectId << 16) | (localId & 0xFFFF); }
+	uint32_t GetHandlerId() const { return (objectId << 16) | (localId & 0xFFFF); }
 
 	// 从全局处理器ID中提取对象ID
-	static quint32 GetObjectId(int handlerId) { return handlerId >> 16; }
+	static uint32_t GetObjectId(uint32_t handlerId) { return handlerId >> 16; }
 
 	// 从全局处理器ID中提取本地ID
-	static int GetLocalId(int handlerId) { return handlerId & 0xFFFF; }
+	static uint32_t GetLocalId(uint32_t handlerId) { return handlerId & 0xFFFF; }
 };
 
 // 事件任务基类
-class BaseEventTask : public QRunnable
+class BaseEventTask
 {
 public:
-	BaseEventTask(const QString &name, const QVariant &data,
-				  std::function<void(const QVariant &)> callback, XNEventManager *manager)
+	/**
+	 * @brief 构造函数
+	 * @param name 事件名称
+	 * @param data 事件数据
+	 * @param callback 回调函数
+	 * @param manager 事件管理器指针
+	 */
+	BaseEventTask(const std::string &name, const std::any &data,
+				  std::function<void(const std::any &)> callback, XNEventManager *manager)
 		: eventName(name), eventData(data), eventCallback(callback), eventManager(manager)
 	{
-		setAutoDelete(true);
 	}
 	virtual ~BaseEventTask() = default;
 
+	/**
+	 * @brief 执行任务
+	 */
+	virtual void execute() = 0;
+
 protected:
-	QString eventName;
-	QVariant eventData;
-	std::function<void(const QVariant &)> eventCallback;
+	std::string eventName;
+	std::any eventData;
+	std::function<void(const std::any &)> eventCallback;
 	XNEventManager *eventManager;
 };
 
-// 实时事件任务
-class RTEventTask
+// 异步事件任务
+class AsyncEventTask : public BaseEventTask
 {
 public:
-	RTEventTask(const QString &name, const QVariant &data,
-				std::function<void(const QVariant &)> callback, XNEventManager *manager)
-		: eventName(name), eventData(data), eventCallback(callback), eventManager(manager)
+	/**
+	 * @brief 构造函数
+	 * @param name 事件名称
+	 * @param data 事件数据
+	 * @param callback 回调函数
+	 * @param manager 事件管理器指针
+	 */
+	AsyncEventTask(const std::string &name, const std::any &data,
+				   std::function<void(const std::any &)> callback, XNEventManager *manager)
+		: BaseEventTask(name, data, callback, manager)
 	{
 	}
 
-	void execute()
+	/**
+	 * @brief 执行任务
+	 */
+	void execute() override
 	{
 		try {
 			eventCallback(eventData);
 			if (eventManager) {
-				QMetaObject::invokeMethod(eventManager, "EventProcessed", Qt::QueuedConnection,
-										  Q_ARG(QString, eventName), Q_ARG(bool, true));
+				eventManager->EventProcessed(eventName, true);
 			}
 		} catch (const std::exception &e) {
-			LOG_ERROR(
-				QString("RT event handler exception for %1: %2").arg(eventName).arg(e.what()));
+			LOG_ERROR("Async event handler exception for " + eventName + ": " + e.what());
 			if (eventManager) {
-				QMetaObject::invokeMethod(eventManager, "EventProcessed", Qt::QueuedConnection,
-										  Q_ARG(QString, eventName), Q_ARG(bool, false));
+				eventManager->EventProcessed(eventName, false);
 			}
 		}
 	}
+};
 
-private:
-	QString eventName;
-	QVariant eventData;
-	std::function<void(const QVariant &)> eventCallback;
-	XNEventManager *eventManager;
+// 实时事件任务
+class RTEventTask : public BaseEventTask
+{
+public:
+	/**
+	 * @brief 构造函数
+	 * @param name 事件名称
+	 * @param data 事件数据
+	 * @param callback 回调函数
+	 * @param manager 事件管理器指针
+	 */
+	RTEventTask(const std::string &name, const std::any &data,
+				std::function<void(const std::any &)> callback, XNEventManager *manager)
+		: BaseEventTask(name, data, callback, manager)
+	{
+	}
+
+	/**
+	 * @brief 执行任务
+	 */
+	void execute() override
+	{
+		try {
+			eventCallback(eventData);
+			if (eventManager) {
+				eventManager->EventProcessed(eventName, true);
+			}
+		} catch (const std::exception &e) {
+			LOG_ERROR("RT event handler exception for " + eventName + ": " + e.what());
+			if (eventManager) {
+				eventManager->EventProcessed(eventName, false);
+			}
+		}
+	}
 };
 
 // 实时线程管理器
@@ -167,35 +216,27 @@ private:
 };
 
 // 事件管理器的私有实现类
-class XNEventManagerPrivate : public XNBaseFrameObjectPrivate
-{
-public:
-	// 声明公共接口类
-	Q_DECLARE_PUBLIC(XNEventManager)
-
-	// 构造函数，初始化私有实现
-	explicit XNEventManagerPrivate(XNEventManager *q) : XNBaseFrameObjectPrivate(q) {}
-
+struct XNEventManagerPrivate : public XNBaseFrameObjectPrivate {
 	// 存储事件及其对应的处理器信息列表
 	// key: 事件名称
 	// value: 该事件对应的所有处理器信息列表
-	QMap<QString, QList<EventHandlerInfo>> eventHandlers;
+	std::map<std::string, std::list<EventHandlerInfo>> eventHandlers;
 
 	// 处理器ID到事件名称的反向映射，用于快速查找
-	QMap<int, QString> handlerToEvent;
+	std::map<int, std::string> handlerToEvent;
 
 	// 本地ID计数器
 	int localIdCounter = 0;
 
 	// 互斥锁，用于保护事件处理器表的线程安全访问
-	QMutex eventMutex;
+	std::mutex eventMutex;
 
-	// 线程池，用于异步执行事件处理器
-	QThreadPool threadPool;
-
-	// 实时线程池
-	QThreadPool rtThreadPool;
+	// 线程池相关
+	std::vector<std::thread> workerThreads;
+	std::queue<BaseEventTask *> taskQueue;
+	std::mutex taskMutex;
+	std::condition_variable taskCond;
+	bool running = true;
 
 	RTThreadManager rtManager;
-	QThreadPool normalThreadPool; // 用于非实时任务
 };

XNCore/XNFramework.cpp

@@ -9,130 +9,21 @@
 #include "XNServiceManager.h"
 #include "XNEventManager.h"
 
-XNFramework::XNFramework(QObject *parent) : XNObject(*new XNFrameworkPrivate(this), parent)
+XNFramework::XNFramework() : XNObject(new XNFrameworkPrivate())
 {
-	setObjectName("XNFramework");
-	setUniqueId(1);
-	XNTimeManager *timeManager		   = new XNTimeManager(this);
-	XNThreadManager *threadManager	   = new XNThreadManager(this);
-	XNScenarioManager *scenarioManager = new XNScenarioManager(this);
-	XNDDSManager *ddsManager		   = new XNDDSManager(this);
-	XNModelManager *modelManager	   = new XNModelManager(this);
-	XNServiceManager *serviceManager   = new XNServiceManager(this);
-	XNEventManager *eventManager	   = new XNEventManager(this);
-
-	//链接各组件初始化信号槽,依次链接,回告完成
-	connect(this, &XNFramework::Initialize, eventManager, &XNEventManager::OnInitialize);
-	connect(eventManager, &XNEventManager::Initialize, timeManager, &XNTimeManager::OnInitialize);
-	connect(timeManager, &XNTimeManager::Initialize, ddsManager, &XNDDSManager::OnInitialize);
-	connect(ddsManager, &XNDDSManager::Initialize, serviceManager, &XNServiceManager::OnInitialize);
-	connect(serviceManager, &XNServiceManager::Initialize, threadManager,
-			&XNThreadManager::OnInitialize);
-	connect(threadManager, &XNThreadManager::Initialize, modelManager,
-			&XNModelManager::OnInitialize);
-	connect(modelManager, &XNModelManager::Initialize, scenarioManager,
-			&XNScenarioManager::OnInitialize);
-	connect(modelManager, &XNModelManager::InitializeSuccess, this,
-			&XNFramework::OnInitializeSuccess);
-
-	//连接各组件初始化失败信号到框架的槽
-	connect(eventManager, &XNEventManager::InitializeFailed, this,
-			&XNFramework::OnInitializeFailed);
-	connect(timeManager, &XNTimeManager::InitializeFailed, this, &XNFramework::OnInitializeFailed);
-	connect(ddsManager, &XNDDSManager::InitializeFailed, this, &XNFramework::OnInitializeFailed);
-	connect(serviceManager, &XNServiceManager::InitializeFailed, this,
-			&XNFramework::OnInitializeFailed);
-	connect(threadManager, &XNThreadManager::InitializeFailed, this,
-			&XNFramework::OnInitializeFailed);
-	connect(modelManager, &XNModelManager::InitializeFailed, this,
-			&XNFramework::OnInitializeFailed);
-	connect(scenarioManager, &XNScenarioManager::InitializeFailed, this,
-			&XNFramework::OnInitializeFailed);
-
-	//连接解析配置文件信号到框架的槽
-	connect(scenarioManager, &XNScenarioManager::AnalyzeScenarioXmlFailed, this,
-			&XNFramework::OnAnalyzeScenarioXmlFailed);
-	connect(scenarioManager, &XNScenarioManager::AnalyzeScenarioXmlSuccess, this,
-			&XNFramework::OnAnalyzeScenarioXmlSuccess);
-
-	//链接各组件准备执行信号槽
-	connect(this, &XNFramework::PrepareForExecute, eventManager,
-			&XNEventManager::OnPrepareForExecute);
-	connect(eventManager, &XNEventManager::PrepareForExecute, timeManager,
-			&XNTimeManager::OnPrepareForExecute);
-	connect(timeManager, &XNTimeManager::PrepareForExecute, ddsManager,
-			&XNDDSManager::OnPrepareForExecute);
-	connect(ddsManager, &XNDDSManager::PrepareForExecute, serviceManager,
-			&XNServiceManager::OnPrepareForExecute);
-	connect(serviceManager, &XNServiceManager::PrepareForExecute, threadManager,
-			&XNThreadManager::OnPrepareForExecute);
-	connect(threadManager, &XNThreadManager::PrepareForExecute, modelManager,
-			&XNModelManager::OnPrepareForExecute);
-	connect(modelManager, &XNModelManager::PrepareForExecute, scenarioManager,
-			&XNScenarioManager::OnPrepareForExecute);
-	connect(modelManager, &XNModelManager::PrepareForExecuteSuccess, this,
-			&XNFramework::OnPrepareForExecuteSuccess);
-
-	//连接准备执行失败的槽
-	connect(eventManager, &XNEventManager::PrepareForExecuteFailed, this,
-			&XNFramework::OnPrepareForExecuteFailed);
-	connect(timeManager, &XNTimeManager::PrepareForExecuteFailed, this,
-			&XNFramework::OnPrepareForExecuteFailed);
-	connect(ddsManager, &XNDDSManager::PrepareForExecuteFailed, this,
-			&XNFramework::OnPrepareForExecuteFailed);
-	connect(serviceManager, &XNServiceManager::PrepareForExecuteFailed, this,
-			&XNFramework::OnPrepareForExecuteFailed);
-	connect(threadManager, &XNThreadManager::PrepareForExecuteFailed, this,
-			&XNFramework::OnPrepareForExecuteFailed);
-	connect(modelManager, &XNModelManager::PrepareForExecuteFailed, this,
-			&XNFramework::OnPrepareForExecuteFailed);
-	connect(scenarioManager, &XNScenarioManager::PrepareForExecuteFailed, this,
-			&XNFramework::OnPrepareForExecuteFailed);
-
-	//threadManager的设置开始时间信号触发timeManager的设置开始时间槽
-	connect(threadManager, &XNThreadManager::SetStartTime, timeManager,
-			&XNTimeManager::OnSetStartTime);
-	//framework的仿真控制信号触发timeManager的仿真控制槽
-	connect(this, &XNFramework::SimControl, timeManager, &XNTimeManager::OnSimControl);
-	//timeManager的仿真控制信号触发threadManager的仿真控制槽
-	connect(timeManager, &XNTimeManager::SimControl, threadManager, &XNThreadManager::OnSimControl);
-	//scenarioManager的分析场景XML信号触发framework的分析场景XML槽
-	connect(this, &XNFramework::AnalyzeScenarioXml, scenarioManager,
-			&XNScenarioManager::AnalysisScenarioXml);
-	//scenarioManager的添加线程池信号触发threadManager的添加线程池槽
-	connect(scenarioManager, &XNScenarioManager::AddThreadPool, threadManager,
-			&XNThreadManager::OnAddThreadPool);
-	//scenarioManager的加载模型信号触发modelManager的加载模型槽
-	connect(scenarioManager, &XNScenarioManager::LoadModel, modelManager,
-			&XNModelManager::OnLoadModel);
-	//scenarioManager的加载服务信号触发serviceManager的加载服务槽
-	connect(scenarioManager, &XNScenarioManager::LoadService, serviceManager,
-			&XNServiceManager::OnLoadService);
-	//scenarioManager的设置工作路径信号触发framework的设置工作路径槽
-	connect(scenarioManager, &XNScenarioManager::SetWorkPath, this, &XNFramework::SetWorkPath);
-	//scenarioManager的设置模型路径信号触发framework的设置模型路径槽
-	connect(scenarioManager, &XNScenarioManager::SetModelPath, this, &XNFramework::SetModelPath);
-	//scenarioManager的设置服务路径信号触发framework的设置服务路径槽
-	connect(scenarioManager, &XNScenarioManager::SetServicePath, this,
-			&XNFramework::SetServicePath);
-	//scenarioManager的设置CPU亲和性信号触发framework的设置CPU亲和性槽
-	connect(scenarioManager, &XNScenarioManager::SetCpuAffinity, this,
-			&XNFramework::SetCpuAffinity);
-	//scenarioManager的设置基频信号触发threadManager的设置基频槽
-	connect(scenarioManager, &XNScenarioManager::SetBaseFreq, threadManager,
-			&XNThreadManager::OnSetBaseFreq);
-	//scenarioManager的设置基频信号触发modelManager的设置基频槽
-	connect(scenarioManager, &XNScenarioManager::SetBaseFreq, modelManager,
-			&XNModelManager::OnSetBaseFreq);
-	//modelManager的注册函数信号触发threadManager的注册函数槽
-	connect(modelManager, &XNModelManager::RegisterFunction, threadManager,
-			&XNThreadManager::OnRegisterFunction);
-	//scenarioManager的设置DDS域ID信号触发ddsManager的设置DDS域ID槽
-	connect(scenarioManager, &XNScenarioManager::SetDomainID, ddsManager,
-			&XNDDSManager::SetDomainID);
+	SetObjectName("XNFramework");
+	SetUniqueId(1);
+	T_D();
+	d->timeManager	   = std::make_shared<XNTimeManager>();
+	d->threadManager   = std::make_shared<XNThreadManager>();
+	d->scenarioManager = std::make_shared<XNScenarioManager>();
+	d->ddsManager	   = std::make_shared<XNDDSManager>();
+	d->modelManager	   = std::make_shared<XNModelManager>();
+	d->serviceManager  = std::make_shared<XNServiceManager>();
+	d->eventManager	   = std::make_shared<XNEventManager>();
 }
 
-XNFramework::XNFramework(XNFrameworkPrivate &dd, QObject *parent) : XNObject(dd, parent)
+XNFramework::XNFramework(PrivateType *p) : XNObject(p)
 {
 }
 
@@ -140,114 +31,205 @@ XNFramework::~XNFramework()
 {
 }
 
-QString XNFramework::GetWorkPath()
+std::string XNFramework::GetWorkPath()
 {
-	Q_D(XNFramework);
+	T_D();
 	return d->workPath;
 }
 
-void XNFramework::SetWorkPath(const QString &workPath)
+void XNFramework::SetWorkPath(const std::string &workPath)
 {
-	Q_D(XNFramework);
+	T_D();
 	d->workPath = workPath;
 }
 
-QString XNFramework::GetModelPath()
+std::string XNFramework::GetModelPath()
 {
-	Q_D(XNFramework);
+	T_D();
 	return d->modelPath;
 }
 
-void XNFramework::SetModelPath(const QString &modelPath)
+void XNFramework::SetModelPath(const std::string &modelPath)
 {
-	Q_D(XNFramework);
+	T_D();
 	d->modelPath = modelPath;
 }
 
-QString XNFramework::GetServicePath()
+std::string XNFramework::GetServicePath()
 {
-	Q_D(XNFramework);
+	T_D();
 	return d->servicePath;
 }
 
-void XNFramework::SetServicePath(const QString &servicePath)
+void XNFramework::SetServicePath(const std::string &servicePath)
 {
-	Q_D(XNFramework);
+	T_D();
 	d->servicePath = servicePath;
 }
 
-quint32 XNFramework::GetCpuAffinity()
+uint32_t XNFramework::GetCpuAffinity()
 {
-	Q_D(XNFramework);
+	T_D();
 	return d->uCpuAffinity;
 }
 
-void XNFramework::SetCpuAffinity(quint32 cpuAffinity)
+void XNFramework::SetCpuAffinity(uint32_t cpuAffinity)
 {
-	Q_D(XNFramework);
+	T_D();
 	d->uCpuAffinity = cpuAffinity;
 }
 
-void XNFramework::OnInitialize()
+bool XNFramework::Initialize(uint32_t initialType)
 {
-	Q_D(XNFramework);
+	T_D();
 	LOG_INFO("XNFramework Initialize ...");
-	emit Initialize();
+	d->ddsManager->SetFramework(XN_THISPTR);
+	d->timeManager->SetFramework(XN_THISPTR);
+	d->threadManager->SetFramework(XN_THISPTR);
+	d->scenarioManager->SetFramework(XN_THISPTR);
+	d->modelManager->SetFramework(XN_THISPTR);
+	d->serviceManager->SetFramework(XN_THISPTR);
+	d->eventManager->SetFramework(XN_THISPTR);
+	bool ret = d->eventManager->Initialize();
+	if (!ret) {
+		LOG_ERROR("XNFramework Initialize Failed!");
+		return false;
+	}
+	ret = d->timeManager->Initialize();
+	if (!ret) {
+		LOG_ERROR("XNFramework Initialize Failed!");
+		return false;
+	}
+	ret = d->ddsManager->Initialize();
+	if (!ret) {
+		LOG_ERROR("XNFramework Initialize Failed!");
+		return false;
+	}
+	ret = d->serviceManager->Initialize();
+	if (!ret) {
+		LOG_ERROR("XNFramework Initialize Failed!");
+		return false;
+	}
+	ret = d->threadManager->Initialize();
+	if (!ret) {
+		LOG_ERROR("XNFramework Initialize Failed!");
+		return false;
+	}
+	ret = d->modelManager->Initialize();
+	if (!ret) {
+		LOG_ERROR("XNFramework Initialize Failed!");
+		return false;
+	}
+	ret = d->scenarioManager->Initialize();
+	if (!ret) {
+		LOG_ERROR("XNFramework Initialize Failed!");
+		return false;
+	}
+	LOG_INFO("XNFramework Initialize Success!");
+	LOG_INFO("XNFramework Analyze Scenario Xml ...");
+	ret = d->scenarioManager->AnalysisScenarioXml(d->scenarioXml, initialType);
+	if (!ret) {
+		LOG_ERROR("XNFramework Analyze Scenario Xml Failed!");
+		return false;
+	}
+	LOG_INFO("XNFramework Analyze Scenario Xml Success!");
+	return true;
 }
 
-void XNFramework::OnPrepareForExecute()
+bool XNFramework::PrepareForExecute()
 {
-	Q_D(XNFramework);
-	emit PrepareForExecute();
+	T_D();
+
+	bool ret = d->eventManager->PrepareForExecute();
+	if (!ret) {
+		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		return false;
+	}
+	ret = d->timeManager->PrepareForExecute();
+	if (!ret) {
+		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		return false;
+	}
+	ret = d->ddsManager->PrepareForExecute();
+	if (!ret) {
+		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		return false;
+	}
+	ret = d->serviceManager->PrepareForExecute();
+	if (!ret) {
+		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		return false;
+	}
+	ret = d->threadManager->PrepareForExecute();
+	if (!ret) {
+		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		return false;
+	}
+	ret = d->modelManager->PrepareForExecute();
+	if (!ret) {
+		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		return false;
+	}
+	ret = d->scenarioManager->PrepareForExecute();
+	if (!ret) {
+		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		return false;
+	}
+	LOG_INFO("XNCore is prepared for execute! Simulation will start soon...");
+	return true;
 }
 
-void XNFramework::SetScenarioXml(const QString &scenarioXml)
+void XNFramework::SetScenarioXml(const std::string &scenarioXml)
 {
-	Q_D(XNFramework);
+	T_D();
 	d->scenarioXml = scenarioXml;
 }
 
-void XNFramework::OnInitializeSuccess()
+void XNFramework::SimControl(uint32_t objectId, SimControlCmd cmd)
 {
-	Q_D(XNFramework);
-	LOG_INFO("XNFramework Initialize Success!");
-	LOG_INFO("XNFramework Analyze Scenario Xml ...");
-	emit AnalyzeScenarioXml(d->scenarioXml);
+	T_D();
+	d->timeManager->SimControl(objectId, cmd);
+	d->threadManager->SimControl(objectId, cmd);
 }
 
-void XNFramework::OnInitializeFailed()
+XNTimeManagerPtr XNFramework::GetTimeManager()
 {
-	LOG_INFO("XNFramework Initialize Failed!");
-	emit InitializeSuccess(false);
+	T_D();
+	return d->timeManager;
 }
 
-void XNFramework::OnAnalyzeScenarioXmlSuccess()
+XNThreadManagerPtr XNFramework::GetThreadManager()
 {
-	LOG_INFO("XNFramework Analyze Scenario Xml Success!");
-	emit InitializeSuccess(true);
+	T_D();
+	return d->threadManager;
 }
 
-void XNFramework::OnAnalyzeScenarioXmlFailed()
+XNScenarioManagerPtr XNFramework::GetScenarioManager()
 {
-	LOG_INFO("XNFramework Analyze Scenario Xml Failed!");
-	emit InitializeSuccess(false);
+	T_D();
+	return d->scenarioManager;
 }
 
-void XNFramework::OnPrepareForExecuteSuccess()
+XNDDSManagerPtr XNFramework::GetDDSManager()
 {
-	Q_D(XNFramework);
-	LOG_INFO("XNCore is prepared for execute! Simulation will start soon...");
-	emit PrepareForExecuteSuccess(true);
+	T_D();
+	return d->ddsManager;
 }
 
-void XNFramework::OnPrepareForExecuteFailed()
+XNEventManagerPtr XNFramework::GetEventManager()
 {
-	Q_D(XNFramework);
-	LOG_INFO("XNCore is failed to prepared for execute!");
-	emit PrepareForExecuteSuccess(false);
+	T_D();
+	return d->eventManager;
 }
 
-void XNFramework::OnSimControl(quint32 objectId, SimControlCmd cmd)
+XNModelManagerPtr XNFramework::GetModelManager()
 {
-	emit SimControl(objectId, cmd);
+	T_D();
+	return d->modelManager;
+}
+
+XNServiceManagerPtr XNFramework::GetServiceManager()
+{
+	T_D();
+	return d->serviceManager;
 }

XNCore/XNFramework.h

@@ -12,195 +12,157 @@
 
 #include "XNObject.h"
 
-class XNFrameworkPrivate;
+struct XNFrameworkPrivate;
 
 /**
  * @brief 框架类
  */
 class XNCORE_EXPORT XNFramework : public XNObject
 {
-	/**
-	 * @brief 宏定义，用于支持Qt的元对象系统
-	 */
-	Q_OBJECT
-
 	/**
 	 * @brief 宏定义，用于禁用拷贝构造函数
 	 */
-	Q_DISABLE_COPY(XNFramework)
+	XN_METATYPE(XNFramework, XNObject)
 
 	/**
 	 * @brief 宏定义，用于声明私有数据成员
 	 */
-	Q_DECLARE_PRIVATE(XNFramework);
-
-	/**
-	 * @brief 宏定义，用于声明属性workPath
-	 */
-	Q_PROPERTY(QString workPath READ GetWorkPath WRITE SetWorkPath)
-
-	/**
-	 * @brief 宏定义，用于声明属性modelPath
-	 */
-	Q_PROPERTY(QString modelPath READ GetModelPath WRITE SetModelPath)
-
-	/**
-	 * @brief 宏定义，用于声明属性cpuAffinity
-	 */
-	Q_PROPERTY(quint32 cpuAffinity READ GetCpuAffinity WRITE SetCpuAffinity)
-
+	XN_DECLARE_PRIVATE(XNFramework)
 public:
 	/**
 	 * @brief 构造函数
 	 * @param parent 父对象
 	 */
-	explicit XNFramework(QObject *parent = nullptr);
+	XNFramework();
 
 	/**
 	 * @brief 析构函数
 	 */
 	virtual ~XNFramework();
 
+protected:
+	/**
+	 * @brief 构造函数
+	 * @param p 私有数据成员
+	 */
+	XNFramework(PrivateType *p);
+
+public:
+	/**
+	 * @brief 获取DDS管理器
+	 * @return DDS管理器
+	 */
+	XNDDSManagerPtr GetDDSManager();
+
+	/**
+	 * @brief 获取事件管理器
+	 * @return 事件管理器
+	 */
+	XNEventManagerPtr GetEventManager();
+
+	/**
+	 * @brief 获取模型管理器
+	 * @return 模型管理器
+	 */
+	XNModelManagerPtr GetModelManager();
+
+	/**
+	 * @brief 获取场景管理器
+	 * @return 场景管理器
+	 */
+	XNScenarioManagerPtr GetScenarioManager();
+
+	/**
+	 * @brief 获取服务管理器
+	 * @return 服务管理器
+	 */
+	XNServiceManagerPtr GetServiceManager();
+
+	/**
+	 * @brief 获取线程管理器
+	 * @return 线程管理器
+	 */
+	XNThreadManagerPtr GetThreadManager();
+
+	/**
+	 * @brief 获取时间管理器
+	 * @return 时间管理器
+	 */
+	XNTimeManagerPtr GetTimeManager();
+
 	/**
 	 * @brief 获取工作路径
 	 * @return 工作路径
 	 */
-	QString GetWorkPath();
+	std::string GetWorkPath();
+
+	/**
+	 * @brief 设置工作路径
+	 * @param workPath 工作路径
+	 */
+	void SetWorkPath(const std::string &workPath);
 
 	/**
 	 * @brief 获取模型库路径
 	 * @return 模型库路径
 	 */
-	QString GetModelPath();
+	std::string GetModelPath();
+
+	/**
+	 * @brief 设置模型库路径
+	 * @param modelPath 模型库路径
+	 */
+	void SetModelPath(const std::string &modelPath);
 
 	/**
 	 * @brief 获取服务库路径
 	 * @return 服务库路径
 	 */
-	QString GetServicePath();
+	std::string GetServicePath();
+
+	/**
+	 * @brief 设置服务库路径
+	 * @param servicePath 服务库路径
+	 */
+	void SetServicePath(const std::string &servicePath);
 
 	/**
 	 * @brief 获取CPU亲和性
 	 * @return CPU亲和性
 	 */
-	quint32 GetCpuAffinity();
+	uint32_t GetCpuAffinity();
+
+	/**
+	 * @brief 设置CPU亲和性
+	 * @param cpuAffinity CPU亲和性
+	 */
+	void SetCpuAffinity(uint32_t cpuAffinity);
 
 	/**
 	 * @brief 设置场景XML
 	 * @param scenarioXml 场景XML
 	 */
-	void SetScenarioXml(const QString &scenarioXml);
-
-signals:
-	/**
-	 * @brief 初始化
-	 */
-	void Initialize();
-
-	/**
-	 * @brief 初始化成功
-	 */
-	void InitializeSuccess(bool isSuccess);
+	void SetScenarioXml(const std::string &scenarioXml);
 
 	/**
 	 * @brief 准备执行
+	 * @return true:	准备成功
+	 * @return false:	准备失败
 	 */
-	void PrepareForExecute();
-
-	/**
-	 * @brief 准备执行成功
-	 */
-	void PrepareForExecuteSuccess(bool isSuccess);
-
-	/**
-	 * @brief 分析场景XML
-	 * @param scenarioXml 场景XML
-	 */
-	void AnalyzeScenarioXml(const QString &scenarioXml);
+	bool PrepareForExecute();
 
 	/**
 	 * @brief 仿真控制
 	 * @param objectId 对象ID
 	 * @param cmd 命令
 	 */
-	void SimControl(quint32 objectId, SimControlCmd cmd);
-
-public slots:
-	/**
-	 * @brief 设置工作路径
-	 * @param workPath 工作路径
-	 */
-	void SetWorkPath(const QString &workPath);
-
-	/**
-	 * @brief 设置模型库路径
-	 * @param modelPath 模型库路径
-	 */
-	void SetModelPath(const QString &modelPath);
-
-	/**
-	 * @brief 设置服务库路径
-	 * @param servicePath 服务库路径
-	 */
-	void SetServicePath(const QString &servicePath);
-
-	/**
-	 * @brief 设置CPU亲和性
-	 * @param cpuAffinity CPU亲和性
-	 */
-	void SetCpuAffinity(quint32 cpuAffinity);
+	void SimControl(uint32_t objectId, SimControlCmd cmd);
 
 	/**
 	 * @brief 初始化
+	 * @param initialType 初始化类型
+	 * @return true:	初始化成功
+	 * @return false:	初始化失败
 	 */
-	void OnInitialize();
-
-	/**
-	 * @brief 初始化成功
-	 */
-	void OnInitializeSuccess();
-
-	/**
-	 * @brief 初始化失败
-	 */
-	void OnInitializeFailed();
-
-	/**
-	 * @brief 解析配置文件成功
-	 */
-	void OnAnalyzeScenarioXmlSuccess();
-
-	/**
-	 * @brief 解析配置文件失败
-	 */
-	void OnAnalyzeScenarioXmlFailed();
-
-	/**
-	 * @brief 准备执行
-	 */
-	void OnPrepareForExecute();
-
-	/**
-	 * @brief 准备执行成功
-	 */
-	void OnPrepareForExecuteSuccess();
-
-	/**
-	 * @brief 准备执行失败
-	 */
-	void OnPrepareForExecuteFailed();
-
-	/**
-	 * @brief 仿真控制
-	 * @param cmd 命令
-	 */
-	void OnSimControl(quint32 objectId, SimControlCmd cmd);
-
-protected:
-	/**
-	 * @brief 构造函数
-	 * @param dd 私有数据成员
-	 * @param parent 父对象
-	 */
-	XNFramework(XNFrameworkPrivate &dd, QObject *parent = nullptr);
+	bool Initialize(uint32_t initialType);
 };

XNCore/XNFramework_p.h

@@ -16,43 +16,65 @@
 /**
  * @brief 框架类的私有数据成员
  */
-class XNFrameworkPrivate : public XNObjectPrivate
-{
-public:
-	/**
-	 * @brief 构造函数
-	 * @param q 框架类指针
-	 */
-	explicit XNFrameworkPrivate(XNFramework *q) : XNObjectPrivate(q) {}
+struct XNFrameworkPrivate : public XNObjectPrivate {
 
 	/**
-	 * @brief 宏定义，用于声明公有数据成员
+	 * @brief DDS管理器
 	 */
-	Q_DECLARE_PUBLIC(XNFramework)
+	XNDDSManagerPtr ddsManager;
+
+	/**
+	 * @brief 事件管理器
+	 */
+	XNEventManagerPtr eventManager;
+
+	/**
+	 * @brief 模型管理器
+	 */
+	XNModelManagerPtr modelManager;
+
+	/**
+	 * @brief 场景管理器
+	 */
+	XNScenarioManagerPtr scenarioManager;
+
+	/**
+	 * @brief 服务管理器
+	 */
+	XNServiceManagerPtr serviceManager;
+
+	/**
+	 * @brief 线程管理器
+	 */
+	XNThreadManagerPtr threadManager;
+
+	/**
+	 * @brief 时间管理器
+	 */
+	XNTimeManagerPtr timeManager;
 
-private:
 	/**
 	 * @brief 工作路径
 	 */
-	QString workPath;
+	std::string workPath;
 
 	/**
 	 * @brief 模型路径
 	 */
-	QString modelPath;
+	std::string modelPath;
 
 	/**
 	 * @brief 服务路径
 	 */
-	QString servicePath;
+	std::string servicePath;
 
 	/**
 	 * @brief CPU亲和性
 	 */
-	quint32 uCpuAffinity;
+	uint32_t uCpuAffinity;
 
 	/**
 	 * @brief 场景XML
 	 */
-	QString scenarioXml;
+	std::string scenarioXml;
 };

XNCore/XNLogger.cpp

@@ -4,39 +4,51 @@ XNLogger::XNLogger()
 	: consoleOutputEnabled{true, true, true, true}, fileOutputEnabled{true, true, true, true}
 {
 	// 获取当前工作目录
-	QString currentDir = QDir::currentPath();
-	QString logDirPath = currentDir + "/log";
+	std::filesystem::path currentDir = std::filesystem::current_path();
+	std::filesystem::path logDirPath = currentDir / "log";
 
 	// 创建 log 文件夹
-	QDir logDir;
-	if (!logDir.exists(logDirPath)) {
-		logDir.mkpath(logDirPath);
+	if (!std::filesystem::exists(logDirPath)) {
+		std::filesystem::create_directories(logDirPath);
 	}
 
 	// 创建以当前日期和时间命名的日志文件
-	QString logFileName =
-		QString("log_%1.log").arg(QDateTime::currentDateTime().toString("yyyyMMdd_HHmmss"));
-	logFile.setFileName(logDirPath + "/" + logFileName);
+	auto now  = std::chrono::system_clock::now();
+	auto time = std::chrono::system_clock::to_time_t(now);
+	std::stringstream ss;
+	ss << std::put_time(std::localtime(&time), "%Y%m%d_%H%M%S");
+	std::string logFileName = "log_" + ss.str() + ".log";
 
-	logFile.open(QIODevice::Append | QIODevice::Text);
+	logFilePath = (logDirPath / logFileName).string();
+	logFile.open(logFilePath, std::ios::app);
 }
 
 XNLogger::~XNLogger()
 {
-	if (logFile.isOpen()) {
+	if (logFile.is_open()) {
 		logFile.close();
 	}
 }
 
-void XNLogger::log(LogLevel level, const QString &message)
+std::string XNLogger::getCurrentTimeString() const
 {
-	QMutexLocker locker(&mutex);
-	QString logMessage = QString("[%1] [%2] %3")
-							 .arg(QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss.zzz"))
-							 .arg(logLevelToString(level))
-							 .arg(message);
+	auto now  = std::chrono::system_clock::now();
+	auto time = std::chrono::system_clock::to_time_t(now);
+	auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
 
-	QString coloredMessage;
+	std::stringstream ss;
+	ss << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S");
+	ss << '.' << std::setfill('0') << std::setw(3) << ms.count();
+	return ss.str();
+}
+
+void XNLogger::log(LogLevel level, const std::string &message)
+{
+	std::lock_guard<std::mutex> locker(mutex);
+	std::string logMessage =
+		"[" + getCurrentTimeString() + "] [" + logLevelToString(level) + "] " + message;
+
+	std::string coloredMessage;
 
 	// 根据日志等级设置颜色
 	switch (level) {
@@ -61,19 +73,18 @@ void XNLogger::log(LogLevel level, const QString &message)
 	if (consoleOutputEnabled[level]) {
 		if (level == Time) {
 			// 如果是时间日志，则不换行，回退到该行开始
-			QTextStream(stdout) << coloredMessage << "\r";
+			std::cout << coloredMessage << "\r" << std::flush;
 		} else {
-			QTextStream(stdout) << coloredMessage << "\n";
+			std::cout << coloredMessage << std::endl;
 		}
 	}
 
 	// 文件输出
-	if (fileOutputEnabled[level] && logFile.isOpen()) {
-		QTextStream fileStream(&logFile);
+	if (fileOutputEnabled[level] && logFile.is_open()) {
 		if (level == Time) {
-			fileStream << logMessage << "\r";
+			logFile << logMessage << "\r" << std::flush;
 		} else {
-			fileStream << logMessage << "\n";
+			logFile << logMessage << std::endl;
 		}
 	}
 }
@@ -88,7 +99,7 @@ void XNLogger::enableFileOutput(LogLevel level, bool enable)
 	fileOutputEnabled[level] = enable;
 }
 
-QString XNLogger::logLevelToString(LogLevel level) const
+std::string XNLogger::logLevelToString(LogLevel level) const
 {
 	switch (level) {
 		case Debug:

XNCore/XNLogger.h

@@ -9,13 +9,15 @@
  * 
  */
 #pragma once
-#include <QString>
-#include <QMutex>
-#include <QFile>
-#include <QTextStream>
-#include <QDateTime>
-#include <QDir>
+#include <string>
+#include <mutex>
+#include <fstream>
+#include <chrono>
+#include <filesystem>
 #include <type_traits>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
 
 /**
  * @brief 日志类
@@ -34,7 +36,6 @@ public:
 	 */
 	static XNLogger &instance()
 	{
-		// 懒汉式单例，C++11 及以上版本的标准保证了局部静态变量的初始化是线程安全的
 		static XNLogger instance;
 		return instance;
 	}
@@ -44,7 +45,7 @@ public:
 	 * @param level 日志等级
 	 * @param message 日志消息
 	 */
-	void log(LogLevel level, const QString &message);
+	void log(LogLevel level, const std::string &message);
 
 	/**
 	 * @brief 启用控制台输出
@@ -64,7 +65,7 @@ private:
 	/**
 	 * @brief 构造函数
 	 */
-	XNLogger(); // 默认构造函数
+	XNLogger();
 
 	/**
 	 * @brief 析构函数
@@ -74,17 +75,17 @@ private:
 	/**
 	 * @brief 禁止拷贝构造
 	 */
-	XNLogger(const XNLogger &) = delete; // 禁止拷贝构造
+	XNLogger(const XNLogger &) = delete;
 
 	/**
 	 * @brief 禁止赋值
 	 */
-	XNLogger &operator=(const XNLogger &) = delete; // 禁止赋值
+	XNLogger &operator=(const XNLogger &) = delete;
 
 	/**
 	 * @brief 日志文件路径
 	 */
-	QString logFilePath;
+	std::string logFilePath;
 
 	/**
 	 * @brief 控制台输出控制
@@ -99,44 +100,50 @@ private:
 	/**
 	 * @brief 日志文件
 	 */
-	QFile logFile;
+	std::ofstream logFile;
 
 	/**
 	 * @brief 互斥锁
 	 */
-	QMutex mutex;
+	std::mutex mutex;
 
 	/**
 	 * @brief 日志等级转换为字符串
 	 * @param level 日志等级
 	 * @return 日志等级字符串
 	 */
-	QString logLevelToString(LogLevel level) const;
+	std::string logLevelToString(LogLevel level) const;
+
+	/**
+	 * @brief 获取当前时间字符串
+	 * @return 格式化的时间字符串
+	 */
+	std::string getCurrentTimeString() const;
 
 	/**
 	 * @brief 控制台输出字体恢复颜色常量
 	 */
-	const QString COLOR_RESET = "\033[0m";
+	const std::string COLOR_RESET = "\033[0m";
 
 	/**
 	 * @brief 调试颜色常量
 	 */
-	const QString COLOR_DEBUG = "\033[34m"; // 蓝色
+	const std::string COLOR_DEBUG = "\033[34m"; // 蓝色
 
 	/**
 	 * @brief 信息颜色常量	
 	 */
-	const QString COLOR_INFO = "\033[32m"; // 绿色
+	const std::string COLOR_INFO = "\033[32m"; // 绿色
 
 	/**
 	 * @brief 警告颜色常量
 	 */
-	const QString COLOR_WARNING = "\033[33m"; // 黄色
+	const std::string COLOR_WARNING = "\033[33m"; // 黄色
 
 	/**
 	 * @brief 错误颜色常量
 	 */
-	const QString COLOR_ERROR = "\033[31m"; // 红色
+	const std::string COLOR_ERROR = "\033[31m"; // 红色
 };
 
 /**
@@ -154,9 +161,9 @@ public:
 	 */
 	template <typename... Args>
 	inline static typename std::enable_if<(sizeof...(Args) > 0), void>::type
-	log(XNLogger::LogLevel level, const QString &message, Args... args)
+	log(XNLogger::LogLevel level, const std::string &message, Args... args)
 	{
-		QString formattedMessage = formatMessage(message, args...);
+		std::string formattedMessage = formatMessage(message, args...);
 		XNLogger::instance().log(level, formattedMessage);
 	}
 
@@ -165,7 +172,7 @@ public:
 	 * @param level 日志等级
 	 * @param message 日志消息
 	 */
-	inline static void log(XNLogger::LogLevel level, const QString &message)
+	inline static void log(XNLogger::LogLevel level, const std::string &message)
 	{
 		XNLogger::instance().log(level, message);
 	}
@@ -173,27 +180,44 @@ public:
 private:
 	// 辅助函数，用于格式化消息
 	template <typename T>
-	static QString convertToString(const T &arg)
+	static std::string convertToString(const T &arg)
 	{
 		if constexpr (std::is_arithmetic<T>::value) {
-			return QString::number(arg); // 处理数值类型
+			return std::to_string(arg); // 处理数值类型
 		} else {
-			return arg;
+			return std::string(arg);
 		}
 	}
 
 	// 递归变参函数，用于处理多个参数
 	template <typename T, typename... Args>
-	static QString formatMessage(const QString &message, T arg, Args... args)
+	static std::string formatMessage(const std::string &message, T arg, Args... args)
 	{
-		return formatMessage(message.arg(convertToString(arg)), args...); // 递归调用
+		// 查找下一个参数占位符
+		std::string result = message;
+		size_t paramIndex  = 0;
+		size_t pos		   = 0;
+
+		// 找到当前参数对应的占位符
+		while (true) {
+			std::string placeholder = "%" + std::to_string(paramIndex + 1);
+			pos						= result.find(placeholder);
+			if (pos != std::string::npos) {
+				// 替换占位符，使用placeholder的长度
+				result.replace(pos, placeholder.length(), convertToString(arg));
+				break;
+			}
+			paramIndex++;
+			if (paramIndex > 100) { // 防止无限循环
+				return result;
+			}
+		}
+
+		return formatMessage(result, args...);
 	}
 
 	// 基础情况
-	static QString formatMessage(const QString &message)
-	{
-		return message; // 处理没有参数的情况
-	}
+	static std::string formatMessage(const std::string &message) { return message; }
 };
 
 /**

XNCore/XNModelManager.cpp

@@ -11,17 +11,15 @@
 #include "XNModelManager.h"
 #include "XNModelManager_p.h"
 #include "XNModelObject.h"
-#include <QLibrary>
-#include <QMetaObject>
-#include <QPointer>
+#include "XNFramework.h"
+#include "XNThreadManager.h"
 
 // 构造函数
-XNModelManager::XNModelManager(QObject *parent)
-	: XNBaseFrameObject(*new XNModelManagerPrivate(this), parent)
+XNModelManager::XNModelManager() : XNBaseFrameObject(new XNModelManagerPrivate())
 {
-	setUniqueId(6);
-	setObjectName("XNModelManager");
-	Q_D(XNModelManager);
+	SetUniqueId(6);
+	SetObjectName("XNModelManager");
+	T_D();
 	d->ModelIDAssigned.resize(10000, false);
 }
 
@@ -30,103 +28,102 @@ XNModelManager::~XNModelManager()
 {
 }
 
-XNModelManager::XNModelManager(XNModelManagerPrivate &dd, QObject *parent)
-	: XNBaseFrameObject(dd, parent)
+XNModelManager::XNModelManager(PrivateType *p) : XNBaseFrameObject(p)
 {
-	Q_D(XNModelManager);
+	T_D();
 	d->ModelIDAssigned.resize(10000, false);
 }
 
 // 运行前最后准备
-void XNModelManager::OnPrepareForExecute()
+bool XNModelManager::PrepareForExecute()
 {
-	Q_D(XNModelManager);
-	emit PrepareForExecute();
+	T_D();
+	for (auto &model : d->ModelMap) {
+		model.second->PrepareForExecute();
+	}
 	d->_status = XNFrameObjectStatus::Ready;
 	LOG_INFO("XNModelManager is prepared!");
-	emit PrepareForExecuteSuccess();
+	return true;
 }
 
-void XNModelManager::OnInitialize()
+bool XNModelManager::Initialize()
 {
-	Q_D(XNModelManager);
+	T_D();
 	LOG_INFO("XNModelManager Initialize Success!");
 	d->_status = XNFrameObjectStatus::Initialized;
-	emit InitializeSuccess();
+	return true;
 }
 
-void XNModelManager::OnLoadModel(const QString &modelPath, const QString &className)
+void XNModelManager::LoadModel(const std::string &modelPath, const std::string &className,
+							   uint32_t initialType, uint32_t threadID)
 {
-	Q_D(XNModelManager);
-	QLibrary lib(modelPath);
-	if (lib.load()) {
-		typedef void (*InitialModelFunc)();
-		QString initialModelName = "Initial" + className;
-		InitialModelFunc initialModel =
-			(InitialModelFunc)lib.resolve(initialModelName.toUtf8().constData());
+	T_D();
+	void *handle = dlopen(modelPath.c_str(), RTLD_LAZY);
+	if (handle) {
+		typedef XNModelObjectPtr (*InitialModelFunc)();
+		std::string initialModelName  = "Initial" + className;
+		InitialModelFunc initialModel = (InitialModelFunc)dlsym(handle, initialModelName.c_str());
 		if (initialModel) {
-			initialModel();
-			QMetaType metaType = QMetaType::fromName(className.toUtf8().constData());
-			if (metaType.isValid()) {
-				QObject *obj = static_cast<QObject *>(metaType.create());
-				if (obj) {
-					XNModelObject *model = qobject_cast<XNModelObject *>(obj);
-					if (model) {
-						quint32 modelID = RegisterModel();
-						if (modelID == 0) {
-							LOG_WARNING("0x2174 Assign Model ID Failed, Model ID is used up!");
-							delete obj;
-							return;
-						}
-						model->setParent(this);
-						model->setObjectName(className);
-						model->setUniqueId(modelID);
-						model->SetBaseFreq(d->dBaseFreq);
-						QString configFilePath =
-							QFileInfo(modelPath).absolutePath() + "/" + className + ".mcfg";
-						model->SetXmlPath(configFilePath);
-						connect(model, &XNModelObject::RegisterFunction, this,
-								&XNModelManager::OnRegisterFunction);
-						connect(this, &XNModelManager::PrepareForExecute, model,
-								&XNModelObject::OnPrepareForExecute);
-						model->OnInitialize();
-					} else {
-						LOG_WARNING("0x2175 Model %1 Instantiation Failed, Not a subclass of "
-									"XNModelObject!",
-									className);
-						delete obj;
-						return;
-					}
-				} else {
-					LOG_WARNING("0x2176 Model %1 Instantiation Failed, Not a subclass of QObject!",
-								className);
-					delete obj;
+			XNModelObjectPtr model = initialModel();
+			if (model) {
+				uint32_t modelID = RegisterModel();
+				if (modelID == 0) {
+					LOG_WARNING("0x2174 Assign Model ID Failed, Model ID is used up!");
+					dlclose(handle);
 					return;
 				}
+				model->SetUniqueId(modelID);
+				model->SetObjectName(className);
+				model->SetFramework(GetFramework());
+				model->SetInitializeType(initialType);
+				model->SetThreadID(threadID);
+				// 使用std::filesystem处理路径
+				std::filesystem::path configPath =
+					std::filesystem::path(modelPath).parent_path() / (className + ".mcfg");
+				model->SetXmlPath(configPath.string());
+
+				// 注册模型到管理器
+				d->ModelMap[modelID] = model;
+
+				// 初始化模型
+				model->Initialize();
+
+				// 注册到线程管理器
+				if (threadID != 0) {
+					auto framework = GetFramework();
+					if (framework) {
+						framework->GetThreadManager()->RegisterFunction(
+							modelID, std::bind(&XNModelObject::StepUpdate, model.get()), threadID,
+							model->GetRunFreq(), model->GetRunNode(), model->GetRunPriority());
+						// 设置模型设置频率
+						double threadFreq =
+							framework->GetThreadManager()->GetThreadFreqByID(threadID);
+						double modelSetFreq = threadFreq / (double)(1 << model->GetRunFreq());
+						model->SetSetFreq(modelSetFreq);
+					}
+				}
 			} else {
-				LOG_WARNING("0x2173 Model %1 Not found in dynamic link library %2!", className,
-							modelPath);
+				LOG_WARNING("0x2173 Model %s Not found in dynamic link library %s!",
+							className.c_str(), modelPath.c_str());
+				dlclose(handle);
+				return;
 			}
 		} else {
-			LOG_WARNING("0x2177 InitialModel function not found in dynamic link library %2!",
-						modelPath);
+			LOG_WARNING("0x2177 InitialModel function not found in dynamic link library %s!",
+						modelPath.c_str());
+			dlclose(handle);
+			return;
 		}
 	} else {
-		LOG_WARNING("0x2172 Model %1 Dynamic link library loading failed! Error: %2", className,
-					lib.errorString());
+		LOG_WARNING("0x2172 Model %s Dynamic link library loading failed! Error: %s",
+					className.c_str(), dlerror());
 	}
 }
 
-void XNModelManager::OnSetBaseFreq(const double &dBaseFreq)
-{
-	Q_D(XNModelManager);
-	d->dBaseFreq = dBaseFreq;
-}
-
 // 模型注册
-quint32 XNModelManager::RegisterModel()
+uint32_t XNModelManager::RegisterModel()
 {
-	Q_D(XNModelManager);
+	T_D();
 	// 从10000～19999的编号中分配ID
 	for (int i = 0; i < 10000; i++) {
 		if (d->ModelIDAssigned[i])
@@ -140,29 +137,32 @@ quint32 XNModelManager::RegisterModel()
 }
 
 // 获取模型指针
-XNModelObject *XNModelManager::GetModel(quint32 modelID)
+XNModelObjectPtr XNModelManager::GetModel(uint32_t modelID)
 {
-	Q_D(XNModelManager);
+	T_D();
 	if (d->ModelIDAssigned[modelID - 10000]) {
-		QList<XNModelObject *> modelList = findChildren<XNModelObject *>();
-		for (auto &model : modelList) {
-			if (model->getUniqueId() == modelID)
-				return model;
+		auto model = d->ModelMap.find(modelID);
+		if (model != d->ModelMap.end()) {
+			return model->second;
 		}
 		return nullptr;
 	} else
 		return nullptr;
 }
 
-void XNModelManager::OnRegisterFunction(quint32 id, XNCallBack fun, quint32 freqGroup,
-										quint32 RunPos, quint32 RunPriorty)
+void XNModelManager::RegisterFunction(uint32_t id, XNCallBack fun, uint32_t threadID,
+									  uint32_t freqGroup, uint32_t RunPos, uint32_t RunPriorty)
 {
-	Q_D(XNModelManager);
+	T_D();
 	if (d->ModelIDAssigned[id - 10000]) {
-		emit RegisterFunction(id, fun, freqGroup, RunPos, RunPriorty);
+		auto framework = GetFramework();
+		if (framework) {
+			framework->GetThreadManager()->RegisterFunction(id, fun, threadID, freqGroup, RunPos,
+															RunPriorty);
+		}
 	} else {
 		LOG_WARNING(
 			"0x2177 Submission of periodic function was rejected, model ID %1 is not registered!",
 			id);
 	}
-}
+}

XNCore/XNModelManager.h

@@ -12,7 +12,9 @@
 #include "XNBaseFrameObject.h"
 
 class XNModelObject;
-class XNModelManagerPrivate;
+XNCLASS_PTR_DECLARE(XNModelObject)
+
+struct XNModelManagerPrivate;
 
 /**
  * @brief 模型管理器类
@@ -20,18 +22,14 @@ class XNModelManagerPrivate;
  */
 class XNModelManager : public XNBaseFrameObject
 {
-	/**
-	 * @brief 使用禁止复制类宏定义自身禁止复制
-	 */
-	Q_OBJECT
-	Q_DECLARE_PRIVATE(XNModelManager)
-	Q_DISABLE_COPY(XNModelManager)
+	XN_METATYPE(XNModelManager, XNBaseFrameObject)
+	XN_DECLARE_PRIVATE(XNModelManager)
 
 public:
 	/**
 	 * @brief 模型管理器类默认构造函数
 	 */
-	explicit XNModelManager(QObject *parent = nullptr);
+	XNModelManager();
 
 	/**
 	 * @brief 模型管理器类默认析构函数
@@ -44,20 +42,20 @@ protected:
 	 * @param p:私有结构体指针
 	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
 	 */
-	XNModelManager(XNModelManagerPrivate &dd, QObject *parent = nullptr);
+	XNModelManager(PrivateType *p);
 
-public slots:
+public:
 	/**
 	 * @brief 系统开始运行前的最后准备工作
 	 * @details	系统运行前模型管理器做最后处理的接口
 	 */
-	virtual void OnPrepareForExecute() override;
+	virtual bool PrepareForExecute() override;
 
 	/**
 	 * @brief 初始化模型管理器
 	 * @details	模型管理器的初始化接口
 	 */
-	virtual void OnInitialize() override;
+	virtual bool Initialize() override;
 
 	/**
 	 * @brief 加载模型
@@ -65,31 +63,23 @@ public slots:
 	 * @param className:	QString类型，模型类名
 	 * @details	加载模型
 	 */
-	void OnLoadModel(const QString &modelPath, const QString &className);
+	void LoadModel(const std::string &modelPath, const std::string &className, uint32_t initialType,
+				   uint32_t threadID);
 
-	/**
-	 * @brief 设置仿真系统运行基频
-	 * @param dBaseFreq:	double类型，频率值，单位Hz
-	 * @details 仿真系统所有线程以此基频的 1 或 1/2 或 1/4 或 1/8 或 1/16 或 1/32 倍运行
-	 */
-	void OnSetBaseFreq(const double &dBaseFreq);
-
-public:
 	/**
 	 * @brief 注册模型信息
 	 * @return UINT32:	模型的全局唯一ID
 	 * @details	模型通过此接口注册自身，并获取自身全局唯一ID
 	 */
-	quint32 RegisterModel();
+	uint32_t RegisterModel();
 
 	/**
 	 * @brief 获取模型指针
 	 * @param modelID:	UINT32类型，模型全局唯一ID
 	 * @return XNModelObjectPtr:	模型基类指针
 	 */
-	XNModelObject *GetModel(quint32 modelID);
+	XNModelObjectPtr GetModel(uint32_t modelID);
 
-public slots:
 	/**
 	 * @brief 注册模型函数
 	 * @param ModelID:	UINT32类型，模型全局唯一ID
@@ -98,22 +88,6 @@ public slots:
 	 * @param RunPos:	UINT32类型，提交的函数运行节点号，<2^(freqGroup)
 	 * @param RunPriorty:	UINT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
 	 */
-	void OnRegisterFunction(quint32 id, XNCallBack fun, quint32 freqGroup, quint32 RunPos,
-							quint32 RunPriorty);
-
-signals:
-	/**
-	 * @brief 注册函数信号
-	 * @param id:	UINT32类型，模型全局唯一ID
-	 * @param fun:	函数指针
-	 * @param freqGroup:	UINT32类型，提交的函数运行频率组，0为基频，1为半频，2为1/4频，3为1/8频，4为1/16频，5为1/32频
-	 * @param RunPos:	UINT32类型，提交的函数运行节点号，<2^(freqGroup)
-	 * @param RunPriorty:	UINT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
-	 */
-	void RegisterFunction(quint32 id, XNCallBack fun, quint32 freqGroup, quint32 RunPos,
-						  quint32 RunPriorty);
-
-	void InitializeSuccess();
-
-	void PrepareForExecuteSuccess();
+	void RegisterFunction(uint32_t id, XNCallBack fun, uint32_t threadID, uint32_t freqGroup,
+						  uint32_t RunPos, uint32_t RunPriorty);
 };

XNCore/XNModelManager_p.h

@@ -1,25 +1,17 @@
 #pragma once
 
 #include "XNBaseFrameObject_p.h"
-#include <QVector>
-#include <QHash>
-
-class XNModelManagerPrivate : public XNBaseFrameObjectPrivate
-{
-public:
-	Q_DECLARE_PUBLIC(XNModelManager)
-
-	explicit XNModelManagerPrivate(XNModelManager *q) : XNBaseFrameObjectPrivate(q) {}
 
+struct XNModelManagerPrivate : public XNBaseFrameObjectPrivate {
+	XNFrameworkPtr framework;
 	/**
 	 * @brief 模型ID库
 	 * @details 所有模型已用ID的存储库
 	 */
-	QVector<bool> ModelIDAssigned;
-
+	std::vector<bool> ModelIDAssigned;
 	/**
-	 * @brief 仿真系统运行基频
-	 * @details 仿真系统所有线程以此基频的 1 或 1/2 或 1/4 或 1/8 或 1/16 或 1/32 倍运行
+	 * @brief 模型ID与模型指针的映射表
+	 * @details 所有模型ID与模型指针的映射表
 	 */
-	double dBaseFreq;
+	std::map<uint32_t, XNModelObjectPtr> ModelMap;
 };

XNCore/XNModelObject.cpp

@@ -15,10 +15,9 @@
 #include "XNModelManager.h"
 #include "XNDDSManager.h"
 #include "XNIDL/XNSimStatusPubSubTypes.hpp"
-#include <QMetaMethod>
 
 // 默认构造函数
-XNModelObject::XNModelObject(QObject *parent) : XNObject(*new XNModelObjectPrivate(this), parent)
+XNModelObject::XNModelObject() : XNObject(new XNModelObjectPrivate())
 {
 }
 
@@ -27,184 +26,284 @@ XNModelObject::~XNModelObject()
 {
 }
 
-XNModelObject::XNModelObject(XNModelObjectPrivate &dd, QObject *parent) : XNObject(dd, parent)
+XNModelObject::XNModelObject(PrivateType *p) : XNObject(p)
 {
 }
 
-// 获取模型描述
-const QString &XNModelObject::GetDescription()
+void XNModelObject::SetFramework(XNFrameworkPtr framework)
 {
-	Q_D(XNModelObject);
+	T_D();
+	d->_framework = framework;
+}
+
+XNFrameworkPtr XNModelObject::GetFramework() const
+{
+	T_D();
+	return d->_framework;
+}
+
+// 获取模型描述
+const std::string &XNModelObject::GetDescription()
+{
+	T_D();
 	return d->_sDescription;
 }
 
 // 设置模型描述
-void XNModelObject::SetDescription(const QString &sDescription)
+void XNModelObject::SetDescription(const std::string &sDescription)
 {
-	Q_D(XNModelObject);
+	T_D();
 	d->_sDescription = sDescription;
 }
 
 // 获取作者
-const QString &XNModelObject::GetAuthor()
+const std::string &XNModelObject::GetAuthor()
 {
-	Q_D(XNModelObject);
+	T_D();
 	return d->_sAuthor;
 }
 
 // 设置作者
-void XNModelObject::SetAuthor(const QString &sAuthor)
+void XNModelObject::SetAuthor(const std::string &sAuthor)
 {
-	Q_D(XNModelObject);
+	T_D();
 	d->_sAuthor = sAuthor;
 }
 
 // 获取模型配置文件路径
-const QString &XNModelObject::GetXmlPath()
+const std::string &XNModelObject::GetXmlPath()
 {
-	Q_D(XNModelObject);
+	T_D();
 	return d->_sXmlPath;
 }
 
 // 设置模型配置文件路径
-void XNModelObject::SetXmlPath(const QString &sXmlPath)
+void XNModelObject::SetXmlPath(const std::string &sXmlPath)
 {
-	Q_D(XNModelObject);
+	T_D();
 	d->_sXmlPath = sXmlPath;
 }
 
 // 获取模型创建时间
-const QDateTime &XNModelObject::GetCreateTime()
+const XNTimePoint &XNModelObject::GetCreateTime()
 {
-	Q_D(XNModelObject);
+	T_D();
 	return d->_cCreatTime;
 }
 
 // 设置模型创建时间
-void XNModelObject::SetCreateTime(const QDateTime &cTime)
+void XNModelObject::SetCreateTime(const XNTimePoint &cTime)
 {
-	Q_D(XNModelObject);
+	T_D();
 	d->_cCreatTime = cTime;
 }
 
 // 获取模型修改时间
-const QDateTime &XNModelObject::GetChangeTime()
+const XNTimePoint &XNModelObject::GetChangeTime()
 {
-	Q_D(XNModelObject);
+	T_D();
 	return d->_cChangeTime;
 }
 
 // 设置模型修改时间
-void XNModelObject::SetChangeTime(const QDateTime &cTime)
+void XNModelObject::SetChangeTime(const XNTimePoint &cTime)
 {
-	Q_D(XNModelObject);
+	T_D();
 	d->_cChangeTime = cTime;
 }
 
 // 获取模型版本号
-const QString &XNModelObject::GetVersion()
+const std::string &XNModelObject::GetVersion()
 {
-	Q_D(XNModelObject);
+	T_D();
 	return d->_sVersion;
 }
 
 // 设置模型版本号
-void XNModelObject::SetVersion(const QString &sVersion)
+void XNModelObject::SetVersion(const std::string &sVersion)
 {
-	Q_D(XNModelObject);
+	T_D();
 	d->_sVersion = sVersion;
 }
 
-void XNModelObject::SetBaseFreq(const double &dBaseFreq)
+void XNModelObject::SetInitializeType(uint32_t initialType)
 {
-	Q_D(XNModelObject);
-	d->_setFreq = dBaseFreq;
+	T_D();
+	d->_initialType = initialType;
+}
+
+void XNModelObject::SetThreadID(uint32_t threadID)
+{
+	T_D();
+	d->_threadID = threadID;
+}
+
+uint32_t XNModelObject::GetThreadID() const
+{
+	T_D();
+	return d->_threadID;
+}
+
+uint32_t XNModelObject::GetRunFreq() const
+{
+	T_D();
+	return d->_runFreq;
+}
+
+void XNModelObject::SetRunFreq(uint32_t runFreq)
+{
+	T_D();
+	d->_runFreq = runFreq;
+}
+
+uint32_t XNModelObject::GetRunNode() const
+{
+	T_D();
+	return d->_runNode;
+}
+
+void XNModelObject::SetRunNode(uint32_t runNode)
+{
+	T_D();
+	d->_runNode = runNode;
+}
+
+uint32_t XNModelObject::GetRunPriority() const
+{
+	T_D();
+	return d->_runPriority;
+}
+
+void XNModelObject::SetRunPriority(uint32_t runPriority)
+{
+	T_D();
+	d->_runPriority = runPriority;
+}
+
+double XNModelObject::GetSetFreq() const
+{
+	T_D();
+	return d->_setFreq;
+}
+
+void XNModelObject::SetSetFreq(double setFreq)
+{
+	T_D();
+	d->_setFreq = setFreq;
 }
 
 // 初始化函数
-void XNModelObject::OnInitialize()
+void XNModelObject::Initialize()
 {
 	// 先尝试调取动态库
-	Q_D(XNModelObject);
-	// 读取配置文件，设置循环执行函数
-	QFile file(GetXmlPath());
-	if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-		LOG_WARNING("0x2161 Failed to open the model configuration file: %1!", GetXmlPath());
-		return;
-	}
-	QDomDocument doc;
-	doc.setContent(&file);
-	QDomElement rootNode = doc.documentElement();
-	// 读取配置文件的模型参数
-	QString modelName = rootNode.firstChildElement("Name").text();
-	if (modelName != objectName()) {
-		LOG_WARNING("0x2162 The model name in the configuration file of model %1 is not consistent "
-					"with the model name in the configuration file of model %2!",
-					objectName(), modelName);
-		return;
-	}
-	d->_sDescription = rootNode.firstChildElement("Description").text();
-	d->_sAuthor		 = rootNode.firstChildElement("Author").text();
-	d->_sVersion	 = rootNode.firstChildElement("Version").text();
-	d->_cCreatTime =
-		QDateTime::fromString(rootNode.firstChildElement("CreateTime").text(), Qt::ISODate);
-	d->_cChangeTime =
-		QDateTime::fromString(rootNode.firstChildElement("ChangeTime").text(), Qt::ISODate);
-	QString funcNode = rootNode.firstChildElement("Node").text();
-	d->_runPriority	 = rootNode.firstChildElement("Priority").text().toInt();
-	// 检查运行节点是否是 "x-x" 形式
-	quint32 tmp = funcNode.indexOf('-');
-	if (tmp <= 0) {
-		LOG_WARNING("0x2162 The value of the run node attribute in the configuration file of model "
-					"%1 is not in the x-x format, registration not executed!",
-					objectName());
-	}
-	d->_runFreq = funcNode.left(tmp).toInt();
-	d->_setFreq = d->_setFreq / pow(2.0, d->_runFreq);
-	d->_runNode = funcNode.right(funcNode.length() - tmp - 1).toInt();
-	// 注册周期性函数
-	emit RegisterFunction(getUniqueId(), std::bind(&XNModelObject::StepUpdate, this), d->_runFreq,
-						  d->_runNode, d->_runPriority);
-	// 加载动态库
-	QString mathlib = rootNode.firstChildElement("MathLib").text();
-	if (mathlib.size() != 0) {
-		d->_sLibPath   = QFileInfo(GetXmlPath()).absolutePath() + "/" + mathlib;
-		d->_dynamicLib = new QLibrary(d->_sLibPath);
-		if (d->_dynamicLib->load()) { // 动态库加载成功
-			LOG_INFO("0x2163 Model %1 loaded algorithm dynamic library %2 successfully!",
-					 objectName(), d->_sLibPath);
-		} else {
-			LOG_WARNING(
-				"0x2160 Model %1 failed to find algorithm dynamic library %2, will not call "
-				"algorithm!",
-				objectName(), d->_sLibPath);
-			delete d->_dynamicLib;
-			d->_dynamicLib = nullptr;
+	T_D();
+	if (d->_initialType == 0) {
+		// 读取配置文件，设置循环执行函数
+		std::ifstream file(GetXmlPath());
+		if (!file.is_open()) {
+			LOG_WARNING("0x2161 Failed to open the model configuration file: %1!", GetXmlPath());
+			return;
+		}
+		tinyxml2::XMLDocument doc;
+		doc.LoadFile(GetXmlPath().c_str());
+		tinyxml2::XMLElement *rootNode = doc.FirstChildElement("Model");
+		if (!rootNode) {
+			LOG_WARNING("0x2161 Failed to parse model configuration file: %1!", GetXmlPath());
+			return;
+		}
+		// 读取配置文件的模型参数
+		const char *modelName = rootNode->FirstChildElement("Name")->GetText();
+		if (!modelName || std::string(modelName) != GetObjectName()) {
+			LOG_WARNING(
+				"0x2162 The model name in the configuration file of model %1 is not consistent "
+				"with the model name in the configuration file of model %2!",
+				GetObjectName(), modelName ? modelName : "null");
+			return;
+		}
+		d->_sDescription = rootNode->FirstChildElement("Description")->GetText();
+		d->_sAuthor		 = rootNode->FirstChildElement("Author")->GetText();
+		d->_sVersion	 = rootNode->FirstChildElement("Version")->GetText();
+
+		// 使用标准C++时间处理
+		std::string createTimeStr = rootNode->FirstChildElement("CreateTime")->GetText();
+		std::string changeTimeStr = rootNode->FirstChildElement("ChangeTime")->GetText();
+		d->_cCreatTime			  = parseISOTime(createTimeStr);
+		d->_cChangeTime			  = parseISOTime(changeTimeStr);
+
+		std::string funcNode = rootNode->FirstChildElement("Node")->GetText();
+		d->_runPriority		 = std::stoi(rootNode->FirstChildElement("Priority")->GetText());
+
+		// 检查运行节点是否是 "x-x" 形式
+		size_t tmp = funcNode.find('-');
+		if (tmp == std::string::npos || tmp == 0) {
+			LOG_WARNING(
+				"0x2162 The value of the run node attribute in the configuration file of model "
+				"%1 is not in the x-x format, registration not executed!",
+				GetObjectName());
+			return;
+		}
+
+		// 使用标准C++字符串处理
+		d->_runFreq = std::stoi(funcNode.substr(0, tmp));
+		d->_runNode = std::stoi(funcNode.substr(tmp + 1));
+
+		// 注册周期性函数
+		auto framework = GetFramework();
+		if (framework) {
+			auto threadManager = framework->GetThreadManager();
+			if (threadManager) {
+				threadManager->RegisterFunction(
+					GetUniqueId(), std::bind(&XNModelObject::StepUpdate, this), d->_threadID,
+					d->_runFreq, d->_runNode, d->_runPriority);
+			}
+		}
+
+		// 加载动态库
+		const char *mathlib = rootNode->FirstChildElement("MathLib")->GetText();
+		if (mathlib && strlen(mathlib) > 0) {
+			// 使用标准C++文件路径处理
+			std::filesystem::path xmlPath(GetXmlPath());
+			d->_sLibPath = xmlPath.parent_path().string() + "/" + mathlib;
+
+			// 使用标准C++动态库加载
+			d->_dynamicLib = dlopen(d->_sLibPath.c_str(), RTLD_LAZY);
+			if (d->_dynamicLib) { // 动态库加载成功
+				LOG_INFO("0x2163 Model %1 loaded algorithm dynamic library %2 successfully!",
+						 GetObjectName(), d->_sLibPath);
+			} else {
+				LOG_WARNING(
+					"0x2160 Model %1 failed to find algorithm dynamic library %2, will not call "
+					"algorithm!",
+					GetObjectName(), d->_sLibPath);
+				d->_dynamicLib = nullptr;
+			}
+		}
+
+		// 处理指令列表
+		tinyxml2::XMLElement *nodeCmds = rootNode->FirstChildElement("CommandList");
+		if (nodeCmds) {
+			for (tinyxml2::XMLElement *nodeCmd = nodeCmds->FirstChildElement("Command");
+				 nodeCmd != nullptr; nodeCmd   = nodeCmd->NextSiblingElement("Command")) {
+				const char *cmdName		   = nodeCmd->Attribute("Name");
+				const char *cmdDescription = nodeCmd->Attribute("Description");
+				const char *cmdCall		   = nodeCmd->Attribute("Call");
+				// TODO: 处理命令列表
+			}
 		}
-	}
-	// TODO 指令列表
-	QDomElement nodeCmds = rootNode.firstChildElement("CommandList");
-	for (QDomElement nodeCmd = nodeCmds.firstChildElement("Command"); !nodeCmd.isNull();
-		 nodeCmd			 = nodeCmd.nextSiblingElement("Command")) {
-		QString cmdName		   = nodeCmd.attribute("Name");
-		QString cmdDescription = nodeCmd.attribute("Description");
-		QString cmdCall		   = nodeCmd.attribute("Call");
 	}
 }
 
 // 单步执行函数
 void XNModelObject::StepUpdate()
 {
-	Q_D(XNModelObject);
-	quint32 setFreq = d->_setFreq < 1.0 ? 1 : (quint32)d->_setFreq;
-	if (d->_dataWriters.contains("XNSim::XNSimStatus::XNModelStatus")
-		&& d->_dataWriters["XNSim::XNSimStatus::XNModelStatus"] != nullptr && d->_runCnt > 0
-		&& d->_runCnt % setFreq == 0) {
+	T_D();
+	uint32_t setFreq = d->_setFreq < 1.0 ? 1 : (uint32_t)d->_setFreq;
+	if (d->_dataWriter != nullptr && d->_runCnt > 0 && d->_runCnt % setFreq == 0) {
 		XNSim::XNSimStatus::XNModelStatus modelStatus;
-		modelStatus.XNModelName(objectName().toStdString());
-		modelStatus.XNModelID(getUniqueId());
+		modelStatus.XNModelName(GetObjectName());
+		modelStatus.XNModelID(GetUniqueId());
 		modelStatus.XNModelSt(1);
-		modelStatus.XNModelThID(pthread_self());
+		modelStatus.XNModelThID(d->_threadID);
 		modelStatus.XNModelNode(d->_runNode);
 		modelStatus.XNModelPro(d->_runPriority);
 		modelStatus.XNModelRunCnt(d->_runCnt);
@@ -214,17 +313,17 @@ void XNModelObject::StepUpdate()
 			(now.tv_sec - d->_lastRunTime.tv_sec) + (now.tv_nsec - d->_lastRunTime.tv_nsec) / 1.0E9;
 		modelStatus.XNMdlCurFreq(d->_setFreq / time_diff);
 		modelStatus.XNMdlSetFreq(d->_setFreq);
-		d->_dataWriters["XNSim::XNSimStatus::XNModelStatus"]->write(&modelStatus);
+		d->_dataWriter->write(&modelStatus);
 		d->_lastRunTime = now;
-		LOG_DEBUG("Model: %1 Write DDS!", objectName());
+		LOG_DEBUG("Model: %1 Write DDS!", GetObjectName());
 	}
 	d->_runCnt++;
 }
 
 // 运行前最后准备函数
-void XNModelObject::OnPrepareForExecute()
+void XNModelObject::PrepareForExecute()
 {
-	Q_D(XNModelObject);
+	T_D();
 	d->_runCnt = 0;
 	// 注册DDS
 	RegisterDDSParticipant();
@@ -233,49 +332,53 @@ void XNModelObject::OnPrepareForExecute()
 
 void XNModelObject::RegisterDDSParticipant()
 {
-	Q_D(XNModelObject);
-	XNModelManager *modelManager = qobject_cast<XNModelManager *>(parent());
-	if (modelManager == nullptr)
+	T_D();
+	auto framework = GetFramework();
+	if (framework == nullptr) {
+		LOG_WARNING("Failed to get Framework!");
 		return;
-	XNDDSManager *ddsManager = modelManager->parent()->findChild<XNDDSManager *>();
-	if (ddsManager == nullptr)
+	}
+	auto ddsManager = framework->GetDDSManager();
+	if (ddsManager == nullptr) {
+		LOG_WARNING("Failed to get DDSManager!");
 		return;
-	quint32 MyID = getUniqueId();
-	XN_PUBLISHTOPIC(XNSim::XNSimStatus::XNModelStatus);
+	}
+	uint32_t MyID  = GetUniqueId();
+	d->_dataWriter = ddsManager->RegisterPublisher<XNSim::XNSimStatus::XNModelStatusPubSubType>(
+		"XNSim::XNSimStatus::XNModelStatus", MyID);
 }
 
-int XNModelObject::RegisterEventHandler(const QString &eventName,
-										std::function<void(const QVariant &)> callback, bool async,
-										XNEvent::Priority priority)
+int XNModelObject::RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
+										bool async, XNEvent::Priority priority)
 {
 	// 获取事件管理器
-	XNModelManager *modelManager = qobject_cast<XNModelManager *>(parent());
-	if (modelManager == nullptr) {
-		LOG_WARNING("Failed to get ModelManager!");
+	auto framework = GetFramework();
+	if (framework == nullptr) {
+		LOG_WARNING("Failed to get Framework!");
 		return -1;
 	}
 
-	XNEventManager *eventManager = modelManager->parent()->findChild<XNEventManager *>();
+	XNEventManagerPtr eventManager = framework->GetEventManager();
 	if (eventManager == nullptr) {
 		LOG_WARNING("Failed to get EventManager!");
 		return -1;
 	}
 
 	// 注册事件处理器
-	return eventManager->RegisterEventHandler(eventName, callback, getUniqueId(), async, priority);
+	return eventManager->RegisterEventHandler(eventName, callback, GetUniqueId(), async, priority);
 }
 
-void XNModelObject::TriggerEvent(const QString &eventName, const QVariant &eventData,
+void XNModelObject::TriggerEvent(const std::string &eventName, const std::any &eventData,
 								 bool forceAsync, XNEvent::Priority priority)
 {
 	// 获取事件管理器
-	XNModelManager *modelManager = qobject_cast<XNModelManager *>(parent());
-	if (modelManager == nullptr) {
-		LOG_WARNING("Failed to get ModelManager!");
+	auto framework = GetFramework();
+	if (framework == nullptr) {
+		LOG_WARNING("Failed to get Framework!");
 		return;
 	}
 
-	XNEventManager *eventManager = modelManager->parent()->findChild<XNEventManager *>();
+	XNEventManagerPtr eventManager = framework->GetEventManager();
 	if (eventManager == nullptr) {
 		LOG_WARNING("Failed to get EventManager!");
 		return;

XNCore/XNModelObject.h

@@ -12,7 +12,7 @@
 #include "XNObject.h"
 #include "XNEventManager.h"
 
-class XNModelObjectPrivate;
+struct XNModelObjectPrivate;
 
 /**
  * @brief 模型基类
@@ -20,22 +20,14 @@ class XNModelObjectPrivate;
  */
 class XNModelObject : public XNObject
 {
-	Q_OBJECT
-	Q_DISABLE_COPY(XNModelObject)
-	Q_DECLARE_PRIVATE(XNModelObject)
-
-	Q_PROPERTY(QString description READ GetDescription WRITE SetDescription)
-	Q_PROPERTY(QString author READ GetAuthor WRITE SetAuthor)
-	Q_PROPERTY(QString xmlPath READ GetXmlPath WRITE SetXmlPath)
-	Q_PROPERTY(QDateTime createTime READ GetCreateTime WRITE SetCreateTime)
-	Q_PROPERTY(QDateTime changeTime READ GetChangeTime WRITE SetChangeTime)
-	Q_PROPERTY(QString version READ GetVersion WRITE SetVersion)
+	XN_METATYPE(XNModelObject, XNObject)
+	XN_DECLARE_PRIVATE(XNModelObject)
 
 public:
 	/**
 	 * @brief 模型基类默认构造函数
 	 */
-	XNModelObject(QObject *parent = nullptr);
+	XNModelObject();
 
 	/**
 	 * @brief 模型基类默认析构函数
@@ -45,89 +37,137 @@ public:
 protected:
 	/**
 	 * @brief 模型基类带参构造函数
-	 * @param dd:XNModelObjectPrivate类型，私有结构体指针
-	 * @param parent:QObject类型，父对象指针
+	 * @param p:XNModelObjectPrivate类型，私有结构体指针
 	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
 	 */
-	XNModelObject(XNModelObjectPrivate &dd, QObject *parent = nullptr);
+	XNModelObject(PrivateType *p);
+
+public:
+	void SetFramework(XNFrameworkPtr framework);
+
+protected:
+	XNFrameworkPtr GetFramework() const;
 
 public:
 	/**
 	 * @brief 获取模型描述
 	 * @return const QString&:模型描述
 	 */
-	const QString &GetDescription();
+	const std::string &GetDescription();
 
 	/**
 	 * @brief 设置模型描述
 	 * @param sDescription:QString类型，模型描述
 	 */
-	void SetDescription(const QString &sDescription);
+	void SetDescription(const std::string &sDescription);
 
 	/**
 	 * @brief 获取作者
 	 * @return const QString&:	作者
 	 */
-	const QString &GetAuthor();
+	const std::string &GetAuthor();
 
 	/**
 	 * @brief 设置作者
 	 * @param sAuthor:	QString类型，作者
 	 */
-	void SetAuthor(const QString &sAuthor);
+	void SetAuthor(const std::string &sAuthor);
 
 	/**
 	 * @brief 获取模型配置文件路径
 	 * @return const QString&:	模型配置文件路径
 	 */
-	const QString &GetXmlPath();
+	const std::string &GetXmlPath();
 
 	/**
 	 * @brief 设置模型配置文件路径
 	 * @param sXmlPath:QString类型，模型配置文件路径
 	 */
-	void SetXmlPath(const QString &sXmlPath);
+	void SetXmlPath(const std::string &sXmlPath);
 
 	/**
 	 * @brief 获取模型创建时间
-	 * @return const QDateTime&:模型创建时间
+	 * @return const XNTimePoint&:模型创建时间
 	 */
-	const QDateTime &GetCreateTime();
+	const XNTimePoint &GetCreateTime();
 
 	/**
 	 * @brief 设置模型创建时间
-	 * @param cTime:	QDateTime类型，模型创建时间
+	 * @param cTime:	XNTimePoint类型，模型创建时间
 	 */
-	void SetCreateTime(const QDateTime &cTime);
+	void SetCreateTime(const XNTimePoint &cTime);
 
 	/**
 	 * @brief 获取模型修改时间
-	 * @return const QDateTime&:模型修改时间
+	 * @return const XNTimePoint&:模型修改时间
 	 */
-	const QDateTime &GetChangeTime();
+	const XNTimePoint &GetChangeTime();
 
 	/**
 	 * @brief 设置模型修改时间
-	 * @param cTime:	QDateTime类型，模型修改时间
+	 * @param cTime:	XNTimePoint类型，模型修改时间
 	 */
-	void SetChangeTime(const QDateTime &cTime);
+	void SetChangeTime(const XNTimePoint &cTime);
 
 	/**
 	 * @brief 获取模型版本号
 	 * @return const XNString&:	模型版本号
 	 */
-	const QString &GetVersion();
-	/**
-	 * @brief 设置模型版本号
-	 * @param sVersion:	QString类型，模型版本号
-	 */
-	void SetVersion(const QString &sVersion);
+	const std::string &GetVersion();
 
 	/**
-	 * @brief 设置仿真系统运行基频
-	 * @param dBaseFreq:	double类型，频率值，单位Hz
+	 * @brief 设置模型版本号
+	 * @param sVersion:	std::string类型，模型版本号
 	 */
-	void SetBaseFreq(const double &dBaseFreq);
+	void SetVersion(const std::string &sVersion);
+
+	/**
+	 * @brief 获取模型运行频率组
+	 * @return uint32_t:	模型运行频率组
+	 */
+	uint32_t GetRunFreq() const;
+
+	/**
+	 * @brief 设置模型运行频率组
+	 * @param runFreq:	uint32_t类型，模型运行频率组
+	 */
+	void SetRunFreq(uint32_t runFreq);
+
+	/**
+	 * @brief 获取模型运行节点
+	 * @return uint32_t:	模型运行节点
+	 */
+	uint32_t GetRunNode() const;
+
+	/**
+	 * @brief 设置模型运行节点
+	 * @param runNode:	uint32_t类型，模型运行节点
+	 */
+	void SetRunNode(uint32_t runNode);
+
+	/**
+	 * @brief 获取模型运行优先级
+	 * @return uint32_t:	模型运行优先级
+	 */
+	uint32_t GetRunPriority() const;
+
+	/**
+	 * @brief 设置模型运行优先级
+	 * @param runPriority:	uint32_t类型，模型运行优先级
+	 */
+	void SetRunPriority(uint32_t runPriority);
+
+	/**
+	 * @brief 获取模型设置频率
+	 * @return double:	模型设置频率
+	 */
+	double GetSetFreq() const;
+
+	/**
+	 * @brief 设置模型设置频率
+	 * @param setFreq:	double类型，模型设置频率
+	 */
+	void SetSetFreq(double setFreq);
 
 	/**
 	 * @brief 单步执行函数
@@ -142,8 +182,8 @@ public:
 	 * @param async: 是否异步处理
 	 * @return: 返回处理器ID，失败返回-1
 	 */
-	int RegisterEventHandler(const QString &eventName,
-							 std::function<void(const QVariant &)> callback, bool async = false,
+	int RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
+							 bool async					= false,
 							 XNEvent::Priority priority = XNEvent::Priority::Normal);
 
 	/**
@@ -152,7 +192,7 @@ public:
 	 * @param eventData: 事件携带的数据
 	 * @param forceAsync: 强制异步处理
 	 */
-	void TriggerEvent(const QString &eventName, const QVariant &eventData = QVariant(),
+	void TriggerEvent(const std::string &eventName, const std::any &eventData = std::any(),
 					  bool forceAsync			 = false,
 					  XNEvent::Priority priority = XNEvent::Priority::Normal);
 
@@ -162,8 +202,7 @@ public:
 	 * @param callback: 事件处理回调函数
 	 * @return: 返回处理器ID，失败返回-1
 	 */
-	int RegisterRTEventHandler(const QString &eventName,
-							   std::function<void(const QVariant &)> callback)
+	int RegisterRTEventHandler(const std::string &eventName, XNEventCallback callback)
 	{
 		return RegisterEventHandler(eventName, callback, true, XNEvent::Priority::RealTime);
 	}
@@ -173,64 +212,37 @@ public:
 	 * @param eventName: 要触发的事件名称
 	 * @param eventData: 事件携带的数据
 	 */
-	void TriggerRTEvent(const QString &eventName, const QVariant &eventData = QVariant())
+	void TriggerRTEvent(const std::string &eventName, const std::any &eventData = std::any())
 	{
 		TriggerEvent(eventName, eventData, true, XNEvent::Priority::RealTime);
 	}
 
-signals:
-	/**
-	 * @brief 			注册周期性执行的函数
-	 * @param id:		quint32类型，模型ID
-	 * @param fun:		QFunctionPointer类型，需要提交的函数的包装
-	 * @param freqGroup:UINT32类型，提交的函数运行频率组，0为基频，1为半频，2为1/4频，3为1/8频，4为1/16频，5为1/32频
-	 * @param RunPos:	UINT32类型，提交的函数运行节点号，<2^(freqGroup)
-	 * @param RunPriorty:INT32类型，提交的函数运行优先级，99～0，优先级数值越大，优先级越高
-	 * @details 向线程管理器添加要周期性执行的函数
-	 */
-	void RegisterFunction(quint32 id, XNCallBack fun, quint32 freqGroup, quint32 RunPos,
-						  quint32 RunPriorty);
+	void SetInitializeType(uint32_t initialType);
+
+	void SetThreadID(uint32_t threadID);
+
+	uint32_t GetThreadID() const;
 
-public slots:
 	/**
 	 * @brief 初始化函数
 	 * @details
 	 * 模型的初始化函数接口，子类继承时要调用父类初始化接口，或在此函数中使用AddMyFunction方法注册需要被线程调用的函数
 	 */
-	virtual void OnInitialize();
+	virtual void Initialize();
 
 	/**
 	 * @brief 仿真系统运行前做最后处理
 	 * @details	系统运行前模型做最后处理的接口
 	 */
-	virtual void OnPrepareForExecute();
+	virtual void PrepareForExecute();
 
 public:
 	virtual void RegisterDDSParticipant();
 };
 
-#define XN_DECLARE_DDS()                                                                           \
-public:                                                                                            \
-	virtual void RegisterDDSParticipant() override;
-
-#define XN_REGISTER_PARTICIPANT_BEGIN(class)                                                       \
-	void class ::RegisterDDSParticipant()                                                          \
+#define XN_MODEL_INITIALIZE(ClassName)                                                             \
+	extern "C" XNModelObjectPtr Initial##ClassName()                                               \
 	{                                                                                              \
-		XNModelObject::RegisterDDSParticipant();                                                   \
-		Q_D(class);                                                                                \
-		XNModelManager *modelManager = qobject_cast<XNModelManager *>(parent());                   \
-		if (modelManager == nullptr)                                                               \
-			return;                                                                                \
-		XNDDSManager *ddsManager = modelManager->parent()->findChild<XNDDSManager *>();            \
-		if (ddsManager == nullptr)                                                                 \
-			return;                                                                                \
-		quint32 MyID = getUniqueId();
-
-#define XN_PUBLISHTOPIC(topic)                                                                     \
-	d->_dataWriters[#topic] = ddsManager->RegisterPublisher<topic##PubSubType>(#topic, MyID);
-
-#define XN_SUBSCRIBETOPIC(topic, fun)                                                              \
-	ddsManager->RegisterSubscriber<topic##PubSubType>(                                             \
-		#topic, MyID, std::bind(fun, this, std::placeholders::_1));
-
-#define XN_REGISTER_PARTICIPANT_END(class) }
+		ClassName##Ptr obj = std::make_shared<ClassName>();                                        \
+		return obj;                                                                                \
+	}