ApiValveLock/Core/OBJ/Modbussimple.c

#include "main.h"
#include "Modbussimple.h"
#include "cmsis_os.h"
#include "Callback.h"

uint32_t g_modbusbuffer[40] ; // 当用DMA发送的时候 帧头要四字节对齐
extern float AD1_Vol,AD2_Vol,AD3_Vol,AD4_Vol,AD5_Vol,AD5_I;
extern uint16_t Running_time;			//	运行时长

ModbusRegister_t modbus_map[] = {
    {0x4000, 2, 1, &g_deviceParams.Firmware_Version},    
		{0x4002, 1, 0, &Running_time},
		{0x4010, 1, 0, &g_deviceParams.SlaveDevice_addr},
		{0x4011, 1, 0, &g_deviceParams.Serial_baud_rate},
    {0x4020, 3, 0, &g_deviceParams.Device_SN},    
    
    {0x0001, 1, 0, &Valve_status},
		{0x0002, 1, 0, &Motor_status},
		{0x0003, 2, 1, &Motor_current},
		{0x0005, 2, 1, &Motor_speed},
    {0x0007, 2, 1, &Magnetic_angle},
    {0x0009, 8, 1, hall_data},		
};


// Modbus CRC16（低位在前，高位在后）
uint16_t modbus_crc16(uint8_t *data, uint16_t length) 
{
    uint16_t crc = 0xFFFF;
    for (uint16_t pos = 0; pos < length; pos++) {
        crc ^= data[pos];
        for (int i = 0; i < 8; i++) {
            if (crc & 0x0001)
                crc = (crc >> 1) ^ 0xA001;
            else
                crc >>= 1;
        }
    }
    return crc;
}

// 从映射表中查找寄存器并复制数据
/*
bool read_modbus_registers(uint16_t addr, uint16_t len, uint8_t *dest_buf, uint16_t *out_byte_count) 
{
    uint16_t offset = 0;
    for (int i = 0; i < sizeof(modbus_map) / sizeof(modbus_map[0]); i++) {
        uint16_t reg_start = modbus_map[i].address;
        uint16_t reg_len = modbus_map[i].length;

        if (addr >= reg_start && (addr + len) <= (reg_start + reg_len)) {
            uint16_t relative = addr - reg_start;

            void* ptr = modbus_map[i].data_ptr;

            if (modbus_map[i].is_uint32_big_endian) {
                copy_uint32_to_modbus_bytes_be((uint32_t*)ptr, relative / 2, len, dest_buf, &offset);
                *out_byte_count = offset;
                return true;
            }

            // 默认处理为 uint16_t 方式
            uint16_t *data_ptr = (uint16_t *)ptr;
            for (uint16_t j = 0; j < len; j++) {
                uint16_t val = data_ptr[relative + j];
                dest_buf[offset++] = (val >> 8) & 0xFF;
                dest_buf[offset++] = val & 0xFF;
            }

            *out_byte_count = offset;
            return true;
        }
    }
    return false;
}
*/
bool read_modbus_registers(uint16_t addr, uint16_t len, uint8_t *dest_buf, uint16_t *out_byte_count)
{
    uint16_t offset = 0;
    uint16_t remaining = len;      // 还有多少个寄存器要读取
    uint16_t curr_addr = addr;     // 当前要读取的地址

    while (remaining > 0) {
        bool matched = false;

        for (int i = 0; i < sizeof(modbus_map) / sizeof(modbus_map[0]); i++) {
            uint16_t map_start = modbus_map[i].address;
            uint16_t map_end = map_start + modbus_map[i].length;

            // 当前地址在该 map 区块范围内
            if (curr_addr >= map_start && curr_addr < map_end) {
                matched = true;

                uint16_t index_in_map = curr_addr - map_start;
                uint16_t can_read = map_end - curr_addr;
                uint16_t read_count = (remaining < can_read) ? remaining : can_read;

                void *ptr = modbus_map[i].data_ptr;

                if (modbus_map[i].is_uint32_big_endian) {
                    // 每个 uint32_t 映射为 2 个寄存器（4 字节）
//                    uint8_t *raw = (uint8_t *)ptr;

                    for (uint16_t j = 0; j < read_count; j++) {
                        uint16_t reg_idx = index_in_map + j;
                        uint32_t word_idx = reg_idx / 2;
                        uint8_t high = (reg_idx % 2 == 0);  // 寄存器高位 or 低位

                        uint32_t val = ((uint32_t *)ptr)[word_idx];

                        uint16_t word = high ? (val >> 16) : (val & 0xFFFF);
                        dest_buf[offset++] = (word >> 8) & 0xFF;
                        dest_buf[offset++] = word & 0xFF;
                    }
                } else {
                    uint16_t *data_ptr = (uint16_t *)ptr;

                    for (uint16_t j = 0; j < read_count; j++) {
                        uint16_t val = data_ptr[index_in_map + j];
                        dest_buf[offset++] = (val >> 8) & 0xFF;
                        dest_buf[offset++] = val & 0xFF;
                    }
                }

                curr_addr += read_count;
                remaining -= read_count;
                break;
            }
        }

        if (!matched) {
            return false;  // 地址不在任何 map 内，非法访问
        }
    }

    *out_byte_count = offset;
    return true;
}

// 将 uint32_t 数组按高字节优先方式拷贝为 Modbus 输出格式（每个 uint32_t 占 4 字节）
void copy_uint32_to_modbus_bytes_be(uint32_t *src, uint16_t start_index, uint16_t word_count, uint8_t *dest_buf, uint16_t *offset) 
{
    for (uint16_t i = 0; i < word_count / 2; i++) {
        uint32_t val = src[start_index + i];
        uint16_t high = (val >> 16) & 0xFFFF;
        uint16_t low  = val & 0xFFFF;

        dest_buf[(*offset)++] = (high >> 8) & 0xFF;
        dest_buf[(*offset)++] = high & 0xFF;
        dest_buf[(*offset)++] = (low >> 8) & 0xFF;
        dest_buf[(*offset)++] = low & 0xFF;
    }
}


// 功能码 0x03 响应帧（角度浮点数值float）
uint16_t modbus_03response_float(uint8_t device_addr, uint8_t num, float value, uint8_t *out_buf) 
{
    uint8_t i = 0;

    out_buf[i++] = device_addr;    // 设备地址
    out_buf[i++] = 0x03;           // 功能码 0x03
    out_buf[i++] = num;           // 字节数（float = 4字节）

    // 将 float 转为 4 字节 IEEE 754 格式
    uint8_t float_bytes[4];
    memcpy(float_bytes, &value, 4);

    // 注意字节序是否和主机匹配
    out_buf[i++] = float_bytes[3];
    out_buf[i++] = float_bytes[2];
	  out_buf[i++] = float_bytes[1];
    out_buf[i++] = float_bytes[0];

    // 计算 CRC
    uint16_t crc = modbus_crc16(out_buf, i);
    out_buf[i++] = crc & 0xFF;      // CRC低位
    out_buf[i++] = crc >> 8;        // CRC高位

    return i; // 返回总长度
}





// 返回错误响应帧，例如非法功能码、非法地址等错误
uint16_t modbus_error_response(uint8_t addr, uint8_t func_code, uint8_t err_code, uint8_t *buf) 
{
    buf[0] = addr;
    buf[1] = func_code | 0x80; // 错误码 = 功能码 + 0x80
    buf[2] = err_code;

    uint16_t crc = modbus_crc16(buf, 3);
    buf[3] = crc & 0xFF;
    buf[4] = crc >> 8;

    return 5;
}

// 修改485串口1的波特率
void Set_485_Baudrate(uint16_t baudrate_id)
{
    uint32_t baudrate = 9600; // 默认值

    // 根据 ID 映射波特率
    switch (baudrate_id)
    {
        case 0x0001: baudrate = 4800; break;
        case 0x0002: baudrate = 9600; break;
        case 0x0003: baudrate = 19200; break;
        case 0x0004: baudrate = 38400; break;
        case 0x0005: baudrate = 57600; break;
        case 0x0006: baudrate = 115200; break;
        case 0x0007: baudrate = 230400; break;
        case 0x0008: baudrate = 256000; break;
        default:   baudrate = 9600; break; // 非法 ID，默认 9600
    }

    // 重新设置 huart1 配置并初始化
    huart1.Instance = USART1;
    huart1.Init.BaudRate = baudrate;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;

    if (HAL_UART_DeInit(&huart1) != HAL_OK)
    {
        Error_Handler();
    }

    if (HAL_UART_Init(&huart1) != HAL_OK)
    {
        Error_Handler();
    }
}


/**
	* 做主机时使用
	*
	*
**/		
//  Modbus 读保持寄存器命令帧（功能码 0x03）
uint16_t build_modbus_read_cmd(uint8_t device_addr, uint16_t reg_addr, uint16_t reg_num, uint8_t *out_buf) 
{
    uint16_t i = 0;

    out_buf[i++] = device_addr;             // 设备地址
    out_buf[i++] = 0x03;                    // 功能码 0x03 读保持寄存器
    out_buf[i++] = (reg_addr >> 8) & 0xFF;  // 起始寄存器地址高位
    out_buf[i++] = reg_addr & 0xFF;         // 起始寄存器地址低位
    out_buf[i++] = (reg_num >> 8) & 0xFF;   // 读取寄存器数量高位
    out_buf[i++] = reg_num & 0xFF;          // 读取寄存器数量低位

    uint16_t crc = modbus_crc16(out_buf, i);
    out_buf[i++] = crc & 0xFF;              // CRC低位
    out_buf[i++] = crc >> 8;                // CRC高位

    return i;  // 命令帧总长度
}

// Modbus 功能码0x10的写寄存器命令
// data: uint16_t 数组，每个元素是一个寄存器的数据（2字节）
// 返回帧长度
uint16_t build_modbus_write_cmd(uint8_t device_addr, uint8_t func_code,
																uint16_t reg_addr, uint16_t reg_count,
                                uint16_t *data, uint8_t *out_buf) 
{
    uint8_t byte_count = reg_count * 2;
    uint16_t i = 0;

    out_buf[i++] = device_addr;                    // 设备地址
    out_buf[i++] = func_code;                      // 功能码（0x10）
    out_buf[i++] = (reg_addr >> 8) & 0xFF;         // 起始寄存器地址高8位
    out_buf[i++] = reg_addr & 0xFF;                // 起始寄存器地址低8位
    out_buf[i++] = (reg_count >> 8) & 0xFF;        // 寄存器数量高8位
    out_buf[i++] = reg_count & 0xFF;               // 寄存器数量低8位
    out_buf[i++] = byte_count;                     // 数据字节数

    // 写入数据（每个寄存器2字节）
    for (uint16_t j = 0; j < reg_count; j++) {
        out_buf[i++] = (data[j] >> 8) & 0xFF;
        out_buf[i++] = data[j] & 0xFF;
    }

    // 计算 CRC
    uint16_t crc = modbus_crc16(out_buf, i);
    out_buf[i++] = crc & 0xFF;    // CRC低位
    out_buf[i++] = crc >> 8;      // CRC高位

    return i; // 返回命令总长度
}