629 lines
21 KiB
C
629 lines
21 KiB
C
/**
|
||
* @file menu_modbus.c
|
||
* @brief 菜单参数-Modbus寄存器映射：注册、查询、数据双向转换（工业级：类型安全、字节序适配）
|
||
*/
|
||
#include "menu.h"
|
||
#include "menu_core.h"
|
||
#include "menu_data.h"
|
||
#include "menu_def.h"
|
||
#include "menu_modbus.h"
|
||
#include <stddef.h>
|
||
#include <string.h>
|
||
|
||
#if MENU_CONFIG_ENABLE_MODBUS_MAP
|
||
|
||
/************************** 内部辅助函数 **************************/
|
||
/**
|
||
* @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;
|
||
}
|
||
|
||
// 校验实际偏移地址不超过配置的最大值
|
||
// 注意：MENU_CONFIG_MODBUS_MAX_ADDR 不应超过 uint16_t 的最大值 0xFFFF
|
||
if (*offset > (uint16_t)MENU_CONFIG_MODBUS_MAX_ADDR)
|
||
{
|
||
MENU_DEBUG("Modbus reg offset out of range: %d, max allowed: %d", *offset, MENU_CONFIG_MODBUS_MAX_ADDR);
|
||
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. 校验参数是否已注册（通过获取参数值间接检查）
|
||
float dummy_val;
|
||
MenuErrCode err = menu_param_get_value(param_id, &dummy_val);
|
||
if (err != MENU_OK)
|
||
{
|
||
MENU_DEBUG("Modbus map param %d not found", param_id);
|
||
return MENU_ERR_NODE_NOT_FOUND;
|
||
}
|
||
|
||
// 2. 校验寄存器地址和转换为偏移
|
||
uint16_t reg_offset;
|
||
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. 获取参数类型
|
||
MenuParamType param_type;
|
||
err = menu_param_get_type(param_id, ¶m_type);
|
||
if (err != MENU_OK)
|
||
{
|
||
return err;
|
||
}
|
||
|
||
// 9. 校验寄存器类型与参数类型匹配
|
||
err = menu_modbus_check_type_match(param_type, reg_type);
|
||
if (err != MENU_OK)
|
||
{
|
||
return err;
|
||
}
|
||
|
||
// 10. 初始化映射关系
|
||
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_HW_PORT_ERROR; // 复用原有错误码
|
||
}
|
||
#endif
|
||
|
||
// 3. 获取参数值
|
||
float param_val;
|
||
MenuErrCode err = menu_param_get_value(param_id, ¶m_val);
|
||
if (err != MENU_OK)
|
||
{
|
||
MENU_DEBUG("Failed to get param value: %d", err);
|
||
return err;
|
||
}
|
||
|
||
// 4. 转换参数值到寄存器数据（按类型和寄存器数量）
|
||
uint16_t* reg_data = (uint16_t*)reg_buf;
|
||
uint8_t req_len = map->pub.reg_count;
|
||
|
||
// 检查缓冲区长度是否足够
|
||
if (*buf_len < req_len * 2) // 寄存器数据按16位计算，每个16位占2字节
|
||
{
|
||
MENU_DEBUG("Modbus reg buf too small: need %d bytes, got %d bytes", req_len * 2, *buf_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 清空缓冲区
|
||
memset(reg_data, 0, req_len * 2);
|
||
|
||
// 根据参数类型转换
|
||
// 使用之前保存的参数类型，不需要再次调用menu_param_find
|
||
switch (map->pub.reg_type)
|
||
{
|
||
case MODBUS_REG_TYPE_COIL:
|
||
case MODBUS_REG_TYPE_DISCRETE_INPUT:
|
||
// 1位寄存器：取参数值的最低位
|
||
if (req_len != 1)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 1-bit reg: %d, expected 1", req_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
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 (map->param_type == MENU_PARAM_TYPE_INT16 || map->param_type == MENU_PARAM_TYPE_UINT16)
|
||
{
|
||
if (req_len != 1)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 16-bit param: %d, expected 1", req_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
reg_data[0] = (uint16_t)param_val;
|
||
}
|
||
else if (map->param_type == MENU_PARAM_TYPE_INT32 || map->param_type == MENU_PARAM_TYPE_UINT32)
|
||
{
|
||
if (req_len != 2)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 32-bit param: %d, expected 2", req_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
uint32_t val = (uint32_t)param_val;
|
||
reg_data[0] = (uint16_t)(val & 0xFFFF);
|
||
reg_data[1] = (uint16_t)((val >> 16) & 0xFFFF);
|
||
}
|
||
else if (map->param_type == MENU_PARAM_TYPE_FLOAT)
|
||
{
|
||
if (req_len != 2)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for float param: %d, expected 2", req_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
// 浮点型转换为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 (map->param_type == MENU_PARAM_TYPE_INT8 || map->param_type == MENU_PARAM_TYPE_UINT8)
|
||
{
|
||
if (req_len != 1)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 8-bit param: %d, expected 1", req_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
reg_data[0] = (uint16_t)param_val;
|
||
}
|
||
break;
|
||
default:
|
||
MENU_DEBUG("Invalid reg type: %d", map->pub.reg_type);
|
||
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_HW_PORT_ERROR; // 复用原有错误码
|
||
}
|
||
#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}; // 足够大的临时缓冲区
|
||
|
||
// 检查缓冲区长度是否足够
|
||
if (buf_len < req_len)
|
||
{
|
||
MENU_DEBUG("Modbus reg buf too small: need %d bytes, got %d bytes", req_len, buf_len);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
|
||
// 复制数据到临时缓冲区
|
||
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;
|
||
// 使用之前保存的参数类型，不需要再次调用menu_param_find
|
||
switch (map->pub.reg_type)
|
||
{
|
||
case MODBUS_REG_TYPE_COIL:
|
||
case MODBUS_REG_TYPE_DISCRETE_INPUT:
|
||
// 1位寄存器：0→0，非0→1
|
||
if (map->pub.reg_count != 1)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 1-bit reg: %d, expected 1", map->pub.reg_count);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
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 (map->param_type == MENU_PARAM_TYPE_INT8)
|
||
{
|
||
if (map->pub.reg_count != 1)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 8-bit param: %d, expected 1", map->pub.reg_count);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
param_val = (int8_t)reg_data[0];
|
||
}
|
||
else if (map->param_type == MENU_PARAM_TYPE_UINT8)
|
||
{
|
||
if (map->pub.reg_count != 1)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 8-bit param: %d, expected 1", map->pub.reg_count);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
param_val = (uint8_t)reg_data[0];
|
||
}
|
||
else if (map->param_type == MENU_PARAM_TYPE_INT16)
|
||
{
|
||
if (map->pub.reg_count != 1)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 16-bit param: %d, expected 1", map->pub.reg_count);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
param_val = (int16_t)reg_data[0];
|
||
}
|
||
else if (map->param_type == MENU_PARAM_TYPE_UINT16)
|
||
{
|
||
if (map->pub.reg_count != 1)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 16-bit param: %d, expected 1", map->pub.reg_count);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
param_val = (uint16_t)reg_data[0];
|
||
}
|
||
else if (map->param_type == MENU_PARAM_TYPE_INT32)
|
||
{
|
||
if (map->pub.reg_count != 2)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 32-bit param: %d, expected 2", map->pub.reg_count);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
uint32_t val = ((uint32_t)reg_data[1] << 16) | reg_data[0];
|
||
param_val = (int32_t)val;
|
||
}
|
||
else if (map->param_type == MENU_PARAM_TYPE_UINT32)
|
||
{
|
||
if (map->pub.reg_count != 2)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for 32-bit param: %d, expected 2", map->pub.reg_count);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
uint32_t val = ((uint32_t)reg_data[1] << 16) | reg_data[0];
|
||
param_val = val;
|
||
}
|
||
else if (map->param_type == MENU_PARAM_TYPE_FLOAT)
|
||
{
|
||
if (map->pub.reg_count != 2)
|
||
{
|
||
MENU_DEBUG("Invalid reg count for float param: %d, expected 2", map->pub.reg_count);
|
||
return MENU_ERR_INVALID_PARAM;
|
||
}
|
||
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:
|
||
MENU_DEBUG("Invalid reg type: %d", map->pub.reg_type);
|
||
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;
|
||
}
|
||
|
||
// 定义Modbus映射静态数组
|
||
ModbusMapInternal s_menu_modbus_maps[MENU_CONFIG_MAX_MODBUS_MAPS];
|
||
|
||
#endif // MENU_CONFIG_ENABLE_MODBUS_MAP
|