RS485协议是什么？它和Modbus协议的区分以及C语言实现

最新推荐文章于 2024-08-22 17:21:16 发布

驽马匠人

最新推荐文章于 2024-08-22 17:21:16 发布

阅读量4.2k

点赞数 17

分类专栏：学习笔记 C/C++ 文章标签：物联网网络

本文链接： https://blog.csdn.net/qq_40326539/article/details/137091884

版权

C/C++ 同时被 2 个专栏收录

6 篇文章 1 订阅

订阅专栏

学习笔记

4 篇文章 0 订阅

订阅专栏

1.RS485的定义

相信做自动化或者智能设备的朋友都听说过RS485协议，RS485通信协议是一种多点通信协议，它允许多个设备在同一总线上进行通信，且每个设备都可以发送和接收数据。RS485通讯协议采用差分信号传输，具有高速、远距离、可靠性强等特点，可实现长距离的数据传输。

RS485通信协议支持半双工通信模式，在同一总线上可以连接多个驱动器和接收器，方便建立设备网络。此外，RS485通信协议的接口电平低，不易损坏芯片，电平与TTL电平兼容，方便与TTL电路连接。RS485通信协议是一种适用于工业控制系统和智能家居等领域的通信协议，具有高速、远距离、可靠性强等优点，能够满足大量数据传输的需求，并提高数据传输的效率和实时性。

2.RS485与Modbus区别

协议性质：RS485是一种物理层通信标准，主要定义了电气特性、信号传输方式和连接方式等，而Modbus是一种通信协议，定义了一种常用的通信格式和规则，用于在主设备和从设备之间进行数据交换。

应用范围：RS485通常用作物理层协议，支持Modbus协议，而Modbus更常用于工业控制领域，是一种通用的通信数据格式，支持RS485、RS232等串口。

所以，RS485和Modbus在协议性质、应用范围和功能特性方面存在明显的区别。在工业控制和智能设备通信领域，二者常常被结合使用，以实现高效、稳定的数据传输。

在物联网中，RS485协议被广泛应用于各种领域，如工业控制、智能家居、城市管理、智能交通等。在这些领域中，RS485协议可以实现设备之间的快速、稳定、可靠的数据传输，提高设备的智能化程度和用户体验。例如，在智能家居中，RS485协议可以用于家庭内部的各种设备之间的通信，包括智能电视、智能音响、智能照明、智能安防等，实现设备的互联互通和集中控制。

3.MODBUS通讯协议及编程

MODBUS通讯协议大致分为以下几种

Modbus-RTU+Modbus-ASCII
Modbus-TCP
Modbus-Plus

Modbus是主从方式通信,也就是说,不能同步进行通信,总线上每次只有一个数据进行传输,即主机发送,从机应答,主机不发送,总线上就没有数据通信.，本文主要讲解RTU协议

3.1. Modbus-RTU协议

这种协议是基于异步串行通信上,一般的介质有:RS-232,RS485,RS-422上,这也是工业上使用的最多的。

3.1.1. 帧结构

帧结构 = 地址 + 功能吗 + 数据 + 校验

地址: 占用一个字节,范围0-255,其中有效范围是1-247,其他有特殊用途,比如255是广播地址(广播地址就是应答所有地址,正常的需要两个设备的地址一样才能进行查询和回复)

功能码:" 占用一个字节,功能码的意义就是,知道这个指令是干啥的,比如你可以查询从机的数据,也可以修改数据,所以不同功能码对应不同功能.

数据: 根据功能码不同,有不同结构,在后续的实例中有说明;

校验: 为了保证数据不错误,增加这个,然后再把前面的数据进行计算看数据是否一致,如果一致,就说明这帧数据是正确的,我再回复;如果不一样,说明你这个数据在传输的时候出了问题,数据不对的,所以就抛弃了;

字符结构

通讯数据结构

3.1.2.常用功能码

03-主机需要发送起始地址+寄存器数量，从机回复总字节数+数据；
06-主机发送起始地址+数据内容（因为你只需要修改一个，所以起始地址就是所要修改的地址），从机返回起始地址+数据内容（发现居然一样！）
10-主机发送起始地址+寄存器个数+总字节数+数据，从机返回起始地址+寄存器数量

.3常用功能码使用举例分析

1.3.1 功能码-0x03读保持寄存器

测试功能描述:
现在我是主机,我要查询从机地址为1的数据

主机发送: 01 03 00 00 00 01 84 0A
从机回复: 01 03 02 12 34 B5 33

3.2.C语言实现

mbrtu_master.h

#ifndef MBRTU_MASTER_H_
#define MBRTU_MASTER_H_

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include "mbrtu_master.h"
#include "usart.h"
#include "tim.h"
#include "main.h"
#include "usart.h"
#include "stdio.h"  
///
/// MODBUS RTU 主机控制结构
///
///
typedef struct
{
	//
	// 收发数据缓存
	//
	uint8_t ucBuf[8];//读取可能是4个字节
	
	//
	// 收发数据状态
	//
	uint16_t usStatus;
	
	//
	// 如果使用了RTOS需要进行互斥,那么需要实现以下两个函数的绑定
	//
	void (*lock)(void);
	void (*unlock)(void);
	
	//
	// 微秒延时函数,用于等待超时
	//
	void (*delayms)(uint32_t nms);
	
	//
	// 定时器启动和停止函数
	//
	void (*timerStop)(void);
	void (*timerStart)(void);
	
	//
	// 发送数据函数,可以是串口、TCP等
	//
	uint32_t (*sendData)(const void* buf, uint32_t len);
	//把接受的数   
	uint32_t (*sendDataLog)(const void *buf, uint32_t len);
	//
	// 以下四个回调函数分别是:读线圈、读离散量输入、读保持寄存器、读输入寄存器
	//
	void (*readCoilsCallback)(uint16_t usStartAddr, uint16_t usNum, const uint8_t* pucBitsOfCoilsState, uint16_t usLen);
	void (*readDiscreteInputsCallback)(uint16_t usStartAddr, uint16_t usNum, const uint8_t* pucBitsOfDiscreteInputsState, uint16_t usLen);
	void (*readHoldingRegistersCallback)(uint16_t usStartAddr, uint16_t usNum, const uint8_t* pusHoldingRegistersVal, uint8_t usLen);
	void (*readInputRegistersCallback)(uint16_t usStartAddr, uint16_t usNum, const uint16_t* pusInputRegistersVal, uint16_t usLen);

}MBRTUMaterTypeDef;


static void timerStop(void);
static void timerStart(void);
static void delayms(uint32_t nms);
static uint32_t sendData(const void *buf, uint32_t len);
static uint32_t sendDataLog(const void *buf, uint32_t len);
static void readCoilsCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pucBitsOfCoilsState, uint16_t usLen);
static void readDiscreteInputsCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pucBitsOfDiscreteInputsState, uint16_t usLen);
static void readHoldingRegistersCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pusHoldingRegistersVal, uint8_t usLen);
static void readInputRegistersCallback(uint16_t usStartAddr, uint16_t usNum, const uint16_t *pusInputRegistersVal, uint16_t usLen);


///
/// MODBUS RTU 主机 API
///
///
int MBRTUMasterReadCoils(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout);
int MBRTUMasterReadDiscreteInputs(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout);
int MBRTUMasterReadHoldingRegisters(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout);
int MBRTUMasterReadInputRegisters(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout);
int MBRTUMasterWriteSingleCoil(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint8_t ucState, uint16_t usTimeout);
int MBRTUMasterWriteSingleRegister(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usRegVal, uint16_t usTimeout);
int MBRTUMasterWriteMultipleCoils(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, const uint8_t* pucStateBitsBuf, uint16_t usTimeout);
int MBRTUMasterWriteMultipleRegisters(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, const uint16_t* pusRegVal, uint16_t usTimeout);


///
/// MODBUS RTU 主机接收数据回调函数和超时回调函数
/// 
/// MBRTUMasterRecvByteISRCallback：放置于串口接收中断中
/// MBRTUMasterTimerISRCallback：放置于定时器超时中断中
///
void MBRTUMasterRecvByteISRCallback(MBRTUMaterTypeDef* psModbus, uint8_t ucByte);
void MBRTUMasterTimerISRCallback(MBRTUMaterTypeDef* psModbus);
//发送日志显示报文
void MBRTUMasterSendDataLog(MBRTUMaterTypeDef *pMaster);
int16_t GetModbusCRC16_Cal(uint8_t *data, uint32_t len);
#endif /* MBRTU_MASTER_H_ */

mbrtu_master.c

/*
 * mbrtu_master.c
 */

#include "mbrtu_master.h"
#include "inttypes.h"

char str[50] = {0};
char str1[50] = {0};

static uint16_t usMBCRC16(uint8_t *pucFrame, uint16_t usLen)
{
    static const uint8_t aucCRCHi[] =
        {
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40};

    static const uint8_t aucCRCLo[] =
        {
            0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7,
            0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
            0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9,
            0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
            0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
            0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
            0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D,
            0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
            0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF,
            0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
            0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1,
            0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
            0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB,
            0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
            0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
            0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
            0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97,
            0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
            0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
            0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
            0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83,
            0x41, 0x81, 0x80, 0x40};

    uint8_t ucCRCHi = 0xFF;
    uint8_t ucCRCLo = 0xFF;
    int iIndex;

    while (usLen--)
    {
        iIndex = ucCRCLo ^ *(pucFrame++);
        ucCRCLo = (uint8_t)(ucCRCHi ^ aucCRCHi[iIndex]);
        ucCRCHi = aucCRCLo[iIndex];
    }
    return (uint16_t)(ucCRCHi << 8 | ucCRCLo);
}
int16_t GetModbusCRC16_Cal(uint8_t *data, uint32_t len)//Modbus-CRC校验-----计算法
{
	uint8_t temp;
	uint16_t wcrc = 0XFFFF;//16位crc寄存器预置
	uint32_t i = 0, j = 0;//计数
	for (i = 0; i < len; i++)//循环计算每个数据
	{
		temp = data[i] & 0X00FF;//将八位数据与crc寄存器亦或
		wcrc ^= temp;						//将数据存入crc寄存器
		for (j = 0; j < 8; j++)	//循环计算数据的
		{
			if (wcrc & 0X0001)//判断右移出的是不是1，如果是1则与多项式进行异或。
			{
				wcrc >>= 1;//先将数据右移一位
				wcrc ^= 0XA001;//与上面的多项式进行异或
			}
			else//如果不是1，则直接移出
			{
				wcrc >>= 1;//直接移出
			}
		}
	}

  return ((wcrc << 8)|(wcrc>>8));//高低位置换
}
//读取数据
static uint32_t MBRTUMasterRead(MBRTUMaterTypeDef *pMaster, uint8_t ucSlaveAddr, uint8_t ucCmd, uint16_t usStartAddr, uint16_t usNum)
{
    uint16_t crc;

    pMaster->ucBuf[0] = ucSlaveAddr;
    pMaster->ucBuf[1] = ucCmd;
    pMaster->ucBuf[2] = ((usStartAddr & 0XFF00) >> 8);
    pMaster->ucBuf[3] = (usStartAddr & 0XFF);
    pMaster->ucBuf[4] = ((usNum & 0XFF00) >> 8);
    pMaster->ucBuf[5] = (usNum & 0XFF);

    crc = usMBCRC16((uint8_t *)pMaster->ucBuf, 6);
    pMaster->ucBuf[6] = (uint8_t)(crc & 0xFF);
    pMaster->ucBuf[7] = (uint8_t)(crc >> 8);
	  //pMaster->sendDataLog(pMaster->ucBuf, 8);//发送日志
		//char str[40] = {0};
		//sprintf(str,"%s0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\r\n","发送：",pMaster->ucBuf[0],pMaster->ucBuf[1],pMaster->ucBuf[2],pMaster->ucBuf[3],pMaster->ucBuf[4],pMaster->ucBuf[5],pMaster->ucBuf[6],pMaster->ucBuf[7]);
		//sendLOGStr(str);
    return pMaster->sendData(pMaster->ucBuf, 8);
}
void MBRTUMasterSendDataLog(MBRTUMaterTypeDef *pMaster)
{
	//pMaster->sendDataLog(pMaster->ucBuf, 8);
	
	//if(pMaster->ucBuf[0] != '\0')
	//{//接受485数据
	//	sendLOGStr(pMaster->ucBuf);
	//	pMaster->ucBuf[0] = 0;
//	}
}
/**
 * 主机读取线圈状态
 * @param  ucSlaveAddress 从机地址
 * @param  usAddress      要读取的线圈起始地址
 * @param  usCmd          0x01
 * @param  usNum          要读取的线圈数量
 * @param  usTimeout      超时时间,单位毫秒
 * @return                0:成功  <0:执行失败
 */
int MBRTUMasterReadCoils(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout)
{
    int ret = -1;
    int delay;

    if (psModbus->lock != NULL)
    {
        psModbus->lock();
    }

    psModbus->usStatus = 0;

    MBRTUMasterRead(psModbus, ucSlaveAddress, 0X01, usAddress, usNum);

    while (usTimeout != 0)
    {
        if (psModbus->usStatus & 0X8000)
        {
            if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X01)
            {
                psModbus->readCoilsCallback(usAddress, usNum, &psModbus->ucBuf[3], psModbus->ucBuf[2]);
                ret = 0;
            }
            else
            {
                ret = -2;
            }
            psModbus->usStatus = 0;
            break;
        }
        delay = usTimeout > 5 ? 5 : usTimeout;
        usTimeout -= delay;
        psModbus->delayms(delay);
    }

    if (psModbus->unlock != NULL)
    {
        psModbus->unlock();
    }

    return ret;
}

/**
 * 主机读取离散量输入
 * @param  ucSlaveAddress 从机地址
 * @param  usAddress      要读取的离散量起始地址
 * @param  usCmd          0x02
 * @param  usNum          要读取的离散量数量
 * @param  usTimeout      超时时间,单位毫秒
 * @return                0:成功  <0:执行失败
 */
int MBRTUMasterReadDiscreteInputs(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout)
{
    int ret = -1;
    int delay;

    if (psModbus->lock != NULL)
    {
        psModbus->lock();
    }

    psModbus->usStatus = 0;

    MBRTUMasterRead(psModbus, ucSlaveAddress, 0X02, usAddress, usNum);

    while (usTimeout != 0)
    {
        if (psModbus->usStatus & 0X8000)
        {
            if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X02)
            {
                psModbus->readDiscreteInputsCallback(usAddress, usNum, &psModbus->ucBuf[3], psModbus->ucBuf[2]);
                ret = 0;
            }
            else
            {
                ret = -2;
            }
            psModbus->usStatus = 0;
            break;
        }
        delay = usTimeout > 5 ? 5 : usTimeout;
        usTimeout -= delay;
        psModbus->delayms(delay);
    }

    if (psModbus->unlock != NULL)
    {
        psModbus->unlock();
    }

    return ret;
}

/**
 * 主机读取保持寄存器!!!!!!!!!!!!
 * @param  ucSlaveAddress 从机地址
 * @param  usAddress      要读取的保持寄存器起始地址
 * @param  usCmd          0x03
 * @param  usNum          要读取的保持寄存器数量
 * @param  usTimeout      超时时间,单位毫秒
 * @return                0:成功  <0:执行失败
 */
int MBRTUMasterReadHoldingRegisters(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout)
{
    int ret = -1;
    int delay;

    if (psModbus->lock != NULL)
    {
        psModbus->lock();
    }

    psModbus->usStatus = 0;

    MBRTUMasterRead(psModbus, ucSlaveAddress, 0X03, usAddress, usNum);

    while (usTimeout != 0)
    {
        if (psModbus->usStatus & 0X8000)
        {
            if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X03)
            {
                psModbus->readHoldingRegistersCallback(usAddress, usNum, (const uint8_t *)&psModbus->ucBuf[3], psModbus->ucBuf[2]);
                ret = 0;
            }
            else
            {
                ret = -2;
            }
            psModbus->usStatus = 0;
            break;
        }
        delay = usTimeout > 5 ? 5 : usTimeout;
        usTimeout -= delay;
        psModbus->delayms(delay);
    }

    if (psModbus->unlock != NULL)
    {
        psModbus->unlock();
    }
		
		char str1[40] = {0};
		sprintf(str1,"%02X%s%d\r\n",psModbus->ucBuf[0],"号伺服电机查询状态：",ret);
		sendLOGStr(str1);
    return ret;
}

/**
 * 主机读取输入寄存器
 * @param  ucSlaveAddress 从机地址
 * @param  usAddress      要读取的输入寄存器起始地址
 * @param  usCmd          0x04
 * @param  usNum          要读取的输入寄存器数量
 * @param  usTimeout      超时时间,单位毫秒
 * @return                0:成功  <0:执行失败
 */
int MBRTUMasterReadInputRegisters(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout)
{
    int ret = -1;
    int delay;

    if (psModbus->lock != NULL)
    {
        psModbus->lock();
    }

    psModbus->usStatus = 0;

    MBRTUMasterRead(psModbus, ucSlaveAddress, 0X04, usAddress, usNum);

    while (usTimeout != 0)
    {
        if (psModbus->usStatus & 0X8000)
        {
            if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X04)
            {
                psModbus->readInputRegistersCallback(usAddress, usNum, (const uint16_t *)&psModbus->ucBuf[3], psModbus->ucBuf[2] >> 1);
                ret = 0;
            }
            else
            {
                ret = -2;
            }
            psModbus->usStatus = 0;
            break;
        }
        delay = usTimeout > 5 ? 5 : usTimeout;
        usTimeout -= delay;
        psModbus->delayms(delay);
    }

    if (psModbus->unlock != NULL)
    {
        psModbus->unlock();
    }

    return ret;
}

/**
 * 主机写单个线圈
 * @param  ucSlaveAddress 从机地址
 * @param  usAddress      线圈地址
 * @param  usCmd          0x05
 * @param  ucState        要设置的线圈状态，1或者0
 * @param  usTimeout      超时时间,单位毫秒
 * @return                0:成功  <0:执行失败
 */

int MBRTUMasterWriteSingleCoil(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint8_t ucState, uint16_t usTimeout)
{
    int ret = -1;
    int delay;
    uint16_t crc;

    if (psModbus->lock != NULL)
    {
        psModbus->lock();
    }

    psModbus->ucBuf[0] = ucSlaveAddress;
    psModbus->ucBuf[1] = 0X05;
    psModbus->ucBuf[2] = usAddress & 0XFF;
    psModbus->ucBuf[3] = usAddress >> 8;
    psModbus->ucBuf[4] = ucState ? 0XFF : 0X00;
    psModbus->ucBuf[5] = 0X00;
    crc = usMBCRC16((uint8_t *)psModbus->ucBuf, 6);
    psModbus->ucBuf[6] = (uint8_t)(crc & 0xFF);
    psModbus->ucBuf[7] = (uint8_t)(crc >> 8);

    psModbus->usStatus = 0;
    psModbus->sendData(psModbus->ucBuf, 8);

    while (usTimeout != 0)
    {
        if (psModbus->usStatus & 0X8000)
        {
            if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X05)
            {
                ret = 0;
            }
            else
            {
                ret = -2;
            }
            psModbus->usStatus = 0;
            break;
        }
        delay = usTimeout > 5 ? 5 : usTimeout;
        usTimeout -= delay;
        psModbus->delayms(delay);
    }

    if (psModbus->unlock != NULL)
    {
        psModbus->unlock();
    }

    return ret;
}

/**
 * 主机写单个寄存器!!!!!!!!!!!
 * @param  ucSlaveAddress 从机地址
 * @param  usAddress      寄存器地址(通信地址)
 * @param  usCmd          0x06
 * @param  usRegVal       寄存器值
 * @param  usTimeout      超时时间,单位毫秒
 * @return                0:成功  <0:执行失败
 */
//	MBRTUMasterWriteSingleRegister(&MBRTUHandle, 1, RUN_MODE_ADDR, 0x0003, 100);
int MBRTUMasterWriteSingleRegister(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usRegVal, uint16_t usTimeout)
{
    int ret = -1;
    int delay;
    uint16_t crc;

    if (psModbus->lock != NULL)
    {
        psModbus->lock();
    }
    psModbus->ucBuf[0] = ucSlaveAddress;
    psModbus->ucBuf[1] = 0X06;
    psModbus->ucBuf[2] = usAddress >> 8;
    psModbus->ucBuf[3] = usAddress & 0XFF;
    psModbus->ucBuf[4] = usRegVal >> 8;
    psModbus->ucBuf[5] = usRegVal & 0XFF;
    crc = GetModbusCRC16_Cal((uint8_t *)psModbus->ucBuf, 6);
    psModbus->ucBuf[6] = (uint8_t)(crc >> 8);
    psModbus->ucBuf[7] = (uint8_t)(crc & 0xFF);
	
    psModbus->usStatus = 0;
    psModbus->sendData(psModbus->ucBuf, 8);

    while (usTimeout != 0)
    {
        if (psModbus->usStatus & 0X8000)
        {
            if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X06)
            {
                ret = 0;
            }
            else
            {
                ret = -2;
            }
            psModbus->usStatus = 0;
            break;
						
        }
        delay = usTimeout > 1 ? 1 : usTimeout;
        usTimeout -= delay;
        psModbus->delayms(delay);
    }
    if (psModbus->unlock != NULL)
    {
        psModbus->unlock();
    }
		//sprintf(str,"%s0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\r\n","响应指令",psModbus->ucBuf[0],psModbus->ucBuf[1],psModbus->ucBuf[2],psModbus->ucBuf[3],psModbus->ucBuf[4],psModbus->ucBuf[5],psModbus->ucBuf[6],psModbus->ucBuf[7]);
		sprintf(str1,"%02X%s%s\r\n",psModbus->ucBuf[0],"号伺服电机返回：",(ret==0?"成功":"失败"));
		sendLOGStr(str1);
    return ret;
}

/**
 * 主机写多个线圈状态
 * @param  ucSlaveAddress  从机地址
 * @param  usAddress       线圈起始地址
 * @param  usNum           要写的线圈数量
 * @param  pucStateBitsBuf 存放线圈状态，1比特代表一个线圈状态
 * @param  usTimeout      超时时间,单位毫秒
 * @return                0:成功  <0:执行失败
 */
int MBRTUMasterWriteMultipleCoils(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, const uint8_t *pucStateBitsBuf, uint16_t usTimeout)
{
    int ret = -1;
    int delay;
    uint16_t crc;
    uint16_t usIndex = 0, usBytes = 0;

    if (psModbus->lock != NULL)
    {
        psModbus->lock();
    }

    psModbus->ucBuf[usIndex++] = ucSlaveAddress;
    psModbus->ucBuf[usIndex++] = 0X0F;
    psModbus->ucBuf[usIndex++] = usAddress & 0XFF;
    psModbus->ucBuf[usIndex++] = usAddress >> 8;
    psModbus->ucBuf[usIndex++] = usNum >> 8;
    psModbus->ucBuf[usIndex++] = usNum & 0XFF;

    usBytes = (usNum - 1) / 8 + 1;
    psModbus->ucBuf[usIndex++] = usBytes;

    while (usBytes--)
    {
        psModbus->ucBuf[usIndex++] = *pucStateBitsBuf++;
    }

    crc = usMBCRC16((uint8_t *)psModbus->ucBuf, usIndex);
    psModbus->ucBuf[usIndex++] = (uint8_t)(crc & 0xFF);
    psModbus->ucBuf[usIndex++] = (uint8_t)(crc >> 8);

    psModbus->usStatus = 0;
    psModbus->sendData(psModbus->ucBuf, usIndex);

    while (usTimeout != 0)
    {
        if (psModbus->usStatus & 0X8000)
        {
            if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X0F)
            {
                ret = 0;
            }
            else
            {
                ret = -2;
            }
            psModbus->usStatus = 0;
            break;
        }
        delay = usTimeout > 5 ? 5 : usTimeout;
        usTimeout -= delay;
        psModbus->delayms(delay);
    }

    if (psModbus->unlock != NULL)
    {
        psModbus->unlock();
    }

    return ret;
}

/**
 * 主机写多个寄存器!!!!!!!!!!!
 * @param  ucSlaveAddress 从机地址
 * @param  usAddress      要写的寄存器起始地址
 * @param  usCmd          0x10
 * @param  usNum          要写的寄存器数量
 * @param  pusRegVal      存放要写的寄存器值
 * @param  usTimeout      超时时间,单位毫秒
 * @return                0:成功  <0:执行失败
 */
int MBRTUMasterWriteMultipleRegisters(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, const uint16_t *pusRegVal, uint16_t usTimeout)
{
    int ret = -1;
    int delay;
    uint16_t crc;
    uint16_t usIndex = 0;

    if (psModbus->lock != NULL)
    {
        psModbus->lock();
    }

    psModbus->ucBuf[usIndex++] = ucSlaveAddress;
    psModbus->ucBuf[usIndex++] = 0X10;
    psModbus->ucBuf[usIndex++] = usAddress & 0XFF;
    psModbus->ucBuf[usIndex++] = usAddress >> 8;
    psModbus->ucBuf[usIndex++] = usNum >> 8;
    psModbus->ucBuf[usIndex++] = usNum & 0XFF;
    psModbus->ucBuf[usIndex++] = usNum << 1;

    while (usNum--)
    {
        psModbus->ucBuf[usIndex++] = *pusRegVal >> 8;
        psModbus->ucBuf[usIndex++] = *pusRegVal & 0XFF;
        pusRegVal++;
    }

    crc = usMBCRC16((uint8_t *)psModbus->ucBuf, usIndex);
    psModbus->ucBuf[usIndex++] = (uint8_t)(crc & 0xFF);
    psModbus->ucBuf[usIndex++] = (uint8_t)(crc >> 8);

    psModbus->usStatus = 0;
    psModbus->sendData(psModbus->ucBuf, usIndex);

    while (usTimeout != 0)
    {
        if (psModbus->usStatus & 0X8000)
        {
            if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X10)
            {
                ret = 0;
            }
            else
            {
                ret = -2;
            }
            psModbus->usStatus = 0;
            break;
        }
        delay = usTimeout > 5 ? 5 : usTimeout;
        usTimeout -= delay;
        psModbus->delayms(delay);
    }

    if (psModbus->unlock != NULL)
    {
        psModbus->unlock();
    }

    return ret;
}

void MBRTUMasterRecvByteISRCallback(MBRTUMaterTypeDef *psModbus, uint8_t ucByte)
{
		
		psModbus->timerStop();
    if (psModbus->usStatus < (sizeof(psModbus->ucBuf)-1))
    {
        psModbus->ucBuf[psModbus->usStatus++] = ucByte;
        psModbus->timerStart();
    }
    else
    {
        psModbus->usStatus |= 0X8000;
    }
}

void MBRTUMasterTimerISRCallback(MBRTUMaterTypeDef *psModbus)
{
    psModbus->timerStop();
    psModbus->usStatus |= 0X8000;
}

#ifdef USE_RTOS

static void mutex_lock(void)
{
}

static void mutex_unlock(void)
{
}

#endif

static void timerStop(void)
{
   // HAL_TIM_Base_Stop_IT(&htim2);
}

static void timerStart(void)
{
  //  __HAL_TIM_SET_COUNTER(&htim2, 0);
  //  HAL_TIM_Base_Start_IT(&htim2);
}

static void delayms(uint32_t nms)
{
    HAL_Delay(nms);
}

static uint32_t sendData(const void *buf, uint32_t len)
{
    if (HAL_UART_Transmit(&huart2, (uint8_t *)buf, len, 100) != HAL_OK)
    {
        len = 0;
    }
    return len;
}
static uint32_t sendDataLog(const void *buf, uint32_t len)
{
    if (HAL_UART_Transmit(&huart1, (uint8_t *)buf, len, 100) != HAL_OK)
    {
        len = 0;
    }
    return len;
}

static void readCoilsCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pucBitsOfCoilsState, uint16_t usLen)
{
    uint8_t ucLoops = (usNum - 1) / 8 + 1;
    uint8_t ucState, ucBits;

    printf(" Read %d coils starting at start address %d: ", usNum, usStartAddr);

    while (ucLoops != 0)
    {
        ucState = *pucBitsOfCoilsState++;
        ucBits = 0;
        while (usNum != 0 && ucBits < 8)
        {
            printf("%d ", ucState & 0X01 ? 1 : 0);
            ucState >>= 1;
            usNum--;
            ucBits++;
        }
        ucLoops--;
    }

    printf("\r\n");
}

static void readDiscreteInputsCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pucBitsOfDiscreteInputsState, uint16_t usLen)
{
    uint8_t ucLoops = (usNum - 1) / 8 + 1;
    uint8_t ucState, ucBits;

    printf(" Read %d discrete inputs starting at start address %d: ", usNum, usStartAddr);

    while (ucLoops != 0)
    {
        ucState = *pucBitsOfDiscreteInputsState++;
        ucBits = 0;
        while (usNum != 0 && ucBits < 8)
        {
            printf("%d ", ucState & 0X01 ? 1 : 0);
            ucState >>= 1;
            usNum--;
            ucBits++;
        }
        ucLoops--;
    }

    printf("\r\n");
}

static void readHoldingRegistersCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pusHoldingRegistersVal, uint8_t usLen)
{
    uint8_t val[4] = {0};
   // printf(" Read %d hold registers starting at start address %d: ", usNum, usStartAddr);
    while (usLen--)
    {
        val[usLen] = *pusHoldingRegistersVal++;
        printf("%02X ", val[usLen]);
    }
    printf("\r\n"); 
}

static void readInputRegistersCallback(uint16_t usStartAddr, uint16_t usNum, const uint16_t *pusInputRegistersVal, uint16_t usLen)
{
    uint16_t val;
    printf(" Read %d input registers starting at start address %d: ", usNum, usStartAddr);
    while (usLen--)
    {
        val = *pusInputRegistersVal++;
        val = ((val & 0X00FF) << 8) | ((val & 0XFF00) >> 8); // 转换大小端
        printf("%04X ", val);
    }
    printf("\r\n");
}

MBRTUMaterTypeDef MBRTUHandle =
        {
                .delayms = delayms,
                .timerStart = timerStart,
                .timerStop = timerStop,
                .sendData = sendData,
								.sendDataLog = sendDataLog,
                .readCoilsCallback = readCoilsCallback,
                .readDiscreteInputsCallback = readDiscreteInputsCallback,
                .readHoldingRegistersCallback = readHoldingRegistersCallback,
                .readInputRegistersCallback = readInputRegistersCallback,

#ifdef USE_RTOS // 使用了RTOS那么需要实现互斥
                .lock = mutex_lock,
                .unlock = mutex_unlock,
#endif
        };

接受数据的时候只需要在串口回调中调用如下代码即可


uint8_t RS485P[1];

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
		while(HAL_UART_Receive_IT(&huart2, (uint8_t *)&RS485P, 1)!=HAL_OK);
		MBRTUMasterRecvByteISRCallback(&MBRTUHandle,RS485P[0]);
}