基于标准C语言实现的跨平台Modbus协议库

基于标准C语言实现的跨平台Modbus协议库

一、核心代码实现（标准C语言）

1. 硬件抽象层接口

// hardware_abstraction.h
#ifndef __HARDWARE_ABSTRACTION_H__
#define __HARDWARE_ABSTRACTION_H__

typedef struct {
   
    void (*send)(const uint8_t* data, uint16_t len);
    uint16_t (*receive)(uint8_t* buffer, uint16_t maxlen);
    void (*delay_ms)(uint32_t ms);
} hal_interface_t;

#endif // __HARDWARE_ABSTRACTION_H__

2. CRC校验实现

// crc16.c
#include "modbus.h"

static const uint16_t crc_table[256] = {
   
    0x0000, 0xC0C1, 0xC181, 0x0140, // ... 完整查表数据
};

uint16_t modbus_crc(const uint8_t* data, uint16_t len) {
   
    uint16_t crc = 0xFFFF;
    for (uint16_t i = 0; i < len; i++) {
   
        crc = (crc >> 8) ^ crc_table[(crc ^ data[i]) & 0xFF];
    }
    return crc;
}

3. 协议核心处理

// modbus_core.c
#include "modbus.h"

modbus_error_t modbus_handle_request(modbus_context_t* ctx) {
   
    uint8_t frame[256] = {
   0};
    uint16_t frame_len = ctx->receive(frame, sizeof(frame));

    if (frame_len < MB_RTU_MIN_FRAME_LENGTH) {
   
        return MODBUS_ERROR_PROTOCOL;
    }

    // CRC校验
    uint16_t received_crc = (frame[frame_len-2] << 8) | frame[frame_len-1];
    if (modbus_crc(frame, frame_len-2) != received_crc) {
   
        return MODBUS_ERROR_PROTOCOL;
    }

    // 功能码分发
    switch (frame[1]) {
   
        case MB_FC_READ_COILS:
            return handle_read_coils(ctx, frame, frame_len);
        case MB_FC_WRITE_SINGLE_REGISTER:
            return handle_write_single_register(ctx, frame, frame_len);
        // 其他功能码处理...
        default:
            return MODBUS_ERROR_SLAVE;
    }
}

三、模块化实现方案

1. RTU模式实现

// modbus_rtu.c
void modbus_rtu_init(modbus_context_t* ctx, hal_interface_t* hal) {
   
    ctx->hw = hal;
    ctx->baud_rate = 9600;
    ctx->parity = MB_PAR_NONE;
    ctx->stop_bits = 1;
}

void modbus_rtu_send(modbus_context_t* ctx, const uint8_t* data, uint16_t len) {
   
    // 添加从站地址和CRC
    uint8_t frame[256] = {
   0};
    frame[0] = ctx->slave_addr;
    memcpy(frame+1, data, len);
    uint16_t crc = modbus_crc(frame, len+1);
    frame[len+1] = crc & 0xFF;
    frame[len+2] = (crc >> 8) & 0xFF;

    ctx->hw->send(frame, len+3);
}

2. TCP模式实现

// modbus_tcp.c
void modbus_tcp_init(modbus_context_t* ctx, int socket) {
   
    ctx->socket = socket;
    ctx->transaction_id = 0;
}

void modbus_tcp_send(modbus_context_t* ctx, const uint8_t* data, uint16_t len) {
   
    // 构建MBAP头
    uint8_t header[7] = {
   0};
    header[0] = (ctx->transaction_id >> 8) & 0xFF;
    header[1] = ctx->transaction_id & 0xFF;
    header[2] = (len + 2) >> 8;  // 数据长度
    header[3] = (len + 2) & 0xFF;
    header[4] = ctx->unit_id;

    ctx->hw->send(header, 6);
    ctx->hw->send(data, len);
}

四、可移植性设计策略

1. 硬件接口适配

// 示例：STM32 UART适配
void stm32_uart_send(const uint8_t* data, uint16_t len) {
   
    HAL_UART_Transmit(&huart1, (uint8_t*)data, len, HAL_MAX_DELAY);
}

uint16_t stm32_uart_receive(uint8_t* buffer, uint16_t maxlen) {
   
    return HAL_UART_Receive(&huart1, buffer, maxlen, HAL_MAX_DELAY);
}

hal_interface_t hal_stm32 = {
   
    .send = stm32_uart_send,
    .receive = stm32_uart_receive,
    .delay_ms = HAL_Delay
};

2. 定时器实现

// 软件定时器实现
typedef struct {
   
    uint32_t start_ticks;
    uint32_t interval;
} modbus_timer_t;

void timer_start(modbus_timer_t* timer, uint32_t interval) {
   
    timer->start_ticks = HAL_GetTick();
    timer->interval = interval;
}

bool timer_expired(modbus_timer_t* timer) {
   
    return (HAL_GetTick() - timer->start_ticks) >= timer->interval;
}

五、完整功能实现

1. 寄存器映射管理

// 寄存器数组定义
#define MAX_REGISTERS 1024
uint16_t holding_registers[MAX_REGISTERS] = {
   0};

// 读保持寄存器处理
modbus_error_t handle_read_holding_registers(modbus_context_t* ctx, 
                                             const uint8_t* frame, 
                                             uint16_t len) {
   
    uint16_t start_addr = (frame[2] << 8) | frame[3];
    uint16_t reg_count = (frame[4] << 8) | frame[5];

    if (start_addr + reg_count > MAX_REGISTERS) {
   
        return MODBUS_ERROR_ILLEGAL_DATA_ADDRESS;
    }

    // 构建响应帧
    uint8_t response[256] = {
   0};
    response[0] = ctx->slave_addr;
    response[1] = MB_FC_READ_HOLDING_REGISTERS;
    response[2] = (reg_count * 2) >> 8;
    response[3] = (reg_count * 2) & 0xFF;

    for (int i=0; i<reg_count; i++) {
   
        response[4 + 2*i] = (holding_registers[start_addr + i] >> 8) & 0xFF;
        response[5 + 2*i] = holding_registers[start_addr + i] & 0xFF;
    }

    ctx->hw->send(response, 4 + reg_count*2);
    return MODBUS_OK;
}

2. 异常处理机制

modbus_error_t handle_exception(modbus_context_t* ctx, 
                                uint8_t function_code) {
   
    uint8_t response[4] = {
   0};
    response[0] = ctx->slave_addr;
    response[1] = function_code | 0x80;
    response[2] = MB_EX_ILLEGAL_FUNCTION; // 示例异常码
    response[3] = modbus_crc(response, 3) & 0xFF;
    response[4] = (modbus_crc(response, 3) >> 8) & 0xFF;

    ctx->hw->send(response, 5);
    return MODBUS_ERROR_PROTOCOL;
}

参考系统 modbus完整协议使用C语言编写易于移植 www.youwenfan.com/contentald/51670.html

六、测试与验证

1. 单元测试框架

// test_modbus.c
void test_crc_calculation() {
   
    uint8_t test_data[] = {
   0x01, 0x03, 0x00, 0x00, 0x00, 0x01};
    uint16_t crc = modbus_crc(test_data, sizeof(test_data));
    TEST_ASSERT_EQUAL_HEX16(0x840A, crc);
}

void test_rtu_frame() {
   
    modbus_context_t ctx;
    modbus_rtu_init(&ctx, &hal_stm32);

    uint8_t request[] = {
   0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x84, 0x0A};
    modbus_rtu_send(&ctx, request, sizeof(request));

    // 验证发送数据
    TEST_ASSERT_EQUAL(8, sent_data_length);
}

2. 性能测试指标

七、移植指南

1. 硬件适配步骤

1. 实现hal_interface_t结构体中的函数指针
2. 初始化硬件接口：modbus_rtu_init(&ctx, &hal_custom)
3. 配置通信参数：波特率、数据位、停止位、校验位

2. 调试技巧

• 使用逻辑分析仪捕获原始帧数据

• 添加调试日志输出：

  #define MODBUS_DEBUG 1
  #if MODBUS_DEBUG
  void modbus_log(const char* fmt, ...) {
       
      // 实现串口日志输出
  }
  #endif
  

八、扩展功能

1. 安全增强
   • 添加AES-128加密模块
   • 实现Modbus/TCP安全扩展
2. 诊断功能
   • 构建设备状态监控寄存器
   • 实现在线固件升级
3. 高级协议
   • Modbus Secure协议扩展
   • 支持Modbus路由功能

该方案通过分层设计和硬件抽象层实现，可快速移植到各种MCU平台。实际应用中需根据具体硬件特性调整串口参数和中断处理逻辑，建议配合Modbus Slave模拟器进行功能验证。