接口动态库自动生成功能已经实现

Release/IDL/C909_V1/ATA04/Aerodynamics_input.cxx

@@ -0,0 +1,77 @@
+#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);
+	this->header[0] = 0xa6; // XNSim头，0xa6
+	this->header[1] = 0xc0; // 机型头，0xc0表示C909
+	this->header[2] = 0x04; // 章节头，0x04表示ATA04
+	this->header[3] = 0x01; // 模型头，0x01表示GroundHandling
+	this->header[4] = 0x00; // 结构体头，0x00表示输入结构体
+	this->header[5] = 0x00; // 数据方向，0x00表示外部输入
+	this->header[6] = 0x00; // 数据大小
+	this->header[7] = 0x00; // 数据大小
+}
+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,86 @@
+#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)
+	{
+		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;
+		clearOutData();
+		assign_value_set(data.l_04_i_aerocomac_alpha_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_alpdot_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_beta_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_press_alt_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_tas_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_mach_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_nx_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_ny_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_nz_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_p_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_q_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_r_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_qbar_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_blcg_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_bscg_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_wlcg_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_ail_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_elv_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_rud_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_stab_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_gear_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_flap_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_slat_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_spl_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_tnet_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_kice_f8(), model_data->Aerodynamics_input);
+		assign_value_set(data.l_04_i_aerocomac_alt_agl_f8(), model_data->Aerodynamics_input);
+	}
+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,63 @@
+#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);
+	this->header[0] = 0xa6; // XNSim头，0xa6
+	this->header[1] = 0xc0; // 机型头，0xc0表示C909
+	this->header[2] = 0x04; // 章节头，0x04表示ATA04
+	this->header[3] = 0x01; // 模型头，0x01表示GroundHandling
+	this->header[4] = 0x00; // 结构体头，0x00表示输入结构体
+	this->header[5] = 0x00; // 数据方向，0x00表示外部输入
+	this->header[6] = 0x00; // 数据大小
+	this->header[7] = 0x00; // 数据大小
+}
+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,58 @@
+#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)
+	{
+		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;
+		clearOutData();
+		assign_value_set(data.l_04_o_aerocomac_fxb_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_fyb_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_fzb_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_mxb_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_myb_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_mzb_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_cls_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_cl_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_cd_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_cm_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_cr_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_cy_f8(), model_data->Aerodynamics_output);
+		assign_value_set(data.l_04_o_aerocomac_cn_f8(), model_data->Aerodynamics_output);
+	}
+private:
+	XNSim::C909::ATA04::Aerodynamics_output data;
+	XNSim::C909::ATA04::Aerodynamics_output out_data;
+};
+}

Release/IDL/C909_V1/ATA04/GroundHandling_heartbeat.cxx

@@ -1,65 +0,0 @@
-#include "GroundHandling_heartbeat.hpp"
-
-namespace XNSim::C909::ATA04
-{
-GroundHandling_heartbeat_Interface::GroundHandling_heartbeat_Interface()
-{
-	MAP_DATA_FUNC(groundhandling_model_heartbeat);
-	this->header[0] = 0xa6; // XNSim头，0xa6
-	this->header[1] = 0xc0; // 机型头，0xc0表示C909
-	this->header[2] = 0x04; // 章节头，0x04表示ATA04
-	this->header[3] = 0x01; // 模型头，0x01表示GroundHandling
-	this->header[4] = 0x02; // 结构体头，0x02表示心跳结构体
-	this->header[5] = 0x00; // 数据方向，0x00表示外部输入
-	this->header[6] = 0x00; // 数据大小
-	this->header[7] = 0x00; // 数据大小
-}
-
-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::heartbeatListener, 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::heartbeatListener, 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()
-{
-	dataWriter->write(&this->out_data);
-}
-
-void GroundHandling_heartbeat_Interface::heartbeatListener(
-	const XNSim::C909::ATA04::GroundHandling_heartbeat &heartbeat)
-{
-	this->data = heartbeat;
-}
-} // namespace XNSim::C909::ATA04

Release/IDL/C909_V1/ATA04/GroundHandling_heartbeat.hpp

@@ -1,39 +0,0 @@
-#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;
-	void heartbeatListener(const XNSim::C909::ATA04::GroundHandling_heartbeat &heartbeat);
-	virtual void clearOutData() override;
-	virtual void sendOutData() override;
-	template <typename T>
-	void getData(T *model_data)
-	{
-		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;
-		clearOutData();
-		assign_value_set(data.groundhandling_model_heartbeat(),
-						 model_data->groundhandling_model_heartbeat);
-		sendOutData();
-	}
-
-private:
-	XNSim::C909::ATA04::GroundHandling_heartbeat data;
-	XNSim::C909::ATA04::GroundHandling_heartbeat out_data;
-};
-} // namespace XNSim::C909::ATA04

Release/IDL/C909_V1/ATA04/GroundHandling_input.cxx

@@ -1,5 +1,4 @@
 #include "GroundHandling_input.hpp"
-
 namespace XNSim::C909::ATA04
 {
 GroundHandling_input_Interface::GroundHandling_input_Interface()
@@ -52,52 +51,39 @@ GroundHandling_input_Interface::GroundHandling_input_Interface()
 	this->header[6] = 0x00; // 数据大小
 	this->header[7] = 0x00; // 数据大小
 }
-
 GroundHandling_input_Interface::~GroundHandling_input_Interface()
 {
 }
-
+void GroundHandling_input_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
-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) { // 读取与发送都进行
+	if (DDS_type == 0) {
-		dataWriter =
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_inputPubSubType>("XNSim::C909::ATA04::GroundHandling_input", modelId);
-			ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_inputPubSubType>(
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_inputPubSubType>("XNSim::C909::ATA04::GroundHandling_input", modelId, std::bind(&GroundHandling_input_Interface::inputDataListener, this, std::placeholders::_1));
-				"XNSim::C909::ATA04::GroundHandling_input", modelId);
+	}
-		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_inputPubSubType>(
+	else if (DDS_type == 1) {
-			"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));
-			std::bind(&GroundHandling_input_Interface::inputDataListener, this,
+	}
-					  std::placeholders::_1));
+	else if (DDS_type == 2) {
-	} else if (DDS_type == 1) { // 只读取
+		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 == 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()
 {
-	dataWriter->write(&this->out_data);
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
 }
-
+void GroundHandling_input_Interface::inputDataListener(const XNSim::C909::ATA04::GroundHandling_input &input)
-void GroundHandling_input_Interface::inputDataListener(
-	const XNSim::C909::ATA04::GroundHandling_input &input)
 {
 	this->data = input;
 }
-} // namespace XNSim::C909::ATA04
+}

Release/IDL/C909_V1/ATA04/GroundHandling_input.hpp

@@ -1,6 +1,6 @@
+#pragma once
 #include "../C909_V1PubSubTypes.hpp"
 #include "XNCore/XNDDSInterface.h"
-
 namespace XNSim::C909::ATA04
 {
 class GroundHandling_input_Interface final : public XNDDSInterface
@@ -8,16 +8,14 @@ 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)
 	{
-		if (model_data == nullptr)
+		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);
@@ -32,110 +30,81 @@ public:
 		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(),
+		assign_value_get(data.l_04_i_gdcomac_pb_active_l1(), model_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_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(),
+		assign_value_get(data.l_04_i_gdcomac_tire_pres_f8(), model_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(),
+		assign_value_get(data.l_04_i_gdcomac_reset_braketemp_l1(), model_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_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(),
+		assign_value_get(data.l_04_i_gdcomac_brake_temp_f8(), model_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_tburst_l1(),
+		assign_value_get(data.l_04_i_gdcomac_tire_tflat_l1(), model_data->l_04_i_gdcomac_tire_tflat_l1);
-						 model_data->l_04_i_gdcomac_tire_tburst_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_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(),
+		assign_value_get(data.l_04_i_gdcomac_pb_towforce_f8(), model_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_gsteer_state_i4(),
+		assign_value_get(data.l_04_i_gdcomac_trim_active_l1(), model_data->l_04_i_gdcomac_trim_active_l1);
-						 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(),
+		assign_value_get(data.l_04_i_gdcomac_theta_deg_f8(), model_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)
+		if(model_data == nullptr)
 			return;
 		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_frz_l1(), model_data->GroundHandling_input);
-		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_chocks_l1(), model_data->GroundHandling_input);
-		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_alt_agl_f8(), model_data->GroundHandling_input);
-		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_frzflt_l1(), model_data->GroundHandling_input);
-		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_p_f8(), model_data->GroundHandling_input);
-		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_q_f8(), model_data->GroundHandling_input);
-		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_r_f8(), model_data->GroundHandling_input);
-		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_ug_f8(), model_data->GroundHandling_input);
-		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_vg_f8(), model_data->GroundHandling_input);
-		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_wg_f8(), model_data->GroundHandling_input);
-		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_blcg_f8(), model_data->GroundHandling_input);
-		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_bscg_f8(), model_data->GroundHandling_input);
-		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_wlcg_f8(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_pb_active_l1(),
+		assign_value_set(data.l_04_i_gdcomac_pb_active_l1(), model_data->GroundHandling_input);
-						 model_data->l_04_i_gdcomac_pb_active_l1);
+		assign_value_set(data.l_04_i_gdcomac_brake_torq_f8(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_brake_torq_f8(),
+		assign_value_set(data.l_04_i_gdcomac_gear_f8(), model_data->GroundHandling_input);
-						 model_data->l_04_i_gdcomac_brake_torq_f8);
+		assign_value_set(data.l_04_i_gdcomac_gsteer_f8(), model_data->GroundHandling_input);
-		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_tire_pres_f8(), model_data->GroundHandling_input);
-		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_onjax_l1(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_tire_pres_f8(),
+		assign_value_set(data.l_04_i_gdcomac_contdep_f8(), model_data->GroundHandling_input);
-						 model_data->l_04_i_gdcomac_tire_pres_f8);
+		assign_value_set(data.l_04_i_gdcomac_thetag_f8(), model_data->GroundHandling_input);
-		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_phig_f8(), model_data->GroundHandling_input);
-		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_rwyrgh_i2(), model_data->GroundHandling_input);
-		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_rwyhdg_f8(), model_data->GroundHandling_input);
-		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_reset_braketemp_l1(), model_data->GroundHandling_input);
-		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_reset_tirepress_l1(), model_data->GroundHandling_input);
-		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_temp_c_f8(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_reset_braketemp_l1(),
+		assign_value_set(data.l_04_i_gdcomac_brake_temp_f8(), model_data->GroundHandling_input);
-						 model_data->l_04_i_gdcomac_reset_braketemp_l1);
+		assign_value_set(data.l_04_i_gdcomac_tire_tburst_l1(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_reset_tirepress_l1(),
+		assign_value_set(data.l_04_i_gdcomac_tire_tflat_l1(), model_data->GroundHandling_input);
-						 model_data->l_04_i_gdcomac_reset_tirepress_l1);
+		assign_value_set(data.l_04_i_gdcomac_brk_reset_tpres_l1(), model_data->GroundHandling_input);
-		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_rcon_ci_f8(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_brake_temp_f8(),
+		assign_value_set(data.l_04_i_gdcomac_pb_towforce_f8(), model_data->GroundHandling_input);
-						 model_data->l_04_i_gdcomac_brake_temp_f8);
+		assign_value_set(data.l_04_i_gdcomac_gsteer_state_i4(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_tire_tburst_l1(),
+		assign_value_set(data.l_04_i_gdcomac_trim_active_l1(), model_data->GroundHandling_input);
-						 model_data->l_04_i_gdcomac_tire_tburst_l1);
+		assign_value_set(data.l_04_i_gdcomac_phi_deg_f8(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_tire_tflat_l1(),
+		assign_value_set(data.l_04_i_gdcomac_theta_deg_f8(), model_data->GroundHandling_input);
-						 model_data->l_04_i_gdcomac_tire_tflat_l1);
+		assign_value_set(data.l_04_i_gdcomac_psi_deg_f8(), model_data->GroundHandling_input);
-		assign_value_set(data.l_04_i_gdcomac_brk_reset_tpres_l1(),
+		assign_value_set(data.l_04_i_gdcomac_resetint_l1(), model_data->GroundHandling_input);
-						 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);
-		sendOutData();
 	}
-
 private:
 	XNSim::C909::ATA04::GroundHandling_input data;
 	XNSim::C909::ATA04::GroundHandling_input out_data;
 };
-} // namespace XNSim::C909::ATA04
+}

Release/IDL/C909_V1/ATA04/GroundHandling_output.cxx

@@ -1,5 +1,4 @@
 #include "GroundHandling_output.hpp"
-
 namespace XNSim::C909::ATA04
 {
 GroundHandling_output_Interface::GroundHandling_output_Interface()
@@ -38,62 +37,48 @@ GroundHandling_output_Interface::GroundHandling_output_Interface()
 	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);
-	MAP_DATA_FUNC(l_04_o_gdcomac_vczt_f8);
 	this->header[0] = 0xa6; // XNSim头，0xa6
 	this->header[1] = 0xc0; // 机型头，0xc0表示C909
 	this->header[2] = 0x04; // 章节头，0x04表示ATA04
 	this->header[3] = 0x01; // 模型头，0x01表示GroundHandling
-	this->header[4] = 0x01; // 结构体头，0x01表示输出结构体
+	this->header[4] = 0x00; // 结构体头，0x00表示输入结构体
 	this->header[5] = 0x00; // 数据方向，0x00表示外部输入
 	this->header[6] = 0x00; // 数据大小
 	this->header[7] = 0x00; // 数据大小
 }
-
 GroundHandling_output_Interface::~GroundHandling_output_Interface()
 {
 }
-
+void GroundHandling_output_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)
-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) { // 读取与发送都进行
+	if (DDS_type == 0) {
-		dataWriter =
+		dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_outputPubSubType>("XNSim::C909::ATA04::GroundHandling_output", modelId);
-			ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_outputPubSubType>(
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_outputPubSubType>("XNSim::C909::ATA04::GroundHandling_output", modelId, std::bind(&GroundHandling_output_Interface::inputDataListener, this, std::placeholders::_1));
-				"XNSim::C909::ATA04::GroundHandling_output", modelId);
+	}
-		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_outputPubSubType>(
+	else if (DDS_type == 1) {
-			"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));
-			std::bind(&GroundHandling_output_Interface::outputDataListener, this,
+	}
-					  std::placeholders::_1));
+	else if (DDS_type == 2) {
-	} else if (DDS_type == 1) { // 只读取
+		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::outputDataListener, 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()
 {
-	dataWriter->write(&this->out_data);
+	if (dataWriter) {
+		dataWriter->write(&this->out_data);
+	}
 }
-
+void GroundHandling_output_Interface::inputDataListener(const XNSim::C909::ATA04::GroundHandling_output &input)
-void GroundHandling_output_Interface::outputDataListener(
-	const XNSim::C909::ATA04::GroundHandling_output &output)
 {
-	this->data = output;
+	this->data = input;
+}
 }
-} // namespace XNSim::C909::ATA04

Release/IDL/C909_V1/ATA04/GroundHandling_output.hpp

@@ -1,6 +1,6 @@
+#pragma once
 #include "../C909_V1PubSubTypes.hpp"
 #include "XNCore/XNDDSInterface.h"
-
 namespace XNSim::C909::ATA04
 {
 class GroundHandling_output_Interface final : public XNDDSInterface
@@ -9,22 +9,19 @@ public:
 	GroundHandling_output_Interface();
 	virtual ~GroundHandling_output_Interface();
 	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
-	void outputDataListener(const XNSim::C909::ATA04::GroundHandling_output &output);
 	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)
 	{
-		if (model_data == nullptr)
+		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(),
+		assign_value_get(data.l_04_o_gdcomac_ac_on_ground_l1(), model_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_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(),
+		assign_value_get(data.l_04_o_gdcomac_zcg_to_tire_f8(), model_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);
@@ -41,83 +38,63 @@ public:
 		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(),
+		assign_value_get(data.l_04_o_gdcomac_distngrxcg_f8(), model_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_distmgrxcg_f8(),
+		assign_value_get(data.l_04_o_gdcomac_distmgrzcg_f8(), model_data->l_04_o_gdcomac_distmgrzcg_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(),
+		assign_value_get(data.l_04_o_gdcomac_tire_burst_l1(), model_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_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(),
+		assign_value_get(data.l_04_o_gdcomac_whl_omega_f8(), model_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);
-		assign_value_get(data.l_04_o_gdcomac_vczt_f8(), model_data->l_04_o_gdcomac_vczt_f8);
 	}
-
 	template <typename T>
 	void setData(T *model_data)
 	{
-		if (model_data == nullptr)
+		if(model_data == nullptr)
 			return;
 		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_frz_l1(), model_data->GroundHandling_output);
-		assign_value_set(data.l_04_o_gdcomac_ac_on_ground_l1(),
+		assign_value_set(data.l_04_o_gdcomac_ac_on_ground_l1(), model_data->GroundHandling_output);
-						 model_data->l_04_o_gdcomac_ac_on_ground_l1);
+		assign_value_set(data.l_04_o_gdcomac_ac_stationary_f8(), model_data->GroundHandling_output);
-		assign_value_set(data.l_04_o_gdcomac_ac_stationary_f8(),
+		assign_value_set(data.l_04_o_gdcomac_alt_tire_f8(), model_data->GroundHandling_output);
-						 model_data->l_04_o_gdcomac_ac_stationary_f8);
+		assign_value_set(data.l_04_o_gdcomac_zcg_to_tire_f8(), model_data->GroundHandling_output);
-		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_fxb_f8(), model_data->GroundHandling_output);
-		assign_value_set(data.l_04_o_gdcomac_zcg_to_tire_f8(),
+		assign_value_set(data.l_04_o_gdcomac_fyb_f8(), model_data->GroundHandling_output);
-						 model_data->l_04_o_gdcomac_zcg_to_tire_f8);
+		assign_value_set(data.l_04_o_gdcomac_fzb_f8(), model_data->GroundHandling_output);
-		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_mxb_f8(), model_data->GroundHandling_output);
-		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_myb_f8(), model_data->GroundHandling_output);
-		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_mzb_f8(), model_data->GroundHandling_output);
-		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_fygs_f8(), model_data->GroundHandling_output);
-		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_mzgs_f8(), model_data->GroundHandling_output);
-		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_mu_f8(), model_data->GroundHandling_output);
-		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_dstroke_f8(), model_data->GroundHandling_output);
-		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_sr_f8(), model_data->GroundHandling_output);
-		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_sy_f8(), model_data->GroundHandling_output);
-		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_sx_f8(), model_data->GroundHandling_output);
-		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_xft_f8(), model_data->GroundHandling_output);
-		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_yft_f8(), model_data->GroundHandling_output);
-		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_zft_f8(), model_data->GroundHandling_output);
-		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_distngrxcg_f8(), model_data->GroundHandling_output);
-		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_distmgrxcg_f8(), model_data->GroundHandling_output);
-		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_distmgrzcg_f8(), model_data->GroundHandling_output);
-		assign_value_set(data.l_04_o_gdcomac_distngrxcg_f8(),
+		assign_value_set(data.l_04_o_gdcomac_tire_vel_f8(), model_data->GroundHandling_output);
-						 model_data->l_04_o_gdcomac_distngrxcg_f8);
+		assign_value_set(data.l_04_o_gdcomac_tire_burst_l1(), model_data->GroundHandling_output);
-		assign_value_set(data.l_04_o_gdcomac_distmgrxcg_f8(),
+		assign_value_set(data.l_04_o_gdcomac_tire_temp_f8(), model_data->GroundHandling_output);
-						 model_data->l_04_o_gdcomac_distmgrxcg_f8);
+		assign_value_set(data.l_04_o_gdcomac_wow_l1(), model_data->GroundHandling_output);
-		assign_value_set(data.l_04_o_gdcomac_distmgrzcg_f8(),
+		assign_value_set(data.l_04_o_gdcomac_utirew_f8(), model_data->GroundHandling_output);
-						 model_data->l_04_o_gdcomac_distmgrzcg_f8);
+		assign_value_set(data.l_04_o_gdcomac_vtirew_f8(), model_data->GroundHandling_output);
-		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_whl_omega_f8(), model_data->GroundHandling_output);
-		assign_value_set(data.l_04_o_gdcomac_tire_burst_l1(),
+		assign_value_set(data.l_04_o_gdcomac_dstruc_f8(), model_data->GroundHandling_output);
-						 model_data->l_04_o_gdcomac_tire_burst_l1);
+		assign_value_set(data.l_04_o_gdcomac_wor_par_f8(), model_data->GroundHandling_output);
-		assign_value_set(data.l_04_o_gdcomac_tire_temp_f8(),
+		assign_value_set(data.l_04_o_gdcomac_nd_f8(), model_data->GroundHandling_output);
-						 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);
-		assign_value_set(data.l_04_o_gdcomac_vczt_f8(), model_data->l_04_o_gdcomac_vczt_f8);
-		sendOutData();
 	}
-
 private:
 	XNSim::C909::ATA04::GroundHandling_output data;
 	XNSim::C909::ATA04::GroundHandling_output out_data;
 };
-} // namespace XNSim::C909::ATA04
+}

Release/IDL/C909_V1/ATA04/WeightBalance_input.cxx

@@ -0,0 +1,73 @@
+#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);
+	this->header[0] = 0xa6; // XNSim头，0xa6
+	this->header[1] = 0xc0; // 机型头，0xc0表示C909
+	this->header[2] = 0x04; // 章节头，0x04表示ATA04
+	this->header[3] = 0x01; // 模型头，0x01表示GroundHandling
+	this->header[4] = 0x00; // 结构体头，0x00表示输入结构体
+	this->header[5] = 0x00; // 数据方向，0x00表示外部输入
+	this->header[6] = 0x00; // 数据大小
+	this->header[7] = 0x00; // 数据大小
+}
+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,78 @@
+#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)
+	{
+		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;
+		clearOutData();
+		assign_value_set(data.l_04_i_wbcomac_theta_deg_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_gear_mode_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_acset_gw_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_acset_cg_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_acset_tankfuel_f4(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_acset_totfuel_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_acset_zfw_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_acset_zfwcg_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_eng_efsep_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_fuel_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_gear_avg_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_kice_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_bycglim_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_bygwlim_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_frz_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_zcgfrz_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_zcgfrz_grfx_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_ycgfrz_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_inertfrz_l1(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_potreq_gw_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_potreq_gwcg_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_phi_deg_f8(), model_data->WeightBalance_input);
+		assign_value_set(data.l_04_i_wbcomac_psi_deg_f8(), model_data->WeightBalance_input);
+	}
+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,106 @@
+#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);
+	this->header[0] = 0xa6; // XNSim头，0xa6
+	this->header[1] = 0xc0; // 机型头，0xc0表示C909
+	this->header[2] = 0x04; // 章节头，0x04表示ATA04
+	this->header[3] = 0x01; // 模型头，0x01表示GroundHandling
+	this->header[4] = 0x00; // 结构体头，0x00表示输入结构体
+	this->header[5] = 0x00; // 数据方向，0x00表示外部输入
+	this->header[6] = 0x00; // 数据大小
+	this->header[7] = 0x00; // 数据大小
+}
+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,144 @@
+#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)
+	{
+		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;
+		clearOutData();
+		assign_value_set(data.l_04_o_wbcomac_frz_l1(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_zcgfrz_l1(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_zcgfrz_grfx_l1(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ycgfrz_l1(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_inertfrz_l1(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_gw_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_cg_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_blcg_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_bscg_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_wlcg_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_xcg_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ixx_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ixy_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ixz_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_iyy_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_iyz_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_izz_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_zfw_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_zfwcg_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_zfw_blcg_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_zfw_wlcg_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_fuel_cmd_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_fuel_mode_i4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_fuel_ixx_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_fuel_ixy_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_fuel_ixz_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_fuel_iyy_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_fuel_iyz_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_fuel_izz_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_l_wt_fuel_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_airframe_total_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_eng_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_eng_total_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_fuselage_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_stab_left_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_stab_right_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_stab_total_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_total_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_total_frac_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_vert_tail_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_wing_left_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_wing_right_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_ice_wing_total_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_init_l1(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_potmin_gw_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_potmax_gw_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_potmin_gwcg_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_potmax_gwcg_f8(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_min_cg_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_min_gw_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_min_zfw_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_min_zfwcg_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_max_cg_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_max_gw_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_max_zfw_f4(), model_data->WeightBalance_output);
+		assign_value_set(data.l_04_o_wbcomac_max_zfwcg_f4(), model_data->WeightBalance_output);
+	}
+private:
+	XNSim::C909::ATA04::WeightBalance_output data;
+	XNSim::C909::ATA04::WeightBalance_output out_data;
+};
+}

Release/IDL/C909_V1/C909_V1.idl

@@ -34,26 +34,6 @@ module XNSim
 				@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
-			{
-				@optional long aero_model_heartbeat;
-			};
 			struct GroundHandling_input
 			{
 				@optional char l_04_i_gdcomac_frz_l1;
@@ -72,7 +52,7 @@ module XNSim
 				@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_gsteer_f8;
 				@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];
@@ -132,11 +112,22 @@ module XNSim
 				@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
+			struct Aerodynamics_output
 			{
-				@optional long groundhandling_model_heartbeat;
+				@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
 			{
@@ -223,10 +214,6 @@ module XNSim
 				@optional float l_04_o_wbcomac_max_zfw_f4;
 				@optional float l_04_o_wbcomac_max_zfwcg_f4;
 			};
-			struct WeightBalance_heartbeat
-			{
-				@optional long weightbody_model_heartbeat;
-			};
 		};
 	};
 };

Release/IDL/C909_V1/C909_V1CdrAux.hpp

@@ -24,22 +24,16 @@
 
 #include "C909_V1.hpp"
 
-constexpr uint32_t XNSim_C909_ATA04_GroundHandling_input_max_cdr_typesize {1093UL};
+constexpr uint32_t XNSim_C909_ATA04_GroundHandling_input_max_cdr_typesize {1021UL};
 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_GroundHandling_output_max_cdr_typesize {1264UL};
-constexpr uint32_t XNSim_C909_ATA04_WeightBalance_heartbeat_max_key_cdr_typesize {0UL};
-
-constexpr uint32_t XNSim_C909_ATA04_GroundHandling_output_max_cdr_typesize {1328UL};
 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};
@@ -48,9 +42,6 @@ constexpr uint32_t XNSim_C909_ATA04_WeightBalance_input_max_key_cdr_typesize {0U
 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 {
@@ -62,14 +53,6 @@ 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::Aerodynamics_output& data);
-
-eProsima_user_DllExport void serialize_key(
-        eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::Aerodynamics_heartbeat& data);
-
 eProsima_user_DllExport void serialize_key(
         eprosima::fastcdr::Cdr& scdr,
         const XNSim::C909::ATA04::GroundHandling_input& data);
@@ -80,7 +63,7 @@ eProsima_user_DllExport void serialize_key(
 
 eProsima_user_DllExport void serialize_key(
         eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::GroundHandling_heartbeat& data);
+        const XNSim::C909::ATA04::Aerodynamics_output& data);
 
 eProsima_user_DllExport void serialize_key(
         eprosima::fastcdr::Cdr& scdr,
@@ -90,10 +73,6 @@ 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::WeightBalance_heartbeat& data);
-
 
 } // namespace fastcdr
 } // namespace eprosima

Release/IDL/C909_V1/C909_V1CdrAux.ipp

@@ -461,340 +461,6 @@ void serialize_key(
 }
 
 
-template<>
-eProsima_user_DllExport size_t calculate_serialized_size(
-        eprosima::fastcdr::CdrSizeCalculator& calculator,
-        const XNSim::C909::ATA04::Aerodynamics_output& data,
-        size_t& current_alignment)
-{
-    using namespace XNSim::C909::ATA04;
-
-    static_cast<void>(data);
-
-    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
-    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
-                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
-                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
-                                current_alignment)};
-
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
-                data.l_04_o_aerocomac_fxb_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
-                data.l_04_o_aerocomac_fyb_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2),
-                data.l_04_o_aerocomac_fzb_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3),
-                data.l_04_o_aerocomac_mxb_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4),
-                data.l_04_o_aerocomac_myb_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5),
-                data.l_04_o_aerocomac_mzb_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(6),
-                data.l_04_o_aerocomac_cls_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(7),
-                data.l_04_o_aerocomac_cl_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(8),
-                data.l_04_o_aerocomac_cd_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(9),
-                data.l_04_o_aerocomac_cm_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(10),
-                data.l_04_o_aerocomac_cr_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(11),
-                data.l_04_o_aerocomac_cy_f8(), current_alignment);
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(12),
-                data.l_04_o_aerocomac_cn_f8(), current_alignment);
-
-
-    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);
-
-    return calculated_size;
-}
-
-template<>
-eProsima_user_DllExport void serialize(
-        eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::Aerodynamics_output& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    eprosima::fastcdr::Cdr::state current_state(scdr);
-    scdr.begin_serialize_type(current_state,
-            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
-            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);
-
-    scdr
-        << eprosima::fastcdr::MemberId(0) << data.l_04_o_aerocomac_fxb_f8()
-        << eprosima::fastcdr::MemberId(1) << data.l_04_o_aerocomac_fyb_f8()
-        << eprosima::fastcdr::MemberId(2) << data.l_04_o_aerocomac_fzb_f8()
-        << eprosima::fastcdr::MemberId(3) << data.l_04_o_aerocomac_mxb_f8()
-        << eprosima::fastcdr::MemberId(4) << data.l_04_o_aerocomac_myb_f8()
-        << eprosima::fastcdr::MemberId(5) << data.l_04_o_aerocomac_mzb_f8()
-        << eprosima::fastcdr::MemberId(6) << data.l_04_o_aerocomac_cls_f8()
-        << eprosima::fastcdr::MemberId(7) << data.l_04_o_aerocomac_cl_f8()
-        << eprosima::fastcdr::MemberId(8) << data.l_04_o_aerocomac_cd_f8()
-        << eprosima::fastcdr::MemberId(9) << data.l_04_o_aerocomac_cm_f8()
-        << eprosima::fastcdr::MemberId(10) << data.l_04_o_aerocomac_cr_f8()
-        << eprosima::fastcdr::MemberId(11) << data.l_04_o_aerocomac_cy_f8()
-        << eprosima::fastcdr::MemberId(12) << data.l_04_o_aerocomac_cn_f8()
-;
-    scdr.end_serialize_type(current_state);
-}
-
-template<>
-eProsima_user_DllExport void deserialize(
-        eprosima::fastcdr::Cdr& cdr,
-        XNSim::C909::ATA04::Aerodynamics_output& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
-            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
-            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
-            {
-                bool ret_value = true;
-                switch (mid.id)
-                {
-                                        case 0:
-                                                dcdr >> data.l_04_o_aerocomac_fxb_f8();
-                                            break;
-
-                                        case 1:
-                                                dcdr >> data.l_04_o_aerocomac_fyb_f8();
-                                            break;
-
-                                        case 2:
-                                                dcdr >> data.l_04_o_aerocomac_fzb_f8();
-                                            break;
-
-                                        case 3:
-                                                dcdr >> data.l_04_o_aerocomac_mxb_f8();
-                                            break;
-
-                                        case 4:
-                                                dcdr >> data.l_04_o_aerocomac_myb_f8();
-                                            break;
-
-                                        case 5:
-                                                dcdr >> data.l_04_o_aerocomac_mzb_f8();
-                                            break;
-
-                                        case 6:
-                                                dcdr >> data.l_04_o_aerocomac_cls_f8();
-                                            break;
-
-                                        case 7:
-                                                dcdr >> data.l_04_o_aerocomac_cl_f8();
-                                            break;
-
-                                        case 8:
-                                                dcdr >> data.l_04_o_aerocomac_cd_f8();
-                                            break;
-
-                                        case 9:
-                                                dcdr >> data.l_04_o_aerocomac_cm_f8();
-                                            break;
-
-                                        case 10:
-                                                dcdr >> data.l_04_o_aerocomac_cr_f8();
-                                            break;
-
-                                        case 11:
-                                                dcdr >> data.l_04_o_aerocomac_cy_f8();
-                                            break;
-
-                                        case 12:
-                                                dcdr >> data.l_04_o_aerocomac_cn_f8();
-                                            break;
-
-                    default:
-                        ret_value = false;
-                        break;
-                }
-                return ret_value;
-            });
-}
-
-void serialize_key(
-        eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::Aerodynamics_output& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    static_cast<void>(scdr);
-    static_cast<void>(data);
-                        if (data.l_04_o_aerocomac_fxb_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_fxb_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_fyb_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_fyb_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_fzb_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_fzb_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_mxb_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_mxb_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_myb_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_myb_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_mzb_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_mzb_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_cls_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_cls_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_cl_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_cl_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_cd_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_cd_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_cm_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_cm_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_cr_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_cr_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_cy_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_cy_f8().value();
-                        }
-
-                        if (data.l_04_o_aerocomac_cn_f8().has_value())
-                        {
-                            scdr << data.l_04_o_aerocomac_cn_f8().value();
-                        }
-
-}
-
-
-template<>
-eProsima_user_DllExport size_t calculate_serialized_size(
-        eprosima::fastcdr::CdrSizeCalculator& calculator,
-        const XNSim::C909::ATA04::Aerodynamics_heartbeat& data,
-        size_t& current_alignment)
-{
-    using namespace XNSim::C909::ATA04;
-
-    static_cast<void>(data);
-
-    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
-    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
-                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
-                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
-                                current_alignment)};
-
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
-                data.aero_model_heartbeat(), current_alignment);
-
-
-    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);
-
-    return calculated_size;
-}
-
-template<>
-eProsima_user_DllExport void serialize(
-        eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::Aerodynamics_heartbeat& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    eprosima::fastcdr::Cdr::state current_state(scdr);
-    scdr.begin_serialize_type(current_state,
-            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
-            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);
-
-    scdr
-        << eprosima::fastcdr::MemberId(0) << data.aero_model_heartbeat()
-;
-    scdr.end_serialize_type(current_state);
-}
-
-template<>
-eProsima_user_DllExport void deserialize(
-        eprosima::fastcdr::Cdr& cdr,
-        XNSim::C909::ATA04::Aerodynamics_heartbeat& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
-            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
-            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
-            {
-                bool ret_value = true;
-                switch (mid.id)
-                {
-                                        case 0:
-                                                dcdr >> data.aero_model_heartbeat();
-                                            break;
-
-                    default:
-                        ret_value = false;
-                        break;
-                }
-                return ret_value;
-            });
-}
-
-void serialize_key(
-        eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::Aerodynamics_heartbeat& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    static_cast<void>(scdr);
-    static_cast<void>(data);
-                        if (data.aero_model_heartbeat().has_value())
-                        {
-                            scdr << data.aero_model_heartbeat().value();
-                        }
-
-}
-
-
 template<>
 eProsima_user_DllExport size_t calculate_serialized_size(
         eprosima::fastcdr::CdrSizeCalculator& calculator,
@@ -1498,9 +1164,6 @@ eProsima_user_DllExport size_t calculate_serialized_size(
         calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(33),
                 data.l_04_o_gdcomac_nd_f8(), current_alignment);
 
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(34),
-                data.l_04_o_gdcomac_vczt_f8(), current_alignment);
-
 
     calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);
 
@@ -1555,7 +1218,6 @@ eProsima_user_DllExport void serialize(
         << eprosima::fastcdr::MemberId(31) << data.l_04_o_gdcomac_dstruc_f8()
         << eprosima::fastcdr::MemberId(32) << data.l_04_o_gdcomac_wor_par_f8()
         << eprosima::fastcdr::MemberId(33) << data.l_04_o_gdcomac_nd_f8()
-        << eprosima::fastcdr::MemberId(34) << data.l_04_o_gdcomac_vczt_f8()
 ;
     scdr.end_serialize_type(current_state);
 }
@@ -1711,10 +1373,6 @@ eProsima_user_DllExport void deserialize(
                                                 dcdr >> data.l_04_o_gdcomac_nd_f8();
                                             break;
 
-                                        case 34:
-                                                dcdr >> data.l_04_o_gdcomac_vczt_f8();
-                                            break;
-
                     default:
                         ret_value = false;
                         break;
@@ -1901,18 +1559,13 @@ void serialize_key(
                             scdr << data.l_04_o_gdcomac_nd_f8().value();
                         }
 
-                        if (data.l_04_o_gdcomac_vczt_f8().has_value())
-                        {
-                            scdr << data.l_04_o_gdcomac_vczt_f8().value();
-                        }
-
 }
 
 
 template<>
 eProsima_user_DllExport size_t calculate_serialized_size(
         eprosima::fastcdr::CdrSizeCalculator& calculator,
-        const XNSim::C909::ATA04::GroundHandling_heartbeat& data,
+        const XNSim::C909::ATA04::Aerodynamics_output& data,
         size_t& current_alignment)
 {
     using namespace XNSim::C909::ATA04;
@@ -1928,7 +1581,43 @@ eProsima_user_DllExport size_t calculate_serialized_size(
 
 
         calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
-                data.groundhandling_model_heartbeat(), current_alignment);
+                data.l_04_o_aerocomac_fxb_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
+                data.l_04_o_aerocomac_fyb_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2),
+                data.l_04_o_aerocomac_fzb_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3),
+                data.l_04_o_aerocomac_mxb_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4),
+                data.l_04_o_aerocomac_myb_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5),
+                data.l_04_o_aerocomac_mzb_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(6),
+                data.l_04_o_aerocomac_cls_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(7),
+                data.l_04_o_aerocomac_cl_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(8),
+                data.l_04_o_aerocomac_cd_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(9),
+                data.l_04_o_aerocomac_cm_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(10),
+                data.l_04_o_aerocomac_cr_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(11),
+                data.l_04_o_aerocomac_cy_f8(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(12),
+                data.l_04_o_aerocomac_cn_f8(), current_alignment);
 
 
     calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);
@@ -1939,7 +1628,7 @@ eProsima_user_DllExport size_t calculate_serialized_size(
 template<>
 eProsima_user_DllExport void serialize(
         eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::GroundHandling_heartbeat& data)
+        const XNSim::C909::ATA04::Aerodynamics_output& data)
 {
     using namespace XNSim::C909::ATA04;
 
@@ -1950,7 +1639,19 @@ eProsima_user_DllExport void serialize(
             eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);
 
     scdr
-        << eprosima::fastcdr::MemberId(0) << data.groundhandling_model_heartbeat()
+        << eprosima::fastcdr::MemberId(0) << data.l_04_o_aerocomac_fxb_f8()
+        << eprosima::fastcdr::MemberId(1) << data.l_04_o_aerocomac_fyb_f8()
+        << eprosima::fastcdr::MemberId(2) << data.l_04_o_aerocomac_fzb_f8()
+        << eprosima::fastcdr::MemberId(3) << data.l_04_o_aerocomac_mxb_f8()
+        << eprosima::fastcdr::MemberId(4) << data.l_04_o_aerocomac_myb_f8()
+        << eprosima::fastcdr::MemberId(5) << data.l_04_o_aerocomac_mzb_f8()
+        << eprosima::fastcdr::MemberId(6) << data.l_04_o_aerocomac_cls_f8()
+        << eprosima::fastcdr::MemberId(7) << data.l_04_o_aerocomac_cl_f8()
+        << eprosima::fastcdr::MemberId(8) << data.l_04_o_aerocomac_cd_f8()
+        << eprosima::fastcdr::MemberId(9) << data.l_04_o_aerocomac_cm_f8()
+        << eprosima::fastcdr::MemberId(10) << data.l_04_o_aerocomac_cr_f8()
+        << eprosima::fastcdr::MemberId(11) << data.l_04_o_aerocomac_cy_f8()
+        << eprosima::fastcdr::MemberId(12) << data.l_04_o_aerocomac_cn_f8()
 ;
     scdr.end_serialize_type(current_state);
 }
@@ -1958,7 +1659,7 @@ eProsima_user_DllExport void serialize(
 template<>
 eProsima_user_DllExport void deserialize(
         eprosima::fastcdr::Cdr& cdr,
-        XNSim::C909::ATA04::GroundHandling_heartbeat& data)
+        XNSim::C909::ATA04::Aerodynamics_output& data)
 {
     using namespace XNSim::C909::ATA04;
 
@@ -1971,7 +1672,55 @@ eProsima_user_DllExport void deserialize(
                 switch (mid.id)
                 {
                                         case 0:
-                                                dcdr >> data.groundhandling_model_heartbeat();
+                                                dcdr >> data.l_04_o_aerocomac_fxb_f8();
+                                            break;
+
+                                        case 1:
+                                                dcdr >> data.l_04_o_aerocomac_fyb_f8();
+                                            break;
+
+                                        case 2:
+                                                dcdr >> data.l_04_o_aerocomac_fzb_f8();
+                                            break;
+
+                                        case 3:
+                                                dcdr >> data.l_04_o_aerocomac_mxb_f8();
+                                            break;
+
+                                        case 4:
+                                                dcdr >> data.l_04_o_aerocomac_myb_f8();
+                                            break;
+
+                                        case 5:
+                                                dcdr >> data.l_04_o_aerocomac_mzb_f8();
+                                            break;
+
+                                        case 6:
+                                                dcdr >> data.l_04_o_aerocomac_cls_f8();
+                                            break;
+
+                                        case 7:
+                                                dcdr >> data.l_04_o_aerocomac_cl_f8();
+                                            break;
+
+                                        case 8:
+                                                dcdr >> data.l_04_o_aerocomac_cd_f8();
+                                            break;
+
+                                        case 9:
+                                                dcdr >> data.l_04_o_aerocomac_cm_f8();
+                                            break;
+
+                                        case 10:
+                                                dcdr >> data.l_04_o_aerocomac_cr_f8();
+                                            break;
+
+                                        case 11:
+                                                dcdr >> data.l_04_o_aerocomac_cy_f8();
+                                            break;
+
+                                        case 12:
+                                                dcdr >> data.l_04_o_aerocomac_cn_f8();
                                             break;
 
                     default:
@@ -1984,15 +1733,75 @@ eProsima_user_DllExport void deserialize(
 
 void serialize_key(
         eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::GroundHandling_heartbeat& data)
+        const XNSim::C909::ATA04::Aerodynamics_output& data)
 {
     using namespace XNSim::C909::ATA04;
 
     static_cast<void>(scdr);
     static_cast<void>(data);
-                        if (data.groundhandling_model_heartbeat().has_value())
+                        if (data.l_04_o_aerocomac_fxb_f8().has_value())
                         {
-                            scdr << data.groundhandling_model_heartbeat().value();
+                            scdr << data.l_04_o_aerocomac_fxb_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_fyb_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_fyb_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_fzb_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_fzb_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_mxb_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_mxb_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_myb_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_myb_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_mzb_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_mzb_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_cls_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_cls_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_cl_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_cl_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_cd_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_cd_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_cm_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_cm_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_cr_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_cr_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_cy_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_cy_f8().value();
+                        }
+
+                        if (data.l_04_o_aerocomac_cn_f8().has_value())
+                        {
+                            scdr << data.l_04_o_aerocomac_cn_f8().value();
                         }
 
 }
@@ -3177,95 +2986,6 @@ void serialize_key(
 }
 
 
-template<>
-eProsima_user_DllExport size_t calculate_serialized_size(
-        eprosima::fastcdr::CdrSizeCalculator& calculator,
-        const XNSim::C909::ATA04::WeightBalance_heartbeat& data,
-        size_t& current_alignment)
-{
-    using namespace XNSim::C909::ATA04;
-
-    static_cast<void>(data);
-
-    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
-    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
-                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
-                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
-                                current_alignment)};
-
-
-        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
-                data.weightbody_model_heartbeat(), current_alignment);
-
-
-    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);
-
-    return calculated_size;
-}
-
-template<>
-eProsima_user_DllExport void serialize(
-        eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::WeightBalance_heartbeat& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    eprosima::fastcdr::Cdr::state current_state(scdr);
-    scdr.begin_serialize_type(current_state,
-            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
-            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);
-
-    scdr
-        << eprosima::fastcdr::MemberId(0) << data.weightbody_model_heartbeat()
-;
-    scdr.end_serialize_type(current_state);
-}
-
-template<>
-eProsima_user_DllExport void deserialize(
-        eprosima::fastcdr::Cdr& cdr,
-        XNSim::C909::ATA04::WeightBalance_heartbeat& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
-            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
-            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
-            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
-            {
-                bool ret_value = true;
-                switch (mid.id)
-                {
-                                        case 0:
-                                                dcdr >> data.weightbody_model_heartbeat();
-                                            break;
-
-                    default:
-                        ret_value = false;
-                        break;
-                }
-                return ret_value;
-            });
-}
-
-void serialize_key(
-        eprosima::fastcdr::Cdr& scdr,
-        const XNSim::C909::ATA04::WeightBalance_heartbeat& data)
-{
-    using namespace XNSim::C909::ATA04;
-
-    static_cast<void>(scdr);
-    static_cast<void>(data);
-                        if (data.weightbody_model_heartbeat().has_value())
-                        {
-                            scdr << data.weightbody_model_heartbeat().value();
-                        }
-
-}
-
-
 
 } // namespace fastcdr
 } // namespace eprosima

Release/IDL/C909_V1/C909_V1PubSubTypes.cxx

@@ -216,370 +216,6 @@ namespace XNSim {
                 register_Aerodynamics_input_type_identifier(type_identifiers_);
             }
 
-            Aerodynamics_outputPubSubType::Aerodynamics_outputPubSubType()
-            {
-                set_name("XNSim::C909::ATA04::Aerodynamics_output");
-                uint32_t type_size = XNSim_C909_ATA04_Aerodynamics_output_max_cdr_typesize;
-                type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
-                max_serialized_type_size = type_size + 4; /*encapsulation*/
-                is_compute_key_provided = false;
-                uint32_t key_length = XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize > 16 ? XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize : 16;
-                key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
-                memset(key_buffer_, 0, key_length);
-            }
-
-            Aerodynamics_outputPubSubType::~Aerodynamics_outputPubSubType()
-            {
-                if (key_buffer_ != nullptr)
-                {
-                    free(key_buffer_);
-                }
-            }
-
-            bool Aerodynamics_outputPubSubType::serialize(
-                    const void* const data,
-                    SerializedPayload_t& payload,
-                    DataRepresentationId_t data_representation)
-            {
-                const Aerodynamics_output* p_type = static_cast<const Aerodynamics_output*>(data);
-
-                // Object that manages the raw buffer.
-                eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
-                // Object that serializes the data.
-                eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-                        data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                        eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
-                payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
-                ser.set_encoding_flag(
-                    data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                    eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR  :
-                    eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
-
-                try
-                {
-                    // Serialize encapsulation
-                    ser.serialize_encapsulation();
-                    // Serialize the object.
-                    ser << *p_type;
-                    ser.set_dds_cdr_options({0,0});
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return false;
-                }
-
-                // Get the serialized length
-                payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
-                return true;
-            }
-
-            bool Aerodynamics_outputPubSubType::deserialize(
-                    SerializedPayload_t& payload,
-                    void* data)
-            {
-                try
-                {
-                    // Convert DATA to pointer of your type
-                    Aerodynamics_output* p_type = static_cast<Aerodynamics_output*>(data);
-
-                    // Object that manages the raw buffer.
-                    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
-
-                    // Object that deserializes the data.
-                    eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
-
-                    // Deserialize encapsulation.
-                    deser.read_encapsulation();
-                    payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
-
-                    // Deserialize the object.
-                    deser >> *p_type;
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return false;
-                }
-
-                return true;
-            }
-
-            uint32_t Aerodynamics_outputPubSubType::calculate_serialized_size(
-                    const void* const data,
-                    DataRepresentationId_t data_representation)
-            {
-                try
-                {
-                    eprosima::fastcdr::CdrSizeCalculator calculator(
-                        data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                        eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
-                    size_t current_alignment {0};
-                    return static_cast<uint32_t>(calculator.calculate_serialized_size(
-                                *static_cast<const Aerodynamics_output*>(data), current_alignment)) +
-                            4u /*encapsulation*/;
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return 0;
-                }
-            }
-
-            void* Aerodynamics_outputPubSubType::create_data()
-            {
-                return reinterpret_cast<void*>(new Aerodynamics_output());
-            }
-
-            void Aerodynamics_outputPubSubType::delete_data(
-                    void* data)
-            {
-                delete(reinterpret_cast<Aerodynamics_output*>(data));
-            }
-
-            bool Aerodynamics_outputPubSubType::compute_key(
-                    SerializedPayload_t& payload,
-                    InstanceHandle_t& handle,
-                    bool force_md5)
-            {
-                if (!is_compute_key_provided)
-                {
-                    return false;
-                }
-
-                Aerodynamics_output data;
-                if (deserialize(payload, static_cast<void*>(&data)))
-                {
-                    return compute_key(static_cast<void*>(&data), handle, force_md5);
-                }
-
-                return false;
-            }
-
-            bool Aerodynamics_outputPubSubType::compute_key(
-                    const void* const data,
-                    InstanceHandle_t& handle,
-                    bool force_md5)
-            {
-                if (!is_compute_key_provided)
-                {
-                    return false;
-                }
-
-                const Aerodynamics_output* p_type = static_cast<const Aerodynamics_output*>(data);
-
-                // Object that manages the raw buffer.
-                eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
-                        XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize);
-
-                // Object that serializes the data.
-                eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
-                ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
-                eprosima::fastcdr::serialize_key(ser, *p_type);
-                if (force_md5 || XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize > 16)
-                {
-                    md5_.init();
-                    md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
-                    md5_.finalize();
-                    for (uint8_t i = 0; i < 16; ++i)
-                    {
-                        handle.value[i] = md5_.digest[i];
-                    }
-                }
-                else
-                {
-                    for (uint8_t i = 0; i < 16; ++i)
-                    {
-                        handle.value[i] = key_buffer_[i];
-                    }
-                }
-                return true;
-            }
-
-            void Aerodynamics_outputPubSubType::register_type_object_representation()
-            {
-                register_Aerodynamics_output_type_identifier(type_identifiers_);
-            }
-
-            Aerodynamics_heartbeatPubSubType::Aerodynamics_heartbeatPubSubType()
-            {
-                set_name("XNSim::C909::ATA04::Aerodynamics_heartbeat");
-                uint32_t type_size = XNSim_C909_ATA04_Aerodynamics_heartbeat_max_cdr_typesize;
-                type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
-                max_serialized_type_size = type_size + 4; /*encapsulation*/
-                is_compute_key_provided = false;
-                uint32_t key_length = XNSim_C909_ATA04_Aerodynamics_heartbeat_max_key_cdr_typesize > 16 ? XNSim_C909_ATA04_Aerodynamics_heartbeat_max_key_cdr_typesize : 16;
-                key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
-                memset(key_buffer_, 0, key_length);
-            }
-
-            Aerodynamics_heartbeatPubSubType::~Aerodynamics_heartbeatPubSubType()
-            {
-                if (key_buffer_ != nullptr)
-                {
-                    free(key_buffer_);
-                }
-            }
-
-            bool Aerodynamics_heartbeatPubSubType::serialize(
-                    const void* const data,
-                    SerializedPayload_t& payload,
-                    DataRepresentationId_t data_representation)
-            {
-                const Aerodynamics_heartbeat* p_type = static_cast<const Aerodynamics_heartbeat*>(data);
-
-                // Object that manages the raw buffer.
-                eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
-                // Object that serializes the data.
-                eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-                        data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                        eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
-                payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
-                ser.set_encoding_flag(
-                    data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                    eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR  :
-                    eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
-
-                try
-                {
-                    // Serialize encapsulation
-                    ser.serialize_encapsulation();
-                    // Serialize the object.
-                    ser << *p_type;
-                    ser.set_dds_cdr_options({0,0});
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return false;
-                }
-
-                // Get the serialized length
-                payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
-                return true;
-            }
-
-            bool Aerodynamics_heartbeatPubSubType::deserialize(
-                    SerializedPayload_t& payload,
-                    void* data)
-            {
-                try
-                {
-                    // Convert DATA to pointer of your type
-                    Aerodynamics_heartbeat* p_type = static_cast<Aerodynamics_heartbeat*>(data);
-
-                    // Object that manages the raw buffer.
-                    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
-
-                    // Object that deserializes the data.
-                    eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
-
-                    // Deserialize encapsulation.
-                    deser.read_encapsulation();
-                    payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
-
-                    // Deserialize the object.
-                    deser >> *p_type;
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return false;
-                }
-
-                return true;
-            }
-
-            uint32_t Aerodynamics_heartbeatPubSubType::calculate_serialized_size(
-                    const void* const data,
-                    DataRepresentationId_t data_representation)
-            {
-                try
-                {
-                    eprosima::fastcdr::CdrSizeCalculator calculator(
-                        data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                        eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
-                    size_t current_alignment {0};
-                    return static_cast<uint32_t>(calculator.calculate_serialized_size(
-                                *static_cast<const Aerodynamics_heartbeat*>(data), current_alignment)) +
-                            4u /*encapsulation*/;
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return 0;
-                }
-            }
-
-            void* Aerodynamics_heartbeatPubSubType::create_data()
-            {
-                return reinterpret_cast<void*>(new Aerodynamics_heartbeat());
-            }
-
-            void Aerodynamics_heartbeatPubSubType::delete_data(
-                    void* data)
-            {
-                delete(reinterpret_cast<Aerodynamics_heartbeat*>(data));
-            }
-
-            bool Aerodynamics_heartbeatPubSubType::compute_key(
-                    SerializedPayload_t& payload,
-                    InstanceHandle_t& handle,
-                    bool force_md5)
-            {
-                if (!is_compute_key_provided)
-                {
-                    return false;
-                }
-
-                Aerodynamics_heartbeat data;
-                if (deserialize(payload, static_cast<void*>(&data)))
-                {
-                    return compute_key(static_cast<void*>(&data), handle, force_md5);
-                }
-
-                return false;
-            }
-
-            bool Aerodynamics_heartbeatPubSubType::compute_key(
-                    const void* const data,
-                    InstanceHandle_t& handle,
-                    bool force_md5)
-            {
-                if (!is_compute_key_provided)
-                {
-                    return false;
-                }
-
-                const Aerodynamics_heartbeat* p_type = static_cast<const Aerodynamics_heartbeat*>(data);
-
-                // Object that manages the raw buffer.
-                eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
-                        XNSim_C909_ATA04_Aerodynamics_heartbeat_max_key_cdr_typesize);
-
-                // Object that serializes the data.
-                eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
-                ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
-                eprosima::fastcdr::serialize_key(ser, *p_type);
-                if (force_md5 || XNSim_C909_ATA04_Aerodynamics_heartbeat_max_key_cdr_typesize > 16)
-                {
-                    md5_.init();
-                    md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
-                    md5_.finalize();
-                    for (uint8_t i = 0; i < 16; ++i)
-                    {
-                        handle.value[i] = md5_.digest[i];
-                    }
-                }
-                else
-                {
-                    for (uint8_t i = 0; i < 16; ++i)
-                    {
-                        handle.value[i] = key_buffer_[i];
-                    }
-                }
-                return true;
-            }
-
-            void Aerodynamics_heartbeatPubSubType::register_type_object_representation()
-            {
-                register_Aerodynamics_heartbeat_type_identifier(type_identifiers_);
-            }
-
             GroundHandling_inputPubSubType::GroundHandling_inputPubSubType()
             {
                 set_name("XNSim::C909::ATA04::GroundHandling_input");
@@ -944,19 +580,19 @@ namespace XNSim {
                 register_GroundHandling_output_type_identifier(type_identifiers_);
             }
 
-            GroundHandling_heartbeatPubSubType::GroundHandling_heartbeatPubSubType()
+            Aerodynamics_outputPubSubType::Aerodynamics_outputPubSubType()
             {
-                set_name("XNSim::C909::ATA04::GroundHandling_heartbeat");
+                set_name("XNSim::C909::ATA04::Aerodynamics_output");
-                uint32_t type_size = XNSim_C909_ATA04_GroundHandling_heartbeat_max_cdr_typesize;
+                uint32_t type_size = XNSim_C909_ATA04_Aerodynamics_output_max_cdr_typesize;
                 type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
                 max_serialized_type_size = type_size + 4; /*encapsulation*/
                 is_compute_key_provided = false;
-                uint32_t key_length = XNSim_C909_ATA04_GroundHandling_heartbeat_max_key_cdr_typesize > 16 ? XNSim_C909_ATA04_GroundHandling_heartbeat_max_key_cdr_typesize : 16;
+                uint32_t key_length = XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize > 16 ? XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize : 16;
                 key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
                 memset(key_buffer_, 0, key_length);
             }
 
-            GroundHandling_heartbeatPubSubType::~GroundHandling_heartbeatPubSubType()
+            Aerodynamics_outputPubSubType::~Aerodynamics_outputPubSubType()
             {
                 if (key_buffer_ != nullptr)
                 {
@@ -964,12 +600,12 @@ namespace XNSim {
                 }
             }
 
-            bool GroundHandling_heartbeatPubSubType::serialize(
+            bool Aerodynamics_outputPubSubType::serialize(
                     const void* const data,
                     SerializedPayload_t& payload,
                     DataRepresentationId_t data_representation)
             {
-                const GroundHandling_heartbeat* p_type = static_cast<const GroundHandling_heartbeat*>(data);
+                const Aerodynamics_output* p_type = static_cast<const Aerodynamics_output*>(data);
 
                 // Object that manages the raw buffer.
                 eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
@@ -1001,14 +637,14 @@ namespace XNSim {
                 return true;
             }
 
-            bool GroundHandling_heartbeatPubSubType::deserialize(
+            bool Aerodynamics_outputPubSubType::deserialize(
                     SerializedPayload_t& payload,
                     void* data)
             {
                 try
                 {
                     // Convert DATA to pointer of your type
-                    GroundHandling_heartbeat* p_type = static_cast<GroundHandling_heartbeat*>(data);
+                    Aerodynamics_output* p_type = static_cast<Aerodynamics_output*>(data);
 
                     // Object that manages the raw buffer.
                     eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
@@ -1031,7 +667,7 @@ namespace XNSim {
                 return true;
             }
 
-            uint32_t GroundHandling_heartbeatPubSubType::calculate_serialized_size(
+            uint32_t Aerodynamics_outputPubSubType::calculate_serialized_size(
                     const void* const data,
                     DataRepresentationId_t data_representation)
             {
@@ -1042,7 +678,7 @@ namespace XNSim {
                         eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
                     size_t current_alignment {0};
                     return static_cast<uint32_t>(calculator.calculate_serialized_size(
-                                *static_cast<const GroundHandling_heartbeat*>(data), current_alignment)) +
+                                *static_cast<const Aerodynamics_output*>(data), current_alignment)) +
                             4u /*encapsulation*/;
                 }
                 catch (eprosima::fastcdr::exception::Exception& /*exception*/)
@@ -1051,18 +687,18 @@ namespace XNSim {
                 }
             }
 
-            void* GroundHandling_heartbeatPubSubType::create_data()
+            void* Aerodynamics_outputPubSubType::create_data()
             {
-                return reinterpret_cast<void*>(new GroundHandling_heartbeat());
+                return reinterpret_cast<void*>(new Aerodynamics_output());
             }
 
-            void GroundHandling_heartbeatPubSubType::delete_data(
+            void Aerodynamics_outputPubSubType::delete_data(
                     void* data)
             {
-                delete(reinterpret_cast<GroundHandling_heartbeat*>(data));
+                delete(reinterpret_cast<Aerodynamics_output*>(data));
             }
 
-            bool GroundHandling_heartbeatPubSubType::compute_key(
+            bool Aerodynamics_outputPubSubType::compute_key(
                     SerializedPayload_t& payload,
                     InstanceHandle_t& handle,
                     bool force_md5)
@@ -1072,7 +708,7 @@ namespace XNSim {
                     return false;
                 }
 
-                GroundHandling_heartbeat data;
+                Aerodynamics_output data;
                 if (deserialize(payload, static_cast<void*>(&data)))
                 {
                     return compute_key(static_cast<void*>(&data), handle, force_md5);
@@ -1081,7 +717,7 @@ namespace XNSim {
                 return false;
             }
 
-            bool GroundHandling_heartbeatPubSubType::compute_key(
+            bool Aerodynamics_outputPubSubType::compute_key(
                     const void* const data,
                     InstanceHandle_t& handle,
                     bool force_md5)
@@ -1091,17 +727,17 @@ namespace XNSim {
                     return false;
                 }
 
-                const GroundHandling_heartbeat* p_type = static_cast<const GroundHandling_heartbeat*>(data);
+                const Aerodynamics_output* p_type = static_cast<const Aerodynamics_output*>(data);
 
                 // Object that manages the raw buffer.
                 eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
-                        XNSim_C909_ATA04_GroundHandling_heartbeat_max_key_cdr_typesize);
+                        XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize);
 
                 // Object that serializes the data.
                 eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
                 ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
                 eprosima::fastcdr::serialize_key(ser, *p_type);
-                if (force_md5 || XNSim_C909_ATA04_GroundHandling_heartbeat_max_key_cdr_typesize > 16)
+                if (force_md5 || XNSim_C909_ATA04_Aerodynamics_output_max_key_cdr_typesize > 16)
                 {
                     md5_.init();
                     md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
@@ -1121,9 +757,9 @@ namespace XNSim {
                 return true;
             }
 
-            void GroundHandling_heartbeatPubSubType::register_type_object_representation()
+            void Aerodynamics_outputPubSubType::register_type_object_representation()
             {
-                register_GroundHandling_heartbeat_type_identifier(type_identifiers_);
+                register_Aerodynamics_output_type_identifier(type_identifiers_);
             }
 
             WeightBalance_inputPubSubType::WeightBalance_inputPubSubType()
@@ -1490,188 +1126,6 @@ namespace XNSim {
                 register_WeightBalance_output_type_identifier(type_identifiers_);
             }
 
-            WeightBalance_heartbeatPubSubType::WeightBalance_heartbeatPubSubType()
-            {
-                set_name("XNSim::C909::ATA04::WeightBalance_heartbeat");
-                uint32_t type_size = XNSim_C909_ATA04_WeightBalance_heartbeat_max_cdr_typesize;
-                type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
-                max_serialized_type_size = type_size + 4; /*encapsulation*/
-                is_compute_key_provided = false;
-                uint32_t key_length = XNSim_C909_ATA04_WeightBalance_heartbeat_max_key_cdr_typesize > 16 ? XNSim_C909_ATA04_WeightBalance_heartbeat_max_key_cdr_typesize : 16;
-                key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
-                memset(key_buffer_, 0, key_length);
-            }
-
-            WeightBalance_heartbeatPubSubType::~WeightBalance_heartbeatPubSubType()
-            {
-                if (key_buffer_ != nullptr)
-                {
-                    free(key_buffer_);
-                }
-            }
-
-            bool WeightBalance_heartbeatPubSubType::serialize(
-                    const void* const data,
-                    SerializedPayload_t& payload,
-                    DataRepresentationId_t data_representation)
-            {
-                const WeightBalance_heartbeat* p_type = static_cast<const WeightBalance_heartbeat*>(data);
-
-                // Object that manages the raw buffer.
-                eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
-                // Object that serializes the data.
-                eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-                        data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                        eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
-                payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
-                ser.set_encoding_flag(
-                    data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                    eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR  :
-                    eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
-
-                try
-                {
-                    // Serialize encapsulation
-                    ser.serialize_encapsulation();
-                    // Serialize the object.
-                    ser << *p_type;
-                    ser.set_dds_cdr_options({0,0});
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return false;
-                }
-
-                // Get the serialized length
-                payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
-                return true;
-            }
-
-            bool WeightBalance_heartbeatPubSubType::deserialize(
-                    SerializedPayload_t& payload,
-                    void* data)
-            {
-                try
-                {
-                    // Convert DATA to pointer of your type
-                    WeightBalance_heartbeat* p_type = static_cast<WeightBalance_heartbeat*>(data);
-
-                    // Object that manages the raw buffer.
-                    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
-
-                    // Object that deserializes the data.
-                    eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
-
-                    // Deserialize encapsulation.
-                    deser.read_encapsulation();
-                    payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
-
-                    // Deserialize the object.
-                    deser >> *p_type;
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return false;
-                }
-
-                return true;
-            }
-
-            uint32_t WeightBalance_heartbeatPubSubType::calculate_serialized_size(
-                    const void* const data,
-                    DataRepresentationId_t data_representation)
-            {
-                try
-                {
-                    eprosima::fastcdr::CdrSizeCalculator calculator(
-                        data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
-                        eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
-                    size_t current_alignment {0};
-                    return static_cast<uint32_t>(calculator.calculate_serialized_size(
-                                *static_cast<const WeightBalance_heartbeat*>(data), current_alignment)) +
-                            4u /*encapsulation*/;
-                }
-                catch (eprosima::fastcdr::exception::Exception& /*exception*/)
-                {
-                    return 0;
-                }
-            }
-
-            void* WeightBalance_heartbeatPubSubType::create_data()
-            {
-                return reinterpret_cast<void*>(new WeightBalance_heartbeat());
-            }
-
-            void WeightBalance_heartbeatPubSubType::delete_data(
-                    void* data)
-            {
-                delete(reinterpret_cast<WeightBalance_heartbeat*>(data));
-            }
-
-            bool WeightBalance_heartbeatPubSubType::compute_key(
-                    SerializedPayload_t& payload,
-                    InstanceHandle_t& handle,
-                    bool force_md5)
-            {
-                if (!is_compute_key_provided)
-                {
-                    return false;
-                }
-
-                WeightBalance_heartbeat data;
-                if (deserialize(payload, static_cast<void*>(&data)))
-                {
-                    return compute_key(static_cast<void*>(&data), handle, force_md5);
-                }
-
-                return false;
-            }
-
-            bool WeightBalance_heartbeatPubSubType::compute_key(
-                    const void* const data,
-                    InstanceHandle_t& handle,
-                    bool force_md5)
-            {
-                if (!is_compute_key_provided)
-                {
-                    return false;
-                }
-
-                const WeightBalance_heartbeat* p_type = static_cast<const WeightBalance_heartbeat*>(data);
-
-                // Object that manages the raw buffer.
-                eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
-                        XNSim_C909_ATA04_WeightBalance_heartbeat_max_key_cdr_typesize);
-
-                // Object that serializes the data.
-                eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
-                ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
-                eprosima::fastcdr::serialize_key(ser, *p_type);
-                if (force_md5 || XNSim_C909_ATA04_WeightBalance_heartbeat_max_key_cdr_typesize > 16)
-                {
-                    md5_.init();
-                    md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
-                    md5_.finalize();
-                    for (uint8_t i = 0; i < 16; ++i)
-                    {
-                        handle.value[i] = md5_.digest[i];
-                    }
-                }
-                else
-                {
-                    for (uint8_t i = 0; i < 16; ++i)
-                    {
-                        handle.value[i] = key_buffer_[i];
-                    }
-                }
-                return true;
-            }
-
-            void WeightBalance_heartbeatPubSubType::register_type_object_representation()
-            {
-                register_WeightBalance_heartbeat_type_identifier(type_identifiers_);
-            }
-
         } // namespace ATA04
 
     } // namespace C909

Release/IDL/C909_V1/C909_V1PubSubTypes.hpp

@@ -125,168 +125,6 @@ namespace XNSim
 
             };
 
-            /*!
-             * @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 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_;
-
-            };
-
             /*!
              * @brief This class represents the TopicDataType of the type GroundHandling_input defined by the user in the IDL file.
              * @ingroup C909_V1
@@ -450,18 +288,18 @@ namespace XNSim
             };
 
             /*!
-             * @brief This class represents the TopicDataType of the type GroundHandling_heartbeat defined by the user in the IDL file.
+             * @brief This class represents the TopicDataType of the type Aerodynamics_output defined by the user in the IDL file.
              * @ingroup C909_V1
              */
-            class GroundHandling_heartbeatPubSubType : public eprosima::fastdds::dds::TopicDataType
+            class Aerodynamics_outputPubSubType : public eprosima::fastdds::dds::TopicDataType
             {
             public:
 
-                typedef GroundHandling_heartbeat type;
+                typedef Aerodynamics_output type;
 
-                eProsima_user_DllExport GroundHandling_heartbeatPubSubType();
+                eProsima_user_DllExport Aerodynamics_outputPubSubType();
 
-                eProsima_user_DllExport ~GroundHandling_heartbeatPubSubType() override;
+                eProsima_user_DllExport ~Aerodynamics_outputPubSubType() override;
 
                 eProsima_user_DllExport bool serialize(
                         const void* const data,
@@ -691,87 +529,6 @@ namespace XNSim
                 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_;
-
-            };
         } // namespace ATA04
     } // namespace C909
 } // namespace XNSim

Release/IDL/C909_V1/C909_V1TypeObjectSupport.hpp

@@ -53,32 +53,6 @@ namespace ATA04 {
 eProsima_user_DllExport void register_Aerodynamics_input_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 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);
-
 /**
  * @brief Register GroundHandling_input related TypeIdentifier.
  *        Fully-descriptive TypeIdentifiers are directly registered.
@@ -106,7 +80,7 @@ eProsima_user_DllExport void register_GroundHandling_output_type_identifier(
         eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
 
 /**
- * @brief Register GroundHandling_heartbeat related TypeIdentifier.
+ * @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.
@@ -115,7 +89,7 @@ eProsima_user_DllExport void register_GroundHandling_output_type_identifier(
  *             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_user_DllExport void register_Aerodynamics_output_type_identifier(
         eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
 
 /**
@@ -144,19 +118,6 @@ eProsima_user_DllExport void register_WeightBalance_input_type_identifier(
 eProsima_user_DllExport void register_WeightBalance_output_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);
-
 } // namespace ATA04
 
 } // namespace C909

Release/IDL/C909_V1/CMakeLists.txt

@@ -1,65 +1,53 @@
 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})
+	set(XNCore_PATH $ENV{XNCore})
 else()
-    message(FATAL_ERROR "Environment variable XNCore is not set.")
+	message(FATAL_ERROR "Environment variable XNCore is not set.")
 endif()
-
-# 添加 XNCore_PATH 下的 include 目录为包含目录
 include_directories(${XNCore_PATH}/include)
-
 if(NOT fastcdr_FOUND)
-    find_package(fastcdr 2 REQUIRED)
+	find_package(fastcdr 2 REQUIRED)
 endif()
-
 if(NOT fastdds_FOUND)
-    find_package(fastdds 3 REQUIRED)
+	find_package(fastdds 3 REQUIRED)
 endif()
-
 find_package(OpenSSL REQUIRED)
-
 add_library(C909_V1_Interface SHARED
-  C909_V1.hpp
+    C909_V1.hpp
-  C909_V1CdrAux.hpp
+    C909_V1CdrAux.hpp
-  C909_V1CdrAux.ipp
+    C909_V1CdrAux.ipp
-  C909_V1PubSubTypes.hpp
+    C909_V1PubSubTypes.hpp
-  C909_V1PubSubTypes.cxx
+    C909_V1PubSubTypes.cxx
-  C909_V1TypeObjectSupport.hpp
+    C909_V1TypeObjectSupport.hpp
-  C909_V1TypeObjectSupport.cxx
+    C909_V1TypeObjectSupport.cxx
-  ATA04/GroundHandling_input.hpp
+    ATA04/Aerodynamics_input.hpp
-  ATA04/GroundHandling_input.cxx
+    ATA04/Aerodynamics_input.cxx
-  ATA04/GroundHandling_output.hpp
+    ATA04/GroundHandling_input.hpp
-  ATA04/GroundHandling_output.cxx
+    ATA04/GroundHandling_input.cxx
-  ATA04/GroundHandling_heartbeat.hpp
+    ATA04/GroundHandling_output.hpp
-  ATA04/GroundHandling_heartbeat.cxx
+    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
 )
-
-
 target_link_libraries(C909_V1_Interface PRIVATE
-	fastcdr
+     fastcdr fastdds OpenSSL::SSL OpenSSL::Crypto
-	fastdds
+     ${XNCore_PATH}/lib/libXNCore.so
-	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)
+	set(CMAKE_INSTALL_PREFIX "${XNCore_PATH}" CACHE PATH "Install path prefix" FORCE)
 endif()
-
 include(GNUInstallDirs)
 install(TARGETS C909_V1_Interface
-    BUNDLE DESTINATION .
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     RUNTIME DESTINATION .
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION .
 )

XNInterfaceGenServer/.vscode/settings.json

@@ -0,0 +1,57 @@
+{
+  "files.associations": {
+    "chrono": "cpp",
+    "cctype": "cpp",
+    "clocale": "cpp",
+    "cmath": "cpp",
+    "cstdarg": "cpp",
+    "cstddef": "cpp",
+    "cstdio": "cpp",
+    "cstdlib": "cpp",
+    "ctime": "cpp",
+    "cwchar": "cpp",
+    "cwctype": "cpp",
+    "array": "cpp",
+    "atomic": "cpp",
+    "bit": "cpp",
+    "*.tcc": "cpp",
+    "codecvt": "cpp",
+    "compare": "cpp",
+    "concepts": "cpp",
+    "cstdint": "cpp",
+    "deque": "cpp",
+    "map": "cpp",
+    "unordered_map": "cpp",
+    "vector": "cpp",
+    "exception": "cpp",
+    "algorithm": "cpp",
+    "functional": "cpp",
+    "iterator": "cpp",
+    "memory": "cpp",
+    "memory_resource": "cpp",
+    "numeric": "cpp",
+    "optional": "cpp",
+    "random": "cpp",
+    "ratio": "cpp",
+    "string": "cpp",
+    "string_view": "cpp",
+    "system_error": "cpp",
+    "tuple": "cpp",
+    "type_traits": "cpp",
+    "utility": "cpp",
+    "fstream": "cpp",
+    "initializer_list": "cpp",
+    "iomanip": "cpp",
+    "iosfwd": "cpp",
+    "istream": "cpp",
+    "limits": "cpp",
+    "new": "cpp",
+    "ostream": "cpp",
+    "ranges": "cpp",
+    "sstream": "cpp",
+    "stdexcept": "cpp",
+    "streambuf": "cpp",
+    "typeinfo": "cpp",
+    "cstring": "cpp"
+  }
+}

XNInterfaceGenServer/CMakeLists.txt

@@ -0,0 +1,55 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(XNInterfaceGenServer LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# 获取环境变量
+if(DEFINED ENV{XNCore})
+    set(XNCore_PATH $ENV{XNCore})
+else()
+    message(FATAL_ERROR "Environment variable XNCore is not set.")
+endif()
+
+# 查找必要的包
+find_package(nlohmann_json 3.9.1 REQUIRED)
+find_package(SQLite3 REQUIRED)
+
+add_library(XNInterfaceGenServer SHARED
+  XNInterfaceGenServer.h
+  XNInterfaceGenServer.cpp
+  GetInterfaceData.h
+  GetInterfaceData.cpp
+  GenIDL.h
+  GenIDL.cpp
+  FastDDSGen.h
+  FastDDSGen.cpp
+  PublicDefine.h
+  PublicDefine.cpp
+  DDSInterfaceGen.h
+  DDSInterfaceGen.cpp
+  CMakeListsGen.h
+  CMakeListsGen.cpp
+)
+
+# 添加头文件搜索路径
+target_include_directories(XNInterfaceGenServer PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(XNInterfaceGenServer PRIVATE 
+  nlohmann_json::nlohmann_json
+  SQLite::SQLite3
+  )
+
+target_compile_definitions(XNInterfaceGenServer PRIVATE XNINTERFACEGENSERVER_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 XNInterfaceGenServer
+    BUNDLE DESTINATION .
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION .
+)

XNInterfaceGenServer/CMakeListsGen.cpp

@@ -0,0 +1,92 @@
+#include "CMakeListsGen.h"
+
+bool CMakeListsGen::generateCMakeLists(const AllInterfaceData &interfaceData,
+									   const std::string &idlPath, const std::string &configName)
+{
+	std::string idlDirPath	  = fs::path(idlPath).parent_path().string();
+	std::string cmakefilePath = idlDirPath + "/CMakeLists.txt";
+
+	// 1. 生成CMakeLists.txt文件
+	std::ofstream cmakeFile(cmakefilePath);
+	if (!cmakeFile.is_open()) {
+		return false;
+	}
+
+	cmakeFile << "cmake_minimum_required(VERSION 3.16)" << std::endl;
+	cmakeFile << "project(" << configName << "_Interface LANGUAGES CXX)" << std::endl;
+	cmakeFile << "set(CMAKE_CXX_STANDARD 17)" << std::endl;
+	cmakeFile << "set(CMAKE_CXX_STANDARD_REQUIRED ON)" << std::endl;
+	cmakeFile << "set(CMAKE_POSITION_INDEPENDENT_CODE ON)" << std::endl;
+
+	// 获取环境变量
+	cmakeFile << "if(DEFINED ENV{XNCore})" << std::endl;
+	cmakeFile << "\tset(XNCore_PATH $ENV{XNCore})" << std::endl;
+	cmakeFile << "else()" << std::endl;
+	cmakeFile << "\tmessage(FATAL_ERROR \"Environment variable XNCore is not set.\")" << std::endl;
+	cmakeFile << "endif()" << std::endl;
+
+	// 添加 XNCore_PATH 下的 include 目录为包含目录
+	cmakeFile << "include_directories(${XNCore_PATH}/include)" << std::endl;
+
+	cmakeFile << "if(NOT fastcdr_FOUND)" << std::endl;
+	cmakeFile << "\tfind_package(fastcdr 2 REQUIRED)" << std::endl;
+	cmakeFile << "endif()" << std::endl;
+
+	cmakeFile << "if(NOT fastdds_FOUND)" << std::endl;
+	cmakeFile << "\tfind_package(fastdds 3 REQUIRED)" << std::endl;
+	cmakeFile << "endif()" << std::endl;
+
+	cmakeFile << "find_package(OpenSSL REQUIRED)" << std::endl;
+
+	cmakeFile << "add_library(" << configName << "_Interface SHARED" << std::endl;
+	cmakeFile << "    " << configName << ".hpp" << std::endl;
+	cmakeFile << "    " << configName << "CdrAux.hpp" << std::endl;
+	cmakeFile << "    " << configName << "CdrAux.ipp" << std::endl;
+	cmakeFile << "    " << configName << "PubSubTypes.hpp" << std::endl;
+	cmakeFile << "    " << configName << "PubSubTypes.cxx" << std::endl;
+	cmakeFile << "    " << configName << "TypeObjectSupport.hpp" << std::endl;
+	cmakeFile << "    " << configName << "TypeObjectSupport.cxx" << std::endl;
+	for (const auto &ataInterfaceData : interfaceData.ataInterfaceData) {
+		std::string ataName = ataInterfaceData.ataName;
+		for (const auto &structInterfaceData : ataInterfaceData.structInterfaceData) {
+			std::string structName = structInterfaceData.modelStructName;
+			cmakeFile << "    " << ataName << "/" << structName << ".hpp" << std::endl;
+			cmakeFile << "    " << ataName << "/" << structName << ".cxx" << std::endl;
+		}
+	}
+	cmakeFile << ")" << std::endl;
+
+	cmakeFile << "target_link_libraries(" << configName << "_Interface PRIVATE" << std::endl;
+	cmakeFile << "     fastcdr fastdds OpenSSL::SSL OpenSSL::Crypto" << std::endl;
+	cmakeFile << "     ${XNCore_PATH}/lib/libXNCore.so" << std::endl;
+	cmakeFile << ")" << std::endl;
+
+	cmakeFile << "target_compile_definitions(" << configName << "_Interface PRIVATE "
+			  << toUpper(configName) << "_INTERFACE_LIBRARY)" << std::endl;
+
+	cmakeFile << "if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)" << std::endl;
+	cmakeFile
+		<< "\tset(CMAKE_INSTALL_PREFIX \"${XNCore_PATH}\" CACHE PATH \"Install path prefix\" FORCE)"
+		<< std::endl;
+	cmakeFile << "endif()" << std::endl;
+
+	cmakeFile << "include(GNUInstallDirs)" << std::endl;
+
+	cmakeFile << "install(TARGETS " << configName << "_Interface" << std::endl;
+	cmakeFile << "    RUNTIME DESTINATION ." << std::endl;
+	cmakeFile << "    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}" << std::endl;
+	cmakeFile << "    ARCHIVE DESTINATION ." << std::endl;
+	cmakeFile << ")" << std::endl;
+
+	cmakeFile.close();
+	return true;
+}
+
+std::string CMakeListsGen::toUpper(const std::string &str)
+{
+	std::string result = str;
+	for (auto &c : result) {
+		c = std::toupper(c);
+	}
+	return result;
+}

XNInterfaceGenServer/CMakeListsGen.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "PublicDefine.h"
+
+class CMakeListsGen
+{
+public:
+	/**
+     * @brief 生成CMakeLists.txt文件
+     * @return 是否生成成功
+     */
+	static bool generateCMakeLists(const AllInterfaceData &interfaceData,
+								   const std::string &idlPath, const std::string &configName);
+
+private:
+	static std::string toUpper(const std::string &str);
+};

XNInterfaceGenServer/DDSInterfaceGen.cpp

@@ -0,0 +1,182 @@
+#include "DDSInterfaceGen.h"
+
+DDSInterfaceGen::DDSInterfaceGen(const std::string &idlPath)
+{
+	IDLPath = fs::path(idlPath).parent_path().string();
+	IDLName = fs::path(idlPath).stem().string();
+}
+
+bool DDSInterfaceGen::generateDDSInterface(const AllInterfaceData &interfaceData)
+{
+	std::string systemName = interfaceData.systemName;
+	std::string planeName  = interfaceData.planeName;
+
+	for (const auto &ata : interfaceData.ataInterfaceData) {
+		std::string ataName				= ata.ataName;
+		std::string interfaceFolderPath = IDLPath + "/" + ataName;
+		fs::create_directories(interfaceFolderPath);
+		std::string nameSpace = systemName + "::" + planeName + "::" + ataName;
+		for (const auto &structData : ata.structInterfaceData) {
+			std::string structName = structData.modelStructName;
+			generateDDSInterfaceHpp(nameSpace, structName, interfaceFolderPath,
+									structData.interfaceData);
+			generateDDSInterfaceCxx(nameSpace, structName, interfaceFolderPath,
+									structData.interfaceData);
+		}
+	}
+	return true;
+}
+
+bool DDSInterfaceGen::generateDDSInterfaceHpp(const std::string &nameSpace,
+											  const std::string &structName,
+											  const std::string &interfaceFolderPath,
+											  const std::vector<InterfaceData> &interfaceData)
+{
+	std::string className	= structName + "_Interface";
+	std::string topicType	= nameSpace + "::" + structName;
+	std::string hppFilePath = interfaceFolderPath + "/" + structName + ".hpp";
+	std::ofstream hppFile(hppFilePath);
+	// 1. 写入引用头文件
+	hppFile << "#pragma once" << std::endl;
+	hppFile << "#include \"../" << IDLName << "PubSubTypes.hpp\"" << std::endl;
+	hppFile << "#include \"XNCore/XNDDSInterface.h\"" << std::endl;
+	// 2. 写入命名空间
+	hppFile << "namespace " << nameSpace << std::endl;
+	hppFile << "{" << std::endl;
+	// 3. 写入类声明
+	hppFile << "class " << className << " final : public XNDDSInterface" << std::endl;
+	hppFile << "{" << std::endl;
+	hppFile << "public:" << std::endl;
+	// 4. 写入构造函数和析构函数
+	hppFile << "\t" << className << "();" << std::endl;
+	hppFile << "\t" << "virtual ~" << className << "();" << std::endl;
+	// 5. 写入初始化函数
+	hppFile << "\t"
+			<< "virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t "
+			   "DDS_type) override;"
+			<< std::endl;
+	// 6. 写入清空数据函数
+	hppFile << "\t" << "virtual void clearOutData() override;" << std::endl;
+	// 7. 写入发送数据函数
+	hppFile << "\t" << "virtual void sendOutData() override;" << std::endl;
+	// 8. 写入输入数据监听函数
+	hppFile << "\t" << "void inputDataListener(const " << topicType << " &input);" << std::endl;
+	// 9. 写入获取数据模板函数
+	hppFile << "\t" << "template <typename T>" << std::endl;
+	hppFile << "\t" << "void getData(T *model_data)" << std::endl;
+	hppFile << "\t" << "{" << std::endl;
+	hppFile << "\t\t" << "if(model_data == nullptr)" << std::endl;
+	hppFile << "\t\t\t" << "return;" << std::endl;
+	for (const auto &interface : interfaceData) {
+		hppFile << "\t\t" << "assign_value_get(data." << interface.interfaceName
+				<< "(), model_data->" << interface.interfaceName << ");" << std::endl;
+	}
+	hppFile << "\t" << "}" << std::endl;
+	// 10. 写入设置数据模板函数
+	hppFile << "\t" << "template <typename T>" << std::endl;
+	hppFile << "\t" << "void setData(T *model_data)" << std::endl;
+	hppFile << "\t" << "{" << std::endl;
+	hppFile << "\t\t" << "if(model_data == nullptr)" << std::endl;
+	hppFile << "\t\t\t" << "return;" << std::endl;
+	hppFile << "\t\t" << "clearOutData();" << std::endl;
+	for (const auto &interface : interfaceData) {
+		hppFile << "\t\t" << "assign_value_set(data." << interface.interfaceName
+				<< "(), model_data->" << structName << ");" << std::endl;
+	}
+	hppFile << "\t" << "}" << std::endl;
+	// 11. 写入私有成员变量
+	hppFile << "" << "private:" << std::endl;
+	hppFile << "\t" << topicType << " data;" << std::endl;
+	hppFile << "\t" << topicType << " out_data;" << std::endl;
+	// 12. 写入类声明结束
+	hppFile << "};" << std::endl;
+	// 13. 写入命名空间结束
+	hppFile << "}" << std::endl;
+	hppFile.close();
+	return true;
+}
+
+bool DDSInterfaceGen::generateDDSInterfaceCxx(const std::string &nameSpace,
+											  const std::string &structName,
+											  const std::string &interfaceFolderPath,
+											  const std::vector<InterfaceData> &interfaceData)
+{
+	std::string className	= structName + "_Interface";
+	std::string topicType	= nameSpace + "::" + structName;
+	std::string cxxFilePath = interfaceFolderPath + "/" + structName + ".cxx";
+	std::ofstream cxxFile(cxxFilePath);
+	// 1. 写入引用头文件
+	cxxFile << "#include \"" << structName << ".hpp\"" << std::endl;
+	// 2. 写入命名空间
+	cxxFile << "namespace " << nameSpace << std::endl;
+	cxxFile << "{" << std::endl;
+	// 3. 写入类构造函数实现
+	cxxFile << className << "::" << className << "()" << std::endl;
+	cxxFile << "{" << std::endl;
+	for (const auto &interface : interfaceData) {
+		cxxFile << "\t" << "MAP_DATA_FUNC(" << interface.interfaceName << ");" << std::endl;
+	}
+	//TODO 这里先待定
+	cxxFile << "\t" << "this->header[0] = 0xa6; // XNSim头，0xa6" << std::endl;
+	cxxFile << "\t" << "this->header[1] = 0xc0; // 机型头，0xc0表示C909" << std::endl;
+	cxxFile << "\t" << "this->header[2] = 0x04; // 章节头，0x04表示ATA04" << std::endl;
+	cxxFile << "\t" << "this->header[3] = 0x01; // 模型头，0x01表示GroundHandling" << std::endl;
+	cxxFile << "\t" << "this->header[4] = 0x00; // 结构体头，0x00表示输入结构体" << std::endl;
+	cxxFile << "\t" << "this->header[5] = 0x00; // 数据方向，0x00表示外部输入" << std::endl;
+	cxxFile << "\t" << "this->header[6] = 0x00; // 数据大小" << std::endl;
+	cxxFile << "\t" << "this->header[7] = 0x00; // 数据大小" << std::endl;
+	cxxFile << "}" << std::endl;
+	// 4. 写入类析构函数实现
+	cxxFile << className << "::~" << className << "()" << std::endl;
+	cxxFile << "{" << std::endl;
+	cxxFile << "}" << std::endl;
+	// 5. 写入类初始化函数实现
+	cxxFile << "void " << className
+			<< "::Initialize(XNFrameworkPtr framework, uint32_t modelId,uint32_t DDS_type)"
+			<< std::endl;
+	cxxFile << "{" << std::endl;
+	cxxFile << "\t" << "auto ddsManager = framework->GetDDSManager();" << std::endl;
+	cxxFile << "\t" << "if (!ddsManager) {" << std::endl;
+	cxxFile << "\t\t" << "LOG_ERROR(\"DDSManager is nullptr\");" << std::endl;
+	cxxFile << "\t\t" << "return;" << std::endl;
+	cxxFile << "\t" << "}" << std::endl;
+	cxxFile << "\t" << "if (DDS_type == 0) {" << std::endl; // 读取与发送都进行
+	cxxFile << "\t\t" << "dataWriter = ddsManager->RegisterPublisher<" << topicType
+			<< "PubSubType>(\"" << topicType << "\", modelId);" << std::endl;
+	cxxFile << "\t\t" << "ddsManager->RegisterSubscriber<" << topicType << "PubSubType>(\""
+			<< topicType << "\", modelId, std::bind(&" << className
+			<< "::inputDataListener, this, std::placeholders::_1));" << std::endl;
+	cxxFile << "\t" << "}" << std::endl;
+	cxxFile << "\t" << "else if (DDS_type == 1) {" << std::endl; // 只读取
+	cxxFile << "\t\t" << "ddsManager->RegisterSubscriber<" << topicType << "PubSubType>(\""
+			<< topicType << "\", modelId, std::bind(&" << className
+			<< "::inputDataListener, this, std::placeholders::_1));" << std::endl;
+	cxxFile << "\t" << "}" << std::endl;
+	cxxFile << "\t" << "else if (DDS_type == 2) {" << std::endl; // 只发送
+	cxxFile << "\t\t" << "dataWriter = ddsManager->RegisterPublisher<" << topicType
+			<< "PubSubType>(\"" << topicType << "\", modelId);" << std::endl;
+	cxxFile << "\t" << "}" << std::endl;
+	cxxFile << "}" << std::endl;
+	// 6. 写入清空数据函数实现
+	cxxFile << "void " << className << "::clearOutData()" << std::endl;
+	cxxFile << "{" << std::endl;
+	cxxFile << "\t" << "this->out_data = " << topicType << "();" << std::endl;
+	cxxFile << "}" << std::endl;
+	// 7. 写入发送数据函数实现
+	cxxFile << "void " << className << "::sendOutData()" << std::endl;
+	cxxFile << "{" << std::endl;
+	cxxFile << "\t" << "if (dataWriter) {" << std::endl;
+	cxxFile << "\t\t" << "dataWriter->write(&this->out_data);" << std::endl;
+	cxxFile << "\t" << "}" << std::endl;
+	cxxFile << "}" << std::endl;
+	// 8. 写入输入数据监听函数实现
+	cxxFile << "void " << className << "::inputDataListener(const " << topicType << " &input)"
+			<< std::endl;
+	cxxFile << "{" << std::endl;
+	cxxFile << "\t" << "this->data = input;" << std::endl;
+	cxxFile << "}" << std::endl;
+	// 9. 写入命名空间实现结束
+	cxxFile << "}" << std::endl;
+	cxxFile.close();
+	return true;
+}

XNInterfaceGenServer/DDSInterfaceGen.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "PublicDefine.h"
+
+class DDSInterfaceGen
+{
+public:
+	DDSInterfaceGen(const std::string &idlPath);
+	bool generateDDSInterface(const AllInterfaceData &interfaceData);
+
+private:
+	bool generateDDSInterfaceHpp(const std::string &nameSpace, const std::string &structName,
+								 const std::string &interfaceFolderPath,
+								 const std::vector<InterfaceData> &interfaceData);
+	bool generateDDSInterfaceCxx(const std::string &nameSpace, const std::string &structName,
+								 const std::string &interfaceFolderPath,
+								 const std::vector<InterfaceData> &interfaceData);
+
+private:
+	std::string IDLPath;
+	std::string IDLName;
+};

XNInterfaceGenServer/FastDDSGen.cpp

@@ -0,0 +1,18 @@
+#include "FastDDSGen.h"
+
+bool FastDDSGen::generateFastDDSCode(std::string idlFilePath)
+{
+	// 检查IDL文件是否存在
+	if (!fs::exists(idlFilePath)) {
+		return false;
+	}
+
+	std::string idlDirPath = fs::path(idlFilePath).parent_path().string();
+	// 构建fastddsgen命令
+	std::string command = "fastddsgen " + idlFilePath + " -replace" + " -d " + idlDirPath;
+
+	// 执行命令
+	int result = std::system(command.c_str());
+
+	return result == 0;
+}

XNInterfaceGenServer/FastDDSGen.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "PublicDefine.h"
+
+/**
+ * @brief FastDDS代码生成类，用于根据IDL文件生成FastDDS代码
+ */
+class FastDDSGen
+{
+public:
+	/**
+     * @brief 生成FastDDS代码
+     * @return 是否生成成功
+     */
+	static bool generateFastDDSCode(std::string idlFilePath);
+};

XNInterfaceGenServer/GenIDL.cpp

@@ -0,0 +1,99 @@
+#include "GenIDL.h"
+#include <fstream>
+#include <sstream>
+#include <algorithm>
+#include <map>
+#include <filesystem>
+
+namespace fs = std::filesystem;
+
+std::string GenIDL::idlFilePath = "";
+
+bool GenIDL::createConfigDirectory(const std::string &configName)
+{
+	std::string dirPath = GetXNCoreEnv() + "/IDL/" + configName;
+	try {
+		fs::create_directories(dirPath);
+		GenIDL::idlFilePath = dirPath + "/" + configName + ".idl";
+		return true;
+	} catch (const fs::filesystem_error &) {
+		GenIDL::idlFilePath = "";
+		return false;
+	}
+}
+
+std::string GenIDL::generateStructDefinition(const StructInterfaceData &structData)
+{
+	std::stringstream ss;
+
+	// 生成结构体名称
+	std::string structName = structData.modelStructName;
+
+	// 生成结构体定义
+	ss << "\t\t\tstruct " << structName << "\n\t\t\t{\n";
+
+	// 生成成员变量
+	for (const auto &interface : structData.interfaceData) {
+		ss << "\t\t\t\t@optional ";
+
+		ss << interface.interfaceType << " ";
+
+		// 生成变量名
+		ss << interface.interfaceName;
+
+		// 如果是数组，添加数组维度
+		if (interface.interfaceIsArray) {
+			if (interface.interfaceArraySize_2 > 1) {
+				ss << "[" << interface.interfaceArraySize_1 << "]["
+				   << interface.interfaceArraySize_2 << "]";
+			} else {
+				ss << "[" << interface.interfaceArraySize_1 << "]";
+			}
+		}
+
+		ss << ";\n";
+	}
+
+	ss << "\t\t\t};\n";
+	return ss.str();
+}
+
+std::string GenIDL::generateIDLContent(const AllInterfaceData &interfaceData)
+{
+	std::stringstream ss;
+
+	// 生成模块定义
+	ss << "module " << interfaceData.systemName << "\n{\n";
+	ss << "\tmodule " << interfaceData.planeName << "\n\t{\n";
+
+	// 遍历ATA数据
+	for (const auto &ataData : interfaceData.ataInterfaceData) {
+		ss << "\t\tmodule " << ataData.ataName << "\n\t\t{\n";
+
+		// 遍历结构体数据
+		for (const auto &structData : ataData.structInterfaceData) {
+			ss << generateStructDefinition(structData);
+		}
+
+		ss << "\t\t};\n";
+	}
+
+	ss << "\t};\n};\n";
+	return ss.str();
+}
+
+bool GenIDL::generateIDL(const AllInterfaceData &interfaceData)
+{
+	if (GenIDL::idlFilePath.empty()) {
+		return false;
+	}
+
+	std::ofstream idlFile(GenIDL::idlFilePath);
+	if (!idlFile.is_open()) {
+		return false;
+	}
+
+	idlFile << generateIDLContent(interfaceData);
+	idlFile.close();
+	return true;
+}

XNInterfaceGenServer/GenIDL.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "GetInterfaceData.h"
+
+/**
+ * @brief IDL文件生成类，用于根据接口数据生成IDL文件
+ */
+class GenIDL
+{
+public:
+	/**
+     * @brief 生成IDL文件
+     * @param interfaceData 接口数据
+     * @return 是否生成成功
+     */
+	static bool generateIDL(const AllInterfaceData &interfaceData);
+
+	/**
+     * @brief 获取IDL文件路径
+     * @return IDL文件完整路径
+     */
+	static std::string &getIDLFilePath() { return idlFilePath; }
+
+	/**
+     * @brief 创建构型目录
+     * @return 是否创建成功
+     */
+	static bool createConfigDirectory(const std::string &configName);
+
+private:
+	/**
+     * @brief 生成IDL文件内容
+     * @param interfaceData 接口数据
+     * @return IDL文件内容
+     */
+	static std::string generateIDLContent(const AllInterfaceData &interfaceData);
+
+	/**
+     * @brief 生成结构体定义
+     * @param structData 结构体数据
+     * @return 结构体定义字符串
+     */
+	static std::string generateStructDefinition(const StructInterfaceData &structData);
+
+	static std::string idlFilePath; ///< IDL文件完整路径
+};

XNInterfaceGenServer/GetInterfaceData.cpp

@@ -0,0 +1,144 @@
+#include "GetInterfaceData.h"
+
+/**
+ * @brief 安全地将字符串转换为整数
+ * @param str 要转换的字符串
+ * @param defaultValue 转换失败时的默认值
+ * @return 转换后的整数值
+ */
+static int safe_stoi(const std::string &str, int defaultValue = 0)
+{
+	if (str.empty()) {
+		return defaultValue;
+	}
+	try {
+		return std::stoi(str);
+	} catch (const std::exception &) {
+		return defaultValue;
+	}
+}
+
+/**
+ * @brief 回调函数，用于处理查询结果
+ * @param data 用户数据指针
+ * @param argc 列数
+ * @param argv 列值数组
+ * @param azColName 列名数组
+ * @return 0表示成功
+ */
+static int callback(void *data, int argc, char **argv, char **azColName)
+{
+	if (!data || !argv || !azColName) {
+		return 0;
+	}
+	auto *allData			  = static_cast<AllInterfaceData *>(data);
+	static bool isFirstRecord = true;
+	std::string currentSystemName;
+	std::string currentPlaneName;
+	std::string currentATAName;
+	std::string currentModelStructName;
+	InterfaceData currentInterfaceData;
+
+	//先把数据都读出来
+	for (int i = 0; i < argc; i++) {
+		std::string colName = azColName[i];
+		std::string value	= argv[i] ? argv[i] : "";
+		if (colName == "SystemName") {
+			currentSystemName = value;
+		} else if (colName == "PlaneName") {
+			currentPlaneName = value;
+		} else if (colName == "ATAName") {
+			currentATAName = value;
+		} else if (colName == "ModelStructName") {
+			currentModelStructName = value;
+		} else if (colName == "InterfaceName") {
+			currentInterfaceData.interfaceName = value;
+		} else if (colName == "InterfaceType") {
+			currentInterfaceData.interfaceType = value;
+		} else if (colName == "InterfaceIsArray") {
+			currentInterfaceData.interfaceIsArray = safe_stoi(value);
+		} else if (colName == "InterfaceArraySize_1") {
+			currentInterfaceData.interfaceArraySize_1 = safe_stoi(value);
+		} else if (colName == "InterfaceArraySize_2") {
+			currentInterfaceData.interfaceArraySize_2 = safe_stoi(value);
+		} else if (colName == "InterfaceNotes") {
+			currentInterfaceData.interfaceNotes = value;
+		}
+	}
+
+	// 如果是第一条记录，初始化系统名称和飞机名称
+	if (isFirstRecord) {
+		allData->systemName = currentSystemName;
+		allData->planeName	= currentPlaneName;
+		isFirstRecord		= false;
+	}
+
+	// 检查系统名称和飞机名称是否匹配
+	if (currentSystemName != allData->systemName || currentPlaneName != allData->planeName) {
+		return 0;
+	}
+
+	//检查ATA是否已存在
+	for (auto &ata : allData->ataInterfaceData) {
+		if (ata.ataName == currentATAName) {
+			for (auto &structData : ata.structInterfaceData) {
+				if (structData.modelStructName == currentModelStructName) {
+					for (auto &interfaceData : structData.interfaceData) {
+						if (interfaceData.interfaceName == currentInterfaceData.interfaceName) {
+							return 0;
+						}
+					}
+					structData.interfaceData.push_back(currentInterfaceData);
+					return 0;
+				}
+			}
+			StructInterfaceData structData;
+			structData.modelStructName = currentModelStructName;
+			structData.interfaceData.push_back(currentInterfaceData);
+			ata.structInterfaceData.push_back(structData);
+			return 0;
+		}
+	}
+	ATAInterfaceData ataData;
+	ataData.ataName = currentATAName;
+	StructInterfaceData structData;
+	structData.modelStructName = currentModelStructName;
+	structData.interfaceData.push_back(currentInterfaceData);
+	ataData.structInterfaceData.push_back(structData);
+	allData->ataInterfaceData.push_back(ataData);
+	return 0;
+}
+
+/**
+ * @brief 从指定表中读取接口数据
+ * @param tableName 数据库表名
+ * @return 接口数据
+ */
+AllInterfaceData GetInterfaceData::getInterfaceData(const std::string &tableName,
+													std::string &errorMsg)
+{
+	AllInterfaceData allData;
+	std::string dbPath = GetXNCoreEnv() + "/database/XNSim.db";
+	sqlite3 *db;
+	int rc = sqlite3_open(dbPath.c_str(), &db);
+	if (rc != SQLITE_OK) {
+		errorMsg = "无法打开数据库: " + std::string(sqlite3_errmsg(db));
+		return allData;
+	}
+
+	char *errMsg = nullptr;
+
+	std::string sql = "SELECT * FROM " + tableName;
+
+	rc = sqlite3_exec(db, sql.c_str(), callback, &allData, &errMsg);
+	if (rc != SQLITE_OK) {
+		std::string error = errMsg;
+		sqlite3_free(errMsg);
+		errorMsg = "SQL错误: " + error;
+		return allData;
+	}
+
+	sqlite3_close(db);
+
+	return allData;
+}

XNInterfaceGenServer/GetInterfaceData.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "PublicDefine.h"
+
+/**
+ * @brief 接口数据读取类，用于从SQLite数据库中读取接口信息
+ */
+class GetInterfaceData
+{
+public:
+	/**
+     * @brief 从指定表中读取接口数据
+     * @param tableName 数据库表名
+     * @return 接口数据
+     */
+	static AllInterfaceData getInterfaceData(const std::string &tableName, std::string &errorMsg);
+};

XNInterfaceGenServer/PublicDefine.cpp

@@ -0,0 +1,9 @@
+
+#include "PublicDefine.h"
+
+std::string GetXNCoreEnv()
+{
+	const char *env_value = std::getenv("XNCore");
+	std::cout << "XNCore: " << env_value << std::endl;
+	return env_value ? env_value : "";
+}

XNInterfaceGenServer/PublicDefine.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <sqlite3.h>
+#include <stdexcept>
+#include <map>
+#include <filesystem>
+#include <cstdlib>
+#include <fstream>
+#include <cstring>
+#include <iostream>
+
+namespace fs = std::filesystem;
+
+struct InterfaceData {
+	std::string interfaceName;	///< 接口名称
+	std::string interfaceType;	///< 接口类型
+	int interfaceIsArray;		///< 是否为数组
+	int interfaceArraySize_1;	///< 数组第一维大小
+	int interfaceArraySize_2;	///< 数组第二维大小
+	std::string interfaceNotes; ///< 接口注释
+};
+
+struct StructInterfaceData {
+	std::string modelStructName; ///< 模型结构名称
+	std::vector<InterfaceData> interfaceData;
+};
+
+struct ATAInterfaceData {
+	std::string ataName; ///< ATA名称
+	std::vector<StructInterfaceData> structInterfaceData;
+};
+
+struct AllInterfaceData {
+	std::string systemName; ///< 系统名称
+	std::string planeName;	///< 飞机名称
+	std::vector<ATAInterfaceData> ataInterfaceData;
+};
+
+/**
+ * @brief 获取XNCore环境变量
+ * @return std::string 返回XNCore环境变量的值，如果环境变量不存在则返回空字符串
+ */
+std::string GetXNCoreEnv();

XNInterfaceGenServer/XNInterfaceGenServer.cpp

@@ -0,0 +1,66 @@
+#include "XNInterfaceGenServer.h"
+#include "GetInterfaceData.h"
+#include "GenIDL.h"
+#include "FastDDSGen.h"
+#include "DDSInterfaceGen.h"
+#include "CMakeListsGen.h"
+
+int XNInterfaceGen(const char *tableName, const int tableNameSize, const char *configName,
+				   const int configNameSize, const char *errorMsg, const int errorMsgSize)
+{
+	std::string errorMsgStr;
+	// 1. 从数据库获取接口数据
+	AllInterfaceData interfaceData = GetInterfaceData::getInterfaceData(tableName, errorMsgStr);
+	if (!errorMsgStr.empty()) {
+		memcpy((void *)errorMsg, errorMsgStr.c_str(), errorMsgSize);
+		return -1;
+	}
+
+	// 2. 创建构型目录
+	bool ret = GenIDL::createConfigDirectory(configName);
+	if (!ret) {
+		memcpy((void *)errorMsg, "Create config directory failed", errorMsgSize);
+		return -1;
+	}
+
+	// 3. 生成IDL文件
+	ret = GenIDL::generateIDL(interfaceData);
+	if (!ret) {
+		memcpy((void *)errorMsg, "Generate IDL failed", errorMsgSize);
+		return -1;
+	}
+
+	// 4. 生成FastDDS代码
+	ret = FastDDSGen::generateFastDDSCode(GenIDL::getIDLFilePath());
+	if (!ret) {
+		memcpy((void *)errorMsg, "Generate FastDDS code failed", errorMsgSize);
+		return -1;
+	}
+
+	// 5. 生成DDS接口
+	DDSInterfaceGen ddsInterfaceGen(GenIDL::getIDLFilePath());
+	ret = ddsInterfaceGen.generateDDSInterface(interfaceData);
+	if (!ret) {
+		memcpy((void *)errorMsg, "Generate DDS interface failed", errorMsgSize);
+		return -1;
+	}
+
+	// 6. 生成CMakeLists.txt文件
+	ret = CMakeListsGen::generateCMakeLists(interfaceData, GenIDL::getIDLFilePath(), configName);
+	if (!ret) {
+		memcpy((void *)errorMsg, "Generate CMakeLists.txt failed", errorMsgSize);
+		return -1;
+	}
+
+	// 7. 执行CMake编译和安装
+	std::string idlDirPath = fs::path(GenIDL::getIDLFilePath()).parent_path().string();
+	std::string buildCmd =
+		"cd " + idlDirPath + " && mkdir -p build && cd build && cmake .. && make && make install";
+	int buildRet = system(buildCmd.c_str());
+	if (buildRet != 0) {
+		memcpy((void *)errorMsg, "CMake build or install failed", errorMsgSize);
+		return -1;
+	}
+
+	return 0;
+}

XNInterfaceGenServer/XNInterfaceGenServer.h

@@ -0,0 +1,10 @@
+#ifndef XN_INTERFACE_GEN_SERVER_H
+#define XN_INTERFACE_GEN_SERVER_H
+
+#include "XNInterfaceGenServer_global.h"
+
+extern "C" XNIGS_EXPORT int XNInterfaceGen(const char *tableName, const int tableNameSize,
+										   const char *configName, const int configNameSize,
+										   const char *errorMsg, const int errorMsgSize);
+
+#endif // XN_INTERFACE_GEN_SERVER_H

XNInterfaceGenServer/XNInterfaceGenServer_global.h

@@ -0,0 +1,10 @@
+#ifndef XNINTERFACEGENSERVER_GLOBAL_H
+#define XNINTERFACEGENSERVER_GLOBAL_H
+
+#ifdef XNINTERFACEGENSERVER_LIBRARY
+#	define XNIGS_EXPORT __attribute__((visibility("default")))
+#else
+#	define XNIGS_EXPORT __attribute__((visibility("default")))
+#endif
+
+#endif // XNINTERFACEGENSERVER_GLOBAL_H

XNInterfaceGenServer/test/CMakeLists.txt

@@ -0,0 +1,49 @@
+cmake_minimum_required(VERSION 3.10)
+project(XNInterfaceGenTest)
+
+# 设置C++标准
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# 获取环境变量
+if(DEFINED ENV{XNCore})
+    set(XNCore_PATH $ENV{XNCore})
+else()
+    message(FATAL_ERROR "Environment variable XNCore is not set.")
+endif()
+
+# 添加可执行文件
+add_executable(XNInterfaceGenTest XNInterfaceGenTest.cpp)
+
+# 添加头文件搜索路径
+target_include_directories(XNInterfaceGenTest PRIVATE 
+    ${CMAKE_SOURCE_DIR}/..  # 添加父目录以包含头文件
+)
+
+# 设置库搜索路径
+set(LIB_SEARCH_PATHS
+    ${XNCore_PATH}/lib
+)
+
+# 查找库文件
+find_library(XNINTERFACE_GEN_SERVER_LIB
+    NAMES XNInterfaceGenServer
+    PATHS ${LIB_SEARCH_PATHS}
+    NO_DEFAULT_PATH
+    REQUIRED
+)
+
+message(STATUS "Found library at: ${XNINTERFACE_GEN_SERVER_LIB}")
+
+if(NOT XNINTERFACE_GEN_SERVER_LIB)
+    message(FATAL_ERROR "XNInterfaceGenServer library not found in ${LIB_SEARCH_PATHS}")
+endif()
+
+# 链接动态库
+target_link_libraries(XNInterfaceGenTest PRIVATE ${XNINTERFACE_GEN_SERVER_LIB})
+
+# 设置运行时库路径
+set_target_properties(XNInterfaceGenTest PROPERTIES
+    INSTALL_RPATH "${XNCore_PATH}/lib"
+    BUILD_WITH_INSTALL_RPATH TRUE
+) 

XNInterfaceGenServer/test/XNInterfaceGenTest.cpp

@@ -0,0 +1,38 @@
+/**
+ * @file test_XNInterfaceGen.cpp
+ * @brief 测试XNInterfaceGen动态库的测试程序
+ */
+
+#include <iostream>
+#include <string>
+#include <cstring>
+
+// 声明外部函数
+extern "C"
+{
+	int XNInterfaceGen(const char *tableName, const int tableNameSize, const char *configName,
+					   const int configNameSize, const char *errorMsg, const int errorMsgSize);
+}
+
+int main()
+{
+	// 测试参数
+	const char *tableName  = "DataInterface_1";
+	const char *configName = "C909_V1";
+	char errorMsg[1024]	   = {0}; // 错误信息缓冲区
+
+	std::cout << "开始测试XNInterfaceGen..." << std::endl;
+
+	// 调用XNInterfaceGen函数
+	int ret = XNInterfaceGen(tableName, strlen(tableName), configName, strlen(configName), errorMsg,
+							 sizeof(errorMsg));
+
+	// 检查结果
+	if (ret == 0) {
+		std::cout << "测试成功！接口生成完成。" << std::endl;
+	} else {
+		std::cout << "测试失败！错误信息: " << errorMsg << std::endl;
+	}
+
+	return ret;
+}