STM32：串口配置[RS485 MODBUS UART]

文章目录

前言

一、相关介绍

1.1 Modbus协议简介

1.2 485通信介绍

1.3 CRC校验

二、代码流程

三、程序实现

1.配置串口（stm32底层）

2.Modbus

附：STM32串口1-5初始化

1.引脚分配

2.串口初始化程序

USART1

USART2

USART3

UART4

UART5

总结

---

前言

工作接触到RS485通信和Modbus协议，借此记录一下，在产品开发当中，Modbus协议在工控领域也比较常用。
另外附stm32串口12345初始化程序。

---

一、相关介绍

1.1 Modbus协议简介

modbus协议就是定义了一套信息交互的协议，让收发双方更好地通信（相互知道对方传过来的数据是什么）。

数据帧元素有：从机地址(8 bit)：选择从机；功能码(8 bit)：功能定义（对应功能是什么）；寄存器地址(16 bit)：数据存放地址；寄存器数量(16 bit)；数据字节数(8 bit)；数据位(可变)；CRC校验(16 bit)。

有了这些定义之后，主从机双方就知道对方发过来的消息是什么了，协议中的寄存器可以简单理解为数组吧，也可以理解为单片机里对应的寄存器，每个寄存器对应一个地址（简单来说，寄存器包含元素：16bit地址+16bit数据）。

modbus定义了四种存储类型：输入线圈、输出线圈、输入寄存器、保持寄存器，其中线圈都是布尔量，也就是0 or 1，用于状态反馈和开关状态，寄存器则是存放16位数据，可以写一些参数。

有三种协议模式，ASCII、RTU、TCP，一般使用RTU模式比较多，报文的发送数据比ASCII模式少。

比较常用的功能码是（十六进制）：01 读线圈，02 读输入离散量， 03 读多个寄存器，04 读输入寄存器， 05 写单个线圈，06 写单个寄存器，0F 写多个线圈，10 写多个寄存器。

再详细的介绍找下其他博文就行。

1.2 485通信介绍

485通信，由于TTL信号的RX、TX信号转485两路差分信号，因此它是一个半双工通信，针对modbus通信，最好就是一问(发)一答(收)再一问一答的通信方式，避免信号阻塞。

485通信，单片机底层就是配置串口，发送数据对应串口协议，一位起始位+5-8位数据位+奇偶校验位(一般无)+停止位(一般1位)，也就是发送一个8bit数据需要发10bit（10个高低电平信号），串口波特率对应就是1s内发多少个bit，9600bps就是一秒内发9600个位。

硬件外围用一个sp3485芯片，将ttl电平信号转485信号就好了。A+、B-通信线缆上通常终端匹配120Ω的电阻，线缆的末尾处各一个。

1.3 CRC校验

modbus协议采用的是CRC-16校验方式。

CRC-16多项式表达式为：G(x) = x^16 + x^15 + x^2 + 1，对应值16位值为：0x8005

CRC校验步骤如下：

CRC-16-MODBUS涉及一个输入数据和输出数据反转概念。
输入数据反转：即在计算开始前，将需要校验的数据反转，如数据位1011，反转后为1101。
输出数据反转：即在计算结束后，与结果异或值异或之前，计算值反转，如计算结果为1011，反转后为1101。
这样每次计算都会作两次反转，因此代码将非常耗时，所以将0x8005按位颠倒成0xA001进行异或，最后将结果高低位互换输出，这种颠倒操作有助于简化计算过程和提高算法效率。
”按位颠倒“是指将0x8005，二进制表示为 0b1000 0000 | 0000 0101，按’|'为中心对称进行颠倒后的结果为0b1010 0000 | 0000 0001，即0xA001。

二、代码流程

串口相关

1 串口发送函数

2 串口接收中断函数

3 接收数据处理函数

关于单次发送、接收、校验连续性问题（就是确保每次都是一发一收的方式）

设定一个接收标志位，如图，圆圈为标志位的状态，在每处函数执行完触发状态变换，每个函数（发送、接收、处理）执行前需判断标志位状态才执行。

三、程序实现

注：下面代码仅作部分展示说明，代码详细见gitee(后续上传)

1.配置串口（stm32底层）

1. 使能对应时钟：如串口2，使能引脚时钟：RCC_APB2Periph_GPIOA；串口2使能：RCC_APB1Periph_USART2
2. 配置引脚模式：TX引脚：GPIO_Mode_AF_PP（复用推挽）；RX引脚：GPIO_Mode_IN_FLOATING（浮空输入）、485还有一个收发方向的引脚定义
3. 串口配置：波特率、8位数据位、1位停止位、无校验、收发模式、软件流控制
4. 中断配置：USART2_IRQn 中断通道，主、次优先级，接收中断

串口、引脚初始化：

/**
  * @brief  串口2初始化 485通信
  * @param  baud 波特率
  * @retval None
  */
void uart2_init(u32 baud)
{
	GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;		    //推挽复用模式  TX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOA, &GPIO_InitStructure );
	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	//浮空输入模式  RX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOA, &GPIO_InitStructure );
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	    //485_DR
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOA, &GPIO_InitStructure );
	GPIO_ResetBits(GPIOA, GPIO_Pin_0);                      //默认接收方向
	
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init( &NVIC_InitStructure );
	
	USART_DeInit(USART2);                                   //复位串口2
	USART_InitStructure.USART_BaudRate = baud;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init( USART2, &USART_InitStructure );
	
	USART_ClearITPendingBit(USART2,USART_IT_RXNE);
	USART_ITConfig(USART2,USART_IT_RXNE, ENABLE);           //使能串口2接收中断
	USART_Cmd( USART2, ENABLE );					        //使能串口2
}

中断服务函数：

串口中断服务函数执行流程图：

/**
  * @brief  串口1中断服务程序
  * @param  None
  * @retval None
  */

void USART1_IRQHandler(void)
{
	u8 res = 0;
	if(USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET)
	{
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
		res = USART_ReceiveData(USART1); //读接收到的字节，同时相关标志自动清除
		if(RS485_RX_CNT < RS485_BUFF_SIZE)
		{
			//接受数据
			RS485_RX_BUFF[RS485_RX_CNT]=res; //数组缓存定义在modbus.c
			RS485_RX_CNT++;
			
			//tim7空闲标志喂狗
			TIM_ClearITPendingBit(TIM7,TIM_IT_Update);//清除定时器溢出中断
			TIM_SetCounter(TIM7,0);//当接收到一个新的字节，将定时器7复位为0，重新计时（相当于喂狗）
			TIM_Cmd(TIM7,ENABLE);//开始计时
		}
		rs485_bus_state = BUS_BUSY;  //串口忙
		rs485_recv_flag = RECV_ING;  //接收中
	}
}

串口发送函数：

/**
  * @brief 发送n个字节数据 主机将数据进行发送
  * @param buff: 发送区首地址
		   len： 字节长度
  * @retval
  */
void uart1_sendbytes(u8 *buff, u8 len)
{
	/* 总线空闲 */
	if(rs485_bus_state == BUS_IDLE)
	{
		//RS485传输方向为发送
		MDMSerialSWRecv_Send(RS485_TX);
		rs485_bus_state = BUS_BUSY;      //串口忙
		while(len--)
		{
			while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);//等待发送区为空
			USART_SendData(USART1,*(buff++));
		}
		while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);     //等待发送完成
		rs485_sc_flag = SEND_OVER;       //发送结束
		MDMSerialSWRecv_Send(RS485_RX);  //RS485传输方向为接收
		rs485_recv_flag = WAIT_RECV;     //等待接收
		rs485_bus_state = BUS_IDLE;      //串口空闲
		
		//tim7空闲标志喂狗
		TIM_ClearITPendingBit(TIM7, TIM_IT_Update);//清除定时器溢出中断
		TIM_SetCounter(TIM7,0);//当接收到一个新的字节，将定时器7复位为0，重新计时（相当于喂狗）
		TIM_Cmd(TIM7,ENABLE);//开始计时
	}
}

2.Modbus

本文写的是主机思路

CRC校验：代码可参考此博主的Modbus-crc16校验原理和方法（含测试代码以及演算过程）

定时器初始化：用于判断接收帧是否结束（4ms内若没有进入串口中断进行计数复位，将进入定时器中断将定时器关闭且转为发送模式）

//
//定时器7初始化      BEGIN
//
/**
  * @brief  定时器7初始化---功能：判断从机返回的数据是否接受完成  
  * @param  None
  * @retval None
  */
void Timer7_Init(void)
{
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	NVIC_InitTypeDef NVIC_InitStructure;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE); //TIM7时钟使能 

	//TIM7初始化设置
	TIM_TimeBaseStructure.TIM_Period = RS485_FRAME_MS_INT*10; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值
	TIM_TimeBaseStructure.TIM_Prescaler =7199; //设置用来作为TIMx时钟频率除数的预分频值 设置计数频率为10kHz
	TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置时钟分割:TDTS = Tck_tim
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
	TIM_TimeBaseInit(TIM7, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
	TIM_Cmd(TIM7,DISABLE);
	TIM_ITConfig( TIM7, TIM_IT_Update, ENABLE);//TIM7 允许更新中断
	

	//TIM7中断分组配置
	NVIC_InitStructure.NVIC_IRQChannel = TIM7_IRQn;  //TIM7中断
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;  //先占优先级2级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;  //从优先级3级
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
	NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
}

/**
  * @brief  定时器7中断服务程序
	用定时器7判断接收空闲时间,当空闲时间大于指定时间，认为一帧结束
  * @param  None
  * @retval None
  */
void TIM7_IRQHandler(void)
{                     
	if(TIM_GetITStatus(TIM7,TIM_IT_Update) != RESET)
	{
		TIM_Cmd(TIM7,DISABLE);                    //停止定时器

		MDMSerialSWRecv_Send(RS485_TX);           //停止接收，切换为发送状态
		rs485_bus_state = BUS_IDLE;               //总线空闲，主机处在发送状态
		rs485_recv_flag = RECV_OVER;              //接收完成标志位
		
		TIM_ClearITPendingBit(TIM7,TIM_IT_Update);//清除中断标志
	}
}

功能码发送函数：

头文件声明：

#define HI(n)  ((n)>>8)    
#define LOW(n) ((n)&0xff)  

/**
  * @brief  MODBUS功能码
  * @param  None
  * @retval None
  */
enum modbus_funcode
{
	READ_COIL     = 1,  //读线圈状态
	READ_DI       = 2,  //读离散输入状态
	READ_HLD_REG  = 3,  //读保持寄存器
	READ_AI       = 4,  //读输入寄存器
	SET_COIL      = 5,  //写单个线圈
	SET_HLD_REG   = 6,  //写单个保持寄存器
	WRITE_COIL    = 15, //写多个线圈
	WRITE_HLD_REG = 16  //写多个保持寄存器
};

各个功能码对应数据存入数组：

/**
  * @brief  Modbus功能码01处理程序，
			读线圈
  * @param  
		board_adr ： 目标从机地址
		reg_addr  ： 寄存器地址
		reg_num   ： 寄存器数目
  * @retval 返回数组长度
  */
static u8 Master_01_Slove(u8 board_adr, u16 reg_addr, u16 reg_num)
{
	u16 calCRC;
	u8  n = 0;
    RS485_TX_BUFF[n++] = board_adr;
    RS485_TX_BUFF[n++] = READ_COIL;       //modbus 01
    RS485_TX_BUFF[n++] = HI(reg_addr);  
    RS485_TX_BUFF[n++] = LOW(reg_addr); 
    RS485_TX_BUFF[n++] = HI(reg_num);
    RS485_TX_BUFF[n++] = LOW(reg_num);
    calCRC = CRC_Compute(RS485_TX_BUFF, 6);
    RS485_TX_BUFF[n++] = (calCRC >> 8) & 0xFF;
    RS485_TX_BUFF[n++] = (calCRC) & 0xFF;
	return n;
}

/**
  * @brief  Modbus功能码02处理程序，
			读离散输入状态
  * @param  
		board_adr ： 目标从机地址
		reg_addr  ： 寄存器地址
		reg_num   ： 寄存器数目
  * @retval None
  */
static u8 Master_02_Slove(u8 board_adr, u16 reg_addr, u16 reg_num)
{
	u16 calCRC;
	u8  n = 0;
    RS485_TX_BUFF[n++] = board_adr;
    RS485_TX_BUFF[n++] = READ_DI;       //modbus 02
    RS485_TX_BUFF[n++] = HI(reg_addr);  
    RS485_TX_BUFF[n++] = LOW(reg_addr); 
    RS485_TX_BUFF[n++] = HI(reg_num);
    RS485_TX_BUFF[n++] = LOW(reg_num);
    calCRC = CRC_Compute(RS485_TX_BUFF, 6);
    RS485_TX_BUFF[n++] = (calCRC >> 8) & 0xFF;
    RS485_TX_BUFF[n++] = (calCRC) & 0xFF;
	return n;
}

/**
  * @brief  Modbus功能码03处理程序，
			读保持寄存器，发送完东西开始接收
  * @param  
		board_adr ： 目标从机地址
		reg_addr  ： 寄存器地址
		reg_num   ： 寄存器数目
  * @retval None
  */
static u8 Master_03_Slove(u8 board_adr, u16 reg_addr, u16 reg_num)
{
	u16 calCRC;
	u8  n = 0;
    RS485_TX_BUFF[n++] = board_adr;
    RS485_TX_BUFF[n++] = READ_HLD_REG;       //modbus 指令码03
    RS485_TX_BUFF[n++] = HI(reg_addr);  
    RS485_TX_BUFF[n++] = LOW(reg_addr); 
    RS485_TX_BUFF[n++] = HI(reg_num);
    RS485_TX_BUFF[n++] = LOW(reg_num);
    calCRC = CRC_Compute(RS485_TX_BUFF, 6);
    RS485_TX_BUFF[n++] = (calCRC >> 8) & 0xFF;
    RS485_TX_BUFF[n++] = (calCRC) & 0xFF;
	return n;
}

/**
  * @brief  Modbus功能码04处理程序
			读输入寄存器，发送完东西开始接收
  * @param  
		board_adr ： 目标从机地址
		reg_addr  ： 寄存器地址
		reg_num   ： 寄存器数目
  * @retval None
  */
static u8 Master_04_Slove(u8 board_adr, u16 reg_addr, u16 reg_num)
{ 
	u16 calCRC;
	u8  n = 0;
    RS485_TX_BUFF[n++] = board_adr;
    RS485_TX_BUFF[n++] = READ_AI;    //modbus 指令码04
    RS485_TX_BUFF[n++] = HI(reg_addr);  
    RS485_TX_BUFF[n++] = LOW(reg_addr); 
    RS485_TX_BUFF[n++] = HI(reg_num);
    RS485_TX_BUFF[n++] = LOW(reg_num);
    calCRC=CRC_Compute(RS485_TX_BUFF,6);
    RS485_TX_BUFF[n++] = (calCRC>>8)&0xFF;
    RS485_TX_BUFF[n++] = (calCRC)&0xFF;
	return n;
}

/**
  * @brief  Modbus功能码05处理程序
			写单个线圈
  * @param  
		board_adr ： 目标从机地址
		reg_addr  ： 寄存器地址
		coil_s    ： 数据 0xff00 / 0x0000 = 线圈状态ON / 线圈状态OFF
  * @retval None
  */
static u8 Master_05_Slove(u8 board_adr, u16 reg_addr, u16 coil_s)
{ 
	u16 calCRC;
	u8  n = 0;
    RS485_TX_BUFF[n++] = board_adr;
    RS485_TX_BUFF[n++] = SET_COIL;
    RS485_TX_BUFF[n++] = HI(reg_addr);  
    RS485_TX_BUFF[n++] = LOW(reg_addr); 
    RS485_TX_BUFF[n++] = HI(coil_s);
    RS485_TX_BUFF[n++] = LOW(coil_s);
    calCRC=CRC_Compute(RS485_TX_BUFF,6);
    RS485_TX_BUFF[n++] = (calCRC>>8)&0xFF;
    RS485_TX_BUFF[n++] = (calCRC)&0xFF;
	return n;
}

/**
  * @brief  Modbus功能码06处理程序
			写单个保持寄存器
  * @param  
		board_adr ： 目标从机地址
		reg_addr  ： 寄存器地址
		data      ： 数据
  * @retval None
  */
static u8 Master_06_Slove(u8 board_adr,u16 reg_addr, u16 data)
{
	u16 calCRC;
	u8 n = 0;
	RS485_TX_BUFF[n++] = board_adr;
	RS485_TX_BUFF[n++] = SET_HLD_REG;   //modbus 指令码06
	RS485_TX_BUFF[n++] = HI(reg_addr);
	RS485_TX_BUFF[n++] = LOW(reg_addr);
	RS485_TX_BUFF[n++] = HI(data);
	RS485_TX_BUFF[n++] = LOW(data);
	calCRC = CRC_Compute(RS485_TX_BUFF,6);
	RS485_TX_BUFF[n++] = (calCRC>>8)&0xFF;
	RS485_TX_BUFF[n++] = (calCRC)&0xFF;
	return n;
}

/**
  * @brief  Modbus功能码16处理程序
			写多个寄存器
  * @param  board_adr ：目标从机地址
			reg_addr  ：寄存器地址
			reg_num   ：寄存器数目
			byte_num  ：字节数
			*data     ：数据指针
  * @retval 返回需要发送的数据长度
  */
static u8 Master_16_Slove(u8 board_adr,u16 reg_addr, u16 reg_num, u8 byte_num, u8 *data)
{
	u16 calCRC;
	u8 i;
	u8 j = 0;
	RS485_TX_BUFF[j++] = board_adr;
	RS485_TX_BUFF[j++] = WRITE_HLD_REG;   //modbus功能码:16
	RS485_TX_BUFF[j++] = HI(reg_addr);
	RS485_TX_BUFF[j++] = LOW(reg_addr);
	RS485_TX_BUFF[j++] = HI(reg_num);
	RS485_TX_BUFF[j++] = LOW(reg_num);
	RS485_TX_BUFF[j++] = byte_num;
	
	for(i = 0; i < byte_num; i++)
	{
		RS485_TX_BUFF[j++] = *data++;
	}
	
	calCRC = CRC_Compute(RS485_TX_BUFF, j);
	RS485_TX_BUFF[j++] = (calCRC>>8)&0xFF;
	RS485_TX_BUFF[j++] = (calCRC)&0xFF;
	return j;
}

将以上功能码整合成一个发送函数：

/**
  * @brief  主机发送数据函数
  * @param  md_stu 发送结构体
			board_adr ：从机地址
			funcode   ：功能码
			reg_addr  ：寄存器地址
			reg_num   ：寄存器数量 or 寄存器值
			byte_num  ：字节数
			*data     ：发送数据指针
  * @retval SEND_SUCCESS：发送成功
			SEND_FALSE：发送失败
  */
u8 mm_send_data(  SenddataSTU *md_stu,
				  u8 board_adr,
				  u8 funcode,
				  u16 reg_addr,
				  u16 reg_num,
				  u8 byte_num,
				  u8 *data)
{
	u8 buff_n;
	if(rs485_recv_flag == WAIT_SEND && comm_error_flag == 0) //等待发送 且 通信错误标志位没有置位
	{
		//将发送信息赋值到结构体中
		md_stu->slave_id = board_adr; //目标地址
		md_stu->fun_code = funcode;   //功能码
		md_stu->reg_addr = reg_addr;  //寄存器地址
		md_stu->reg_num = reg_num;    //寄存器数量
		md_recvdata_stu.crcflag = CRC_WAIT; //crc等待校验
		rs485_sc_flag = WAIT_SEND; //等待发送
		switch(funcode) //根据不同的功能码进行处理
		{    
			case READ_COIL: //1 读线圈状态
			{																
				buff_n = Master_01_Slove(board_adr, reg_addr, reg_num);
				break;
			}
			case READ_DI: //2 读离散输入状态
			{
				buff_n = Master_02_Slove(board_adr, reg_addr, reg_num);
				break;
			}	
			case READ_HLD_REG: //3 读保持寄存器
			{
				buff_n = Master_03_Slove(board_adr, reg_addr,reg_num);
				break;
			}	
			case READ_AI: //4 读输入寄存器
			{																
				buff_n = Master_04_Slove(board_adr, reg_addr, reg_num);
				break;
			}
			case SET_COIL:  //5 写单个线圈
			{
				buff_n = Master_05_Slove(board_adr, reg_addr,reg_num);
				break;
			}
			case SET_HLD_REG:  //6 写单个保持寄存器
			{
				buff_n = Master_06_Slove(board_adr,reg_addr, reg_num);
				break;
			}
			case WRITE_HLD_REG:  //16  写多个保持寄存器
			{
				buff_n = Master_16_Slove(board_adr, reg_addr, reg_num, byte_num, data);
				break;
			}	
		}
		md_send_bytes(RS485_TX_BUFF, buff_n); // 
		md_stu->data_update = UPDATE;         // 更新标志位
		single_send_ver_flag = 1;             // 单次发送校验标志位置1
		rs485_sc_flag = SEND_OVER;            // 发送结束
		return SEND_SUCCESS;
	}
	return SEND_FALSE;
}

接收处理函数：

/**
  * @brief  RS485服务程序，用于处理接收到的数据(请在主函数中循环调用)
  * @param  None
  * @retval None
  */
void RS485_RX_Service(void)
{
	u16 calCRC;
	u16 recCRC;
	if(rs485_recv_flag == RECV_OVER) //timer7监听数据帧结束
	{
		if(rs485_comerr != COM_NORMAL && rs485_error_count < COM_MAX_ERRORS) //通信出错 且 在小于错误次数范围内
		{
			rs485_error_count++;
			if(rs485_error_count == COM_MAX_ERRORS)
			{
				md_handle_error(); //错误处理
			}
			else
			{
				rs485_lastcomerr = rs485_comerr; //查看上一次的通信错误类型
				rs485_comerr = COM_NORMAL; //错误复位
			}
		}
		
		if( RS485_RX_BUFF[0] == DEV_ADDR )
		//验证地址
		{
			//验证功能码且正确
			if(IS_FUNCODE(RS485_RX_BUFF[1]))
			{
				if(RS485_RX_CNT > 2)
				{
					//CRC校验比对
					calCRC = CRC_Compute(RS485_RX_BUFF, (RS485_RX_CNT - 2));//计算所接收数据的CRC
					recCRC = RS485_RX_BUFF[RS485_RX_CNT-1] | (RS485_RX_BUFF[RS485_RX_CNT-2]<<8);  //接收到的CRC(低字节在前，高字节在后)
				}
				if(calCRC == recCRC)//CRC校验正确
				{
					md_recvdata_stu.crcflag = CRC_PASS; //此标志位用于判断发送成功后，从机成功响应且校正通过
					Recv_data_process(RS485_RX_BUFF, RS485_RX_CNT, &md_recvdata_stu);//赋值结构体，方便下面处理
					modbus_data_process(&md_senddata_stu, &md_recvdata_stu);//对函数数据处理
				}
				else //CRC校验错误
				{
					md_recvdata_stu.crcflag = CRC_FALSE;  //此标志位用于判断发送成功后有响应且校正通过
					rs485_comerr = CRC_ERROR; //CRC校验错误
				}                                                                                       
			}
			else//功能码错误
			{
				rs485_comerr = FUNCODE_ERR; //功能码错误
			}
		}
		if(RS485_RX_CNT == 0) //出现了发送没有返回的现象添加
		{
			rs485_comerr = COM_OVERTIME; //通信超时
		}
		if(rs485_comerr == COM_NORMAL) //通信正常 
		{
			if(rs485_error_count > 0 && rs485_error_count < COM_MAX_ERRORS) // 0 < 错误次数 < COM_MAX_ERRORS
			{
				rs485_error_count = 0; //证明前面通信有出错，但在错误范围内恢复
			}
			single_send_ver_flag = 0;  //单次发送校验标志位清零
		}
		else
		{
			single_send_ver_flag = 2;  // 校验不通过
		}
		rs485_recv_flag = WAIT_SEND;   // 等待下一帧发送
		RS485_RX_CNT = 0;              // 接收计数器清零
		MDMSerialSWRecv_Send(RS485_TX);// 切换为发送状态
	}
}

结构体赋值：（方便处理数据）

/**
  * @brief  将从机返回的数据存放在结构体中便于数据分析处理
  * @param  data_p 数据指针
			datalen 数据长度
			md_stu 接收数据结构体
  * @retval None
  */
u8 Recv_data_process(u8 *data_p, u16 datalen, RecvdataSTU *md_stu)
{
	u16 i = 0;
	u8 *databuff;
	u8 v_hi, v_lo;
	
	if(data_p == NULL) return 0;
	if(datalen >= RS485_BUFF_SIZE) return 0;
	
	databuff = md_stu->data_point; //定义数据指针
	md_stu->slave_id = *data_p++;  //从机地址
	md_stu->fun_code = *data_p++;  //功能码
	switch(md_stu->fun_code)       //根据不同的功能码进行处理
	{    
		case READ_COIL: //1 读线圈状态
		{																
			md_stu->byte_num = *data_p++;   //返回的字节数
			if(md_stu->byte_num > RECVD_BUFF_LIMIT) return 0;
			for(i = 0; i < md_stu->byte_num; i++) //线圈数据 8bit
			{
				*databuff++ = *data_p++;
			}
			break;
		}
				
		case READ_DI: //2 读离散输入状态
		{
			md_stu->byte_num = *data_p++; //返回的字节数
			if(md_stu->byte_num > RECVD_BUFF_LIMIT) return 0;
			for(i = 0; i < md_stu->byte_num; i++) //返回数据 8bit
			{
				*databuff++ = *data_p++;
			}
			break;
		}
				
		case READ_HLD_REG: //3 读保持寄存器
		{
			md_stu->byte_num = *data_p++;         //返回的字节数
			if(md_stu->byte_num > RECVD_BUFF_LIMIT) return 0;
			for(i = 0; i < md_stu->byte_num; i++) //返回数据 寄存器数据16bit
			{
				*databuff++ = *data_p++;
			}
			break;
		}	
		case READ_AI: //4 读输入寄存器
		{																
			md_stu->byte_num = *data_p++;     //返回的字节数
			if(md_stu->byte_num > RECVD_BUFF_LIMIT) return 0;
			for(i = 0; i < md_stu->byte_num; i++)  //返回数据 寄存器数据16bit
			{
				*databuff++ = *data_p++;
			}
			break;
		}
				
		case SET_COIL:  //5 写单个线圈
		{
			v_hi = *data_p++;
			v_lo = *data_p++;
			md_stu->reg_addr = (v_hi << 8) | v_lo;  //寄存器地址
			*databuff++ = *data_p++;                //返回的数据 2字节
			*databuff = *data_p;
			break;
		}
				
		case SET_HLD_REG:  //6 写单个保持寄存器
		{
			v_hi = *data_p++;
			v_lo = *data_p++;
			md_stu->reg_addr = (v_hi << 8) | v_lo;  //寄存器地址
			*databuff++ = *data_p++;                //返回的数据 2字节
			*databuff = *data_p;										
			break;
		}
		case WRITE_HLD_REG:  //16  写多个保持寄存器
		{
			v_hi = *data_p++;
			v_lo = *data_p++;
			md_stu->reg_addr = (v_hi << 8) | v_lo; //获取寄存器地址
			v_hi = *data_p++;
			v_lo = *data_p++;
			md_stu->reg_num = (v_hi << 8) | v_lo;  //获取字节数
			break;
		}	
	}
	if(md_senddata_stu.data_update == UPDATE) 
		md_stu->data_update = UPDATE;
	return 1;
}

数据处理：传入发送数据结构体与接收数据结构体用于校验对比

/**
  * @brief  数据处理
  * @param  senddata：发送数据存放结构体, recvdata：接收数据存放结构体
  * @retval None
  */
void modbus_data_process(SenddataSTU *senddata, RecvdataSTU *recvdata)
{
	//获取参数
	u8 *recv_data_update_flag, *send_data_update_flag, funcode, slaveID;
	u16 reg_addr , byte_num;
	funcode = recvdata->fun_code;
	slaveID = recvdata->slave_id;
	reg_addr = senddata->reg_addr;
	byte_num = recvdata->byte_num;
	send_data_update_flag = &senddata->data_update;
	recv_data_update_flag = &recvdata->data_update;
	
	if(*recv_data_update_flag == UPDATE)
	{
		//验证从机地址
		if(senddata->slave_id != recvdata->slave_id)
			rs485_comerr = SLAVEID_ERR;
		//验证寄存器地址
		if(funcode == SET_COIL || funcode == SET_HLD_REG || funcode == WRITE_COIL || funcode == WRITE_HLD_REG )
			if(senddata->reg_addr != recvdata->reg_addr)
				rs485_comerr = REG_ADDR_ERR; //部分返回没有寄存器地址
		//验证功能码
		if(senddata->fun_code != recvdata->fun_code)
			rs485_comerr = FUNCODE_ERR;
		//此处插入对数据处理的函数 BEGIN
		//***用户自定义
		//此处插入对数据处理的函数 END
		*recv_data_update_flag = PROCESSED;
		*send_data_update_flag = PROCESSED;
	}
}

附：STM32串口1-5初始化

1.引脚分配

串口	TX	RX
串口1	PA9	PA10
串口2	PA2	PA3
串口3	PB10	PB11
串口4	PC10	PC11
串口5	PC12	PD2

2.串口初始化程序

以下初始化为485串口初始化，除了初始化串口TX、RX外还初始化了一个DR引脚，自己做筛选。

USART1

见三.1

USART2

/**
  * @brief  串口2初始化 485通信
  * @param  baud 波特率
  * @retval None
  */
void uart2_init(u32 baud)
{
	GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;		    //推挽复用模式  TX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOA, &GPIO_InitStructure );
	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	//浮空输入模式  RX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOA, &GPIO_InitStructure );
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	    //485_DR
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOA, &GPIO_InitStructure );
	RS485_COM2_TX_EN = 0;                                   //默认接收方向
	
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init( &NVIC_InitStructure );
	
	USART_DeInit(USART2);                                    //复位串口2
	USART_InitStructure.USART_BaudRate = baud;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init( USART2, &USART_InitStructure );
	
	USART_ClearITPendingBit(USART2,USART_IT_RXNE);
	USART_ITConfig(USART2,USART_IT_RXNE, ENABLE);           //使能串口2接收中断
	USART_Cmd( USART2, ENABLE );					        //使能串口2
}

USART3

/**
  * @brief  串口3初始化 485通信
  * @param  baud 波特率
  * @retval None
  */
void uart3_init(u32 baud)
{
	GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );
    RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART3, ENABLE );

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;              //PB10
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;		    //推挽复用模式  TX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOB, &GPIO_InitStructure );
	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;              //PB11
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	//浮空输入模式  RX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOB, &GPIO_InitStructure );
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;                //PB1
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	     //485_DR
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOB, &GPIO_InitStructure );
	GPIO_ResetBits(GPIOB, GPIO_Pin_1);                       //默认接收方向
	
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init( &NVIC_InitStructure );
	
	USART_DeInit(USART3);                                    //复位串口3
	USART_InitStructure.USART_BaudRate = baud;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(USART3, &USART_InitStructure);  
	
	USART_ClearITPendingBit(USART3, USART_IT_RXNE);
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);     //使能串口3接收中断
	USART_Cmd(USART3, ENABLE);					       //使能串口3
}

UART4

/**
  * @brief  串口4初始化 485通信
  * @param  baud 波特率
  * @retval None
  */
void uart4_init(u32 baud)
{
	GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE );
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_AFIO, ENABLE );
    RCC_APB1PeriphClockCmd( RCC_APB1Periph_UART4, ENABLE );
	
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;              //PC10
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;		    //推挽复用模式  TX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOC, &GPIO_InitStructure );
	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;              //PC11
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	//浮空输入模式  RX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOC, &GPIO_InitStructure );
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;               //PA15
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	     //485_DR
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOA, &GPIO_InitStructure );
	GPIO_ResetBits(GPIOA, GPIO_Pin_15);                      //默认接收方向
	
	NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
	
	USART_DeInit(UART4);                                     //复位串口4
	USART_InitStructure.USART_BaudRate = baud;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(UART4, &USART_InitStructure);  
	
	USART_ClearITPendingBit(UART4, USART_IT_RXNE);
	USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);      //使能串口4接收中断
	USART_Cmd(UART4, ENABLE);					       //使能串口4
}

UART5

/**
  * @brief  串口5初始化
  * @param  baud 波特率
  * @retval None
  */
void uart5_init(u32 baud)
{
	GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE );
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOD, ENABLE );
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );
    RCC_APB1PeriphClockCmd( RCC_APB1Periph_UART5, ENABLE );
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_AFIO, ENABLE);
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;              //PC12
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;		    //推挽复用模式  TX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOC, &GPIO_InitStructure );
	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;               //PD2
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	//浮空输入模式  RX
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOD, &GPIO_InitStructure );
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;                //PB3
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	     //485_DR
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( GPIOB, &GPIO_InitStructure );
	GPIO_ResetBits( GPIOB, GPIO_Pin_3);                      //默认接收方向
	
	NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
	
	USART_DeInit(UART5);                                     //复位串口5
	USART_InitStructure.USART_BaudRate = baud;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(UART5, &USART_InitStructure);  
	
	USART_ClearITPendingBit(UART5, USART_IT_RXNE);
	USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);      //使能串口5接收中断
	USART_Cmd(UART5, ENABLE);					       //使能串口5
}

---

总结

记录MODBUS开发过程，涉及串口通信、485通信等相关知识，篇幅太长筛选一部分说明，后续gitee上传代码。（仅个人记录，若侵权删）

作者：Free丶Chan