STM32H743通过串口控制超声波模块KS103，可以用串口2和3向电脑发送字符串，但发送给超声波模块没有响应，救救孩子吧，调了好....

pengbo · 发表于 2019-11-6 20:36:45

1.main.c
#include "sys.h"
#include "delay.h"
#include "usart.h"
/************************************************
ALIENTEK 阿波罗STM32H7开发板实验0
新建工程实验-HAL库版本
关注微信公众平台微信号："正点原子"，免费获取STM32资料。
广州市星翼电子科技有限公司
作者：正点原子 @ALIENTEK
************************************************/

void Delay(__IO uint32_t nCount);
void Delay(__IO uint32_t nCount)
{
while(nCount--){}
}

int main(void)
{
Cache_Enable();                            //打开L1-Cache
HAL_Init();                      //初始化HAL库
Stm32_Clock_Init(160,5,2,4);             //设置时钟,400Mhz
delay_init(400);
uart_init(115200,9600,9600);

   //printf("%d",12);
   //printf("%d\n",13);
   //printf("%d\n",14);
   HAL_UART_Transmit(&UART3_Handler,"0xe8",8,1000); //发送
   while(__HAL_UART_GET_FLAG(&UART3_Handler,UART_FLAG_TC)!=SET); //等待发送结束
   delay_us(100);

   HAL_UART_Transmit(&UART3_Handler,"0x02",8,1000); //发送
   while(__HAL_UART_GET_FLAG(&UART3_Handler,UART_FLAG_TC)!=SET); //等待发送结束
   delay_us(100);

   HAL_UART_Transmit(&UART3_Handler,"0xbc",8,1000); //发送
   while(__HAL_UART_GET_FLAG(&UART3_Handler,UART_FLAG_TC)!=SET); //等待发送结束
   delay_us(200);
}
2.usart.c
#include "usart.h"
//////////////////////////////////////////////////////////////////////////////////
//如果使用os,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "includes.h" //os 使用
#endif
//////////////////////////////////////////////////////////////////////////////////
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32H7开发板
//串口1初始化
//修改日期:2017/6/8
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2009-2019
//All rights reserved
//********************************************************************************
//V1.0修改说明
//////////////////////////////////////////////////////////////////////////////////
//加入以下代码,支持printf函数,而不需要选择use MicroLIB
//#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#if 1
//#pragma import(__use_no_semihosting)
//标准库需要的支持函数
struct __FILE
{
int handle;
};

FILE __stdout;
//定义_sys_exit()以避免使用半主机模式
void _sys_exit(int x)
{
x = x;
}
//重定义fputc函数
int fputc(int ch, FILE *f)
{
while((USART1->ISR&0X40)==0);//循环发送,直到发送完毕
USART1->TDR=(u8)ch;
return ch;
}
#endif

#if EN_USART1_RX&EN_USART2_RX&EN_USART3_RX  //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误
u8 USART1_RX_BUF[USART_REC_LEN];    //接收缓冲,最大USART_REC_LEN个字节.
u8 USART2_RX_BUF[USART_REC_LEN];    //接收缓冲,最大USART_REC_LEN个字节.
u8 USART3_RX_BUF[USART_REC_LEN];    //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，接收完成标志
//bit14，接收到0x0d
//bit13~0，接收到的有效字节数目
u16 USART1_RX_STA=0;    //接收状态标记
u16 USART2_RX_STA=0;    //接收状态标记
u16 USART3_RX_STA=0;    //接收状态标记

int distance_left,distance_right;

u8 aRxBuffer1[RXBUFFERSIZE1];//HAL库使用的串口接收缓冲
u8 aRxBuffer2[RXBUFFERSIZE2];//HAL库使用的串口接收缓冲
u8 aRxBuffer3[RXBUFFERSIZE3];//HAL库使用的串口接收缓冲

UART_HandleTypeDef UART1_Handler; //UART1句柄
UART_HandleTypeDef UART2_Handler; //UART2句柄
UART_HandleTypeDef UART3_Handler; //UART3句柄

//初始化IO 串口1
//bound:波特率
void uart_init(u32 bound1,u32 bound2,u32 bound3)
{
//UART1 初始化设置
UART1_Handler.Instance=USART1;       //USART1
UART1_Handler.Init.BaudRate=bound1;       //波特率1
UART1_Handler.Init.WordLength=UART_WORDLENGTH_8B; //字长为8位数据格式
UART1_Handler.Init.StopBits=UART_STOPBITS_1;       //一个停止位
UART1_Handler.Init.Parity=UART_PARITY_NONE;       //无奇偶校验位
UART1_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE; //无硬件流控
UART1_Handler.Init.Mode=UART_MODE_TX_RX;       //收发模式
HAL_UART_Init(&UART1_Handler);       //HAL_UART_Init()会使能UART1

HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer1, RXBUFFERSIZE1);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量

//UART2 初始化设置
UART2_Handler.Instance=USART2;       //USART2
UART2_Handler.Init.BaudRate=bound2;       //波特率2
UART2_Handler.Init.WordLength=UART_WORDLENGTH_8B; //字长为8位数据格式
UART2_Handler.Init.StopBits=UART_STOPBITS_1;       //一个停止位
UART2_Handler.Init.Parity=UART_PARITY_NONE;       //无奇偶校验位
UART2_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE; //无硬件流控
UART2_Handler.Init.Mode=UART_MODE_TX_RX;       //收发模式
HAL_UART_Init(&UART2_Handler);       //HAL_UART_Init()会使能UART2

HAL_UART_Receive_IT(&UART2_Handler, (u8 *)aRxBuffer2, RXBUFFERSIZE2);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量

//UART3 初始化设置
UART3_Handler.Instance=USART3;       //USART3
UART3_Handler.Init.BaudRate=bound3;       //波特率3
UART3_Handler.Init.WordLength=UART_WORDLENGTH_8B; //字长为8位数据格式
UART3_Handler.Init.StopBits=UART_STOPBITS_1;       //一个停止位
UART3_Handler.Init.Parity=UART_PARITY_NONE;       //无奇偶校验位
UART3_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE; //无硬件流控
UART3_Handler.Init.Mode=UART_MODE_TX_RX;       //收发模式
HAL_UART_Init(&UART3_Handler);       //HAL_UART_Init()会使能UART3

HAL_UART_Receive_IT(&UART3_Handler, (u8 *)aRxBuffer3, RXBUFFERSIZE3);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量
}

//UART底层初始化，时钟使能，引脚配置，中断配置
//此函数会被HAL_UART_Init()调用
//huart:串口句柄

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_Initure;

//串口1MSP初始化
if(huart->Instance==USART1)//如果是串口1，进行串口1 MSP初始化
{
__HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
__HAL_RCC_USART1_CLK_ENABLE(); //使能USART1时钟

GPIO_Initure.Pin=GPIO_PIN_9; //PA9
GPIO_Initure.Mode=GPIO_MODE_AF_PP; //复用推挽输出
GPIO_Initure.Pull=GPIO_PULLUP; //上拉
GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
GPIO_Initure.Alternate=GPIO_AF7_USART1; //复用为USART1
HAL_GPIO_Init(GPIOA,&GPIO_Initure);    //初始化PA9

GPIO_Initure.Pin=GPIO_PIN_10; //PA10
GPIO_Initure.Mode = GPIO_MODE_INPUT; //浮空输入
HAL_GPIO_Init(GPIOA,&GPIO_Initure);    //初始化PA10

#if EN_USART1_RX
HAL_NVIC_EnableIRQ(USART1_IRQn); //使能USART1中断通道
HAL_NVIC_SetPriority(USART1_IRQn,3,3); //抢占优先级3，子优先级3
#endif
}

//串口2MSP初始化
if(huart->Instance==USART2)//如果是串口2，进行串口2 MSP初始化
{
__HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
__HAL_RCC_USART2_CLK_ENABLE(); //使能USART1时钟

GPIO_Initure.Pin=GPIO_PIN_2; //PA2
GPIO_Initure.Mode=GPIO_MODE_AF_PP; //复用推挽输出
GPIO_Initure.Pull=GPIO_PULLUP; //上拉
GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
GPIO_Initure.Alternate=GPIO_AF7_USART2; //复用为USART2
HAL_GPIO_Init(GPIOA,&GPIO_Initure);    //初始化PA2

GPIO_Initure.Pin=GPIO_PIN_3; //PA3
GPIO_Initure.Mode = GPIO_MODE_INPUT; //浮空输入
HAL_GPIO_Init(GPIOA,&GPIO_Initure);    //初始化PA3

#if EN_USART2_RX
HAL_NVIC_EnableIRQ(USART2_IRQn); //使能USART1中断通道
HAL_NVIC_SetPriority(USART1_IRQn,3,2); //抢占优先级3，子优先级3
#endif
}

//串口3MSP初始化
if(huart->Instance==USART3)//如果是串口3，进行串口3 MSP初始化
{
__HAL_RCC_GPIOB_CLK_ENABLE(); //使能GPIOB时钟
__HAL_RCC_USART3_CLK_ENABLE(); //使能USART3时钟

GPIO_Initure.Pin=GPIO_PIN_10; //PB10
GPIO_Initure.Mode=GPIO_MODE_AF_PP; //复用推挽输出
GPIO_Initure.Pull=GPIO_PULLUP; //上拉
GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
GPIO_Initure.Alternate=GPIO_AF7_USART3; //复用为USART3
HAL_GPIO_Init(GPIOB,&GPIO_Initure);    //初始化PB10

GPIO_Initure.Pin=GPIO_PIN_11; //PB11
GPIO_Initure.Mode = GPIO_MODE_INPUT; //浮空输入
HAL_GPIO_Init(GPIOB,&GPIO_Initure);    //初始化PB11

#if EN_USART3_RX
HAL_NVIC_EnableIRQ(USART3_IRQn); //使能USART3中断通道
HAL_NVIC_SetPriority(USART1_IRQn,3,1); //抢占优先级3，子优先级3
#endif
}

}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
//串口1回调函数
if(huart->Instance==USART1)//如果是串口1
{
if((USART1_RX_STA&0x8000)==0)//接收未完成
{
if(USART1_RX_STA&0x4000)//接收到了0x0d
{
if(aRxBuffer1[0]!=0x0a)USART1_RX_STA=0;//接收错误,重新开始
else USART1_RX_STA|=0x8000; //接收完成了
}
else //还没收到0X0D
{
if(aRxBuffer1[0]==0x0d)USART1_RX_STA|=0x4000;
else
{
USART1_RX_BUF[USART1_RX_STA&0X3FFF]=aRxBuffer1[0] ;
USART1_RX_STA++;
if(USART1_RX_STA>(USART_REC_LEN-1))USART1_RX_STA=0;//接收数据错误,重新开始接收
}
}
}

}

//串口2回调函数
if(huart->Instance==USART2)//如果是串口2
{
   u8 j=0;
   if((__HAL_UART_GET_FLAG(&UART3_Handler,UART_FLAG_RXNE)!=RESET))
   {
      HAL_UART_Receive(&UART2_Handler,&USART3_RX_BUF[j],8,1000);
      j++;
      if(j==2)
      {
      j=0;
      distance_left=USART2_RX_BUF[0]*256+USART2_RX_BUF[1];
      }
   }
}

//串口3回调函数
if(huart->Instance==USART3)//如果是串口3
{
   u8 k=0;
   if((__HAL_UART_GET_FLAG(&UART3_Handler,UART_FLAG_RXNE)!=RESET))
   {
      HAL_UART_Receive(&UART3_Handler,&USART3_RX_BUF[k],8,1000);
      k++;
      if(k==2)
      {
      k=0;
      distance_right=USART3_RX_BUF[0]*256+USART3_RX_BUF[1];
      }
   }
}
}

//串口1中断服务程序
void USART1_IRQHandler(void)
{
u32 timeout=0;
u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntEnter();
#endif

HAL_UART_IRQHandler(&UART1_Handler); //调用HAL库中断处理公用函数

timeout=0;
while (HAL_UART_GetState(&UART1_Handler)!=HAL_UART_STATE_READY)//等待就绪
{
      timeout++;////超时处理
      if(timeout>maxDelay) break;
}

timeout=0;
while(HAL_UART_Receive_IT(&UART1_Handler,(u8 *)aRxBuffer1, RXBUFFERSIZE1)!=HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
{
      timeout++; //超时处理
      if(timeout>maxDelay) break;
}
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntExit();
#endif
}

//串口2中断服务程序
void USART2_IRQHandler(void)
{
u32 timeout=0;
u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntEnter();
#endif

HAL_UART_IRQHandler(&UART2_Handler); //调用HAL库中断处理公用函数

timeout=0;
while (HAL_UART_GetState(&UART1_Handler)!=HAL_UART_STATE_READY)//等待就绪
{
      timeout++;////超时处理
      if(timeout>maxDelay) break;
}

timeout=0;
while(HAL_UART_Receive_IT(&UART1_Handler,(u8 *)aRxBuffer1, RXBUFFERSIZE1)!=HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
{
      timeout++; //超时处理
      if(timeout>maxDelay) break;
}
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntExit();
#endif
}

//串口3中断服务程序
void USART3_IRQHandler(void)
{
u32 timeout=0;
u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntEnter();
#endif

HAL_UART_IRQHandler(&UART3_Handler); //调用HAL库中断处理公用函数

timeout=0;
while (HAL_UART_GetState(&UART1_Handler)!=HAL_UART_STATE_READY)//等待就绪
{
      timeout++;////超时处理
      if(timeout>maxDelay) break;
}

timeout=0;
while(HAL_UART_Receive_IT(&UART1_Handler,(u8 *)aRxBuffer1, RXBUFFERSIZE1)!=HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
{
      timeout++; //超时处理
      if(timeout>maxDelay) break;
}
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntExit();
#endif
}
#endif
3.usart.h
#ifndef _USART_H
#define _USART_H
#include "sys.h"
#include "stdio.h"
//////////////////////////////////////////////////////////////////////////////////
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32H7开发板
//串口1初始化
//修改日期:2017/6/8
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 正点原子 2009-2019
//All rights reserved
//********************************************************************************
//V1.0修改说明
//////////////////////////////////////////////////////////////////////////////////
#define USART_REC_LEN    200    //定义最大接收字节数 200
#define EN_USART1_RX 1 //使能（1）/禁止（0）串口1接收
#define EN_USART2_RX 1 //使能（1）/禁止（0）串口1接收
#define EN_USART3_RX 1 //使能（1）/禁止（0）串口1接收

extern u8  USART1_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
extern u8  USART2_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
extern u8  USART3_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符

extern u16 USART1_RX_STA;          //接收状态标记
extern u16 USART2_RX_STA;          //接收状态标记
extern u16 USART3_RX_STA;          //接收状态标记

extern UART_HandleTypeDef UART1_Handler; //UART1句柄
extern UART_HandleTypeDef UART2_Handler; //UART2句柄
extern UART_HandleTypeDef UART3_Handler; //UART3句柄

extern int distance_left,distance_right;

#define RXBUFFERSIZE1 1 //缓存大小
extern u8 aRxBuffer1[RXBUFFERSIZE1];//HAL库USART1接收Buffer
#define RXBUFFERSIZE2 2 //缓存大小
extern u8 aRxBuffer2[RXBUFFERSIZE2];//HAL库USART2接收Buffer
#define RXBUFFERSIZE3 2 //缓存大小
extern u8 aRxBuffer3[RXBUFFERSIZE3];//HAL库USART3接收Buffer

//如果想串口中断接收，请不要注释以下宏定义
void uart_init(u32 bound,u32 bound2,u32 bound3);
#endif

pengbo · 发表于 2019-11-6 20:36:46

感谢各位大佬，又重新调了几次，改了好多错误，终于调出来了。模块没反应应该是我发送命令的格式不对，用回了直接操作寄存器就好了，特把调出的代码贴出来，请各位大佬批评指正。
1.main.c
#include "sys.h"
#include "delay.h"
#include "usart.h"
/************************************************
ALIENTEK 阿波罗STM32H7开发板实验0
新建工程实验-HAL库版本
关注微信公众平台微信号："正点原子"，免费获取STM32资料。
广州市星翼电子科技有限公司
作者：正点原子 @ALIENTEK
************************************************/

void Delay(__IO uint32_t nCount);
void Delay(__IO uint32_t nCount)
{
while(nCount--){}
}

int main(void)
{
Cache_Enable();                            //打开L1-Cache
HAL_Init();                      //初始化HAL库
Stm32_Clock_Init(160,5,2,4);             //设置时钟,400Mhz
delay_init(400);
uart_init(115200,9600,9600);

//超声波1指令发送，串口2
   USART2->TDR=0xe8;                                                 //发送
   //while(__HAL_UART_GET_FLAG(&UART1_Handler,UART_FLAG_TC)!=SET); //等待发送结束
   while((USART2->ISR&0X40)==0);
   delay_us(100);

   USART2->TDR=0x02;                                                 //发送
//while(__HAL_UART_GET_FLAG(&UART1_Handler,UART_FLAG_TC)!=SET); //等待发送结束
   while((USART2->ISR&0X40)==0);
   delay_us(100);

   USART2->TDR=0xb4;                                              //发送
   //while(__HAL_UART_GET_FLAG(&UART1_Handler,UART_FLAG_TC)!=SET);    //等待发送结束
   while((USART2->ISR&0X40)==0);
   delay_ms(100);

//超声波2指令发送，串口3
   USART3->TDR=0xe8;                                                 //发送
   while((USART3->ISR&0X40)==0);                                     //等待发送结束
   delay_us(100);

   USART3->TDR=0x02;                                                 //发送
   while((USART3->ISR&0X40)==0);                                     //等待发送结束
   delay_us(100);

   USART3->TDR=0xb4;                                              //发送
   while((USART3->ISR&0X40)==0);                                     //等待发送结束
   delay_ms(100);
}
2.usart.c
#include "usart.h"
#include "delay.h"
//////////////////////////////////////////////////////////////////////////////////
//如果使用os,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "includes.h" //os 使用
#endif
//////////////////////////////////////////////////////////////////////////////////
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32H7开发板
//串口1初始化
//修改日期:2017/6/8
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2009-2019
//All rights reserved
//********************************************************************************
//V1.0修改说明
//////////////////////////////////////////////////////////////////////////////////
//加入以下代码,支持printf函数,而不需要选择use MicroLIB
//#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#if 1
//#pragma import(__use_no_semihosting)
//标准库需要的支持函数
struct __FILE
{
int handle;
};

FILE __stdout;
//定义_sys_exit()以避免使用半主机模式
void _sys_exit(int x)
{
x = x;
}
//重定义fputc函数
int fputc(int ch, FILE *f)
{
while((USART1->ISR&0X40)==0);//循环发送,直到发送完毕
USART1->TDR=(u8)ch;
return ch;
}
#endif

//注意,读取USARTx->SR能避免莫名其妙的错误
u8 USART1_RX_BUF[USART_REC_LEN];    //接收缓冲,最大USART_REC_LEN个字节.
u8 USART2_RX_BUF[USART_REC_LEN];    //接收缓冲,最大USART_REC_LEN个字节.
u8 USART3_RX_BUF[USART_REC_LEN];    //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，接收完成标志
//bit14，接收到0x0d
//bit13~0，接收到的有效字节数目
u16 USART1_RX_STA=0;    //接收状态标记

u16 distance_left,distance_right;

u8 aRxBuffer1[RXBUFFERSIZE1];//HAL库使用的串口接收缓冲
u8 aRxBuffer2[RXBUFFERSIZE2];//HAL库使用的串口接收缓冲
u8 aRxBuffer3[RXBUFFERSIZE3];//HAL库使用的串口接收缓冲

UART_HandleTypeDef UART1_Handler; //UART1句柄
UART_HandleTypeDef UART2_Handler; //UART2句柄
UART_HandleTypeDef UART3_Handler; //UART3句柄

//初始化IO 串口1
//bound:波特率
void uart_init(u32 bound1,u32 bound2,u32 bound3)
{
//UART1 初始化设置
UART1_Handler.Instance=USART1;       //USART1
UART1_Handler.Init.BaudRate=bound1;       //波特率1
UART1_Handler.Init.WordLength=UART_WORDLENGTH_8B; //字长为8位数据格式
UART1_Handler.Init.StopBits=UART_STOPBITS_1;       //一个停止位
UART1_Handler.Init.Parity=UART_PARITY_NONE;       //无奇偶校验位
UART1_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE; //无硬件流控
UART1_Handler.Init.Mode=UART_MODE_TX_RX;       //收发模式
HAL_UART_Init(&UART1_Handler);       //HAL_UART_Init()会使能UART1

HAL_UART_Receive_IT(&UART1_Handler, aRxBuffer1, RXBUFFERSIZE1);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量

//UART2 初始化设置
UART2_Handler.Instance=USART2;       //USART2
UART2_Handler.Init.BaudRate=bound2;       //波特率2
UART2_Handler.Init.WordLength=UART_WORDLENGTH_8B; //字长为8位数据格式
UART2_Handler.Init.StopBits=UART_STOPBITS_1;       //一个停止位
UART2_Handler.Init.Parity=UART_PARITY_NONE;       //无奇偶校验位
UART2_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE; //无硬件流控
UART2_Handler.Init.Mode=UART_MODE_TX_RX;       //收发模式
HAL_UART_Init(&UART2_Handler);       //HAL_UART_Init()会使能UART2

HAL_UART_Receive_IT(&UART2_Handler, aRxBuffer2, RXBUFFERSIZE2);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量

//UART3 初始化设置
UART3_Handler.Instance=USART3;       //USART3
UART3_Handler.Init.BaudRate=bound3;       //波特率3
UART3_Handler.Init.WordLength=UART_WORDLENGTH_8B; //字长为8位数据格式
UART3_Handler.Init.StopBits=UART_STOPBITS_1;       //一个停止位
UART3_Handler.Init.Parity=UART_PARITY_NONE;       //无奇偶校验位
UART3_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE; //无硬件流控
UART3_Handler.Init.Mode=UART_MODE_TX_RX;       //收发模式
HAL_UART_Init(&UART3_Handler);       //HAL_UART_Init()会使能UART3

HAL_UART_Receive_IT(&UART3_Handler, aRxBuffer3, RXBUFFERSIZE3);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量
}

//UART底层初始化，时钟使能，引脚配置，中断配置
//此函数会被HAL_UART_Init()调用
//huart:串口句柄

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_Initure;

//串口1MSP初始化
if(huart->Instance==USART1)//如果是串口1，进行串口1 MSP初始化
{
__HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
__HAL_RCC_USART1_CLK_ENABLE(); //使能USART1时钟

GPIO_Initure.Pin=GPIO_PIN_9; //PA9
GPIO_Initure.Mode=GPIO_MODE_AF_PP; //复用推挽输出
GPIO_Initure.Pull=GPIO_PULLUP; //上拉
GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
GPIO_Initure.Alternate=GPIO_AF7_USART1; //复用为USART1
HAL_GPIO_Init(GPIOA,&GPIO_Initure);    //初始化PA9

GPIO_Initure.Pin=GPIO_PIN_10; //PA10
HAL_GPIO_Init(GPIOA,&GPIO_Initure);    //初始化PA10

#if EN_USART1_RX
HAL_NVIC_SetPriority(USART1_IRQn,3,3); //抢占优先级3，子优先级3
HAL_NVIC_EnableIRQ(USART1_IRQn); //使能USART1中断通道
#endif
}

//串口2MSP初始化
if(huart->Instance==USART2)//如果是串口2，进行串口2 MSP初始化
{
__HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
__HAL_RCC_USART2_CLK_ENABLE();       //使能USART2时钟

GPIO_Initure.Pin=GPIO_PIN_2; //PA2
GPIO_Initure.Mode=GPIO_MODE_AF_PP; //复用推挽输出
GPIO_Initure.Pull=GPIO_PULLUP; //上拉
GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
GPIO_Initure.Alternate=GPIO_AF7_USART2; //复用为USART2
HAL_GPIO_Init(GPIOA,&GPIO_Initure);    //初始化PA2

GPIO_Initure.Pin=GPIO_PIN_3; //PA3
HAL_GPIO_Init(GPIOA,&GPIO_Initure);    //初始化PA3

#if EN_USART2_RX
      HAL_NVIC_SetPriority(USART2_IRQn,3,2); //抢占优先级3，子优先级2
HAL_NVIC_EnableIRQ(USART2_IRQn); //使能USART2中断通道
#endif
}

//串口3MSP初始化
if(huart->Instance==USART3)//如果是串口3，进行串口3 MSP初始化
{
__HAL_RCC_GPIOB_CLK_ENABLE(); //使能GPIOB时钟
__HAL_RCC_USART3_CLK_ENABLE(); //使能USART3时钟

GPIO_Initure.Pin=GPIO_PIN_10; //PB10
GPIO_Initure.Mode=GPIO_MODE_AF_PP; //复用推挽输出
GPIO_Initure.Pull=GPIO_PULLUP; //上拉
GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
GPIO_Initure.Alternate=GPIO_AF7_USART3; //复用为USART3
HAL_GPIO_Init(GPIOB,&GPIO_Initure);    //初始化PB10

GPIO_Initure.Pin=GPIO_PIN_11; //PB11
HAL_GPIO_Init(GPIOB,&GPIO_Initure);    //初始化PB11

#if EN_USART3_RX
HAL_NVIC_SetPriority(USART3_IRQn,3,1); //抢占优先级3，子优先级3
HAL_NVIC_EnableIRQ(USART3_IRQn); //使能USART3中断通道
#endif
}

}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
//串口1回调函数
if(huart->Instance==USART1)//如果是串口1
{
   printf("%d",*((huart->pRxBuffPtr)-1));
}

//串口2回调函数
if(huart->Instance==USART2)//如果是串口2
{
   //USART2_RX_BUF[0]=*((huart->pRxBuffPtr)-2);
   //USART2_RX_BUF[1]=*((huart->pRxBuffPtr)-1);
   distance_left=aRxBuffer2[0]*256+aRxBuffer2[1];
   printf("\r\n左侧距离为:\r\n");
   printf("%d\n",distance_left);
}

//串口3回调函数
if(huart->Instance==USART3)//如果是串口3
{
   //USART3_RX_BUF[0]=*((huart->pRxBuffPtr)-2);
   //USART3_RX_BUF[1]=*((huart->pRxBuffPtr)-1);
   distance_right=USART3_RX_BUF[0]*256+USART3_RX_BUF[1];
   printf("\r\n右侧距离:\r\n");
   printf("%d\n",distance_left);
}
}

//串口1中断服务程序
void USART1_IRQHandler(void)
{
u32 timeout=0;
u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntEnter();
#endif

HAL_UART_IRQHandler(&UART1_Handler); //调用HAL库中断处理公用函数

timeout=0;
while (HAL_UART_GetState(&UART1_Handler)!=HAL_UART_STATE_READY)//等待就绪
{
      timeout++;////超时处理
      if(timeout>maxDelay) break;
}

timeout=0;
while(HAL_UART_Receive_IT(&UART1_Handler,(u8 *)aRxBuffer1, RXBUFFERSIZE1)!=HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
{
      timeout++; //超时处理
      if(timeout>maxDelay) break;
}
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntExit();
#endif
}

//串口2中断服务程序
void USART2_IRQHandler(void)
{
u32 timeout=0;
u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntEnter();
#endif

HAL_UART_IRQHandler(&UART2_Handler); //调用HAL库中断处理公用函数

timeout=0;
while (HAL_UART_GetState(&UART2_Handler)!=HAL_UART_STATE_READY)//等待就绪
{
      timeout++;////超时处理
      if(timeout>maxDelay) break;
}

timeout=0;
while(HAL_UART_Receive_IT(&UART2_Handler,(u8 *)aRxBuffer2, RXBUFFERSIZE2)!=HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount2为2
{
      timeout++; //超时处理
      if(timeout>maxDelay) break;
}
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntExit();
#endif
}

//串口3中断服务程序
void USART3_IRQHandler(void)
{
u32 timeout=0;
u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntEnter();
#endif

HAL_UART_IRQHandler(&UART3_Handler); //调用HAL库中断处理公用函数

timeout=0;
while (HAL_UART_GetState(&UART1_Handler)!=HAL_UART_STATE_READY)//等待就绪
{
      timeout++;////超时处理
      if(timeout>maxDelay) break;
}

timeout=0;
while(HAL_UART_Receive_IT(&UART3_Handler,(u8 *)aRxBuffer3, RXBUFFERSIZE3)!=HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount3为2
{
      timeout++; //超时处理
      if(timeout>maxDelay) break;
}
#if SYSTEM_SUPPORT_OS      //使用OS
OSIntExit();
#endif
}
3.usart.h
#ifndef _USART_H
#define _USART_H
#include "sys.h"
#include "stdio.h"
//////////////////////////////////////////////////////////////////////////////////
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32H7开发板
//串口1初始化
//修改日期:2017/6/8
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 正点原子 2009-2019
//All rights reserved
//********************************************************************************
//V1.0修改说明
//////////////////////////////////////////////////////////////////////////////////
#define USART_REC_LEN    200    //定义最大接收字节数 200

#define EN_USART1_RX 1 //使能（1）/禁止（0）串口1接收
#define EN_USART2_RX 1 //使能（1）/禁止（0）串口1接收
#define EN_USART3_RX 1 //使能（1）/禁止（0）串口1接收

extern u8  USART1_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
extern u8  USART2_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
extern u8  USART3_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符

extern u16 USART1_RX_STA;          //接收状态标记
extern u16 USART2_RX_STA;          //接收状态标记
extern u16 USART3_RX_STA;          //接收状态标记

extern UART_HandleTypeDef UART1_Handler; //UART1句柄
extern UART_HandleTypeDef UART2_Handler; //UART2句柄
extern UART_HandleTypeDef UART3_Handler; //UART3句柄

extern u16 distance_left,distance_right;

#define RXBUFFERSIZE1 1 //缓存大小
extern u8 aRxBuffer1[RXBUFFERSIZE1];//HAL库USART1接收Buffer
#define RXBUFFERSIZE2 2 //缓存大小
extern u8 aRxBuffer2[RXBUFFERSIZE2];//HAL库USART2接收Buffer
#define RXBUFFERSIZE3 2 //缓存大小
extern u8 aRxBuffer3[RXBUFFERSIZE3];//HAL库USART3接收Buffer

//如果想串口中断接收，请不要注释以下宏定义
void uart_init(u32 bound,u32 bound2,u32 bound3);
#endif