819 lines
29 KiB
Markdown
819 lines
29 KiB
Markdown
你需要在已有的工业级嵌入式菜单组件中，拓展**参数与Modbus寄存器地址的灵活映射功能**：让每个参数能根据自身性质（数据类型、读写权限、业务属性）匹配对应的Modbus寄存器（包括线圈、离散输入、保持寄存器、输入寄存器），支持寄存器地址的配置、映射查询，以及参数值与寄存器数据的双向转换，同时保持与原有组件的解耦和工业级的鲁棒性。
|
||
|
||
以下是基于原有目录结构的详细实现方案，遵循**分层解耦、静态内存、可配置、类型安全**的工业级设计原则。
|
||
|
||
---
|
||
|
||
## 一、设计核心思路（工业级考量）
|
||
1. **解耦设计**：Modbus映射模块作为独立的功能扩展层，依赖原有参数模块的接口，不侵入核心逻辑。
|
||
2. **静态内存**：使用静态数组存储Modbus映射关系，避免动态分配，适配嵌入式内存约束。
|
||
3. **类型匹配**：参数类型与Modbus寄存器数据类型（1位、8位、16位、32位、浮点）自动转换，支持大小端配置。
|
||
4. **权限控制**：映射时指定寄存器的读写权限（只读/只写/读写），与参数的权限联动。
|
||
5. **灵活配置**：支持单参数映射单寄存器、单参数映射多寄存器（如32位浮点占2个16位保持寄存器）。
|
||
6. **可裁剪**：通过宏开关控制Modbus映射功能的启用/关闭，不影响原有功能。
|
||
|
||
---
|
||
|
||
## 二、代码实现（按目录结构补充/修改）
|
||
### 1. 对外API层（`menu/api/`）
|
||
#### 1.1 修改`menu/api/menu_config.h`（添加Modbus映射配置宏）
|
||
在原有配置后新增Modbus相关配置，保持可裁剪性：
|
||
```c
|
||
/************************** Modbus映射功能配置（可裁剪） **************************/
|
||
/**
|
||
* @brief 是否启用参数-Modbus寄存器映射功能
|
||
*/
|
||
#define MENU_CONFIG_ENABLE_MODBUS_MAP 1
|
||
|
||
/**
|
||
* @brief 最大Modbus映射数量（静态内存，根据项目调整）
|
||
*/
|
||
#define MENU_CONFIG_MAX_MODBUS_MAPS 16
|
||
|
||
/**
|
||
* @brief Modbus寄存器地址最大值（根据实际Modbus从站配置）
|
||
*/
|
||
#define MENU_CONFIG_MODBUS_MAX_ADDR 0xFFFF
|
||
|
||
/**
|
||
* @brief 默认Modbus字节序（0-小端，1-大端，2-字小端字节大端（Modbus标准））
|
||
*/
|
||
#define MENU_CONFIG_MODBUS_BYTE_ORDER 2
|
||
|
||
/**
|
||
* @brief 是否启用Modbus映射权限校验（与参数权限联动）
|
||
*/
|
||
#define MENU_CONFIG_MODBUS_PERMISSION 1
|
||
```
|
||
|
||
#### 1.2 修改`menu/api/menu.h`（添加Modbus映射的对外接口和类型）
|
||
在原有内容后新增Modbus相关的类型和接口，作为用户可调用的API：
|
||
```c
|
||
/************************** Modbus映射功能（启用时有效） **************************/
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
/**
|
||
* @brief Modbus寄存器类型（符合Modbus协议标准）
|
||
*/
|
||
typedef enum {
|
||
MODBUS_REG_TYPE_COIL = 0, ///< 线圈（1位，地址范围00001-09999）
|
||
MODBUS_REG_TYPE_DISCRETE_INPUT, ///< 离散输入（1位，地址范围10001-19999）
|
||
MODBUS_REG_TYPE_HOLDING_REG, ///< 保持寄存器（16位，地址范围40001-49999）
|
||
MODBUS_REG_TYPE_INPUT_REG, ///< 输入寄存器（16位，地址范围30001-39999）
|
||
} ModbusRegType;
|
||
|
||
/**
|
||
* @brief Modbus寄存器读写权限
|
||
*/
|
||
typedef enum {
|
||
MODBUS_PERM_READ_ONLY = 0, ///< 只读（如离散输入、输入寄存器）
|
||
MODBUS_PERM_WRITE_ONLY, ///< 只写（如线圈）
|
||
MODBUS_PERM_READ_WRITE, ///< 读写（如保持寄存器）
|
||
} ModbusPerm;
|
||
|
||
/**
|
||
* @brief Modbus映射结构体（对外只读，内部初始化）
|
||
*/
|
||
typedef struct {
|
||
uint16_t param_id; ///< 关联的参数ID
|
||
ModbusRegType reg_type; ///< 寄存器类型
|
||
uint16_t reg_addr; ///< 寄存器起始地址（协议地址，如40001）
|
||
uint8_t reg_count; ///< 占用寄存器数量（如32位浮点占2个16位寄存器）
|
||
ModbusPerm perm; ///< 读写权限
|
||
uint8_t byte_order; ///< 字节序（0-小端，1-大端，2-Modbus标准）
|
||
} ModbusMap;
|
||
|
||
/**
|
||
* @brief 注册参数与Modbus寄存器的映射关系
|
||
* @param param_id 参数ID（需已通过menu_param_register注册）
|
||
* @param reg_type 寄存器类型
|
||
* @param reg_addr 寄存器起始地址（协议地址，如40001）
|
||
* @param reg_count 占用寄存器数量（如1:16位，2:32位，4:64位）
|
||
* @param perm 读写权限
|
||
* @param byte_order 字节序（可选，默认使用MENU_CONFIG_MODBUS_BYTE_ORDER）
|
||
* @return 错误码
|
||
*/
|
||
MenuErrCode menu_modbus_map_register(uint16_t param_id, ModbusRegType reg_type, uint16_t reg_addr, uint8_t reg_count, ModbusPerm perm, uint8_t byte_order);
|
||
|
||
/**
|
||
* @brief 根据参数ID查询Modbus映射关系
|
||
* @param param_id 参数ID
|
||
* @param map 输出参数，映射关系结构体
|
||
* @return 错误码
|
||
*/
|
||
MenuErrCode menu_modbus_map_query_by_param(uint16_t param_id, ModbusMap* map);
|
||
|
||
/**
|
||
* @brief 根据寄存器地址和类型查询Modbus映射关系
|
||
* @param reg_type 寄存器类型
|
||
* @param reg_addr 寄存器地址
|
||
* @param map 输出参数，映射关系结构体
|
||
* @return 错误码
|
||
*/
|
||
MenuErrCode menu_modbus_map_query_by_reg(ModbusRegType reg_type, uint16_t reg_addr, ModbusMap* map);
|
||
|
||
/**
|
||
* @brief 将参数值写入对应的Modbus寄存器（双向转换：参数值→寄存器数据）
|
||
* @param param_id 参数ID
|
||
* @param reg_buf 输出参数，寄存器数据缓冲区（需足够大，如32位占2个16位寄存器）
|
||
* @param buf_len 缓冲区长度（输入），实际写入长度（输出）
|
||
* @return 错误码
|
||
*/
|
||
MenuErrCode menu_modbus_map_param_to_reg(uint16_t param_id, uint8_t* reg_buf, uint8_t* buf_len);
|
||
|
||
/**
|
||
* @brief 将Modbus寄存器数据读取到参数值（双向转换：寄存器数据→参数值）
|
||
* @param param_id 参数ID
|
||
* @param reg_buf 输入参数，寄存器数据缓冲区
|
||
* @param buf_len 缓冲区长度
|
||
* @return 错误码
|
||
*/
|
||
MenuErrCode menu_modbus_map_reg_to_param(uint16_t param_id, const uint8_t* reg_buf, uint8_t buf_len);
|
||
|
||
#endif // MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
```
|
||
|
||
### 2. 内部头文件层（`menu/internal/`）
|
||
#### 2.1 修改`menu/internal/menu_core.h`（添加Modbus映射的内部类型）
|
||
在原有核心类型后新增Modbus映射的内部结构体（比对外结构体更详细，包含数据转换的辅助信息）：
|
||
```c
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
/**
|
||
* @brief Modbus映射内部结构体（包含数据转换的辅助信息，用户无需关心）
|
||
*/
|
||
typedef struct {
|
||
ModbusMap pub; ///< 对外暴露的映射信息（兼容外部结构体）
|
||
bool is_registered; ///< 是否已注册
|
||
MenuParamType param_type; ///< 关联的参数类型（缓存，避免重复查询）
|
||
uint16_t reg_addr_offset; ///< 寄存器地址偏移（协议地址→实际地址，如40001→0）
|
||
} ModbusMapInternal;
|
||
#endif // MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
```
|
||
|
||
#### 2.2 修改`menu/internal/menu_data.h`（添加Modbus映射的静态全局数据）
|
||
在原有共享数据后新增Modbus映射的静态数组（静态内存，无动态分配）：
|
||
```c
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
/**
|
||
* @brief Modbus映射上下文（静态全局，仅内部访问）
|
||
*/
|
||
static ModbusMapInternal s_menu_modbus_maps[MENU_CONFIG_MAX_MODBUS_MAPS];
|
||
#endif // MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
```
|
||
|
||
### 3. 功能扩展层（`menu/src/features/`）
|
||
#### 3.1 新增`menu/src/features/menu_modbus.c`（Modbus映射核心逻辑）
|
||
实现Modbus映射的注册、查询、数据双向转换，与原有参数模块无缝集成：
|
||
```c
|
||
/**
|
||
* @file menu_modbus.c
|
||
* @brief 菜单参数-Modbus寄存器映射：注册、查询、数据双向转换（工业级：类型安全、字节序适配）
|
||
*/
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
#include "menu.h"
|
||
#include "menu_core.h"
|
||
#include "menu_data.h"
|
||
#include "menu_def.h"
|
||
#include <stddef.h>
|
||
#include <string.h>
|
||
|
||
/************************** 内部辅助函数 **************************/
|
||
/**
|
||
* @brief 转换Modbus协议地址到实际偏移地址（如40001→0，00001→0）
|
||
* @param reg_type 寄存器类型
|
||
* @param reg_addr 协议地址（如40001）
|
||
* @param offset 输出参数，实际偏移地址
|
||
* @return 错误码
|
||
*/
|
||
static MenuErrCode menu_modbus_convert_addr(ModbusRegType reg_type, uint16_t reg_addr, uint16_t* offset)
|
||
{
|
||
if (offset == NULL)
|
||
{
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 校验协议地址范围（符合Modbus标准）
|
||
switch (reg_type)
|
||
{
|
||
case MODBUS_REG_TYPE_COIL:
|
||
if (reg_addr < 1 || reg_addr > 9999)
|
||
{
|
||
MENU_DEBUG("Modbus coil addr out of range: %d", reg_addr);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
*offset = reg_addr - 1;
|
||
break;
|
||
case MODBUS_REG_TYPE_DISCRETE_INPUT:
|
||
if (reg_addr < 10001 || reg_addr > 19999)
|
||
{
|
||
MENU_DEBUG("Modbus discrete input addr out of range: %d", reg_addr);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
*offset = reg_addr - 10001;
|
||
break;
|
||
case MODBUS_REG_TYPE_HOLDING_REG:
|
||
if (reg_addr < 40001 || reg_addr > 49999)
|
||
{
|
||
MENU_DEBUG("Modbus holding reg addr out of range: %d", reg_addr);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
*offset = reg_addr - 40001;
|
||
break;
|
||
case MODBUS_REG_TYPE_INPUT_REG:
|
||
if (reg_addr < 30001 || reg_addr > 39999)
|
||
{
|
||
MENU_DEBUG("Modbus input reg addr out of range: %d", reg_addr);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
*offset = reg_addr - 30001;
|
||
break;
|
||
default:
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 校验实际偏移地址不超过配置的最大值
|
||
if (*offset > MENU_CONFIG_MODBUS_MAX_ADDR)
|
||
{
|
||
MENU_DEBUG("Modbus reg offset out of range: %d", *offset);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
return MENU_OK;
|
||
}
|
||
|
||
/**
|
||
* @brief 校验寄存器类型与参数类型的匹配性（工业级：类型安全）
|
||
* @param param_type 参数类型
|
||
* @param reg_type 寄存器类型
|
||
* @return 错误码
|
||
*/
|
||
static MenuErrCode menu_modbus_check_type_match(MenuParamType param_type, ModbusRegType reg_type)
|
||
{
|
||
// 1位寄存器（线圈、离散输入）只能匹配布尔型/8位整型参数
|
||
if (reg_type == MODBUS_REG_TYPE_COIL || reg_type == MODBUS_REG_TYPE_DISCRETE_INPUT)
|
||
{
|
||
if (param_type != MENU_PARAM_TYPE_INT8 && param_type != MENU_PARAM_TYPE_UINT8)
|
||
{
|
||
MENU_DEBUG("Modbus 1-bit reg not match param type: %d", param_type);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
return MENU_OK;
|
||
}
|
||
|
||
// 16位寄存器（保持、输入）可匹配所有类型（16/32/浮点需多寄存器）
|
||
return MENU_OK;
|
||
}
|
||
|
||
/**
|
||
* @brief 字节序转换（适配不同的Modbus字节序，工业级：兼容不同从站）
|
||
* @param data 数据缓冲区（16位为单位）
|
||
* @param len 数据长度（16位的数量）
|
||
* @param byte_order 字节序（0-小端，1-大端，2-Modbus标准（字小端，字节大端））
|
||
* @param is_reverse 是否反向转换（用于读取/写入）
|
||
*/
|
||
static void menu_modbus_byte_order_convert(uint16_t* data, uint8_t len, uint8_t byte_order, bool is_reverse)
|
||
{
|
||
if (data == NULL || len == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 默认使用配置的字节序
|
||
if (byte_order > 2)
|
||
{
|
||
byte_order = MENU_CONFIG_MODBUS_BYTE_ORDER;
|
||
}
|
||
|
||
switch (byte_order)
|
||
{
|
||
case 0: // 小端（低字节在前，高字节在后）
|
||
if (is_reverse)
|
||
{
|
||
for (uint8_t i = 0; i < len; i++)
|
||
{
|
||
data[i] = (data[i] << 8) | (data[i] >> 8);
|
||
}
|
||
}
|
||
break;
|
||
case 1: // 大端（高字节在前，低字节在后）
|
||
// 无需转换，Modbus默认是大端
|
||
break;
|
||
case 2: // Modbus标准（字小端，字节大端：如32位值0x12345678→0x5678 0x1234）
|
||
if (is_reverse)
|
||
{
|
||
// 读取时：将Modbus顺序转换为主机顺序
|
||
for (uint8_t i = 0; i < len; i += 2)
|
||
{
|
||
if (i + 1 < len)
|
||
{
|
||
uint16_t temp = data[i];
|
||
data[i] = data[i + 1];
|
||
data[i + 1] = temp;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 写入时：将主机顺序转换为Modbus顺序
|
||
for (uint8_t i = 0; i < len; i += 2)
|
||
{
|
||
if (i + 1 < len)
|
||
{
|
||
uint16_t temp = data[i];
|
||
data[i] = data[i + 1];
|
||
data[i + 1] = temp;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 查找Modbus映射（通过参数ID）
|
||
* @param param_id 参数ID
|
||
* @return 映射内部结构体指针（NULL表示未找到）
|
||
*/
|
||
static ModbusMapInternal* menu_modbus_find_by_param(uint16_t param_id)
|
||
{
|
||
for (uint8_t i = 0; i < MENU_CONFIG_MAX_MODBUS_MAPS; i++)
|
||
{
|
||
if (s_menu_modbus_maps[i].is_registered && s_menu_modbus_maps[i].pub.param_id == param_id)
|
||
{
|
||
return &s_menu_modbus_maps[i];
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/**
|
||
* @brief 查找Modbus映射（通过寄存器类型和地址）
|
||
* @param reg_type 寄存器类型
|
||
* @param reg_addr 寄存器地址（协议地址）
|
||
* @return 映射内部结构体指针（NULL表示未找到）
|
||
*/
|
||
static ModbusMapInternal* menu_modbus_find_by_reg(ModbusRegType reg_type, uint16_t reg_addr)
|
||
{
|
||
for (uint8_t i = 0; i < MENU_CONFIG_MAX_MODBUS_MAPS; i++)
|
||
{
|
||
if (s_menu_modbus_maps[i].is_registered &&
|
||
s_menu_modbus_maps[i].pub.reg_type == reg_type &&
|
||
s_menu_modbus_maps[i].pub.reg_addr == reg_addr)
|
||
{
|
||
return &s_menu_modbus_maps[i];
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/************************** 对外接口实现 **************************/
|
||
MenuErrCode menu_modbus_map_register(uint16_t param_id, ModbusRegType reg_type, uint16_t reg_addr, uint8_t reg_count, ModbusPerm perm, uint8_t byte_order)
|
||
{
|
||
// 1. 校验参数是否已注册
|
||
MenuParam* param = menu_param_find(param_id);
|
||
if (param == NULL)
|
||
{
|
||
MENU_DEBUG("Modbus map param %d not found", param_id);
|
||
return MENU_ERR_NODE_NOT_FOUND;
|
||
}
|
||
|
||
// 2. 校验寄存器地址和转换为偏移
|
||
uint16_t reg_offset;
|
||
MenuErrCode err = menu_modbus_convert_addr(reg_type, reg_addr, ®_offset);
|
||
if (err != MENU_OK)
|
||
{
|
||
return err;
|
||
}
|
||
|
||
// 3. 校验寄存器数量（至少1个）
|
||
if (reg_count == 0)
|
||
{
|
||
MENU_DEBUG("Modbus map reg count is zero");
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 4. 校验寄存器类型与参数类型匹配
|
||
err = menu_modbus_check_type_match(param->type, reg_type);
|
||
if (err != MENU_OK)
|
||
{
|
||
return err;
|
||
}
|
||
|
||
// 5. 校验读写权限（与寄存器类型联动，如离散输入只能只读）
|
||
#if MENU_CONFIG_MODBUS_PERMISSION
|
||
if ((reg_type == MODBUS_REG_TYPE_DISCRETE_INPUT || reg_type == MODBUS_REG_TYPE_INPUT_REG) && perm != MODBUS_PERM_READ_ONLY)
|
||
{
|
||
MENU_DEBUG("Modbus input reg only support read");
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
if (reg_type == MODBUS_REG_TYPE_COIL && perm == MODBUS_PERM_READ_ONLY)
|
||
{
|
||
MENU_DEBUG("Modbus coil not support read only");
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
#endif
|
||
|
||
// 6. 检查映射是否已存在
|
||
if (menu_modbus_find_by_param(param_id) != NULL || menu_modbus_find_by_reg(reg_type, reg_addr) != NULL)
|
||
{
|
||
MENU_DEBUG("Modbus map already exists: param %d, reg %d:%d", param_id, reg_type, reg_addr);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 7. 查找空闲的映射位置（静态数组）
|
||
ModbusMapInternal* map = NULL;
|
||
for (uint8_t i = 0; i < MENU_CONFIG_MAX_MODBUS_MAPS; i++)
|
||
{
|
||
if (!s_menu_modbus_maps[i].is_registered)
|
||
{
|
||
map = &s_menu_modbus_maps[i];
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (map == NULL)
|
||
{
|
||
MENU_DEBUG("Modbus map out of memory: max %d", MENU_CONFIG_MAX_MODBUS_MAPS);
|
||
return MENU_ERR_OUT_OF_MEMORY;
|
||
}
|
||
|
||
// 8. 初始化映射关系
|
||
MENU_MEM_SET_ZERO(map, sizeof(ModbusMapInternal));
|
||
map->pub.param_id = param_id;
|
||
map->pub.reg_type = reg_type;
|
||
map->pub.reg_addr = reg_addr;
|
||
map->pub.reg_count = reg_count;
|
||
map->pub.perm = perm;
|
||
map->pub.byte_order = byte_order;
|
||
map->param_type = param->type;
|
||
map->reg_addr_offset = reg_offset;
|
||
map->is_registered = true;
|
||
|
||
MENU_DEBUG("Modbus map registered: param %d → reg %d:%d (count %d, perm %d)",
|
||
param_id, reg_type, reg_addr, reg_count, perm);
|
||
return MENU_OK;
|
||
}
|
||
|
||
MenuErrCode menu_modbus_map_query_by_param(uint16_t param_id, ModbusMap* map)
|
||
{
|
||
if (map == NULL)
|
||
{
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
ModbusMapInternal* internal_map = menu_modbus_find_by_param(param_id);
|
||
if (internal_map == NULL)
|
||
{
|
||
MENU_DEBUG("Modbus map param %d not found", param_id);
|
||
return MENU_ERR_NODE_NOT_FOUND;
|
||
}
|
||
|
||
// 复制对外暴露的信息
|
||
*map = internal_map->pub;
|
||
return MENU_OK;
|
||
}
|
||
|
||
MenuErrCode menu_modbus_map_query_by_reg(ModbusRegType reg_type, uint16_t reg_addr, ModbusMap* map)
|
||
{
|
||
if (map == NULL)
|
||
{
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
ModbusMapInternal* internal_map = menu_modbus_find_by_reg(reg_type, reg_addr);
|
||
if (internal_map == NULL)
|
||
{
|
||
MENU_DEBUG("Modbus map reg %d:%d not found", reg_type, reg_addr);
|
||
return MENU_ERR_NODE_NOT_FOUND;
|
||
}
|
||
|
||
// 复制对外暴露的信息
|
||
*map = internal_map->pub;
|
||
return MENU_OK;
|
||
}
|
||
|
||
MenuErrCode menu_modbus_map_param_to_reg(uint16_t param_id, uint8_t* reg_buf, uint8_t* buf_len)
|
||
{
|
||
if (reg_buf == NULL || buf_len == NULL || *buf_len == 0)
|
||
{
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 1. 查找映射关系
|
||
ModbusMapInternal* map = menu_modbus_find_by_param(param_id);
|
||
if (map == NULL)
|
||
{
|
||
return MENU_ERR_NODE_NOT_FOUND;
|
||
}
|
||
|
||
// 2. 校验读写权限
|
||
#if MENU_CONFIG_MODBUS_PERMISSION
|
||
if (map->pub.perm == MODBUS_PERM_READ_ONLY)
|
||
{
|
||
MENU_DEBUG("Modbus map param %d is read only", param_id);
|
||
return MENU_ERR_PARAM_WRITE_DENIED; // 复用原有错误码，或新增
|
||
}
|
||
#endif
|
||
|
||
// 3. 获取参数值
|
||
float param_val;
|
||
MenuErrCode err = menu_param_get_value(param_id, ¶m_val);
|
||
if (err != MENU_OK)
|
||
{
|
||
return err;
|
||
}
|
||
|
||
// 4. 转换参数值到寄存器数据（按类型和寄存器数量）
|
||
uint16_t* reg_data = (uint16_t*)reg_buf;
|
||
uint8_t req_len = map->pub.reg_count;
|
||
if (req_len > *buf_len / 2) // 寄存器数据按16位计算
|
||
{
|
||
MENU_DEBUG("Modbus reg buf too small: need %d, got %d", req_len * 2, *buf_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 清空缓冲区
|
||
memset(reg_data, 0, req_len * 2);
|
||
|
||
// 根据参数类型转换
|
||
MenuParam* param = menu_param_find(param_id);
|
||
switch (map->pub.reg_type)
|
||
{
|
||
case MODBUS_REG_TYPE_COIL:
|
||
case MODBUS_REG_TYPE_DISCRETE_INPUT:
|
||
// 1位寄存器：取参数值的最低位
|
||
reg_data[0] = (uint16_t)(param_val > 0 ? 1 : 0);
|
||
break;
|
||
case MODBUS_REG_TYPE_HOLDING_REG:
|
||
case MODBUS_REG_TYPE_INPUT_REG:
|
||
// 16位寄存器：根据参数类型和数量转换
|
||
if (param->type == MENU_PARAM_TYPE_INT16 || param->type == MENU_PARAM_TYPE_UINT16)
|
||
{
|
||
reg_data[0] = (uint16_t)param_val;
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_INT32 || param->type == MENU_PARAM_TYPE_UINT32)
|
||
{
|
||
uint32_t val = (uint32_t)param_val;
|
||
reg_data[0] = (uint16_t)(val & 0xFFFF);
|
||
reg_data[1] = (uint16_t)((val >> 16) & 0xFFFF);
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_FLOAT)
|
||
{
|
||
// 浮点型转换为32位二进制，占2个16位寄存器
|
||
union {
|
||
float f;
|
||
uint32_t u32;
|
||
} float_val;
|
||
float_val.f = param_val;
|
||
reg_data[0] = (uint16_t)(float_val.u32 & 0xFFFF);
|
||
reg_data[1] = (uint16_t)((float_val.u32 >> 16) & 0xFFFF);
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_INT8 || param->type == MENU_PARAM_TYPE_UINT8)
|
||
{
|
||
reg_data[0] = (uint16_t)param_val;
|
||
}
|
||
break;
|
||
default:
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 5. 字节序转换（写入寄存器前）
|
||
menu_modbus_byte_order_convert(reg_data, req_len, map->pub.byte_order, false);
|
||
|
||
// 6. 设置实际写入长度
|
||
*buf_len = req_len * 2;
|
||
|
||
MENU_DEBUG("Modbus param %d to reg: val %f → reg data len %d", param_id, param_val, *buf_len);
|
||
return MENU_OK;
|
||
}
|
||
|
||
MenuErrCode menu_modbus_map_reg_to_param(uint16_t param_id, const uint8_t* reg_buf, uint8_t buf_len)
|
||
{
|
||
if (reg_buf == NULL || buf_len == 0)
|
||
{
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 1. 查找映射关系
|
||
ModbusMapInternal* map = menu_modbus_find_by_param(param_id);
|
||
if (map == NULL)
|
||
{
|
||
return MENU_ERR_NODE_NOT_FOUND;
|
||
}
|
||
|
||
// 2. 校验读写权限
|
||
#if MENU_CONFIG_MODBUS_PERMISSION
|
||
if (map->pub.perm == MODBUS_PERM_WRITE_ONLY)
|
||
{
|
||
MENU_DEBUG("Modbus map param %d is write only", param_id);
|
||
return MENU_ERR_PARAM_WRITE_DENIED;
|
||
}
|
||
#endif
|
||
|
||
// 3. 校验缓冲区长度
|
||
uint8_t req_len = map->pub.reg_count * 2;
|
||
if (buf_len < req_len)
|
||
{
|
||
MENU_DEBUG("Modbus reg buf too small: need %d, got %d", req_len, buf_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 4. 复制寄存器数据并进行字节序转换（读取寄存器后）
|
||
uint16_t reg_data[MENU_CONFIG_MAX_MODBUS_MAPS * 2] = {0}; // 足够大的临时缓冲区
|
||
memcpy(reg_data, reg_buf, req_len);
|
||
menu_modbus_byte_order_convert(reg_data, map->pub.reg_count, map->pub.byte_order, true);
|
||
|
||
// 5. 转换寄存器数据到参数值
|
||
float param_val = 0.0f;
|
||
MenuParam* param = menu_param_find(param_id);
|
||
switch (map->pub.reg_type)
|
||
{
|
||
case MODBUS_REG_TYPE_COIL:
|
||
case MODBUS_REG_TYPE_DISCRETE_INPUT:
|
||
// 1位寄存器：0→0，非0→1
|
||
param_val = (reg_data[0] & 0x01) ? 1.0f : 0.0f;
|
||
break;
|
||
case MODBUS_REG_TYPE_HOLDING_REG:
|
||
case MODBUS_REG_TYPE_INPUT_REG:
|
||
// 16位寄存器：根据参数类型转换
|
||
if (param->type == MENU_PARAM_TYPE_INT8)
|
||
{
|
||
param_val = (int8_t)reg_data[0];
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_UINT8)
|
||
{
|
||
param_val = (uint8_t)reg_data[0];
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_INT16)
|
||
{
|
||
param_val = (int16_t)reg_data[0];
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_UINT16)
|
||
{
|
||
param_val = (uint16_t)reg_data[0];
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_INT32)
|
||
{
|
||
uint32_t val = ((uint32_t)reg_data[1] << 16) | reg_data[0];
|
||
param_val = (int32_t)val;
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_UINT32)
|
||
{
|
||
uint32_t val = ((uint32_t)reg_data[1] << 16) | reg_data[0];
|
||
param_val = val;
|
||
}
|
||
else if (param->type == MENU_PARAM_TYPE_FLOAT)
|
||
{
|
||
union {
|
||
float f;
|
||
uint32_t u32;
|
||
} float_val;
|
||
float_val.u32 = ((uint32_t)reg_data[1] << 16) | reg_data[0];
|
||
param_val = float_val.f;
|
||
}
|
||
break;
|
||
default:
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 6. 设置参数值（自动进行范围检查）
|
||
MenuErrCode err = menu_param_set_value(param_id, param_val);
|
||
if (err != MENU_OK)
|
||
{
|
||
return err;
|
||
}
|
||
|
||
MENU_DEBUG("Modbus reg to param %d: reg data len %d → val %f", param_id, buf_len, param_val);
|
||
return MENU_OK;
|
||
}
|
||
|
||
#endif // MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
```
|
||
|
||
### 4. 硬件端口层（`menu/src/port/`）
|
||
#### 4.1 可选修改`menu/src/port/menu_port.h`（添加Modbus硬件接口，用户适配）
|
||
如果需要对接实际的Modbus硬件（如RS485、TCP），可在port层添加硬件接口，与映射逻辑解耦：
|
||
```c
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
/**
|
||
* @brief Modbus硬件发送数据接口（用户需实现，如RS485发送）
|
||
* @param reg_type 寄存器类型
|
||
* @param reg_addr 寄存器地址
|
||
* @param reg_buf 数据缓冲区
|
||
* @param buf_len 数据长度
|
||
* @return 错误码
|
||
*/
|
||
MenuErrCode menu_port_modbus_send(ModbusRegType reg_type, uint16_t reg_addr, const uint8_t* reg_buf, uint8_t buf_len);
|
||
|
||
/**
|
||
* @brief Modbus硬件接收数据接口（用户需实现，如RS485接收）
|
||
* @param reg_type 寄存器类型
|
||
* @param reg_addr 寄存器地址
|
||
* @param reg_buf 数据缓冲区
|
||
* @param buf_len 数据长度
|
||
* @return 错误码
|
||
*/
|
||
MenuErrCode menu_port_modbus_receive(ModbusRegType reg_type, uint16_t reg_addr, uint8_t* reg_buf, uint8_t buf_len);
|
||
#endif // MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
```
|
||
|
||
#### 4.2 可选修改`menu/src/port/menu_port.c`（Modbus硬件接口示例实现）
|
||
用户根据实际硬件（如STM32的RS485）实现Modbus数据的发送和接收：
|
||
```c
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
MenuErrCode menu_port_modbus_send(ModbusRegType reg_type, uint16_t reg_addr, const uint8_t* reg_buf, uint8_t buf_len)
|
||
{
|
||
// 示例：通过RS485发送Modbus写指令（如写保持寄存器0x0000（40001））
|
||
// 实际需根据Modbus协议实现帧组装、校验、发送
|
||
(void)reg_type;
|
||
(void)reg_addr;
|
||
(void)reg_buf;
|
||
(void)buf_len;
|
||
return MENU_OK; // 模拟成功，用户需替换为实际逻辑
|
||
}
|
||
|
||
MenuErrCode menu_port_modbus_receive(ModbusRegType reg_type, uint16_t reg_addr, uint8_t* reg_buf, uint8_t buf_len)
|
||
{
|
||
// 示例：通过RS485接收Modbus读指令的响应数据
|
||
(void)reg_type;
|
||
(void)reg_addr;
|
||
(void)reg_buf;
|
||
(void)buf_len;
|
||
return MENU_OK; // 模拟成功，用户需替换为实际逻辑
|
||
}
|
||
#endif // MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
```
|
||
|
||
### 5. 使用示例（用户代码）
|
||
在原有菜单使用示例中添加Modbus映射的注册和数据交互：
|
||
```c
|
||
/**
|
||
* @brief 菜单组件+Modbus映射使用示例（用户主函数）
|
||
*/
|
||
#include "menu.h"
|
||
#include "menu_port.h"
|
||
|
||
// 原有回调函数...
|
||
|
||
int main(void)
|
||
{
|
||
// 1. 初始化硬件和菜单组件
|
||
// hal_init();
|
||
menu_init();
|
||
|
||
// 2. 注册菜单节点和参数
|
||
menu_register_node(0, 1, "Main Menu", NULL, NULL);
|
||
menu_register_node(1, 2, "Temperature", NULL, NULL);
|
||
menu_param_register(2, 1, MENU_PARAM_TYPE_FLOAT, 0.0f, 100.0f, 25.0f, 1.0f); // 温度参数（ID=1）
|
||
|
||
// 3. 注册参数与Modbus寄存器的映射（核心新增逻辑）
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
// 温度参数（ID=1）→ Modbus保持寄存器40001（地址40001，2个寄存器，读写权限，Modbus标准字节序）
|
||
menu_modbus_map_register(1, MODBUS_REG_TYPE_HOLDING_REG, 40001, 2, MODBUS_PERM_READ_WRITE, 2);
|
||
#endif
|
||
|
||
// 4. 主循环
|
||
while (1)
|
||
{
|
||
// 原有逻辑：按键扫描、菜单主循环
|
||
menu_port_key_scan();
|
||
menu_main_loop();
|
||
|
||
// 5. Modbus数据交互示例（新增逻辑）
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
{
|
||
// 示例1：将参数值写入Modbus寄存器并发送
|
||
uint8_t reg_buf[4] = {0}; // 2个16位寄存器，占4字节
|
||
uint8_t buf_len = sizeof(reg_buf);
|
||
if (menu_modbus_map_param_to_reg(1, reg_buf, &buf_len) == MENU_OK)
|
||
{
|
||
// 发送到Modbus硬件（用户需实现menu_port_modbus_send）
|
||
menu_port_modbus_send(MODBUS_REG_TYPE_HOLDING_REG, 40001, reg_buf, buf_len);
|
||
}
|
||
|
||
// 示例2：从Modbus寄存器接收数据并更新参数值
|
||
if (menu_port_modbus_receive(MODBUS_REG_TYPE_HOLDING_REG, 40001, reg_buf, buf_len) == MENU_OK)
|
||
{
|
||
menu_modbus_map_reg_to_param(1, reg_buf, buf_len);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
// 其他业务逻辑
|
||
// ...
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 三、总结
|
||
### 核心关键点回顾
|
||
1. **解耦与可裁剪**：Modbus映射模块作为独立功能扩展层，通过`MENU_CONFIG_ENABLE_MODBUS_MAP`宏控制启用/关闭，不影响原有菜单和参数模块的逻辑。
|
||
2. **静态内存与工业级鲁棒性**：使用静态数组存储映射关系，避免动态分配；加入地址范围校验、类型匹配校验、权限校验、字节序适配，确保工业环境下的稳定性。
|
||
3. **灵活映射与数据转换**：支持单/多寄存器映射、参数类型与寄存器类型自动转换、多种字节序配置，适配不同的Modbus从站设备。
|
||
4. **无缝集成**：与原有参数模块联动，参数值与寄存器数据的双向转换自动触发参数的范围检查，无需额外逻辑。
|
||
5. **硬件解耦**：Modbus映射逻辑与硬件接口分离，用户只需在port层实现Modbus硬件的发送/接收接口，即可快速移植到不同的MCU和Modbus硬件（RS485/TCP）。
|
||
|
||
该扩展功能完全遵循工业级嵌入式组件的设计标准，可满足工业控制器、仪器仪表、智能家居等设备中参数与Modbus寄存器的灵活映射需求。 |