一、USART简介
1.1 UART 简介
通用同步异步收发器(USART：Universal Synchronous/Asynchronous Receiver/Transmitter)
特点：串行、全双工、同步/异步通信(USART可支持同步通信，UART只支持异步通信)
; H1 {6 `" I  n. y9 r2 @" X4 E- J& o. F. e
& B  G2 F- E4 \5 |- D$ B! }发送和接收共用的可编程波特率
可编程数据字长度(8位或9位)（常用8位）
可配置的停止位-支持1或2个停止位（常用1位停止位）
/ J% s, G  z: p' {% T可配置奇偶校验位（一般不用）

1.2 物理拓补图
) E8 J4 z& V" f2 y% ~接口通过三个引脚与其他设备连接在一起。任何USART双向通信至少需要两个脚
1 m# Y1 Q0 }& |2 I  L& `# Q+ eRX：接收数据输入
TX：发送数据输出
$ ^9 c) P- P, c# u! M7 z4 BGND：双方要共地，双方通过USART进行通信，两个设备必须要共地，因为逻辑1---3.3V电压(对于地的电压)，如果两个设备不共地则对地电压的高电平(3.3V就可能不太一样)。共地的意义是让两个设备的通信电平对地电压相等



. u: s( W: P5 Y* e  r' A1.3 数据帧格式
一帧数据=1bit起始位[低电平]+8bit数据位+1bit奇偶校验位[可以不用]+1bit停止位[高电平]

% e$ ~$ u% t, `9 P4 x' Y& \USART总线空闲，即没有数据发生，TX线为高电平

' p6 F- A8 k6 W3 K<1>数据位：USART发送的1次数据量是1Byte=8bit；[5、6、7、8]
9 V% s9 F0 W# T# W: o, A, C<2>数据字：数据位+奇偶校验位；如果不用校验位，数据字=数据位=8bit；如果使用校验位，数据字=数据位+校验位=9bit
                    奇校验：数据位中的1的个数+校验位中的1的个数为奇数
- p9 J$ W$ C% c$ T, i+ c' q$ H2 B5 f                    偶校验：数据位中的1的个数+校验位中的1的个数为偶数
% }" \3 ^) y, p  ~<3>停止位：可以被配置为1bit(默认)；2个停止位(可用于常规USART模式、单线模式以及调制解调器模式);0.5个停止位：在智能卡模式下接收数据时使用;1.5个停止位：在智能卡模式下发送和接收数据时使用
<4>发送顺序:先发送低位，再发送高位
, f9 y, C% R& s! T+ y' i
& |( Q: N: U! k5 U1.4 框图

& t0 F: O: G) z7 O7 i# E" q
9 f$ O- h6 S/ L9 r
7 f8 g( r  m( B对于这个框图，最关键的是两个标志位TXE(发送为空标志位)，RXNE(接收不为空标志位)
数据通过RX端口进入MCU的UART的接收移位寄存器，随后进入接收数据寄存器(RDR),进入后RXNE被置1，表明可以读
MCU通过数据总线获得数据，数据再到发送数据寄存器(TDR),若TXE=1，说明数据已经被转移到移位寄存器，表明可以发送

0 f9 [; [2 c: a% v# \; U二、串口通信
- [& _! d! I, h& }  f* u  _% o2 U( \配置UART
6 D; D  G7 c2 W2 T# @" ~; q
开启了接收中断和空闲中断

/****************************
*@brief    uasrt1端口配置函数
*@param     void
& u# u, b" {  l*@return    void
*@NOTE      PA10->RX PA9->TX
            PA10,PA9位于APB2上
*@time     2025-6-3
******************************/
void usart1_Init(uint32_t Baud_Rate)
{
        //1.打开引脚时钟PA
* `* Z2 o' {+ H        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE)      ;
      
        //2.打开usart1时钟
  @+ W! C7 ]; c3 x9 x( y. O        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE)    ;
      
8 a% X8 B( k) a$ P+ E. C        //PA9->TX推挽复用输出
        GPIO_InitTypeDef GPIO_InitStruct_TX                      ;
        GPIO_InitStruct_TX.GPIO_Mode  = GPIO_Mode_AF_PP          ;
        GPIO_InitStruct_TX.GPIO_Pin   = GPIO_Pin_9               ;
: C. p9 t8 ^1 ]# [  Q8 ~" i3 s        GPIO_InitStruct_TX.GPIO_Speed = GPIO_Speed_10MHz         ;
        GPIO_Init(GPIOA,&GPIO_InitStruct_TX)        ;
/ P# |8 b6 n) t/ V: v. Q      
, J% M# V2 d% H2 d$ u      
        //3.配置,PA10->RX浮空输入
        GPIO_InitTypeDef GPIO_InitStruct_RX                      ;
6 [- P0 E% g: X. ?; ?4 h4 ~        GPIO_InitStruct_RX.GPIO_Mode  = GPIO_Mode_IN_FLOATING    ;
7 {: l7 `: T, T0 s; B" s        GPIO_InitStruct_RX.GPIO_Pin   = GPIO_Pin_10              ;
        GPIO_Init(GPIOA,&GPIO_InitStruct_RX)        ;
      
5 O, g6 ~3 x' ]        //4.配置usart1,
        USART_InitTypeDef USART_InitStruct                                           ;
% T3 h- {" m9 n        USART_InitStruct.USART_Mode                = USART_Mode_Rx|USART_Mode_Tx     ;
        USART_InitStruct.USART_Parity              = USART_Parity_No                 ;
- T) n/ ?6 P8 s        USART_InitStruct.USART_StopBits            = USART_StopBits_1                ;
        USART_InitStruct.USART_BaudRate            = Baud_Rate                       ;      
% G, I/ X* @3 ]9 T, |/ q2 b% j' U. z        USART_InitStruct.USART_WordLength          = USART_WordLength_8b             ;
0 S$ m' e+ q4 o, b+ k* r        USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None  ;
6 s* Z7 U7 Z! L% U2 U% R        USART_Init(USART1,&USART_InitStruct)                                         ;

                  
                  USART_ITConfig(USART1,USART_IT_RXNE,ENABLE)                     ;//开启接收中断 RXNEIE=1
                        USART_ITConfig(USART1,USART_IT_IDLE,ENABLE)                     ;//开启空闲中断 IDLE=1
0 Q+ J1 p; Y1 |3 k                  //初始化NVIC
                  NVIC_InitTypeDef  NVIC_InitStruct                               ;
                  NVIC_InitStruct.NVIC_IRQChannel                   = USART1_IRQn ;//中断通道
! T& ?5 g0 g+ K+ K/ L3 |0 k& Z                  NVIC_InitStruct.NVIC_IRQChannelCmd                = ENABLE      ;//中断使能
                  NVIC_InitStruct.NVIC_IRQChannelSubPriority        = 2           ;//响应先级
              NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2           ;//抢占优先级
              NVIC_Init(&NVIC_InitStruct)                                     ;
, ?6 @1 j; T* E9 q7 H. C      
2 v0 D: S. ~2 h8 D& F        //5.使能usart1
        USART_Cmd(USART1,ENABLE)                                                     ;
/ d( W( P( d' Y}  

2 y- l5 h5 M) k( w8 a. q
9 Q/ _# [1 v2 ?% R5 t接收发送函数
9 a5 G' o; U# h6 U+ {( V3 l
/****************************
+ J, s. G6 x/ a5 l9 Q. _1 S*@brief     发送字符函数
# N; `4 q8 U! ^, e3 Y. k% X% K*@param    void
# ^0 i, V) ]% m, P) L- s, m*@return   void
*@note     MCU会将数据发送到DR寄存器中的TDR寄存器中，
当TXE==1时，TDR寄存器会将数据加载到移位寄存器中,可以发送
4 a0 A3 J% s0 l4 Z; P/ I*@time    2025-6-3
" G1 J; J5 b+ A' ]8 n******************************/
void usart1_sendbyte(uint8_t str)
1 p6 g, ~. j6 D  l1 ^+ C$ w& z+ B{
2 ^0 `9 f0 m5 A+ u2 j        while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==0);
( e; {& p6 d' I" t/ I        USART_SendData(USART1,str);
}

/****************************
*@brief     发送字符串函数
*@param   uint8_t *str
2 c5 ~( P2 t& B: q: [1 v1 B( |*@return  uint16_t len
*@note    发送字符串本质上就是发送字符
$ K9 V! C& V: p! D6 j' m* T& g: U*@time    2025-6-3
******************************/
void usart1_sendstr(char *str,int len)
{
        while(len)
   {
6 T& ^- B* Q( Y  Q" R" }( g2 A                 usart1_sendbyte(*str++);
5 ]; |  g) C( M                 len--;
+ [( l9 ?  E' E& V: F         }
}
: o4 c0 Z" B8 R2 J$ d
: I) z. e: C" s' e; v% x* W1 D1 j/****************************
+ u& _+ O1 ]! l% N  d*@brief    接收字符
$ J( k# U# F: Q" z9 M* a3 v2 U*@param    void
) {+ z, n  p, @, F+ o# g  }+ e*@return   void
1 K( H) ], m/ r. }" k4 w" [*@note    MCU接收到数据后先放在DR寄存器的接收移位寄存器
. J* `+ x# K4 N% Z$ U          数据会到RDR寄存器中，当RXNE==1时，说明RDR有数据，可以读
2 t  X: s) N/ Z*@time     2025-6-3
******************************/
0 x1 r7 z6 W% e! e/ ~uint16_t usart1_receivebyte()
4 g$ w3 f; V2 m{
        while(USART_GetFlagStatus(USART1,USART_FLAG_RXNE)==0);
4 I1 z3 A( p2 X/ c, m        return  USART_ReceiveData(USART1);
}
4 ?3 _9 ~$ X3 Q) e# B# f9 l8 S' ]/****************************
5 x) v: p0 h6 Z4 ?. B*@brief    接收字符串函数(idle标志位)
*@param  void
*@return   void
/ X+ y! U; T- @1 c4 l/ f& J*@note     void
*@time    2025-6-3
******************************/
! k3 V! @2 c  U* d+ b% bvoid usart1_receivestr(char*buff)
{
        uint8_t flag;
+ k3 n7 l! Q! M4 m) L        while(1)
   {
                 if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE)==1)
       {
* f  }) N2 m6 P! P& B* o                                 *buff=USART_ReceiveData(USART1);
                                 buff++;
                                 flag=1;
- q4 H/ H- I. _; m. H; Z6 Y                         }
                        if(USART_GetFlagStatus(USART1,USART_FLAG_IDLE)==1&&flag)
       {
& s1 Q1 `( ]4 F- `4 X) ^, L                                 *buff='\0'; //当发送时 发送结束标志
) F1 X7 t" e$ Q" d* G! O                                 //先读SR，再读DR将置IDLE位置0
6 z/ w2 d" n. x; A- r* `                                 USART1->SR;
                                 USART1->DR;
3 {8 k/ X) Y8 i9 s. s; v                                 break;
                         }
' c3 j( Y9 I7 D6 X8 I4 ^- Q2 u         }
}
+ h5 p# o  M& B- J+ u% V
& K7 Q2 I5 s2 S, S
打印函数
6 {+ w+ y7 k5 X, a# z
记得勾选微库，printf函数不涉及到中断，它是将内存中的数据输出到上位机

: C! t( G9 s1 V; v//printf()的底层借助fputc函数进行输出
int fputc(int ch,FILE*stream)
{
        usart1_sendbyte(ch);
        return ch;
}
# @# |+ G4 K5 C7 _, g7 e



. A' a' {5 d0 Q/ T8 ^9 w中断函数
MCU接收到数据时，进入接收中断函数，将数据存到rx_buff[100]数组里；当上位机不发送数据时，说明空闲状态，进入空闲中断，将 rx_buff[100]数组里面的数据发到上位机
' A* }$ d; y! e" `
6 \1 d, u$ V. c  |& u: M; I/****************************
*@brief    usart1中断实验
/ O7 G, F8 q, g- ~. s# i& N) @*@param  void
*@return   void
*@note     void
*@time   2025-6-4
4 {: x7 U- A; L/ m# V******************************/
char rx_buff[1000]={0};
char cnt=0;
void USART1_IRQHandler(void)
0 g# S) [4 J# d, T! ]# H{
   //当RXNE=1时,有数据接收
0 V1 ]2 z" P! q8 D; P0 M        if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)
0 B5 x) }2 S& M  E1 O   {
                 rx_buff[cnt++]=USART_ReceiveData(USART1);
8 G5 L6 ~0 n1 F# T                 USART_ClearITPendingBit(USART1,USART_IT_RXNE);//清除标志位
  k2 c) q, t: j$ C4 x, h" ]. E8 y3 d) w         }
         
         //当IDLE=1时，
        if(USART_GetITStatus(USART1,USART_IT_IDLE)==SET)
   {
# W3 n' v& p8 D  `" w1 S                 usart1_sendstr(rx_buff,strlen(rx_buff));
4 P8 f2 R) a* _& ]4 v# P                 cnt=0;
                 USART1->SR;
5 E! Q6 g7 E/ n                 USART1->DR;                                  //清除标志位
$ I3 q9 L' P; d& \8 B% V         }
}


————————————————