测试了数据处理模型的接口函数

Release/Scenario/testGRD.xml

@@ -5,5 +5,6 @@
             	<Log Debug="0" Info="1" Error="1" Warning="1"/>
                 <ModelGroup Name="本体模型组" Freq="120" Priority="99" CPUAff="0">
                   	<Model Name="ATA04地面操纵模型" ClassName="XNGroundHandling"/>
+                  	<Model Name="ATA04数据处理模型" ClassName="XNATA04DataProcessor"/>
             	</ModelGroup>
       </Scenario>

Release/include/XNCore/XNDDSInterface.h

@@ -20,7 +20,7 @@ public:
 	 * @brief 初始化
 	 * @param framework: 框架
 	 */
-	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelID) = 0;
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelID, uint32_t DDS_type) = 0;
 
 	/**
 	 * @brief 获取该接口的UDP包
@@ -28,6 +28,12 @@ public:
 	 */
 	XNByteArray getUDPPackage();
 
+	/**
+	 * @brief 通过UDP包设置数据
+	 * @param package: UDP包
+	 */
+	void setDataByUDPPackage(const XNByteArray &package);
+
 	/**
 	 * @brief 批量获取指定变量的数据
 	 * @param varNames: 变量名列表
@@ -305,18 +311,23 @@ protected:
 	virtual void sendOutData() {}
 
 protected:
-	struct ByteArrayFunc {
+	struct GetByteArrayFunc {
 		std::function<XNByteArray(void)> func;
 		size_t size;
 	};
 
+	struct SetByteArrayFunc {
+		std::function<void(XNByteArray)> func;
+		size_t size;
+	};
+
 	std::unordered_map<std::string, std::function<std::string()>> getDataFunction;
 	std::unordered_map<std::string, std::function<void(std::string)>> setDataFunction;
-	std::vector<ByteArrayFunc> getByteArrayFunction;
+	std::vector<GetByteArrayFunc> getByteArrayFunction;
-	std::unordered_map<std::string, std::function<void(XNByteArray)>> setByteArrayFunction;
+	std::unordered_map<std::string, SetByteArrayFunc> setByteArrayFunction;
 	std::mutex mutex;
-	uint8_t header[5]{}; // 固定大小的头部
+	uint8_t header[8]{0}; // 固定大小的头部
-	size_t headerSize = 5;
+	size_t headerSize = 8;
 	FAST_DDS_MACRO::DataWriter *dataWriter;
 };
 
@@ -327,6 +338,6 @@ protected:
 	};                                                                                             \
 	getByteArrayFunction.push_back(                                                                \
 		{[this]() { return getByteArray(data.NAME()); }, getTypeSize<decltype(data.NAME())>()});   \
-	setByteArrayFunction[#NAME] = [this](XNByteArray byteArray) {                                  \
+	setByteArrayFunction[#NAME] = {                                                                \
-		setByteArray(data.NAME(), byteArray);                                                      \
+		[this](XNByteArray byteArray) { setByteArray(out_data.NAME(), byteArray); },               \
-	}
+		getTypeSize<decltype(out_data.NAME())>()};

XNCore/CMakeLists.txt

@@ -64,6 +64,7 @@ add_library(XNCore SHARED
   XNServiceObject_p.h
   XNServiceObject.cpp
   XNDDSInterface.h
+  XNDDSInterface.cpp
   ${DDS_XNIDL_SOURCES_CXX}
 )
 

XNCore/XNDDSInterface.cpp

@@ -11,10 +11,8 @@ XNByteArray XNDDSInterface::getUDPPackage()
 	size_t currentPos = 0;
 
 	// 复制头部
-	if (headerSize >= 5) {
+	result.append(header, headerSize);
-		result.append(header, 5);
+	currentPos = headerSize;
-		currentPos = 5;
-	}
 
 	// 复制数据
 	for (auto func : getByteArrayFunction) {
@@ -27,13 +25,45 @@ XNByteArray XNDDSInterface::getUDPPackage()
 	}
 
 	// 更新包大小
-	if (currentPos >= 5) {
+	if (currentPos >= 8 && currentPos < MAX_UDP_PACKET_SIZE) {
-		result[4] = static_cast<uint8_t>(currentPos);
+		result[6] = static_cast<uint8_t>((currentPos >> 8) & 0xFF);
+		result[7] = static_cast<uint8_t>(currentPos & 0xFF);
 	}
 
 	return result;
 }
 
+void XNDDSInterface::setDataByUDPPackage(const XNByteArray &package)
+{
+	clearOutData();
+	if (package.size() < headerSize) {
+		return;
+	}
+
+	// 获取包大小
+	uint16_t packageSize = (package[6] << 8) | package[7];
+	if (packageSize > MAX_UDP_PACKET_SIZE) {
+		return;
+	}
+
+	size_t currentPos = 8;
+
+	// 获取数据
+	for (auto func : setByteArrayFunction) {
+		if (currentPos + func.second.size <= packageSize) {
+			XNByteArray byteArray(func.second.size);
+			for (size_t i = 0; i < func.second.size; i++) {
+				byteArray[i] = package[currentPos + i];
+			}
+			func.second.func(byteArray);
+			currentPos += func.second.size;
+		} else {
+			break;
+		}
+	}
+	sendOutData();
+}
+
 std::unordered_map<std::string, std::string>
 XNDDSInterface::getStringData(std::vector<std::string> varNames)
 {

XNCore/XNDDSInterface.h

@@ -20,7 +20,7 @@ public:
 	 * @brief 初始化
 	 * @param framework: 框架
 	 */
-	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelID) = 0;
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelID, uint32_t DDS_type) = 0;
 
 	/**
 	 * @brief 获取该接口的UDP包
@@ -28,6 +28,12 @@ public:
 	 */
 	XNByteArray getUDPPackage();
 
+	/**
+	 * @brief 通过UDP包设置数据
+	 * @param package: UDP包
+	 */
+	void setDataByUDPPackage(const XNByteArray &package);
+
 	/**
 	 * @brief 批量获取指定变量的数据
 	 * @param varNames: 变量名列表
@@ -305,18 +311,23 @@ protected:
 	virtual void sendOutData() {}
 
 protected:
-	struct ByteArrayFunc {
+	struct GetByteArrayFunc {
 		std::function<XNByteArray(void)> func;
 		size_t size;
 	};
 
+	struct SetByteArrayFunc {
+		std::function<void(XNByteArray)> func;
+		size_t size;
+	};
+
 	std::unordered_map<std::string, std::function<std::string()>> getDataFunction;
 	std::unordered_map<std::string, std::function<void(std::string)>> setDataFunction;
-	std::vector<ByteArrayFunc> getByteArrayFunction;
+	std::vector<GetByteArrayFunc> getByteArrayFunction;
-	std::unordered_map<std::string, std::function<void(XNByteArray)>> setByteArrayFunction;
+	std::unordered_map<std::string, SetByteArrayFunc> setByteArrayFunction;
 	std::mutex mutex;
-	uint8_t header[5]{}; // 固定大小的头部
+	uint8_t header[8]{0}; // 固定大小的头部
-	size_t headerSize = 5;
+	size_t headerSize = 8;
 	FAST_DDS_MACRO::DataWriter *dataWriter;
 };
 
@@ -327,6 +338,6 @@ protected:
 	};                                                                                             \
 	getByteArrayFunction.push_back(                                                                \
 		{[this]() { return getByteArray(data.NAME()); }, getTypeSize<decltype(data.NAME())>()});   \
-	setByteArrayFunction[#NAME] = [this](XNByteArray byteArray) {                                  \
+	setByteArrayFunction[#NAME] = {                                                                \
-		setByteArray(data.NAME(), byteArray);                                                      \
+		[this](XNByteArray byteArray) { setByteArray(out_data.NAME(), byteArray); },               \
-	}
+		getTypeSize<decltype(out_data.NAME())>()};

XNModels/XNATA04DataProcessor/CMakeLists.txt

@@ -2,9 +2,6 @@ cmake_minimum_required(VERSION 3.16)
 
 project(XNATA04DataProcessor LANGUAGES CXX)
 
-set(CMAKE_AUTOUIC ON)
-set(CMAKE_AUTOMOC ON)
-set(CMAKE_AUTORCC ON)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
@@ -18,9 +15,6 @@ endif()
 # 添加 XNCore_PATH 下的 include 目录为包含目录
 include_directories(${XNCore_PATH}/include)
 
-find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core)
-find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core)
-
 add_library(XNATA04DataProcessor SHARED
 	XNATA04DataProcessor_global.h
 	XNATA04DataProcessor.cpp
@@ -29,7 +23,6 @@ add_library(XNATA04DataProcessor SHARED
 )
 
 target_link_libraries(XNATA04DataProcessor PRIVATE 
-    Qt${QT_VERSION_MAJOR}::Core 
     ${XNCore_PATH}/lib/libXNCore.so
 	${XNCore_PATH}/Models/libXNAerodynamicsInterface.so
 	${XNCore_PATH}/Models/libXNGroundHandlingInterface.so

XNModels/XNATA04DataProcessor/XNATA04DataProcessor.h

@@ -1,66 +1,50 @@
 #pragma once
 #include "XNATA04DataProcessor_global.h"
 #include <XNCore/XNModelObject.h>
-#include "../XNAerodynamics/XNAerodynamicsInterface/XNAerodynamicsPubSubTypes.hpp"
+// #include "../XNAerodynamics/XNAerodynamicsInterface/XNAerodynamicsPubSubTypes.hpp"
-#include "../XNWeightBalance/XNWeightBalanceInterface/XNWeightBalancePubSubTypes.hpp"
+// #include "../XNWeightBalance/XNWeightBalanceInterface/XNWeightBalancePubSubTypes.hpp"
-#include "../XNGroundHandling/XNGroundHandlingInterface/XNGroundHandlingPubSubTypes.hpp"
-#include <QVariant>
 class XNATA04DataProcessorPrivate;
 
 class XNATA04DATAPROCESSOR_EXPORT XNATA04DataProcessor : public XNModelObject
 {
-	Q_OBJECT
+	XN_METATYPE(XNATA04DataProcessor, XNModelObject)
-	Q_DISABLE_COPY(XNATA04DataProcessor)
+	XN_DECLARE_PRIVATE(XNATA04DataProcessor)
-	Q_DECLARE_PRIVATE(XNATA04DataProcessor)
-	XN_DECLARE_DDS()
 public:
-	explicit XNATA04DataProcessor(QObject *parent = nullptr);
+	XNATA04DataProcessor();
 	virtual ~XNATA04DataProcessor();
 
 protected:
-	XNATA04DataProcessor(XNATA04DataProcessorPrivate &dd, QObject *parent = nullptr);
+	XNATA04DataProcessor(PrivateType *p);
 
-public slots:
+public:
-	virtual void OnInitialize() override;
+	virtual void Initialize() override;
-	virtual void OnPrepareForExecute() override;
+	virtual void PrepareForExecute() override;
 
 public:
 	virtual void StepUpdate() override;
 
 private:
-	void OnWbOutput(const XNSim::ATA04::WeightBalance_output &output);
+	// void OnAeroInput(const QVariant &data);
 
-	void OnGhOutput(const XNSim::ATA04::GroundHandling_output &output);
+	// void OnWbInput(const QVariant &data);
 
-	void OnAeroOutput(const XNSim::ATA04::Aerodynamics_output &output);
+	void OnGhInput(const std::any &data);
-
-	void OnAeroHeartbeat(const XNSim::ATA04::Aerodynamics_heartbeat &heartbeat);
-
-	void OnWbHeartbeat(const XNSim::ATA04::WeightBalance_heartbeat &heartbeat);
-
-	void OnGhHeartbeat(const XNSim::ATA04::GroundHandling_heartbeat &heartbeat);
-
-	void OnAeroInput(const QVariant &data);
-
-	void OnWbInput(const QVariant &data);
-
-	void OnGhInput(const QVariant &data);
 
 	void SendUdpData();
 
-	void SendAeroOutput();
+	// void SendAeroOutput();
 
-	void SendWbOutput();
+	// void SendWbOutput();
 
 	void SendGhOutput();
 
-	void SendAeroHeartbeat();
+	// void SendAeroHeartbeat();
 
-	void SendWbHeartbeat();
+	// void SendWbHeartbeat();
 
 	void SendGhHeartbeat();
 
-	void SendUdpTestData();
+	//void SendUdpTestData();
 };
 
-Q_DECLARE_METATYPE(XNATA04DataProcessor)
+XNCLASS_PTR_DECLARE(XNATA04DataProcessor)

XNModels/XNATA04DataProcessor/XNATA04DataProcessor_global.h

@@ -1,12 +1,10 @@
 #ifndef XNATA04DATAPROCESSOR_GLOBAL_H
 #define XNATA04DATAPROCESSOR_GLOBAL_H
 
-#include <QtCore/qglobal.h>
-
 #if defined(XNATA04DATAPROCESSOR_LIBRARY)
-#	define XNATA04DATAPROCESSOR_EXPORT Q_DECL_EXPORT
+#	define XNATA04DATAPROCESSOR_EXPORT __attribute__((visibility("default")))
 #else
-#	define XNATA04DATAPROCESSOR_EXPORT Q_DECL_IMPORT
+#	define XNATA04DATAPROCESSOR_EXPORT __attribute__((visibility("default")))
 #endif
 
 #endif // XNATA04DATAPROCESSOR_GLOBAL_H

XNModels/XNATA04DataProcessor/XNATA04DataProcessor_p.h

@@ -1,30 +1,22 @@
 #pragma once
 #include <XNCore/XNModelObject_p.h>
-#include <QMutex>
+#include "../XNGroundHandling/XNGroundHandlingInterface/XNGroundHandlingInterface.hpp"
 
-class XNATA04DataProcessorPrivate : public XNModelObjectPrivate
+struct XNATA04DataProcessorPrivate : public XNModelObjectPrivate {
-{
+	// XNSim::C909::ATA04::Aerodynamics_input _aeroInput;
-public:
+	// XNSim::C909::ATA04::Aerodynamics_output _aeroOutput;
-	Q_DECLARE_PUBLIC(XNATA04DataProcessor)
+	// XNSim::C909::ATA04::WeightBalance_input _wbInput;
+	// XNSim::C909::ATA04::WeightBalance_output _wbOutput;
+	XNSim::C909::ATA04::GroundHandling_input _ghInput;
+	XNSim::C909::ATA04::GroundHandling_output _ghOutput;
+	// XNSim::C909::ATA04::Aerodynamics_heartbeat _aeroHeartbeat;
+	// XNSim::C909::ATA04::WeightBalance_heartbeat _wbHeartbeat;
+	XNSim::C909::ATA04::GroundHandling_heartbeat _ghHeartbeat;
 
-	XNATA04DataProcessorPrivate(XNATA04DataProcessor *q) : XNModelObjectPrivate(q) {}
+	XNSim::C909::ATA04::GroundHandling_input_Interface _ghInputInterface;
-
+	XNSim::C909::ATA04::GroundHandling_output_Interface _ghOutputInterface;
-	XNSim::ATA04::Aerodynamics_input _aeroInput;
+	XNSim::C909::ATA04::GroundHandling_heartbeat_Interface _ghHeartbeatInterface;
-	XNSim::ATA04::Aerodynamics_output _aeroOutput;
+	std::mutex _ghOutputMutex;
-	XNSim::ATA04::WeightBalance_input _wbInput;
+	std::mutex _ghHeartbeatMutex;
-	XNSim::ATA04::WeightBalance_output _wbOutput;
+	std::mutex _ghInputMutex;
-	XNSim::ATA04::GroundHandling_input _ghInput;
-	XNSim::ATA04::GroundHandling_output _ghOutput;
-	XNSim::ATA04::Aerodynamics_heartbeat _aeroHeartbeat;
-	XNSim::ATA04::WeightBalance_heartbeat _wbHeartbeat;
-	XNSim::ATA04::GroundHandling_heartbeat _ghHeartbeat;
-	QMutex _wbOutputMutex;
-	QMutex _ghOutputMutex;
-	QMutex _aeroOutputMutex;
-	QMutex _aeroHeartbeatMutex;
-	QMutex _wbHeartbeatMutex;
-	QMutex _ghHeartbeatMutex;
-	QMutex _aeroInputMutex;
-	QMutex _wbInputMutex;
-	QMutex _ghInputMutex;
 };

XNModels/XNGroundHandling/XNGroundHandling/XNGroundHandling.cpp

@@ -111,9 +111,9 @@ void XNGroundHandling::PrepareForExecute()
 	for (int i = 0; i < 3; i++) {
 		d->_data.output_ground->l_04_o_gdcomac_vczt_f8[i] = new double[2];
 	}
-	d->_inputInterface.Initialize(GetFramework(), GetUniqueId());
+	d->_inputInterface.Initialize(GetFramework(), GetUniqueId(), 1);
-	d->_outputInterface.Initialize(GetFramework(), GetUniqueId());
+	d->_outputInterface.Initialize(GetFramework(), GetUniqueId(), 2);
-	d->_heartbeatInterface.Initialize(GetFramework(), GetUniqueId());
+	d->_heartbeatInterface.Initialize(GetFramework(), GetUniqueId(), 2);
 }
 
 void XNGroundHandling::StepUpdate()

XNModels/XNGroundHandling/XNGroundHandlingInterface/XNGroundHandlingInterface.cxx

@@ -43,24 +43,46 @@ GroundHandling_input_Interface::GroundHandling_input_Interface()
 	MAP_DATA_FUNC(l_04_i_gdcomac_theta_deg_f8);
 	MAP_DATA_FUNC(l_04_i_gdcomac_psi_deg_f8);
 	MAP_DATA_FUNC(l_04_i_gdcomac_resetint_l1);
+	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; // 数据大小
 }
 
 GroundHandling_input_Interface::~GroundHandling_input_Interface()
 {
 }
 
-void GroundHandling_input_Interface::Initialize(XNFrameworkPtr framework, uint32_t modelId)
+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;
 	}
-	dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_inputPubSubType>(
+	if (DDS_type == 0) { // 读取与发送都进行
-		"XNSim::C909::ATA04::GroundHandling_input", modelId);
+		dataWriter =
-	ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_inputPubSubType>(
+			ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_inputPubSubType>(
-		"XNSim::C909::ATA04::GroundHandling_input", modelId,
+				"XNSim::C909::ATA04::GroundHandling_input", modelId);
-		std::bind(&GroundHandling_input_Interface::inputDataListener, this, std::placeholders::_1));
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_inputPubSubType>(
+			"XNSim::C909::ATA04::GroundHandling_input", modelId,
+			std::bind(&GroundHandling_input_Interface::inputDataListener, this,
+					  std::placeholders::_1));
+	} else if (DDS_type == 1) { // 只读取
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_inputPubSubType>(
+			"XNSim::C909::ATA04::GroundHandling_input", modelId,
+			std::bind(&GroundHandling_input_Interface::inputDataListener, this,
+					  std::placeholders::_1));
+	} else if (DDS_type == 2) { // 只发送
+		dataWriter =
+			ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_inputPubSubType>(
+				"XNSim::C909::ATA04::GroundHandling_input", modelId);
+	}
 }
 
 void GroundHandling_input_Interface::clearOutData()
@@ -116,25 +138,46 @@ GroundHandling_output_Interface::GroundHandling_output_Interface()
 	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[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)
+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;
 	}
-	dataWriter = ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_outputPubSubType>(
+	if (DDS_type == 0) { // 读取与发送都进行
-		"XNSim::C909::ATA04::GroundHandling_output", modelId);
+		dataWriter =
-	ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_outputPubSubType>(
+			ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_outputPubSubType>(
-		"XNSim::C909::ATA04::GroundHandling_output", modelId,
+				"XNSim::C909::ATA04::GroundHandling_output", modelId);
-		std::bind(&GroundHandling_output_Interface::outputDataListener, this,
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_outputPubSubType>(
-				  std::placeholders::_1));
+			"XNSim::C909::ATA04::GroundHandling_output", modelId,
+			std::bind(&GroundHandling_output_Interface::outputDataListener, this,
+					  std::placeholders::_1));
+	} else if (DDS_type == 1) { // 只读取
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_outputPubSubType>(
+			"XNSim::C909::ATA04::GroundHandling_output", modelId,
+			std::bind(&GroundHandling_output_Interface::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()
@@ -156,26 +199,46 @@ void GroundHandling_output_Interface::outputDataListener(
 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)
+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;
 	}
-	dataWriter =
+	if (DDS_type == 0) { // 读取与发送都进行
-		ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_heartbeatPubSubType>(
+		dataWriter =
-			"XNSim::C909::ATA04::GroundHandling_heartbeat", modelId);
+			ddsManager->RegisterPublisher<XNSim::C909::ATA04::GroundHandling_heartbeatPubSubType>(
-	ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_heartbeatPubSubType>(
+				"XNSim::C909::ATA04::GroundHandling_heartbeat", modelId);
-		"XNSim::C909::ATA04::GroundHandling_heartbeat", modelId,
+		ddsManager->RegisterSubscriber<XNSim::C909::ATA04::GroundHandling_heartbeatPubSubType>(
-		std::bind(&GroundHandling_heartbeat_Interface::heartbeatListener, this,
+			"XNSim::C909::ATA04::GroundHandling_heartbeat", modelId,
-				  std::placeholders::_1));
+			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()

XNModels/XNGroundHandling/XNGroundHandlingInterface/XNGroundHandlingInterface.hpp

@@ -10,7 +10,7 @@ public:
 	GroundHandling_input_Interface();
 	virtual ~GroundHandling_input_Interface();
 
-	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId) override;
+	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId, uint32_t DDS_type) override;
 	virtual void clearOutData() override;
 	virtual void sendOutData() override;
 
@@ -145,7 +145,7 @@ class GroundHandling_output_Interface final : public XNDDSInterface
 public:
 	GroundHandling_output_Interface();
 	virtual ~GroundHandling_output_Interface();
-	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId) override;
+	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;
@@ -263,7 +263,7 @@ class GroundHandling_heartbeat_Interface final : public XNDDSInterface
 public:
 	GroundHandling_heartbeat_Interface();
 	virtual ~GroundHandling_heartbeat_Interface();
-	virtual void Initialize(XNFrameworkPtr framework, uint32_t modelId) override;
+	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;