51单片机编写的标准modbus协议通信模版

以下是51单片机编写的标准modbus协议通信模板：

#include <reg51.h>

#define FOSC 11059200L // 定义系统时钟频率
#define BAUD 9600 // 定义波特率
#define TIMER_PRESCALER 12 // 定义定时器分频比

// 定义modbus协议相关的常量
#define MB_SLAVE_ADDRESS 0x01
#define MB_FUNC_READ_HOLDING_REGISTERS 0x03
#define MB_FUNC_WRITE_MULTIPLE_REGISTERS 0x10

// 定义modbus协议数据包结构体
typedef struct {
    unsigned char slave_address;
    unsigned char func_code;
    unsigned char start_address_hi;
    unsigned char start_address_lo;
    unsigned char register_count_hi;
    unsigned char register_count_lo;
    unsigned char byte_count;
    unsigned char data[256];
} ModbusPacket;

// 定义modbus协议响应数据包结构体
typedef struct {
    unsigned char slave_address;
    unsigned char func_code;
    unsigned char byte_count;
    unsigned char data[256];
} ModbusResponsePacket;

// 初始化串口通信
void InitUART() {
    TMOD |= 0x20; // 定时器1为8位自动重装模式
    SCON = 0x50; // 串口工作在模式1，允许接收
    TH1 = 256 - FOSC / 12 / 32 / BAUD; // 计算定时器1重装值
    TR1 = 1; // 启动定时器1
}

// 发送一个字节数据到串口
void SendByte(unsigned char byte) {
    SBUF = byte;
    while (!TI); // 等待数据发送完成
    TI = 0; // 清除发送完成标志
}

// 发送modbus协议数据包
void SendModbusPacket(ModbusPacket *packet) {
    unsigned char i;
    unsigned int crc = 0xFFFF;

    // 发送从站地址、功能码、起始地址和寄存器个数等信息
    SendByte(packet->slave_address);
    SendByte(packet->func_code);
    SendByte(packet->start_address_hi);
    SendByte(packet->start_address_lo);
    SendByte(packet->register_count_hi);
    SendByte(packet->register_count_lo);
    SendByte(packet->byte_count);

    // 发送数据区内容，并计算CRC校验码
    for (i = 0; i < packet->byte_count; i++) {
        SendByte(packet->data[i]);
        crc = crc ^ packet->data[i];
        for (unsigned char j = 0; j < 8; j++) {
            if (crc & 0x0001) {
                crc = (crc >> 1) ^ 0xA001;
            } else {
                crc >>= 1;
            }
        }
    }

    // 发送CRC校验码
    SendByte(crc & 0xFF);
    SendByte(crc >> 8);
}

// 接收一个字节数据
unsigned char ReceiveByte() {
    while (!RI); // 等待数据接收完成
    RI = 0; // 清除接收完成标志
    return SBUF; // 返回接收到的数据
}

// 接收modbus协议响应数据包
void ReceiveModbusResponsePacket(ModbusResponsePacket *packet) {
    // 等待从站地址、功能码和数据字节数接收完成
    while (ReceiveByte() != packet->slave_address);
    packet->func_code = ReceiveByte();
    packet->byte_count = ReceiveByte();

    // 接收数据区内容
    for (unsigned char i = 0; i < packet->byte_count; i++) {
        packet->data[i] = ReceiveByte();
    }
}

// 发送modbus协议读取保持寄存器命令，并等待响应
void ModbusReadHoldingRegisters(unsigned int start_address, unsigned int register_count, unsigned int *data) {
    ModbusPacket packet;
    ModbusResponsePacket response_packet;

    // 填充modbus协议读取保持寄存器命令数据包
    packet.slave_address = MB_SLAVE_ADDRESS;
    packet.func_code = MB_FUNC_READ_HOLDING_REGISTERS;
    packet.start_address_hi = start_address >> 8;
    packet.start_address_lo = start_address & 0xFF;
    packet.register_count_hi = register_count >> 8;
    packet.register_count_lo = register_count & 0xFF;
    packet.byte_count = 0;

    // 发送modbus协议读取保持寄存器命令，并等待响应
    SendModbusPacket(&packet);
    ReceiveModbusResponsePacket(&response_packet);

    // 解析响应数据包，并将数据存入data数组中
    for (unsigned char i = 0; i < response_packet.byte_count / 2; i++) {
        data[i] = response_packet.data[i * 2] << 8 | response_packet.data[i * 2 + 1];
    }
}

// 发送modbus协议写入多个保持寄存器命令，并等待响应
void ModbusWriteMultipleRegisters(unsigned int start_address, unsigned int register_count, unsigned int *data) {
    ModbusPacket packet;
    ModbusResponsePacket response_packet;

    // 填充modbus协议写入多个保持寄存器命令数据包
    packet.slave_address = MB_SLAVE_ADDRESS;
    packet.func_code = MB_FUNC_WRITE_MULTIPLE_REGISTERS;
    packet.start_address_hi = start_address >> 8;
    packet.start_address_lo = start_address & 0xFF;
    packet.register_count_hi = register_count >> 8;
    packet.register_count_lo = register_count & 0xFF;
    packet.byte_count = register_count * 2;

    // 将数据存入数据区
    for (unsigned char i = 0; i < register_count; i++) {
        packet.data[i * 2] = data[i] >> 8;
        packet.data[i * 2 + 1] = data[i] & 0xFF;
    }

    // 发送modbus协议写入多个保持寄存器命令，并等待响应
    SendModbusPacket(&packet);
    ReceiveModbusResponsePacket(&response_packet);
}

void main() {
    unsigned int data[10];

    // 初始化串口通信
    InitUART();

    // 读取保持寄存器地址0x0000开始的10个寄存器的数据
    ModbusReadHoldingRegisters(0x0000, 10, data);

    // 将0x0000开始的10个寄存器的值都加1
    for (unsigned char i = 0; i < 10; i++) {
        data[i]++;
    }

    // 写入0x0000开始的10个保持寄存器的数据
    ModbusWriteMultipleRegisters(0x0000, 10, data);
}

以上代码仅供参考，实际应用中还需要根据具体的硬件和modbus协议要求进行修改。