一、stm32串口通信
         stm32串口通信一般是指通过UART（Universal Asynchronous Receiver/Transmitter）通用异步收发传输器传输数据，UART 作为异步串口通信协议的一种，工作原理是将传输数据的每个字符一位接一位地传输，其在应用程序开发过程中使用频率最高的数据总线。而MCU的UART 通信实际上是基于GPIO引脚电平信号实现的，因此，在预制UART外设不够时，也会可以采用GPIO引脚自行模拟UART串口通信。
: C3 j( E: b$ ~: G4 h0 e
) o: I, l4 h0 q7 o+ T* v        1.1 硬件流控
3 w9 Z& {! B4 N' `! X; Y. w        UART 串口的特点是将数据一位一位地顺序传送，只要 2 根传输线就可以实现双向通信，一根线发送数据的同时用另一根线接收数据。但是，数据在两个串口之间进行通讯的时候常常会出现丢失数据的现象，主要原因是数据处理及数据接收效率不一致引起的冲突，为了解决这种问题，引入了流控概念。流控的概念源于 RS232 这个标准，用来解决这个速度匹配的问题，通过新增传输线来控制数据传输数据线的流向、流速等，这就是简单的三线串口的通讯方式，如下图：


8 v' e" u% T8 f' U4 N
         在两条数据线基础上，增加两根控制线，一根叫 CTS(Clear To Send 为输入信号，一根叫 RTS(Require To Send 为输出信号)，一个是接收控制，一个是发送控制。可以看到，数据线方向与流控线数据方向相反，因为流控的主要是协调接收数据和处理数据一致性，所以需要让发送端等待，接收端发出来的信号叫 RTS 信号，发送端检测管脚叫 CTS。

        数据接收与 RTS 信号标记如下图，接收端缓存没数据时，RTS是低电平状态，发送端可以发送数据；当接收端接收到数据后，RTS切换为高电平，就是告诉发送端，数据还没有被拿走，请发送端等待；RTS 信号在数据没有被读取之前都是保持在高电平状态，一旦数据被 DMA 或者 CPU 从 DR 寄存器读取之后，RTS 就释放高电平，变为低电平，这时候发送端又可以发送数据的了。另外，如果 USART 是FIFO 模式，即缓冲模式开启的时候，在 FIFO 满的时候才会去拉高 RTS 信号。


) U9 y4 V9 p- d2 a3 x' b
5 B1 M' e. m. v$ b% W" M         相应的，发送数据和CTS信号类似，发送端在发送数据时，要实时监测 CTS 的电平状态，如果发现是高电平，就不会再发送新的数据，直到 CTS 检测发现已经没有高电平信号才会再次发送。

        我们在cubeIDE中，对应上述的就是勾选RS232流控制支持，就可以选择CTS/RTS引脚配置。
1 D# [4 f$ G$ [


: ^* z6 i+ g- d% j! u" r$ g. m         如上面所述，由设想的两根数据线传输多出两根流控制线，这无形中增加硬件成本，因此，RS485出现后，RS232的CTS/RT合二为一DE ，STM32 上有一个 DE 管脚和 RS485 的接收器芯片直接相连，控制数据的收发，主要就是数据的方向的控制。因为 RS485 是一个半双工的通讯模式，它的数据收的时候就不能发，发的时候不能收。
8 f4 L4 p' Z. @" p) V
* a, H1 U' J$ L4 ~% @$ \1 u& l0 m

         在cubeMX中，需要支持DE引脚开始，就需要勾选RS485流控制功能
4 p9 s+ ~( t8 C- t: R1 \9 C" ?( f
0 y5 [2 T) z0 b( |- O6 E  {

9 |5 W' G4 d/ C& k9 L6 C         1.2 软件流控
' n$ r  h3 z5 f+ {        上述的增加流控制线的做法都是属于硬件流控的实现，在实际项目开发过程，我们很多时候为了方便以及节省引脚，往往采用软流控。软件流控是以特殊的字符来代表从机已经不能再接收新的数据了，基本的流程就是从机在接收数据很多的时候或主动给发送端发送一个特殊字符，当发送端接收到这个特殊字符后就不能再发送数据了。

　　软件流控很方便，不需要增加新的硬件，还是以前的TX、RX两根数据线实现，但是使用了软件流控，它本身的字符也是数据，这个数据只不过是说在软件里把它设置了一个特殊的含义。如果它是一个全双工的通讯，在给另一个串口发送数据的时候如果也包含了这样一个特殊字符，对方就会误以为我让它不要再发送数据了，会有一定的概率出现错误，而硬件流控就不需要考虑这方面，只需要使用 CTS 和 RTS，所有的数据都是由硬件来操作的，因此硬件流控在稳定性上更可靠。
" a' W0 O" T: ]! W# ?
. M+ ?2 P3 u- L9 B6 M8 z       1.3 串口通信参数
         UART 串口通信有几个重要的参数，分别是起始位、波特率、数据位、停止位和奇偶检验位（流控，按需），对于两个使用 UART 串口通信的端口，这些参数必须匹配，否则通信将无法正常完成。
9 t& ^6 p7 v2 l5 l- R8 [% T/ z  e
        起始位：表示数据传输的开始，默认电平逻辑为 “0” 。
8 U2 i# K, _7 T% |. i6 a
; {3 y# O: }7 j' J2 N        波特率：串口通信时的速率，它用单位时间内传输的二进制代码的有效位(bit)数来表示，其单位为每秒比特数 bit/s(bps)。常见的波特率值有 4800、9600、14400、38400、115200等，数值越大数据传输的越快，波特率为 115200 表示每秒钟传输 115200 位数据。
4 t+ a# q# p0 v! t: [/ N( w
        数据位：可能值有 5、6、7、8、9，表示传输这几个 bit 位数据。一般取值为 8，因为一个 ASCII 字符值为 8 位。
2 c% R5 Q8 W% a* S" c- f( R8 a) B
        停止位： 表示一帧数据的结束。默认电平逻辑为 “1”。

        奇偶校验位：用于接收方对接收到的数据进行校验，校验 “1” 的位数为偶数(偶校验)或奇数(奇校验)，以此来校验数据传送的正确性，使用时不需要此位也可以。

二、新建RS485通信工程
, o' O+ O& V/ u        2.1 项目实现背景信息
+ \% ~% y7 x  u5 w% Q; L5 K( s+ L        本文采用的STM32L496VGTX-ali开发板，该开发板预留了扩展接口支持USART4通信，本文将USART4与USB转RS485(CH340）连接，进而与电脑通信。

; y* \. P0 c+ \8 j- y: T; @9 L: f

         实物图：

4 u9 J+ N9 E9 k* W- |3 l7 P

; ?$ \5 {+ M; `  k         扩展接口原理框图如下：
% Z. q5 g% t7 K% h  a: G7 X& R1 N

. x- g: d* a3 ^+ r# H* t( y/ \# j
         另外本人开发板标注背后扩展口标注的是PA0、PA1，查看其他描述，确定就是PA0、PA1引脚。

        现将在该工程基础上，实现串口Usart4和lpusart通信，并lcd屏打印其发送数据；Usart4发送'A'/'B'可以点亮及熄灭LED0。


       2.2 项目配置
# o0 L- G- R3 v* R- H        双击(.ioc)打开cubeMX配置界面，开启USART4串口功能，配置串口参数
. b1 b9 T1 l. p2 L
$ f# ?- y/ J: U- q1 Z% ~5 I+ S
- Q# n) ?- X0 X( [8 v% A% e" E
+ J! m+ f+ k9 P1 t; f        并开启usart4的中断支持
; F4 U* E$ [) u- W. G


         点击保存生成输出代码。

        2.3 代码实现
        在ICore目录下，新建rs485文件夹，并在该文件目录下，创建rs485.h和rs485.c源文件，其实现代码如下：
. h; z. R' G% a. o' w0 g7 J$ `
        rs485.h
, j% n7 F2 K3 h: V

1. #ifndef RS485_RS485_H_
   
2. #define RS485_RS485_H_
   2 d; N0 W- J7 A, I) x/ W! y# |
3. 
   , l: o2 \1 F2 t$ _
4. #include "stm32l4xx_hal.h" //HAL库文件声明
   " Z' @; {$ ~3 r3 y; r
5. 
   
6. extern UART_HandleTypeDef huart4;//声明USART4的HAL库结构体
   
7. void RS485_printf (char *fmt, ...);  //RS485发送
   * P5 [( O4 F# K( I
8. 
   ) C# R8 r: @1 {  o
9. #endif /* RS485_RS485_H_ */

复制代码

! m0 f* p! g  Y2 o$ \8 R        rs485.c
; ?( t# F1 e& J2 b0 \

1. #include "../usart/usart.h"
   
2. #include "main.h"
   
3. #include <stdarg.h>
   8 J0 W- a# ]4 b2 i4 o3 U
4. /*
   ; r! Q3 G7 u; N2 h
5. RS485总线通信，使用UART4，这是RS485专用的printf函数
   
6. */
   3 a, s: R) A/ ]1 N
7. void RS485_printf (char *fmt, ...)
   ) G! m" f5 m" V( i- G* G3 w2 J
8. {
   
9.     char buff[USART4_REC_LEN+1];  //用于存放转换后的数据 [长度]
   
10.     uint16_t i=0;
    
11.     va_list arg_ptr;
    + `) a9 Y) o/ x( p
12.     va_start(arg_ptr,fmt);
    
13.     vsnprintf(buff, USART4_REC_LEN+1,fmt,arg_ptr);//数据转换
    3 G2 y; U; x5 W8 V0 ?
14.     i=strlen(buff);//得出数据长度
    & [. m8 k6 w3 n) `2 I6 j. g. D/ K
15.     if(strlen(buff)>USART4_REC_LEN)i=USART4_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    
16.     HAL_UART_Transmit(&huart4,(uint8_t *)buff,i,0Xffff);//串口发送函数（串口号，内容，数量，溢出时间）
    1 w3 K# @. Y2 d1 H* W2 q2 T/ L2 f# ?
17.     va_end(arg_ptr);
    
18. }
    5 d1 F5 ~7 {1 Z
19. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在【USART.C】文件中。

复制代码

        调整usart.h和usart.c文件，重新实现串口USART4的中断回调函数

        usart.h

1. #ifndef _USART_H_
   . y+ W! a: X* |4 g+ ?
2. #define _USART_H_
   ( X% F& ]: m" B3 b+ ?. M
3. 
   
4. #include "stm32l4xx_hal.h" //HAL库文件声明
   . Q8 l& a7 Q, @$ ?
5. #include <string.h>//用于字符串处理的库
   
6. #include "../print/print.h"//用于printf函数串口重映射
   . |# V/ y7 W/ o, N& n
7. 
   - H. w- M0 s2 i1 Q& v0 d: l; s7 y
8. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
   
9. extern UART_HandleTypeDef huart4;//声明USART4的HAL库结构体
   
10. 
    
11. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
    
12. #define USART4_REC_LEN 256
    
13. 
    
14. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    / l2 I. J8 r% X9 `
15. extern uint16_t HLPUSART_RX_STA;//接收状态标记
    % e% l* \% e1 t3 D
16. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    ! {! {! O$ O2 _* A1 R7 x
17. 
    : B# m' X, P+ B& [3 B; O  V) B) Z
18. extern uint8_t USART4_RX_BUF[USART4_REC_LEN];
    ) \" a8 D1 \: c+ T) `
19. extern uint16_t USART4_RX_STA;
    ( L5 L) {5 T& @% L0 Q# L' ^9 E
20. extern uint8_t USART4_NewData;
    
21. 
    
22. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    # h% O* C& Z2 i
23. 
    
24. #endif /* _USART_H_ */

复制代码

        usart.c
6 ^4 c5 _1 g; I) b8 Q, ?8 c0 O4 |

1. #include "usart.h"
   7 v% T3 u* _# [2 Z
2. 
   
3. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
   ! O4 G' J2 B* `! J9 X
4. /*
   ; P, I+ k5 l( D/ D( O
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   , l" |+ B, L# l8 X, z
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   
7. * bit13:预留
   
8. * bit12:预留
   
9. * bit11~0：接收到的有效字节数目(0~4095)
   , n! W& ^) h. m% L, n2 n
10. */
    ( _3 a) M5 B$ Q$ T; J# Y+ \
11. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
    ( a3 W& V. ?* y
12. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    ' C; k" n3 q1 t1 i) b2 O( [& Z
13. 
    
14. uint8_t USART4_RX_BUF[USART4_REC_LEN];
    
15. uint16_t USART4_RX_STA=0;
    
16. uint8_t USART4_NewData;
    ! B0 P. G/ `- v
17. 
    
18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    3 z) f  \6 \" x+ x8 a% i2 g
19. {
    ' j$ C% w& |% j" g, ?! }! \
20.         if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
    3 L' g; J& p3 N0 c; R; L0 V( V  r
21.     {
    " [, ]0 s+ p/ M# g0 g2 N
22.                 if(HLPUSART_NewData==0x0d){//回车标记
    + O: l- n# U. ~' l
23.                HLPUSART_RX_STA|=0x8000;//标记接到回车
    / P4 R' V: E, z! G+ T3 ]
24.                 }else{
    . a" [- U- `7 X# G- ]
25.                         if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
    
26.                                 HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
    6 b  `: }0 F0 k
27.                                 HLPUSART_RX_STA++;  //数据长度计数加1
    3 l6 v4 B1 d; W# Q% }& w  E
28.                         }else{
    9 F: _: h5 ^9 ~8 x  `
29.                                 HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    2 ]4 m6 i' A8 x; j- N9 o) Z
30.                         }
    . ~# _% |) n' c! k$ w
31.         }
    
32.        HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
    ) A' `2 O5 E+ N1 n  \
33.     }
    # S4 m, d! g# M$ J! \
34.         if(huart ==&huart4)//判断中断来源（串口4：USB转串口）
    ; m, g6 {5 \/ \& R- B5 g
35.     {
    & f; ~0 F% R( m3 I$ z$ ^
36. //                printf("%c",USART4_NewData);
      O8 q7 b. U- Q; j$ e! V
37.                 if(USART4_NewData==0x0d){//回车标记
    
38.                         USART4_RX_STA|=0x8000;//标记接到回车
    9 I) I  J4 z) d: ~: L
39.                 }else{
    0 }& @6 X! e7 D; U, @' m" d) j: S
40.                         if((USART4_RX_STA&0X0FFF)<USART4_REC_LEN){
    
41.                                 USART4_RX_BUF[USART4_RX_STA&0X0FFF]=USART4_NewData; //将收到的数据放入数组
    ( ^4 B, T* T/ y+ O
42.                                 USART4_RX_STA++;  //数据长度计数加1
    / W. h: Y( o5 Z* F
43.                         }else{
    7 P0 e8 i! s5 l; `. v
44.                                 USART4_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    + f  n! G/ Q4 P# y# T7 U  w6 a
45.                         }
    
46.         }
    & j" j' D) S7 ?: F
47.        HAL_UART_Receive_IT(&huart4,(uint8_t *)&USART4_NewData,1); //再开启接收中断
    % E$ z- R4 k; n5 b2 S
48.     }
    
49. }

复制代码

; H# v% Z# x& _6 m5 \: o   三、RS485驱动调用及测试
        3.1 接口调用
        在main.c文件中加入rs485.h头文件支持

1. /* USER CODE BEGIN Includes */
   
2. #include "../../ICore/key/key.h"
   
3. #include "../../ICore/led/led.h"
   
4. #include "../../ICore/print/print.h"
   
5. #include "../../ICore/usart/usart.h"
   / i) `" h! N7 Q$ Z" }" C' T5 e
6. #include "../../ICore/rs485/rs485.h"
   7 a. m& X3 s* h4 U; ^  T
7. #include "../../ICore/oled/oled.h"
   . e9 C/ @0 _. m# G" b. p6 _- A. o9 r
8. /* USER CODE END Includes */

复制代码

! Y) q2 t/ x* X2 M  x1 L        在主函数初始化中调整加入usart4初始化设定
+ n! w2 S% A$ |5 L6 O5 m+ i

1.   /* USER CODE BEGIN 2 */
   
2.   ResetPrintInit(&hlpuart1);
   6 T$ e8 Z' T; \8 L, [$ x! E
3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
   6 ~# f8 a2 ?. X6 S. o8 ^* m: {. z3 E
4.   HLPUSART_RX_STA = 0;
   
5.   HAL_UART_Receive_IT(&huart4,(uint8_t *)&USART4_NewData,1); //开启串口4接收中断
   6 H2 |/ L' e, U/ t- m
6.   USART4_RX_STA = 0;
   2 A/ m" ]- j8 M  ?5 I
7.   //
   
8.   OLED_init();
   
9.   //设置OLED蓝色背景显示
   3 N; y3 D; g2 v: Q( m4 `) p9 P3 V
10.   BSP_LCD_Clear_DMA(LCD_DISP_BLUE);
    
11.   printf("OLED_Clear_DMA\r\n");
    ! s: C! G! R$ A6 I- T9 e
12.   /* USER CODE END 2 */

复制代码

        在主函数循环体中，修改代码实现对usart4接收数据处理
6 X3 b9 b; i7 w: ^* N2 E' m+ Y

1.   /* USER CODE BEGIN WHILE */
   6 m: z& i% G7 z2 [5 Z, ]: g
2.   while (1)
   ! t+ F3 N% k- m
3.   {
   # b( E; J* k$ ^% s
4.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
   7 f1 }9 }0 y# e# `$ c6 ?
5.                   RS485_printf("%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   
6.                   OLED_printf(10,10,"%.*s",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   4 t6 c* G' |2 g7 C
7.                   HLPUSART_RX_STA=0;//接收错误,重新开始
   
8.                   HAL_Delay(100);//等待
   " @1 m6 T9 z& M7 U. Z6 |
9.           }
   % A% A7 J3 m1 L3 \
10.           if(USART4_RX_STA&0xC000){//溢出或换行，重新开始
    2 n. E, [) b+ n) K
11.                   if(1==(USART4_RX_STA&0x0FFF))
    4 G0 X- C1 C1 n' B4 r! d: B0 E
12.                   {
    ) M- h% H4 H* W! {4 Z
13.                           switch (USART4_RX_BUF[0]){
    7 v7 ^$ c  l+ r& V6 z+ w" h
14.                           case 'A':
    9 o) E2 _* C, w4 l
15.                                   set_led0_val(1);
    ; V" k/ H# t6 @6 X; T& W
16.                                   break;
    
17.                           case 'B':
    
18.                                   set_led0_val(0);
    # o  o$ @8 @( ]8 j: [# S8 @' C
19.                                   break;
    
20.                           default:
    
21.                                   break;
    3 a9 g1 z- P; J7 @* R; ?$ H
22.                           }
    - r+ P' L/ ~. D- U# e" M( x0 o
23.                   }
    
24.                     printf("%.*s\r\n",USART4_RX_STA&0X0FFF, USART4_RX_BUF);
      K. e/ w' s# {
25.                     OLED_printf(10,42,"%.*s",USART4_RX_STA&0X0FFF, USART4_RX_BUF);
    * R- k' Q. z" y( d
26.                     USART4_RX_STA=0;//接收错误,重新开始
    
27.                     HAL_Delay(100);//等待
    * G: q% D7 e; \7 s, i- ]3 h
28.             }
    
29.     /* USER CODE END WHILE */

复制代码

       3.2 编译及下载及测试

% d/ j$ w" X  H7 z

         LED0在发送'A'字符是关闭（LED灯是低位有效）

$ [- a& N# Y, _! H4 ]

————————————————
' i2 _7 {( n7 t! F版权声明：py_free-物联智能
如有侵权请联系删除
9 b1 d" ?. L2 y# L