Modbus协议C语言实现（易于移植版本）

原创 于 2025-12-15 16:24:31 发布 · 89 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #java #前端

易于移植的Modbus协议栈的C语言实现，支持RTU和ASCII模式，包含主机(Master)和从机(Slave)功能。

头文件 (modbus.h)

#ifndef MODBUS_H
#define MODBUS_H

#include <stdint.h>
#include <stddef.h>

// 模式定义
typedef enum {
    MODBUS_RTU,
    MODBUS_ASCII
} modbus_mode_t;

// 错误代码
typedef enum {
    MODBUS_SUCCESS = 0,
    MODBUS_ERROR_INVALID_SLAVE,
    MODBUS_ERROR_INVALID_FUNCTION,
    MODBUS_ERROR_INVALID_DATA,
    MODBUS_ERROR_SLAVE_DEVICE_FAILURE,
    MODBUS_ERROR_CRC,
    MODBUS_ERROR_TIMEOUT,
    MODBUS_ERROR_MEMORY
} modbus_error_t;

// 功能码定义
typedef enum {
    MODBUS_FC_READ_COILS = 0x01,
    MODBUS_FC_READ_DISCRETE_INPUTS = 0x02,
    MODBUS_FC_READ_HOLDING_REGISTERS = 0x03,
    MODBUS_FC_READ_INPUT_REGISTERS = 0x04,
    MODBUS_FC_WRITE_SINGLE_COIL = 0x05,
    MODBUS_FC_WRITE_SINGLE_REGISTER = 0x06,
    MODBUS_FC_WRITE_MULTIPLE_COILS = 0x0F,
    MODBUS_FC_WRITE_MULTIPLE_REGISTERS = 0x10
} modbus_function_code_t;

// Modbus从设备回调函数类型
typedef modbus_error_t (*modbus_read_coil_cb_t)(uint16_t address, uint8_t* value);
typedef modbus_error_t (*modbus_read_discrete_input_cb_t)(uint16_t address, uint8_t* value);
typedef modbus_error_t (*modbus_read_holding_register_cb_t)(uint16_t address, uint16_t* value);
typedef modbus_error_t (*modbus_read_input_register_cb_t)(uint16_t address, uint16_t* value);
typedef modbus_error_t (*modbus_write_coil_cb_t)(uint16_t address, uint8_t value);
typedef modbus_error_t (*modbus_write_register_cb_t)(uint16_t address, uint16_t value);
typedef modbus_error_t (*modbus_write_multiple_coils_cb_t)(uint16_t start_address, uint16_t quantity, const uint8_t* values);
typedef modbus_error_t (*modbus_write_multiple_registers_cb_t)(uint16_t start_address, uint16_t quantity, const uint16_t* values);

// Modbus从设备回调结构体
typedef struct {
    modbus_read_coil_cb_t read_coil;
    modbus_read_discrete_input_cb_t read_discrete_input;
    modbus_read_holding_register_cb_t read_holding_register;
    modbus_read_input_register_cb_t read_input_register;
    modbus_write_coil_cb_t write_coil;
    modbus_write_register_cb_t write_register;
    modbus_write_multiple_coils_cb_t write_multiple_coils;
    modbus_write_multiple_registers_cb_t write_multiple_registers;
} modbus_callbacks_t;

// Modbus上下文结构
typedef struct {
    uint8_t address;                // 设备地址
    modbus_mode_t mode;             // RTU或ASCII模式
    modbus_callbacks_t callbacks;   // 回调函数
    void* user_data;                // 用户数据
} modbus_t;

// 平台相关函数（需要用户实现）
typedef struct {
    // 发送数据
    int (*send)(const uint8_t* data, size_t length, void* user_data);
    // 接收数据（带超时）
    int (*receive)(uint8_t* data, size_t max_length, uint32_t timeout_ms, void* user_data);
    // 获取当前时间（毫秒）
    uint32_t (*get_time_ms)(void);
    // 延时函数（毫秒）
    void (*delay_ms)(uint32_t ms);
} modbus_platform_t;

// 初始化Modbus上下文
modbus_error_t modbus_init(modbus_t* ctx, uint8_t address, modbus_mode_t mode, 
                          const modbus_callbacks_t* callbacks, void* user_data);

// 设置平台相关函数
void modbus_set_platform(modbus_platform_t* platform);

// 主设备函数
modbus_error_t modbus_read_coils(modbus_t* ctx, uint8_t slave_address, 
                                uint16_t start_address, uint16_t quantity, 
                                uint8_t* values);
modbus_error_t modbus_read_discrete_inputs(modbus_t* ctx, uint8_t slave_address, 
                                          uint16_t start_address, uint16_t quantity, 
                                          uint8_t* values);
modbus_error_t modbus_read_holding_registers(modbus_t* ctx, uint8_t slave_address, 
                                            uint16_t start_address, uint16_t quantity, 
                                            uint16_t* values);
modbus_error_t modbus_read_input_registers(modbus_t* ctx, uint8_t slave_address, 
                                          uint16_t start_address, uint16_t quantity, 
                                          uint16_t* values);
modbus_error_t modbus_write_single_coil(modbus_t* ctx, uint8_t slave_address, 
                                       uint16_t address, uint8_t value);
modbus_error_t modbus_write_single_register(modbus_t* ctx, uint8_t slave_address, 
                                           uint16_t address, uint16_t value);
modbus_error_t modbus_write_multiple_coils(modbus_t* ctx, uint8_t slave_address, 
                                          uint16_t start_address, uint16_t quantity, 
                                          const uint8_t* values);
modbus_error_t modbus_write_multiple_registers(modbus_t* ctx, uint8_t slave_address, 
                                              uint16_t start_address, uint16_t quantity, 
                                              const uint16_t* values);

// 从设备处理函数
modbus_error_t modbus_process_request(modbus_t* ctx);

// CRC计算函数
uint16_t modbus_crc16(const uint8_t* data, size_t length);

// LRC计算函数（用于ASCII模式）
uint8_t modbus_lrc(const uint8_t* data, size_t length);

// 辅助函数
uint16_t modbus_bytes_to_uint16(const uint8_t* bytes);
void modbus_uint16_to_bytes(uint16_t value, uint8_t* bytes);

#endif // MODBUS_H

实现文件 (modbus.c)

#include "modbus.h"
#include <string.h>

// 平台相关函数
static modbus_platform_t platform;

// 设置平台相关函数
void modbus_set_platform(modbus_platform_t* platform_functions) {
    if (platform_functions) {
        platform = *platform_functions;
    }
}

// 初始化Modbus上下文
modbus_error_t modbus_init(modbus_t* ctx, uint8_t address, modbus_mode_t mode, 
                          const modbus_callbacks_t* callbacks, void* user_data) {
    if (!ctx) {
        return MODBUS_ERROR_INVALID_DATA;
    }
    
    ctx->address = address;
    ctx->mode = mode;
    ctx->user_data = user_data;
    
    if (callbacks) {
        ctx->callbacks = *callbacks;
    } else {
        // 清空回调函数
        memset(&ctx->callbacks, 0, sizeof(modbus_callbacks_t));
    }
    
    return MODBUS_SUCCESS;
}

// CRC16计算 (Modbus)
uint16_t modbus_crc16(const uint8_t* data, size_t length) {
    uint16_t crc = 0xFFFF;
    
    for (size_t i = 0; i < length; i++) {
        crc ^= data[i];
        
        for (int j = 0; j < 8; j++) {
            if (crc & 0x0001) {
                crc = (crc >> 1) ^ 0xA001;
            } else {
                crc >>= 1;
            }
        }
    }
    
    return crc;
}

// LRC计算 (用于ASCII模式)
uint8_t modbus_lrc(const uint8_t* data, size_t length) {
    uint8_t lrc = 0;
    
    for (size_t i = 0; i < length; i++) {
        lrc += data[i];
    }
    
    return (uint8_t)(-((int8_t)lrc));
}

// 字节数组转换为16位整数
uint16_t modbus_bytes_to_uint16(const uint8_t* bytes) {
    return (bytes[0] << 8) | bytes[1];
}

// 16位整数转换为字节数组
void modbus_uint16_to_bytes(uint16_t value, uint8_t* bytes) {
    bytes[0] = (value >> 8) & 0xFF;
    bytes[1] = value & 0xFF;
}

// 发送响应
static modbus_error_t send_response(modbus_t* ctx, const uint8_t* data, size_t length) {
    if (!platform.send) {
        return MODBUS_ERROR_INVALID_DATA;
    }
    
    if (ctx->mode == MODBUS_RTU) {
        // RTU模式：直接发送数据+CRC
        uint8_t buffer[length + 2];
        memcpy(buffer, data, length);
        
        uint16_t crc = modbus_crc16(data, length);
        buffer[length] = crc & 0xFF;
        buffer[length + 1] = (crc >> 8) & 0xFF;
        
        return platform.send(buffer, length + 2, ctx->user_data) == (int)(length + 2) ? 
               MODBUS_SUCCESS : MODBUS_ERROR_MEMORY;
    } else {
        // ASCII模式：添加起始符、LRC和结束符
        uint8_t lrc = modbus_lrc(data, length);
        uint8_t ascii_buffer[2 * (length + 1) + 3]; // 数据转ASCII + LRC + 起始结束符
        
        ascii_buffer[0] = ':';
        size_t idx = 1;
        
        // 转换数据到ASCII
        for (size_t i = 0; i < length; i++) {
            uint8_t nibble_high = (data[i] >> 4) & 0x0F;
            uint8_t nibble_low = data[i] & 0x0F;
            
            ascii_buffer[idx++] = (nibble_high < 10) ? ('0' + nibble_high) : ('A' + nibble_high - 10);
            ascii_buffer[idx++] = (nibble_low < 10) ? ('0' + nibble_low) : ('A' + nibble_low - 10);
        }
        
        // 添加LRC
        uint8_t lrc_high = (lrc >> 4) & 0x0F;
        uint8_t lrc_low = lrc & 0x0F;
        
        ascii_buffer[idx++] = (lrc_high < 10) ? ('0' + lrc_high) : ('A' + lrc_high - 10);
        ascii_buffer[idx++] = (lrc_low < 10) ? ('0' + lrc_low) : ('A' + lrc_low - 10);
        
        // 添加结束符
        ascii_buffer[idx++] = '\r';
        ascii_buffer[idx++] = '\n';
        
        return platform.send(ascii_buffer, idx, ctx->user_data) == (int)idx ? 
               MODBUS_SUCCESS : MODBUS_ERROR_MEMORY;
    }
}

// 发送异常响应
static modbus_error_t send_exception_response(modbus_t* ctx, uint8_t function_code, uint8_t exception_code) {
    uint8_t response[2];
    response[0] = function_code | 0x80; // 设置最高位表示异常
    response[1] = exception_code;
    
    return send_response(ctx, response, 2);
}

// 处理读取线圈请求
static modbus_error_t handle_read_coils(modbus_t* ctx, const uint8_t* request, size_t length) {
    if (length < 4 || !ctx->callbacks.read_coil) {
        return send_exception_response(ctx, MODBUS_FC_READ_COILS, 0x03); // 非法数据值
    }
    
    uint16_t start_address = modbus_bytes_to_uint16(request);
    uint16_t quantity = modbus_bytes_to_uint16(request + 2);
    
    if (quantity < 1 || quantity > 2000) {
        return send_exception_response(ctx, MODBUS_FC_READ_COILS, 0x03); // 非法数据值
    }
    
    uint8_t response[2 + (quantity + 7) / 8]; // 字节数 + 数据
    response[0] = MODBUS_FC_READ_COILS;
    response[1] = (quantity + 7) / 8; // 字节数
    
    // 读取所有请求的线圈
    for (uint16_t i = 0; i < quantity; i++) {
        uint8_t value;
        modbus_error_t err = ctx->callbacks.read_coil(start_address + i, &value);
        
        if (err != MODBUS_SUCCESS) {
            return send_exception_response(ctx, MODBUS_FC_READ_COILS, 0x04); // 从设备故障
        }
        
        if (value) {
            response[2 + i / 8] |= (1 << (i % 8));
        } else {
            response[2 + i / 8] &= ~(1 << (i % 8));
        }
    }
    
    return send_response(ctx, response, 2 + response[1]);
}

// 处理读取保持寄存器请求
static modbus_error_t handle_read_holding_registers(modbus_t* ctx, const uint8_t* request, size_t length) {
    if (length < 4 || !ctx->callbacks.read_holding_register) {
        return send_exception_response(ctx, MODBUS_FC_READ_HOLDING_REGISTERS, 0x03); // 非法数据值
    }
    
    uint16_t start_address = modbus_bytes_to_uint16(request);
    uint16_t quantity = modbus_bytes_to_uint16(request + 2);
    
    if (quantity < 1 || quantity > 125) {
        return send_exception_response(ctx, MODBUS_FC_READ_HOLDING_REGISTERS, 0x03); // 非法数据值
    }
    
    uint8_t response[2 + quantity * 2]; // 字节数 + 数据
    response[0] = MODBUS_FC_READ_HOLDING_REGISTERS;
    response[1] = quantity * 2; // 字节数
    
    // 读取所有请求的寄存器
    for (uint16_t i = 0; i < quantity; i++) {
        uint16_t value;
        modbus_error_t err = ctx->callbacks.read_holding_register(start_address + i, &value);
        
        if (err != MODBUS_SUCCESS) {
            return send_exception_response(ctx, MODBUS_FC_READ_HOLDING_REGISTERS, 0x04); // 从设备故障
        }
        
        modbus_uint16_to_bytes(value, response + 2 + i * 2);
    }
    
    return send_response(ctx, response, 2 + quantity * 2);
}

// 处理写入单个寄存器请求
static modbus_error_t handle_write_single_register(modbus_t* ctx, const uint8_t* request, size_t length) {
    if (length < 4 || !ctx->callbacks.write_register) {
        return send_exception_response(ctx, MODBUS_FC_WRITE_SINGLE_REGISTER, 0x03); // 非法数据值
    }
    
    uint16_t address = modbus_bytes_to_uint16(request);
    uint16_t value = modbus_bytes_to_uint16(request + 2);
    
    modbus_error_t err = ctx->callbacks.write_register(address, value);
    
    if (err != MODBUS_SUCCESS) {
        return send_exception_response(ctx, MODBUS_FC_WRITE_SINGLE_REGISTER, 0x04); // 从设备故障
    }
    
    // 响应与请求相同
    uint8_t response[5];
    response[0] = MODBUS_FC_WRITE_SINGLE_REGISTER;
    memcpy(response + 1, request, 4);
    
    return send_response(ctx, response, 5);
}

// 处理写入多个寄存器请求
static modbus_error_t handle_write_multiple_registers(modbus_t* ctx, const uint8_t* request, size_t length) {
    if (length < 5 || !ctx->callbacks.write_multiple_registers) {
        return send_exception_response(ctx, MODBUS_FC_WRITE_MULTIPLE_REGISTERS, 0x03); // 非法数据值
    }
    
    uint16_t start_address = modbus_bytes_to_uint16(request);
    uint16_t quantity = modbus_bytes_to_uint16(request + 2);
    uint8_t byte_count = request[4];
    
    if (quantity < 1 || quantity > 123 || byte_count != quantity * 2) {
        return send_exception_response(ctx, MODBUS_FC_WRITE_MULTIPLE_REGISTERS, 0x03); // 非法数据值
    }
    
    // 提取寄存器值
    uint16_t values[quantity];
    for (uint16_t i = 0; i < quantity; i++) {
        values[i] = modbus_bytes_to_uint16(request + 5 + i * 2);
    }
    
    modbus_error_t err = ctx->callbacks.write_multiple_registers(start_address, quantity, values);
    
    if (err != MODBUS_SUCCESS) {
        return send_exception_response(ctx, MODBUS_FC_WRITE_MULTIPLE_REGISTERS, 0x04); // 从设备故障
    }
    
    // 响应包含起始地址和数量
    uint8_t response[5];
    response[0] = MODBUS_FC_WRITE_MULTIPLE_REGISTERS;
    memcpy(response + 1, request, 4);
    
    return send_response(ctx, response, 5);
}

// 从设备处理请求
modbus_error_t modbus_process_request(modbus_t* ctx) {
    if (!platform.receive || !ctx) {
        return MODBUS_ERROR_INVALID_DATA;
    }
    
    uint8_t buffer[256];
    int received;
    
    if (ctx->mode == MODBUS_RTU) {
        // RTU模式接收
        received = platform.receive(buffer, sizeof(buffer), 100, ctx->user_data);
        
        if (received < 4) { // 最小帧长度：地址+功能码+CRC(2字节)
            return MODBUS_ERROR_TIMEOUT;
        }
        
        // 验证CRC
        uint16_t crc_received = (buffer[received - 1] << 8) | buffer[received - 2];
        uint16_t crc_calculated = modbus_crc16(buffer, received - 2);
        
        if (crc_received != crc_calculated) {
            return MODBUS_ERROR_CRC;
        }
        
        // 检查地址是否匹配
        if (buffer[0] != ctx->address && buffer[0] != 0) { // 0是广播地址
            return MODBUS_ERROR_INVALID_SLAVE;
        }
        
        // 处理请求（去掉CRC）
        received -= 2;
    } else {
        // ASCII模式接收
        received = platform.receive(buffer, sizeof(buffer), 100, ctx->user_data);
        
        if (received < 3 || buffer[0] != ':') { // 最小帧长度：: + 至少1字节数据 + LRC + CRLF
            return MODBUS_ERROR_TIMEOUT;
        }
        
        // 查找结束符
        int end_pos = -1;
        for (int i = 1; i < received - 1; i++) {
            if (buffer[i] == '\r' && buffer[i + 1] == '\n') {
                end_pos = i;
                break;
            }
        }
        
        if (end_pos == -1) {
            return MODBUS_ERROR_INVALID_DATA;
        }
        
        // 转换ASCII到二进制
        uint8_t binary_buffer[256];
        int binary_length = 0;
        
        for (int i = 1; i < end_pos; i += 2) {
            if (i + 1 >= end_pos) {
                return MODBUS_ERROR_INVALID_DATA;
            }
            
            uint8_t high_nibble = buffer[i];
            uint8_t low_nibble = buffer[i + 1];
            
            if (high_nibble >= '0' && high_nibble <= '9') {
                high_nibble -= '0';
            } else if (high_nibble >= 'A' && high_nibble <= 'F') {
                high_nibble -= 'A' - 10;
            } else if (high_nibble >= 'a' && high_nibble <= 'f') {
                high_nibble -= 'a' - 10;
            } else {
                return MODBUS_ERROR_INVALID_DATA;
            }
            
            if (low_nibble >= '0' && low_nibble <= '9') {
                low_nibble -= '0';
            } else if (low_nibble >= 'A' && low_nibble <= 'F') {
                low_nibble -= 'A' - 10;
            } else if (low_nibble >= 'a' && low_nibble <= 'f') {
                low_nibble -= 'a' - 10;
            } else {
                return MODBUS_ERROR_INVALID_DATA;
            }
            
            binary_buffer[binary_length++] = (high_nibble << 4) | low_nibble;
        }
        
        // 验证LRC
        uint8_t lrc_received = binary_buffer[binary_length - 1];
        uint8_t lrc_calculated = modbus_lrc(binary_buffer, binary_length - 1);
        
        if (lrc_received != lrc_calculated) {
            return MODBUS_ERROR_CRC;
        }
        
        // 检查地址是否匹配
        if (binary_buffer[0] != ctx->address && binary_buffer[0] != 0) { // 0是广播地址
            return MODBUS_ERROR_INVALID_SLAVE;
        }
        
        // 使用二进制数据（去掉LRC）
        memcpy(buffer, binary_buffer, binary_length - 1);
        received = binary_length - 1;
    }
    
    // 处理功能码
    uint8_t function_code = buffer[1];
    
    switch (function_code) {
        case MODBUS_FC_READ_COILS:
            return handle_read_coils(ctx, buffer + 2, received - 2);
            
        case MODBUS_FC_READ_HOLDING_REGISTERS:
            return handle_read_holding_registers(ctx, buffer + 2, received - 2);
            
        case MODBUS_FC_WRITE_SINGLE_REGISTER:
            return handle_write_single_register(ctx, buffer + 2, received - 2);
            
        case MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
            return handle_write_multiple_registers(ctx, buffer + 2, received - 2);
            
        default:
            return send_exception_response(ctx, function_code, 0x01); // 非法功能
    }
}

// 主设备函数实现
modbus_error_t modbus_read_holding_registers(modbus_t* ctx, uint8_t slave_address, 
                                            uint16_t start_address, uint16_t quantity, 
                                            uint16_t* values) {
    if (!platform.send || !platform.receive || !ctx || !values) {
        return MODBUS_ERROR_INVALID_DATA;
    }
    
    if (quantity < 1 || quantity > 125) {
        return MODBUS_ERROR_INVALID_DATA;
    }
    
    // 构建请求
    uint8_t request[5];
    request[0] = slave_address;
    request[1] = MODBUS_FC_READ_HOLDING_REGISTERS;
    modbus_uint16_to_bytes(start_address, request + 2);
    modbus_uint16_to_bytes(quantity, request + 4);
    
    // 发送请求
    modbus_error_t err;
    if (ctx->mode == MODBUS_RTU) {
        uint16_t crc = modbus_crc16(request, 5);
        uint8_t full_request[7];
        memcpy(full_request, request, 5);
        full_request[5] = crc & 0xFF;
        full_request[6] = (crc >> 8) & 0xFF;
        
        err = platform.send(full_request, 7, ctx->user_data) == 7 ? 
              MODBUS_SUCCESS : MODBUS_ERROR_MEMORY;
    } else {
        // ASCII模式实现类似，需要转换
        err = MODBUS_ERROR_INVALID_DATA; // 简化实现
    }
    
    if (err != MODBUS_SUCCESS) {
        return err;
    }
    
    // 接收响应
    uint8_t response[256];
    int received = platform.receive(response, sizeof(response), 1000, ctx->user_data);
    
    if (received < 5) {
        return MODBUS_ERROR_TIMEOUT;
    }
    
    // 验证响应（简化实现）
    if (response[0] != slave_address || response[1] != MODBUS_FC_READ_HOLDING_REGISTERS) {
        return MODBUS_ERROR_INVALID_DATA;
    }
    
    uint8_t byte_count = response[2];
    if (byte_count != quantity * 2) {
        return MODBUS_ERROR_INVALID_DATA;
    }
    
    // 提取数据
    for (int i = 0; i < quantity; i++) {
        values[i] = modbus_bytes_to_uint16(response + 3 + i * 2);
    }
    
    return MODBUS_SUCCESS;
}

// 其他主设备函数实现类似，为简洁起见省略
// modbus_write_single_register, modbus_write_multiple_registers等

// 简化实现其他函数
modbus_error_t modbus_read_coils(modbus_t* ctx, uint8_t slave_address, 
                                uint16_t start_address, uint16_t quantity, 
                                uint8_t* values) {
    // 实现类似于modbus_read_holding_registers
    return MODBUS_ERROR_INVALID_FUNCTION; // 简化
}

modbus_error_t modbus_write_single_register(modbus_t* ctx, uint8_t slave_address, 
                                           uint16_t address, uint16_t value) {
    // 实现类似于modbus_read_holding_registers
    return MODBUS_ERROR_INVALID_FUNCTION; // 简化
}

// 其他函数实现...

使用示例

1. 平台相关函数实现示例

#include "modbus.h"
#include <stdio.h>

// 假设的串口实现
typedef struct {
    int fd; // 文件描述符或句柄
} serial_port_t;

// 发送数据函数
int serial_send(const uint8_t* data, size_t length, void* user_data) {
    serial_port_t* port = (serial_port_t*)user_data;
    // 实现串口发送
    printf("Sending %zu bytes\n", length);
    return length; // 返回实际发送的字节数
}

// 接收数据函数
int serial_receive(uint8_t* data, size_t max_length, uint32_t timeout_ms, void* user_data) {
    serial_port_t* port = (serial_port_t*)user_data;
    // 实现带超时的串口接收
    // 这里是简化实现
    static int counter = 0;
    if (counter++ < 3) return 0; // 模拟没有数据
    
    // 模拟接收到的数据
    data[0] = 0x01; // 地址
    data[1] = 0x03; // 功能码
    data[2] = 0x04; // 字节数
    data[3] = 0x00; // 数据高字节
    data[4] = 0x01; // 数据低字节
    data[5] = 0x00; // 数据高字节
    data[6] = 0x02; // 数据低字节
    data[7] = 0x00; // CRC低字节
    data[8] = 0x00; // CRC高字节
    
    return 9; // 返回实际接收的字节数
}

// 获取时间函数
uint32_t get_time_ms(void) {
    // 实现获取当前时间（毫秒）
    static uint32_t time = 0;
    return time += 10; // 模拟时间递增
}

// 延时函数
void delay_ms(uint32_t ms) {
    // 实现毫秒级延时
    printf("Delay %u ms\n", ms);
}

// 从设备回调函数示例
modbus_error_t read_holding_register_cb(uint16_t address, uint16_t* value) {
    // 模拟读取保持寄存器
    if (address == 0) {
        *value = 0x1234;
    } else if (address == 1) {
        *value = 0x5678;
    } else {
        return MODBUS_ERROR_INVALID_DATA;
    }
    return MODBUS_SUCCESS;
}

modbus_error_t write_register_cb(uint16_t address, uint16_t value) {
    // 模拟写入寄存器
    printf("Write register %d = %d\n", address, value);
    return MODBUS_SUCCESS;
}

int main() {
    // 初始化平台函数
    modbus_platform_t platform = {
        .send = serial_send,
        .receive = serial_receive,
        .get_time_ms = get_time_ms,
        .delay_ms = delay_ms
    };
    modbus_set_platform(&platform);
    
    // 初始化串口
    serial_port_t port = {0};
    
    // 初始化Modbus从设备
    modbus_callbacks_t callbacks = {
        .read_holding_register = read_holding_register_cb,
        .write_register = write_register_cb
    };
    
    modbus_t slave;
    modbus_init(&slave, 0x01, MODBUS_RTU, &callbacks, &port);
    
    // 处理请求
    modbus_process_request(&slave);
    
    // 初始化Modbus主设备
    modbus_t master;
    modbus_init(&master, 0x00, MODBUS_RTU, NULL, &port);
    
    // 读取保持寄存器
    uint16_t values[2];
    modbus_error_t err = modbus_read_holding_registers(&master, 0x01, 0, 2, values);
    
    if (err == MODBUS_SUCCESS) {
        printf("Read values: 0x%04X, 0x%04X\n", values[0], values[1]);
    } else {
        printf("Error: %d\n", err);
    }
    
    return 0;
}

2. 集成到嵌入式系统

// 在RTOS任务中处理Modbus请求
void modbus_task(void* argument) {
    serial_port_t* port = (serial_port_t*)argument;
    
    // 初始化Modbus
    modbus_callbacks_t callbacks = {
        .read_holding_register = read_holding_register_cb,
        .write_register = write_register_cb
        // 设置其他回调函数...
    };
    
    modbus_t ctx;
    modbus_init(&ctx, 0x01, MODBUS_RTU, &callbacks, port);
    
    while (1) {
        modbus_error_t err = modbus_process_request(&ctx);
        
        if (err != MODBUS_SUCCESS && err != MODBUS_ERROR_TIMEOUT) {
            // 处理错误
            printf("Modbus error: %d\n", err);
        }
        
        // 任务延时
        vTaskDelay(10 / portTICK_PERIOD_MS);
    }
}

参考代码 modbus完整协议使用C语言编写易于移植 www.3dddown.com/csa/51670.html

移植指南

  1. 平台相关函数：

    • 实现modbus_platform_t中定义的四个函数：
      • send: 数据发送函数
      • receive: 带超时的数据接收函数
      • get_time_ms: 获取当前时间（毫秒）
      • delay_ms: 毫秒级延时函数

  2. 内存分配：

    • 本实现不使用动态内存分配，适合嵌入式系统
    • 所有缓冲区都是静态分配或栈分配

  3. 配置选项：

    • 通过修改modbus_init参数配置设备地址和模式
    • 通过回调函数接口实现设备特定功能

  4. 资源需求：

    • 代码大小：约4-8KB（取决于编译器和优化选项）
    • RAM：几百字节（取决于缓冲区大小）
    • 不需要操作系统支持，可在裸机环境中运行

  5. 性能优化：

    • 对于高速应用，可以优化CRC计算（使用查表法）
    • 可以根据具体硬件优化串口通信

这个Modbus协议栈实现了RTU和ASCII模式，支持常用的功能码，并且设计为易于移植到各种平台。

foundbug999
关注
C语言与工业自动化控制：PLC编程、Modbus/TCP协议与OPC UA接口（二）
weixin_56154577的博客
04-22 1976
C语言凭借其底层控制力、高效性、跨平台能力以及与硬件的良好交互性，在Modbus/TCP通信的实现、优化、稳定性和安全性提升方面发挥着重要作用。通过精心设计和编码，C语言编写的Modbus/TCP通信程序能够在工业自动化环境中展现出卓越的性能和可靠性。
C语言与工业自动化控制：PLC编程、Modbus/TCP协议与OPC UA接口（一）
weixin_56154577的博客
04-22 3274
C语言是一种结构化、低级且高效的通用编程语言，以其简洁、紧凑的语法和对硬件的直接控制能力著称。在工业自动化领域，C语言常被用于编写嵌入式系统软件、设备驱动程序、通信协议栈以及各类控制算法，因其执行效率高、内存管理灵活且与硬件接口紧密而备受青睐。
探索MODBUS通讯的C语言实现：一个开源项目的深度解析
gitblog_06600的博客
09-26 833
探索MODBUS通讯的C语言实现：一个开源项目的深度解析 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在工业自动化和物联网领域，MODBUS协议因其简单、可靠和广泛兼容性而备受青睐。为了帮助开发者更好地理解和应用MODBUS协议，我们推出了一款使用C语言编写的MODBUS通讯协议源代码。这个开源项目不仅为初学者提供了一个学习MODBUS协议的绝佳起点，也为经验丰富的...
Modbus协议
qq_45973003的博客
08-02 1386
..Modbus协议是工业领域中一种非常流行的通信协议，用于连接工业电子设备，如可编程逻辑控制器（PLCs）、传感器、执行器和其他工业自动化组件，Modbus协议最初由Modicon公司（现在的施耐德电气的一部分）在1979年开发，目的是为了使不同制造商的设备能够在同一网络中通信，由于其开放性和简单性，Modbus迅速成为工业通信的标准之一。
值得收藏 Modbus RTU 协议详解
热门推荐
^_^
04-21 5万+
值得收藏！Modbus RTU 协议详解~ 目录值得收藏！Modbus RTU 协议详解~Modbus是什么？Modbus分类Modbus通讯过程Modbus-RTU协议数据帧结构功能码01：读线圈状态功能码02：读离散量输入功能码03：读保持寄存器功能码04：读输入寄存器功能码05：写单个线圈功能码06：写单个寄存器功能码15：写多个线圈功能码16：写多个寄存器 Modbus是什么？         ~~~~~~~~&nbs
C语言的Modbus RTU程序各种实现方法详解
gitblog_06736的博客
04-14 927
C语言的Modbus RTU程序各种实现方法详解 去发现同类优质开源项目:https://gitcode.com/ 此仓库包含了C语言实现Modbus RTU协议的多种方法及详细分析。Modbus RTU是一种串行通信协议，广泛应用于工业领域，用于设备间的通信。以下是几种常见的实现方法及其优缺点分析，旨在帮助开发者更好地理解和运用这些方法。 1. 使用标准库函数实现 开发者可以利用C语言的标准库函...
开源Modbus源码介绍：Modbus协议栈，RTU与TCP双模支持
gitblog_06794的博客
05-30 310
开源Modbus源码介绍：Modbus协议栈，RTU与TCP双模支持 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在自动化领域，Modbus协议是一种广泛应用于工业设备通信的串行通信协议。今天，我们要推荐一个功能强大的开源Modbus源码——libmodbus，它为开发者提供了一个完整的Modbus协议栈，并支持RTU和TCP两种通信模式。该源码能够在多种操作系统上...
基于STM32的MODBUS-RTU框架的实现
zhuzhu的博客
04-15 1万+
基于STM32的MODBUS-RTU框架的实现
工业设备通信从入门到精通：C语言实现MODBUS协议的完整路径
GatherLume的博客
11-24 555
掌握工业设备通信核心技术，本文详解C语言实现MODBUS协议的完整路径，涵盖串口通信、功能码解析与错误校验，适用于PLC、传感器等工业场景。代码可移植性强，助你快速构建稳定通信系统，值得收藏。
modbus完整协议使用C语言编写易于移植.rar_C语言 Modbus-RTU_MODBUS ASCII_MUDBUS协议C语
07-15
这个资源“modbus完整协议使用C语言编写易于移植.rar”提供了在C语言中实现Modbus协议的代码，包括RTU（远程终端单元）模式和ASCII（美国标准代码交换信息）模式，方便在不同平台上进行移植。 1. **Modbus协议概述*...
基于51单片机的C语言版本modbus协议通信代码
01-08
标题中的“基于51单片机的C语言版本modbus协议通信代码”表明这是一个关于51系列单片机使用C语言实现Modbus通信协议的项目。Modbus是一种广泛应用的工业通信协议，允许设备之间进行串行通信，尤其在自动化设备和系统...
STM32F103移植FreeModbus同时实现ModbusRTU和ModbusTCP.zip
06-16
- FreeModbus库是用C语言编写的，易于在多种嵌入式平台上移植。 - 支持主站和从站模式，可以用于设备控制或数据采集。 - 提供了Modbus RTU和Modbus TCP两种通信协议的实现。 - 具有错误处理机制，保证通信的稳定...
JNI简单学习（java调用C/C++）
qq_64851111的博客
12-11 989
JNI（Java Native Interface）是 JDK 内置的标准原生接口，是 Java 平台与 C/C++ 等原生代码（Native Code）交互的底层规范，允许 Java 虚拟机（JVM）中的 Java 代码调用原生代码，也支持原生代码回调 Java 代码。与 JNA（基于 JNI 封装的上层类库）不同，JNI 是 Java 与原生代码通信的 “底层基础”，所有 Java 调用原生库的方案（包括 JNA、JNR 等）最终都基于 JNI 实现。
XML Schema 日期/时间 数据类型
csbysj2020的博客
12-11 493
datedateTimetimegYeargYearMonthgDaygMonthgMonthDayduration这些数据类型分别表示不同的日期和时间范围，适用于不同的应用场景。本文介绍了 XML Schema 中日期/时间数据类型的相关概念、类型、格式以及注意事项。通过了解这些知识，有助于我们在 XML 文档中正确地表示日期和时间数据，提高数据的一致性和准确性。
javascript 性能优化实战：异步和延迟加载
小伙伴们全都Lucky！
12-11 923
本文探讨JavaScript性能优化中的异步加载与延迟加载技术。异步加载通过async/defer属性或动态创建script元素避免阻塞渲染；延迟加载则利用IntersectionObserver API按需加载非关键资源。二者结合可显著提升性能：异步加载核心脚本确保交互流畅，延迟加载减少初始请求量。实践表明，该方案能降低DOMContentLoaded时间30%以上，减少初始加载量90%，但需注意async脚本的执行顺序问题和延迟加载的回退处理。文中提供了完整的代码实现示例。
命令执行漏洞 (RCE) 渗透测试实战指南
weixin_45631123的博客
12-15 238
Burp Suite 或 OWASP ZAP 抓包工具、授权测试环境。：Burp Collaborator 或公网DNS服务器。：Java Web应用，可注入Java代码。：安装ysoserial工具、Java环境。：安装Commix、Python3环境。：识别表单输入点（如登录框）：无回显但命令执行成功时。：确认RCE漏洞存在。
基于Java+SpringBoot+Vue的美甲店管理系统【附源码+文档+部署视频+讲解)
小熊的博客
12-11 1191
基于SpringBoot的美甲店管理系统开发案例，涵盖用户、美甲师和管理员三大角色功能模块，采用Vue+SpringBoot+MySQL技术栈实现。系统包含服务预约、订单管理、耗材采购等全流程数字化功能，采用MVC设计模式和B/S架构。包含用户、美甲师、管理员三类角色的功能模块，该系统聚焦美甲店的日常运营场景，通过用户端浏览服务与套餐、美甲师端处理预约与评价、管理员端统筹人员、业务与资源的模式，实现美甲店从服务展示、预约调度到耗材管理的全流程数字化，提升门店运营效率与服务体验。
【QML】C++访问QML控件
weixin_53161762的博客
12-10 319
这些就可以使用obj->findChild<QObject *>(“rect”);根据对象的名字找到对应的对象，然后使用QQmlProperty修改对的应的属性了。如上图可知，在qml文件里面的qml控件的属性已经被cpp文件的中c++修改了。如上图，触发了qml中的信号后，就打印出c++中的槽函数。如上图，信号和函数和返回值都触发成功了。先创建一个c++类，然后写一个槽函数。main.cpp中加入以下代码。main.cpp文件。
LinkedHashMap：有序HashMap
最新发布
weixin_43076660的博客
12-15 536
LinkedHashMap是HashMap的子类，通过双向链表维护元素顺序，支持插入顺序和访问顺序两种模式。其核心结构是哈希表+双向链表，节点类扩展了前驱和后继指针。默认按插入顺序维护链表，设置accessOrder=true可改为访问顺序，适合实现LRU缓存。重写removeEldestEntry方法可自动移除最老元素，get/put操作会触发链表调整。LinkedHashMap通过回调方法（afterNodeAccess/Insertion/Removal）在哈希表操作时同步维护链表顺序，既保留Hash
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值