保姆级教程：在OpenHarmony 3.2上，用C++库libmodbus搞定Modbus TCP设备数据读取-平芜编程栈

从零到一：OpenHarmony 3.2集成libmodbus实现Modbus TCP设备通信全指南

当你第一次尝试在OpenHarmony上连接工业设备时，那种既兴奋又忐忑的心情我深有体会。作为一名曾经在工业物联网领域摸爬滚打多年的开发者，我清楚地记得自己第一次成功从Modbus设备读取数据时的成就感。本文将带你完整走一遍这个流程，从环境搭建到数据读取，再到那些教科书上不会告诉你的实战陷阱。

1. 环境准备：构建OpenHarmony与libmodbus的开发基础

在开始编码之前，我们需要确保开发环境配置正确。OpenHarmony 3.2为开发者提供了丰富的API支持，但要与Modbus TCP设备通信，我们需要引入一个强大的助手——libmodbus库。

1.1 OpenHarmony 3.2开发环境配置

首先确认你的开发环境满足以下要求：

操作系统：Ubuntu 20.04 LTS或Windows 10/11（推荐使用WSL2）
开发工具：
- DevEco Studio 3.1或更高版本
- OpenHarmony SDK 3.2
硬件准备：
- Hi3861或RK3568开发板
- 支持Modbus TCP的温湿度传感器（如AHT20模块）

提示：建议使用Ubuntu系统进行开发，可以避免许多环境兼容性问题。我在Windows上遇到过路径问题，花了半天时间才解决。

1.2 libmodbus库的引入与配置

libmodbus是一个轻量级的C库，简化了Modbus协议的实现。在OpenHarmony中引入它需要一些特殊处理：

# 下载libmodbus源码 git clone https://github.com/stephane/libmodbus.git cd libmodbus ./autogen.sh ./configure --prefix=/usr/local/ohos/modbus --host=arm-linux-ohosmusl make && make install

将编译好的库文件集成到OpenHarmony项目中：

在//applications/sample/目录下创建modbus文件夹
将编译生成的libmodbus.a和头文件复制到此目录
修改BUILD.gn文件，添加库依赖：

executable("modbus_demo") { sources = [ "modbus_demo.c", ] include_dirs = [ "//applications/sample/modbus/include", ... ] lib_dirs = [ "//applications/sample/modbus/lib", ] libs = [ "modbus", ] }

2. Modbus TCP连接建立与配置

2.1 理解Modbus TCP通信基础

与Modbus RTU不同，Modbus TCP基于以太网通信，不需要处理串口配置和CRC校验。关键参数包括：

参数	说明	典型值
IP地址	设备网络地址	192.168.1.10
端口号	Modbus TCP默认端口	502
设备ID	从站设备标识	1
寄存器地址	要读取的数据位置	0x0000

2.2 建立TCP连接的代码实现

让我们从创建一个基本的Modbus TCP连接开始：

#include <modbus.h> #include <stdio.h> int main() { modbus_t *ctx; uint16_t tab_reg[32]; int rc; // 创建Modbus TCP上下文 ctx = modbus_new_tcp("192.168.1.10", 502); if (ctx == NULL) { fprintf(stderr, "无法创建Modbus上下文\n"); return -1; } // 设置从站ID（设备地址） modbus_set_slave(ctx, 1); // 建立连接 if (modbus_connect(ctx) == -1) { fprintf(stderr, "连接失败: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } printf("成功连接到Modbus设备\n"); // 后续操作... // 关闭连接 modbus_close(ctx); modbus_free(ctx); return 0; }

这段代码做了以下几件事：

创建Modbus TCP上下文
设置从站设备地址
尝试建立连接
错误处理

注意：在实际项目中，你应该将IP地址和端口号作为配置参数，而不是硬编码在代码中。我在一个项目中因为硬编码导致切换测试环境时浪费了大量时间。

3. 数据读取实战：从寄存器获取温湿度值

3.1 理解温湿度传感器的寄存器映射

大多数Modbus温湿度传感器使用保持寄存器来存储数据。以常见的AHT20传感器为例：

寄存器地址	数据类型	描述	示例值
0x0000	uint16	温度整数部分	25
0x0001	uint16	温度小数部分(×0.1)	3
0x0002	uint16	湿度整数部分	50
0x0003	uint16	湿度小数部分(×0.1)	2

3.2 实现数据读取功能

扩展前面的代码，添加数据读取功能：

// 读取保持寄存器（功能码0x03） rc = modbus_read_registers(ctx, 0x0000, 4, tab_reg); if (rc == -1) { fprintf(stderr, "读取失败: %s\n", modbus_strerror(errno)); modbus_close(ctx); modbus_free(ctx); return -1; } // 解析温湿度数据 float temperature = tab_reg[0] + tab_reg[1] / 10.0; float humidity = tab_reg[2] + tab_reg[3] / 10.0; printf("当前温度: %.1f°C\n", temperature); printf("当前湿度: %.1f%%\n", humidity);

3.3 数据解析进阶技巧

工业设备常使用特殊的数据格式，比如：

大端/小端转换：

uint32_t raw_value = (tab_reg[0] << 16) | tab_reg[1]; float real_value = *(float*)&raw_value;

浮点数转换（ABCD顺序）：

float modbus_get_float_abcd(const uint16_t *src);

有符号数处理：

int16_t signed_value = (int16_t)tab_reg[0];

4. 实战避坑指南：常见问题与解决方案

4.1 连接失败排查清单

遇到连接问题时，按照以下步骤排查：

网络连通性检查

ping 192.168.1.10 telnet 192.168.1.10 502

Modbus配置验证
- 确认设备ID匹配
- 检查寄存器地址是否正确
- 验证字节顺序设置

libmodbus调试输出

modbus_set_debug(ctx, TRUE); // 启用调试输出

4.2 典型错误代码与解决方法

错误现象	可能原因	解决方案
Connection timed out	网络不通或IP错误	检查物理连接和IP配置
Illegal data address	寄存器地址无效	查阅设备文档确认有效地址范围
Illegal data value	写入值超出允许范围	检查设备规格中的有效值范围
Slave device failure	从站设备内部错误	重启设备或检查设备日志

4.3 性能优化建议

批量读取：减少请求次数

// 一次性读取多个寄存器 modbus_read_registers(ctx, start_addr, num_regs, buffer);

连接复用：避免频繁建立/断开连接

超时设置：根据网络状况调整

struct timeval response_timeout; response_timeout.tv_sec = 1; response_timeout.tv_usec = 0; modbus_set_response_timeout(ctx, &response_timeout);

5. 进阶应用：将Modbus数据集成到OpenHarmony应用

5.1 创建Native C++服务

在OpenHarmony中，我们可以创建一个Native服务来管理Modbus连接：

// modbus_service.h #include <string> #include <vector> class ModbusService { public: static ModbusService& GetInstance(); bool Connect(const std::string& ip, int port, int slave_id); std::vector<float> ReadTemperatureHumidity(); void Disconnect(); private: ModbusService(); ~ModbusService(); void* modbus_ctx_; };

5.2 通过NAPI暴露给JS应用

// modbus_napi.cpp #include <napi/native_api.h> #include "modbus_service.h" static napi_value Connect(napi_env env, napi_callback_info info) { // 获取JS参数 size_t argc = 3; napi_value args[3]; napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); // 解析参数 char ip[16]; size_t ip_len; napi_get_value_string_utf8(env, args[0], ip, sizeof(ip), &ip_len); int port; napi_get_value_int32(env, args[1], &port); int slave_id; napi_get_value_int32(env, args[2], &slave_id); // 调用Modbus服务 bool result = ModbusService::GetInstance().Connect(ip, port, slave_id); // 返回结果 napi_value retval; napi_get_boolean(env, result, &retval); return retval; } // 注册NAPI方法 EXTERN_C_START static napi_value Init(napi_env env, napi_value exports) { napi_property_descriptor desc[] = { {"connect", nullptr, Connect, nullptr, nullptr, nullptr, napi_default, nullptr}, // 注册其他方法... }; napi_define_properties(env, exports, sizeof(desc)/sizeof(desc[0]), desc); return exports; } EXTERN_C_END

5.3 在JS应用中调用

import modbus from 'libmodbus.so'; // 连接设备 const connected = modbus.connect('192.168.1.10', 502, 1); if (!connected) { console.error('连接Modbus设备失败'); return; } // 定时读取数据 setInterval(() => { const [temp, humidity] = modbus.readTemperatureHumidity(); console.log(`温度: ${temp}°C, 湿度: ${humidity}%`); }, 5000);

6. 项目实战：构建一个温湿度监控应用

6.1 应用架构设计

OpenHarmony温湿度监控应用架构 ├── UI层 (ETS) │ ├── 实时数据显示 │ ├── 历史数据图表 │ └── 设备配置界面 ├── 业务逻辑层 │ ├── 数据采集服务 │ ├── 数据存储服务 │ └── 告警服务 └── 设备通信层 ├── Modbus TCP通信 └── 设备状态管理

6.2 关键实现代码

数据采集服务：

// data_service.ets import worker from '@ohos.worker'; import modbus from 'libmodbus.so'; const MAX_RETRY = 3; export class DataService { private worker: worker.ThreadWorker; private retryCount = 0; constructor(private config: ModbusConfig) { this.worker = new worker.ThreadWorker('workers/data_worker.js'); this.setupWorkerHandlers(); } private setupWorkerHandlers() { this.worker.onmessage = (message: worker.MessageEvents) => { if (message.data.type === 'DATA_UPDATE') { // 更新UI数据 AppStorage.SetOrCreate('currentTemp', message.data.temp); AppStorage.SetOrCreate('currentHumidity', message.data.humidity); this.retryCount = 0; } else if (message.data.type === 'ERROR') { if (this.retryCount++ < MAX_RETRY) { console.warn(`采集失败，第${this.retryCount}次重试...`); this.worker.postMessage({type: 'RETRY'}); } else { console.error('采集失败次数过多，停止采集'); this.stop(); } } }; } start() { this.worker.postMessage({ type: 'START', config: this.config }); } stop() { this.worker.postMessage({type: 'STOP'}); } }

Worker线程实现(workers/data_worker.js):

// workers/data_worker.js import worker from '@ohos.worker'; import modbus from 'libmodbus.so'; const workerPort = worker.workerPort; let intervalId = null; let modbusConnected = false; workerPort.onmessage = (e) => { switch (e.data.type) { case 'START': startMonitoring(e.data.config); break; case 'STOP': stopMonitoring(); break; case 'RETRY': if (!modbusConnected) { connectModbus(e.data.config); } break; } }; function connectModbus(config) { modbusConnected = modbus.connect(config.ip, config.port, config.slaveId); if (!modbusConnected) { workerPort.postMessage({ type: 'ERROR', message: '连接Modbus设备失败' }); } return modbusConnected; } function startMonitoring(config) { if (!connectModbus(config)) return; intervalId = setInterval(() => { try { const [temp, humidity] = modbus.readTemperatureHumidity(); workerPort.postMessage({ type: 'DATA_UPDATE', temp: temp, humidity: humidity, timestamp: new Date().getTime() }); } catch (error) { modbusConnected = false; workerPort.postMessage({ type: 'ERROR', message: error.message }); } }, config.interval || 5000); } function stopMonitoring() { if (intervalId) clearInterval(intervalId); if (modbusConnected) modbus.disconnect(); workerPort.close(); }

6.3 性能优化与稳定性增强

连接池管理：对于多设备场景，实现连接池避免频繁创建销毁连接
数据缓存：在网络不稳定时提供最近一次有效数据
断线重连：自动检测连接状态并尝试恢复
数据校验：对读取的数据进行合理性检查

// 连接池实现示例 class ModbusConnectionPool { public: static const int MAX_POOL_SIZE = 5; ModbusConnection* GetConnection(const std::string& ip, int port) { std::lock_guard<std::mutex> lock(mutex_); // 查找空闲连接 for (auto& conn : connections_) { if (conn->IsIdle() && conn->Match(ip, port)) { conn->SetBusy(); return conn.get(); } } // 创建新连接 if (connections_.size() < MAX_POOL_SIZE) { auto conn = std::make_unique<ModbusConnection>(ip, port); auto* raw_ptr = conn.get(); connections_.push_back(std::move(conn)); return raw_ptr; } return nullptr; } void ReleaseConnection(ModbusConnection* conn) { std::lock_guard<std::mutex> lock(mutex_); conn->SetIdle(); } private: std::vector<std::unique_ptr<ModbusConnection>> connections_; std::mutex mutex_; };

7. 测试与调试：确保工业级可靠性

7.1 单元测试策略

针对Modbus通信层，我们需要构建全面的测试用例：

// modbus_test.cpp #include <gtest/gtest.h> #include "modbus_service.h" class ModbusTest : public ::testing::Test { protected: void SetUp() override { service = &ModbusService::GetInstance(); } ModbusService* service; }; TEST_F(ModbusTest, ConnectionTest) { // 使用模拟器地址 bool connected = service->Connect("127.0.0.1", 5502, 1); EXPECT_TRUE(connected); if (connected) { auto data = service->ReadTemperatureHumidity(); EXPECT_EQ(data.size(), 2); service->Disconnect(); } } TEST_F(ModbusTest, InvalidAddressTest) { bool connected = service->Connect("192.168.99.99", 502, 1); EXPECT_FALSE(connected); }

7.2 集成测试方案

硬件在环测试：使用真实的Modbus设备进行端到端测试
模拟器方案：开发Modbus设备模拟器进行自动化测试

# Modbus设备模拟器示例（Python） from pyModbusTCP.server import ModbusServer, DataBank server = ModbusServer("127.0.0.1", 5502, no_block=True) server.start() # 设置模拟数据 DataBank.set_words(0, [250, 5]) # 温度25.5°C DataBank.set_words(2, [600, 0]) # 湿度60.0% print("Modbus模拟器运行中...") input("按Enter键停止...") server.stop()

7.3 性能测试指标

测试项	目标值	测试方法
单次读取延迟	<100ms	统计100次读取的平均时间
并发连接数	≥10	模拟多客户端同时连接
长时间稳定性	24小时无故障运行	持续运行并监控内存泄漏
断网恢复能力	<5秒自动恢复	手动断开网络后测量恢复时间

8. 部署与运维：生产环境最佳实践

8.1 打包与部署

OpenHarmony应用的打包需要考虑Modbus库的依赖：

静态链接：将libmodbus静态编译到应用中

executable("modbus_app") { sources = [ "main.cpp" ] libs = [ "//third_party/modbus:libmodbus" ] ldflags = [ "-static" ] }

动态链接：将libmodbus.so打包到应用的libs目录

8.2 配置管理

建议采用分层配置方案：

// config.json { "modbus": { "devices": [ { "name": "温湿度传感器1", "ip": "192.168.1.10", "port": 502, "slave_id": 1, "registers": { "temperature": {"address": 0, "type": "float"}, "humidity": {"address": 2, "type": "float"} } } ], "polling_interval": 5000, "timeout": 1000 } }

8.3 监控与日志

实现完善的日志系统对工业应用至关重要：

class ModbusLogger { public: enum Level { DEBUG, INFO, WARNING, ERROR }; static void Log(Level level, const std::string& message) { std::string level_str; switch (level) { case DEBUG: level_str = "DEBUG"; break; case INFO: level_str = "INFO"; break; case WARNING: level_str = "WARNING"; break; case ERROR: level_str = "ERROR"; break; } std::time_t now = std::time(nullptr); std::string timestamp = std::ctime(&now); timestamp.pop_back(); // 移除换行符 std::string log_entry = "[" + timestamp + "] [" + level_str + "] " + message; // 控制台输出 std::cout << log_entry << std::endl; // 文件日志 std::ofstream log_file("modbus.log", std::ios::app); if (log_file.is_open()) { log_file << log_entry << std::endl; } // 系统日志 // ... } };

9. 扩展思考：从Modbus到工业物联网平台

9.1 多协议支持架构

class IndustrialProtocol { public: virtual ~IndustrialProtocol() = default; virtual bool connect() = 0; virtual std::vector<float> readData() = 0; virtual void disconnect() = 0; }; class ModbusProtocol : public IndustrialProtocol { // 实现Modbus协议 }; class OPCUAProtocol : public IndustrialProtocol { // 实现OPC UA协议 }; class ProtocolFactory { public: static std::unique_ptr<IndustrialProtocol> create(ProtocolType type) { switch (type) { case ProtocolType::MODBUS: return std::make_unique<ModbusProtocol>(); case ProtocolType::OPCUA: return std::make_unique<OPCUAProtocol>(); default: return nullptr; } } };

9.2 数据标准化与云端集成

// 数据上传服务 class CloudService { async upload(data: SensorData[]) { const standardized = data.map(item => ({ timestamp: item.timestamp, deviceId: item.deviceId, metrics: { temperature: { value: item.temp, unit: "°C" }, humidity: { value: item.humidity, unit: "%" } }, metadata: { protocol: "modbus", accuracy: 0.5 } })); try { const response = await fetch('https://cloud-api.example.com/telemetry', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(standardized) }); if (!response.ok) { throw new Error(`上传失败: ${response.status}`); } } catch (error) { // 重试逻辑 console.error('数据上传失败:', error); this.retryQueue.push(standardized); } } private retryQueue: any[] = []; startRetryTimer() { setInterval(async () => { if (this.retryQueue.length > 0) { const data = this.retryQueue.shift(); await this.upload(data); } }, 60000); } }

9.3 边缘计算与数据处理

// 边缘数据处理示例 class EdgeProcessor { public: void addData(const SensorData& data) { // 简单滤波 if (lastValues_.size() >= windowSize_) { lastValues_.pop_front(); } lastValues_.push_back(data.value); // 计算移动平均 currentAverage_ = std::accumulate(lastValues_.begin(), lastValues_.end(), 0.0) / lastValues_.size(); // 异常检测 if (std::abs(data.value - currentAverage_) > threshold_) { triggerAlert(data); } } private: std::deque<float> lastValues_; size_t windowSize_ = 5; float currentAverage_ = 0; float threshold_ = 2.0; void triggerAlert(const SensorData& data) { // 本地处理或上报 AlertManager::instance().addAlert({ type: "DATA_ANOMALY", value: data.value, average: currentAverage_, timestamp: data.timestamp }); } };

10. 安全考量：工业通信的安全加固

10.1 基础安全措施

网络隔离：将工业设备部署在独立网络区域
访问控制：限制可以访问Modbus端口的IP地址
端口安全：修改默认的502端口（如果可能）

10.2 数据完整性验证

// 数据校验增强 class DataValidator { public: bool validate(const ModbusResponse& response) { // 范围检查 if (response.value < minValue_ || response.value > maxValue_) { return false; } // 变化率检查 float rate = std::abs(response.value - lastValue_) / lastValue_; if (rate > maxRate_) { return false; } lastValue_ = response.value; return true; } private: float lastValue_ = 0; float minValue_ = 0; float maxValue_ = 100; float maxRate_ = 0.2; // 20% };

10.3 安全通信进阶方案

对于高安全要求的场景，可以考虑：

VPN隧道：在Modbus TCP外层建立加密通道
协议转换：通过安全网关将Modbus转换为更安全的协议
签名验证：在应用层添加数据签名机制

// 简单的应用层签名示例 class SecureModbus { public: struct SecureResponse { uint16_t value; uint32_t checksum; }; SecureResponse readSecure(uint8_t function, uint16_t address) { auto raw = modbus_read_registers(ctx, address, 1); SecureResponse response; response.value = raw[0]; response.checksum = calculateChecksum(function, address, raw[0]); return response; } bool validateResponse(const SecureResponse& resp, uint8_t function, uint16_t address) { return resp.checksum == calculateChecksum(function, address, resp.value); } private: uint32_t calculateChecksum(uint8_t function, uint16_t address, uint16_t value) { // 简单的校验和计算 return (function << 24) | (address << 8) | (value & 0xFF); } };

11. 性能调优：应对高频率数据采集

11.1 多线程数据采集

class DataCollector { public: DataCollector(int interval_ms) : interval_(interval_ms) {} void start() { stop_ = false; worker_ = std::thread([this]() { while (!stop_) { auto start = std::chrono::steady_clock::now(); // 并行读取多个设备 std::vector<std::future<SensorData>> futures; for (auto& device : devices_) { futures.push_back(std::async(std::launch::async, [&device]() { return device.read(); })); } // 收集结果 std::vector<SensorData> results; for (auto& fut : futures) { results.push_back(fut.get()); } // 通知观察者 notifyObservers(results); // 精确间隔控制 auto end = std::chrono::steady_clock::now(); auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start); if (elapsed < interval_) { std::this_thread::sleep_for(interval_ - elapsed); } } }); } void stop() { stop_ = true; if (worker_.joinable()) { worker_.join(); } } private: std::vector<ModbusDevice> devices_; std::chrono::milliseconds interval_; std::thread worker_; std::atomic<bool> stop_{false}; };

11.2 批量读取优化

// 批量读取多个寄存器的优化实现 std::map<uint16_t, uint16_t> ModbusDevice::readMultipleRegisters( const std::vector<uint16_t>& addresses) { if (addresses.empty()) return {}; // 找出连续的寄存器块 std::vector<std::pair<uint16_t, uint16_t>> blocks; std::sort(addresses.begin(), addresses.end()); uint16_t start = addresses[0]; uint16_t count = 1; for (size_t i = 1; i < addresses.size(); ++i) { if (addresses[i] == addresses[i-1] + 1) { count++; } else { blocks.emplace_back(start, count); start = addresses[i]; count = 1; } } blocks.emplace_back(start, count); // 并行读取各个块 std::map<uint16_t, uint16_t> results; std::mutex results_mutex; std::vector<std::thread> threads; for (const auto& block : blocks) { threads.emplace_back([&, block]() { std::vector<uint16_t> values(block.second); if (modbus_read_registers(ctx, block.first, block.second, values.data()) == block.second) { std::lock_guard<std::mutex> lock(results_mutex); for (uint16_t i = 0; i < block.second; ++i) { results[block.first + i] = values[i]; } } }); } for (auto& t : threads) { t.join(); } return results; }

11.3 内存与资源管理

// 资源管理RAII类 class ModbusConnectionRAII { public: ModbusConnectionRAII(const std::string& ip, int port) { ctx_ = modbus_new_tcp(ip.c_str(), port); if (ctx_ && modbus_connect(ctx_) == -1) { modbus_free(ctx_); ctx_ = nullptr; } } ~ModbusConnectionRAII() { if (ctx_) { modbus_close(ctx_); modbus_free(ctx_); } } operator modbus_t*() const { return ctx_; } explicit operator bool() const { return ctx_ != nullptr; } // 禁止拷贝 ModbusConnectionRAII(const ModbusConnectionRAII&) = delete; ModbusConnectionRAII& operator=(const ModbusConnectionRAII&) = delete; // 允许移动 ModbusConnectionRAII(ModbusConnectionRAII&& other) noexcept : ctx_(other.ctx_) { other.ctx_ = nullptr; } ModbusConnectionRAII& operator=(ModbusConnectionRAII&& other) noexcept { if (this != &other) { if (ctx_) { modbus_close(ctx_); modbus_free(ctx_); } ctx_ = other.ctx_; other.ctx_ = nullptr; } return *this; } private: modbus_t* ctx_ = nullptr; };

12. 跨平台考量：代码的可移植性设计

12.1 抽象硬件依赖

// 硬件抽象层接口 class HardwareAbstraction { public: virtual ~HardwareAbstraction() = default; virtual bool initialize() = 0; virtual std::vector<uint8_t> readBytes(size_t count) = 0; virtual bool writeBytes(const std::vector<uint8_t>& data) = 0; virtual uint64_t getTickCount() = 0; }; // OpenHarmony实现 class OpenHarmonyHardware : public HardwareAbstraction { public: bool initialize() override { // 初始化OHOS硬件接口 return true; } std::vector<uint8_t> readBytes(size_t count) override { std::vector<uint8_t> data(count); // 调用OHOS的硬件读取API return data; } bool writeBytes(const std::vector<uint8_t>& data) override { // 调用OHOS的硬件写入API return true; } uint64_t getTickCount() override { return OHOS::GetSystemTickCount(); } };

12.2 条件编译处理平台差异

// platform_abstraction.h #ifdef OPENHARMONY_PLATFORM #include "openharmony_hardware.h" using PlatformHardware = OpenHarmonyHardware; #elif defined(LINUX_PLATFORM) #include "linux_hardware.h" using PlatformHardware = LinuxHardware; #else #error "Unsupported platform" #endif // 应用代码中使用 void doSomething() { PlatformHardware hardware; if (hardware.initialize()) { auto data = hardware.readBytes(128); // ... } }

12.3 构建系统适配

# BUILD.gn import("//build/ohos.gni") if (current_os == "ohos") { defines = [ "OPENHARMONY_PLATFORM" ] sources = [ "src/openharmony_adapter.cpp" ] } else { defines = [ "LINUX_PLATFORM" ] sources = [ "src/linux_adapter.cpp" ] } executable("modbus_demo") { sources += [ "src/main.cpp" ] defines += [ "MODBUS_ENABLED" ] deps = [ "//third_party/modbus" ] }

13. 生态整合：与OpenHarmony其他模块协同

13.1 与分布式数据管理集成

// 分布式数据同步 import distributedData from '@ohos.data.distributedData'; class DistributedDataSync { private kvManager: distributedData.KVManager; private kvStore: distributedData.KVStore; async init() { this.kvManager = distributedData.createKVManager({ bundleName: 'com.example.modbus', kvStoreType: distributedData.KVStoreType.SINGLE_VERSION }); this.kvStore = await this.kvManager.getKVStore('modbus_data', { createIfMissing: true, encrypt: false, backup: false, autoSync: true, kvStoreType: distributedData.KVStoreType.SINGLE_VERSION }); } async syncData(deviceId: string, data: SensorData) { try { await this.kvStore.put(deviceId, JSON.stringify(data)); console.log('数据同步成功'); } catch (error) { console.error('数据同步失败:', error); } } }

13.2 与通知系统集成

// 告警通知 import notification from '@ohos.notification'; class AlarmNotifier { static async notifyAlarm(deviceName