你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

基于STM32串口的经验总结

[复制链接]
攻城狮Melo 发布时间:2023-3-18 12:11
在日常中,串口经常作为和上位机通信的接口,进行打印信息方便调试程序,有时也会作为模块的驱动接口,所以总结一下串口的几种使用方法对以后的开发还是很有帮助的。
7 A' h7 W8 k0 H% T* @
0 @6 {8 `* `1 `4 w. A一.仅向上位机打印调试信息
- \0 B' {1 \) q5 \+ \单纯利用串口向上位机打印调试信息,程序如下:( _5 T% ^: z2 y$ ^1 S; c0 l, |
  1. void USART1_Init( uint32_t btl )
    3 h( e- p1 v: q
  2. {3 V/ z& A# c5 X& B0 C7 @9 o! |* E: t# R
  3.         GPIO_InitTypeDef  GPIO_InitStruct;0 U$ M' j7 u- z6 C2 B
  4.         USART_InitTypeDef USART_InitStruct;0 Q- E" |- Z/ [5 T
  5.         9 U2 j3 I: x) L* z% l/ w6 M8 A
  6.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE );4 w, W4 b" }- W5 ~- T* W
  7.         8 W6 K# G# H1 K' F% H; q
  8.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;( ?) k% l5 @% E4 x
  9.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;//Tx
    4 Y6 ^8 o8 u, i4 C9 O
  10.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    8 e& E# f; h8 k
  11.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    & a1 \) ?+ B' l
  12.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;//Rx
    ; n1 x3 o8 j# X4 `, `) o
  13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    3 u- H! d; Y9 r; U; w5 x! m
  14.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    # B9 J; ^  i3 j" u" ]; u0 p
  15.        
    ) j# L- w# Q& s1 u1 b5 F
  16.         USART_InitStruct.USART_BaudRate = btl;6 Q/ c, i( Y. l* `# P% }) L
  17.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    0 r2 b2 N9 V" l2 j
  18.         USART_InitStruct.USART_Mode = USART_Mode_Tx;
    0 R& Y+ ~$ k: H: N1 w8 b7 {1 C
  19.         USART_InitStruct.USART_Parity = USART_Parity_No;
    : X, ?5 Z8 w/ Z2 d3 |
  20.         USART_InitStruct.USART_StopBits = USART_StopBits_1;$ u, p8 b6 H5 C# X+ Q; E6 T
  21.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;  a/ n5 r+ R) s+ t
  22.         USART_Init( USART1, &USART_InitStruct );% @9 }% {- ^- K  E4 m8 w7 q
  23.         * Q" @; b$ i' o8 G" v) f- y
  24.         USART_Cmd( USART1, ENABLE );" q: s$ D) \# k/ u1 |6 I9 k
  25.        
    8 o* N  r; \5 ^* r
  26. }
    " V1 S4 o1 f  L& t

  27. ' i3 @3 e4 H" w  t. S/ k
  28. //串口重定向,直接利用printf函数输出调试信息
    ; z, w3 B  _4 x4 ~/ R# S
  29. int fputc( int ch, FILE *f )
    - U6 W# p6 K" C; h
  30. {
    2 D+ g' {3 _1 |4 B+ l; ]2 J
  31.         USART_SendData( USART1, ( uint8_t )ch );- K# {$ i+ w% w; ]3 n& q8 h
  32.         while( USART_GetFlagStatus( USART1, USART_FLAG_TXE )!=SET );
    1 h$ V/ ^4 u& E3 N1 N; e% D
  33.         return ch;
    - E0 `6 N- ]5 t+ m0 V
  34. }
    2 @( N, \5 y7 H6 v+ y3 r  S+ m* }: V% z

  35. ( F0 o* j" S2 ]$ x( A
  36. 2 g5 B3 U- H: p0 f3 j7 n
复制代码
1 |7 Y% \6 @% w4 f; L
记得包含头文件,勾选Use MicroLIB,以使用printf等函数* Z2 n, `7 y/ j3 G
3 S" X- Q! @  x! d
2020042220264754.png
0 N! X+ ?: m3 M
! u0 L9 P# S6 G2 s8 U8 L! O9 Y
" w$ m2 U! Z. c5 B% I+ t. f+ _
二.与上位机交互信息
4 E# h/ U% v  N$ a相比于上面的单向通信,有时候需要从上位机接收信息,然后进行反馈,这个时候就使用到串口的中断了。9 {! O" L' h8 O3 ?
上位机向单片机发送字符串,接收后再发送给上位机:
/ `# }. I( P* h/ Q
  1. ' y( Y# _, O  @- V* ~% w
  2. void USART1_Init( uint32_t btl )
    1 D( y7 {* i7 q' r; ~/ N
  3. {
    " ~9 `3 }7 f9 S
  4.         /* 结构体声明 */5 s6 P/ ^* |- O% S  E) e" H
  5.         GPIO_InitTypeDef  GPIO_InitStruct;" Y; ?9 J- m) ?5 C1 I8 V" L1 T
  6.         USART_InitTypeDef USART_InitStruct;
    " o$ n' H3 `& W' M' V+ i
  7.         NVIC_InitTypeDef NVIC_InitStruct;
    ( D2 _/ d: y1 N# {
  8.         + M+ K/ A" C4 Q' L, _
  9.         /* 打开时钟 */& }, S& S) d' D' k: t6 _% i
  10.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );; }' z6 Y7 ?! F* x
  11.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1, ENABLE );# J$ M3 ~0 ]$ i$ B" Z( u, \# Z
  12.        
    ( H4 B8 P- ?: D* ]3 T( p
  13.         /* GPIO配置 */3 H- T7 U6 E1 S' `+ a8 Q* ?; s
  14.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    2 v6 u) g, s  a
  15.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;//Tx+ [6 @: P7 F7 F: U
  16.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    . ?0 L4 j' H5 s
  17.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    2 E5 `( _6 v7 F
  18.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;//Rx
    ! i4 W3 N, d0 a3 A0 H1 j
  19.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;: p( X  @) [% q  L7 v
  20.         GPIO_Init( GPIOA, &GPIO_InitStruct );) H* ]" F  g! ^, s( B+ ?
  21.        
    # m9 r% V+ d# j4 H/ V6 F% ?
  22.         /* 串口配置 */9 ^4 f" ?) r( x6 o# @
  23.         USART_InitStruct.USART_BaudRate = btl;
    % Y9 Q6 z" X  \9 S! ?" K. h8 [: d
  24.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    " U- _. {- X6 `1 _9 F" s+ ?2 x
  25.         USART_InitStruct.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;//收发模式
    3 E$ a% ^1 S; ^/ f- m! e. u
  26.         USART_InitStruct.USART_Parity = USART_Parity_No;0 a' ?+ f4 v# v+ O. F
  27.         USART_InitStruct.USART_StopBits = USART_StopBits_1;
      ~" G$ {! Q8 N" W& G( X+ }' Z; l
  28.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    3 L  G6 _0 r3 N6 c/ A8 d
  29.         USART_Init( USART1, &USART_InitStruct );
    6 }0 h* M7 o" [4 U: Q2 R( f
  30.         " _2 X( n( V6 h8 R
  31.         /* 中断配置 */
    ( V+ I2 w1 Y# V; M* m5 p! |4 @& q; l
  32.         NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
    4 C7 Q# w5 i, ]
  33.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=3 ;
    8 t* X: }+ A: r& n* |  t
  34.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 3;               
    + R8 A+ `3 q) h
  35.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;                        ( ^+ j+ `3 G9 Z& c3 S, v
  36.         NVIC_Init(&NVIC_InitStruct);       
    ) \% n9 L$ o& d3 D' h+ |# z8 Z
  37.         USART_ITConfig( USART1, USART_IT_RXNE, ENABLE );//接收寄存器非空触发中断+ V# G9 M2 Y" U- Y9 S1 o% O  c8 U
  38.        
    7 r7 N' Z# r" S, ]$ U5 @
  39.         /* 使能串口 */
    6 F) {2 a/ [9 E- y7 g" _! N
  40.         USART_Cmd( USART1, ENABLE );: ]. [1 u- V& _
  41.        
    ( \+ ^: x* k' }8 F
  42. }
    5 B; s- ^4 {8 b+ k9 P0 C5 z

  43. 5 I$ W9 E9 ~: d+ ~' b, ^1 ]- o

  44. 2 a9 Y# _4 s$ y) H% m# W0 u
  45. volatile uint8_t n=0;) {8 ~8 Z4 `) |) a& q) R  J% a
  46. //接收缓冲区
    # E) e3 @% F( o1 a. y) V# `7 d
  47. uint8_t USART1_Rx_Buf[100];
    + e$ @% l2 _1 |6 _; U" \
  48. void USART1_IRQHandler( void )
    " J6 n/ q* y; Q& u: K
  49. {. }; m4 @8 m# T# b+ G* C* [
  50.         if( USART_GetITStatus( USART1, USART_IT_RXNE )==SET )7 B- ?, W3 r7 t
  51.         {+ Y* q, a& l6 p0 k5 B
  52.                         USART1_Rx_Buf[n]=USART_ReceiveData( USART1 );; V# U, r0 R! w
  53.                         n++;9 L0 Z" x+ ]+ O' _. _& P2 T
  54.         }        : j$ U) p* J4 ?
  55.         USART_ClearFlag( USART1, USART_IT_RXNE );
    # [( p$ m/ {: e/ T$ y& a
  56. }0 c$ V( `, C5 m5 G  F
复制代码

$ ^* A2 F7 o% o! E" t! W, c每从上位机中接收一字节的数据,都将数据存储在串口的接收缓冲区USART1_Rx_Buf[100]中。' _) Z! d" ?0 ^% k8 }! h- y& ~: j# O

2 @: i9 i$ y8 {; B3 Y
/ u* z1 S, O* h! R* T0 w
三.作为驱动接口5 y" o* F1 T  `. |/ \+ n, G
一些模块的驱动接口就是串口,这个时候就需要单片机从模块中读取指定格式的数据,比如GPS模块,将定位信息从串口发出,单片机解析串口数据,显示在上位机中。
3 X: d4 X" z' ousart3用来与GPS模块通信,从GPS模块接收数据,认为10ms内的数据属于一次数据,所以就需要定时器来控制时间。7 c2 d/ K( r# c8 k" b& g
usart3:% J) \/ ]) v; a' q& _
  1. //串口1中断服务程序2 M) w7 O% O; F$ k# y  d+ @' R4 h
  2. //注意,读取USARTx->SR能避免莫名其妙的错误           ( Y% x, {! o4 |! R
  3. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
    6 v1 D: F" |. ^+ K7 [" L
  4. //接收状态
    3 M' {, ?" w: u7 g, u% l4 {8 z' ^
  5. //bit15,        接收完成标志
    : I6 F# N4 v. k( w/ T0 R6 F+ f. c, W( ~
  6. //bit14,        接收到0x0d# ?/ w1 ?& v/ B! j( c& Z% d
  7. //bit13~0,        接收到的有效字节数目
    ( R. D2 p" ], V/ {8 o, t& \& z9 ?
  8. u16 USART_RX_STA=0;       //接收状态标记          1 t7 e" q# x$ W
  9.   
    0 Z7 D& Z0 n2 @! r3 z' U4 d+ ]
  10. void uart_init(u32 bound){
    1 Z% |. b" w* ]5 |
  11.   //GPIO端口设置
    # P+ _9 S  g  |; |  i* F  E) L
  12.   GPIO_InitTypeDef GPIO_InitStructure;
    5 ^1 \% E4 K$ ?, N1 i
  13.         USART_InitTypeDef USART_InitStructure;
    " B, h! j' N3 _6 P2 u0 U' |) m# \
  14.         NVIC_InitTypeDef NVIC_InitStructure;
    : I+ E5 t, Q# {
  15.         * m2 h. p0 y/ J; g3 b+ a4 u' G
  16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1,GPIOA时钟$ q: b# [. f' g& ^8 s) m; h$ L
  17.   # c5 }: v: O" D1 i( X0 s% }: K+ f
  18.         //USART1_TX   GPIOA.9
    & N) x! o4 y4 f' Q4 x
  19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    / l, @( T1 O$ w' z" O, |
  20.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    7 h' m) w. v! F- Q2 H  y
  21.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    3 X" z1 ]3 @  ]
  22.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9+ `- B8 x) Z4 l
  23.    3 }0 M4 @$ L' \3 Q* p
  24.   //USART1_RX          GPIOA.10初始化% ^; L0 }- X1 L8 g
  25.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    4 q4 s3 i9 B- x& O! v; Y: m
  26.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入$ E# |. E& I, r( v& g# z9 t( C5 @
  27.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  ! ^. `( w+ k  J" ?7 |
  28. ( P, |+ B# B' a! M" ?
  29.   //Usart1 NVIC 配置
    ) c+ r+ P1 U& k2 X
  30.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;2 l- u. j3 w* a
  31.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级35 A9 l7 g" ~: b: O3 y( `% t
  32.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    + D. ]" {% Z! q! I6 ~8 K6 @
  33.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    2 [$ a5 [' E7 r, H1 C0 y$ G6 p
  34.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器/ y5 m# {6 I: H: T# @1 M  x# A# b
  35.   
    ) M  t  `: \, M( C3 z
  36.    //USART 初始化设置
    . w7 v' k' l: U' B/ M$ q/ Z8 \* V
  37. . H4 E; v4 h6 x
  38.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
      F3 c9 u" }7 I4 G$ y+ @
  39.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
      y6 q9 S5 o; M# d+ E
  40.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位+ k/ Z) q$ r! G! x. L7 Q
  41.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位6 ~2 O7 O" k4 D
  42.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制% a' B2 _# H6 U" a7 b
  43.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    6 s7 @! S/ L# S
  44. 4 ^" {  P3 H0 g
  45.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    4 S! D2 G7 a) C
  46.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断# j  _3 d& ]( X- A3 A" S
  47.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    " k7 j* ~/ ^* s1 u: \$ i
  48. ; l& r- M# v1 @# a4 W: U0 T* E
  49. }
    8 m. R. h7 c+ ^" D7 s: \) |- L( s9 R
  50. - A2 j: \% i6 I! M0 C" G
  51. void USART1_IRQHandler(void)                        //串口1中断服务程序7 c  t) d# b& ?; G
  52.         {- V* D9 g3 m5 G/ ^9 m" p
  53.         u8 Res;$ ]( A0 D5 @! j5 U. p2 C
  54. 8 X7 h' x7 w- ]. m6 w1 U
  55.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    ( E1 K1 V8 p% b: B- N, k
  56.                 {
    5 ~2 m+ M# m$ }& y
  57.                 Res =USART_ReceiveData(USART1);        //读取接收到的数据$ t2 M% m: W7 u& S/ w; k2 @
  58.                
    4 H* e' j& C5 ~" S6 I9 M: S
  59.                 if((USART_RX_STA&0x8000)==0)//接收未完成- Z. k* o* K$ J  b+ p
  60.                         {# G, c$ B7 V, p. C
  61.                         if(USART_RX_STA&0x4000)//接收到了0x0d
    % B0 v4 A4 b  c5 }/ X6 S) P
  62.                                 {
    $ l) Q% v* I9 M6 H, b
  63.                                 if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
    & Y5 A6 C. N7 U+ `2 s! q, g8 a( L
  64.                                 else USART_RX_STA|=0x8000;        //接收完成了 $ f! I7 ]" q% j6 e( `4 }1 q  J
  65.                                 }
    % z3 N" R; D/ c
  66.                         else //还没收到0X0D1 e2 _6 q6 j- r
  67.                                 {        7 ~: F4 U( }+ g4 V/ r
  68.                                 if(Res==0x0d)USART_RX_STA|=0x4000;
    4 O* |# J$ K: }- F9 d7 X' u
  69.                                 else
    4 r* ]+ [' M2 I% f% k6 m( _' f  k1 [
  70.                                         {
    - F$ l7 J, n6 a( R
  71.                                         USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;. R) ]- Z7 [; z3 a& Q: [
  72.                                         USART_RX_STA++;+ s: m. C- b" i) u
  73.                                         if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收          9 k8 A2 v! z$ E- R
  74.                                         }                 
    $ j6 r6 v9 u7 H, S# A7 C, _, [
  75.                                 }2 @8 h" S3 \% q+ C4 G. i& }, z
  76.                         }                    / A! g8 [6 C) h- }0 t2 S$ E
  77.      }
    5 j! a1 w9 c* \  P! n
  78. }
    4 T% c) E3 G3 @+ b

  79. 4 w. D9 k- O* ^- b
复制代码
; `! e* p; k9 L  ^( n  W$ R; F6 W
time7:
6 ]: i2 {$ @+ K- ^- g
  1. : h; [0 r" @- A6 z
  2. extern vu16 USART3_RX_STA;# `% G) s2 Y* J$ R5 t  j+ a
  3. ( X3 G# C' e9 q; q: T
  4. //定时器7中断服务程序                    
    , I5 \$ J6 z  x6 s( p
  5. void TIM7_IRQHandler(void)
    ; H! x: V) }# ~/ a- ?/ ^
  6. {         # t5 G/ H, X  i/ |+ {- i. J/ c( S$ @
  7.         if (TIM_GetITStatus(TIM7, TIM_IT_Update) != RESET)//是更新中断; ^0 e3 \  m! X* `
  8.         {                                   
    , `! a# D- E! F' c2 Q
  9.                 USART3_RX_STA|=1<<15;        //标记接收完成
    - T# J! h% j; @2 x1 h
  10.                 TIM_ClearITPendingBit(TIM7, TIM_IT_Update  );  //清除TIM7更新中断标志   
    . s! }; Z% j7 ~4 d9 o  u9 Y
  11.                 TIM_Cmd(TIM7, DISABLE);  //关闭TIM7
    % i( G/ ?6 F  @( R; ^
  12.         }            
      E% S- ]4 F2 I% [8 w' t; f
  13. }
    7 I1 h. e. u3 q' d/ M( }0 D! [0 M$ l

  14. # {( z2 J$ K; U: g8 o- i. I
  15. //通用定时器7中断初始化: S0 {' g7 z4 T8 W0 B
  16. //这里时钟选择为APB1的2倍,而APB1为42M) i" y$ ^4 H: Z0 U$ I# C% B9 W! ^" X
  17. //arr:自动重装值。
    7 B* [; J, q' g: v5 m+ ?
  18. //psc:时钟预分频数
    2 z% A1 \: a* V$ {! T
  19. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    1 D  W# Y5 g- r: ?3 Z
  20. //Ft=定时器工作频率,单位:Mhz
    $ e! Y" }+ @! X6 F
  21. //通用定时器中断初始化$ F+ v$ w0 q' w* i- @1 v1 B
  22. //这里始终选择为APB1的2倍,而APB1为36M4 m' I$ u+ C. ]) ~
  23. //arr:自动重装值。
    ' b8 h# P+ ]+ S
  24. //psc:时钟预分频数                 7 ?- ?4 i* |/ s  q" _
  25. void TIM7_Int_Init(u16 arr,u16 psc)
    6 Q8 s4 o1 D4 M4 l0 y$ G# z
  26. {        & d! c. }: l0 ]/ K# x, `
  27.         NVIC_InitTypeDef NVIC_InitStructure;
    ; u! H0 k0 G: d/ n, I' V
  28.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    0 Y' `0 T" U1 Q3 w7 H. \8 K, ^) n

  29. # C# G0 |5 f2 O/ X) E1 J0 |
  30.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE);//TIM7时钟使能   
    3 a2 @4 I" ~6 i
  31.        
    3 Q: D4 ~4 S( `* h) Z5 V# u
  32.         //定时器TIM7初始化. b6 X* Z. E. D
  33.         TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值       
    % t. y# I/ r; p/ O. Y1 ?2 ~& g% Y
  34.         TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值: X4 _+ j$ X3 Y& ^0 z
  35.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim) K" G) V6 f$ C5 d% ?. k
  36.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式) p1 K- k: r/ P& L& V# W; y
  37.         TIM_TimeBaseInit(TIM7, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx的时间基数单位/ e! A5 N6 M& G  z  X% l& }
  38. % v6 @( e, ^( u
  39.         TIM_ITConfig(TIM7,TIM_IT_Update,ENABLE ); //使能指定的TIM7中断,允许更新中断
    ; l0 X* Z0 V, M* z2 j6 I
  40.         , Q3 i$ u2 R9 d2 r" W9 F( Z' O
  41.         TIM_Cmd(TIM7,ENABLE);//开启定时器7/ s# A$ F9 U2 Y5 h9 v6 Q
  42.        
    ( b* d& ?# q# ?9 b
  43.         NVIC_InitStructure.NVIC_IRQChannel = TIM7_IRQn;
    7 _# d- Q* s% J* ~  g6 V4 B
  44.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级0
    ! l. |2 G1 t. G& E$ {4 j) g
  45.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                //子优先级2
    3 }* r4 k- M5 A
  46.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    , l. _6 R: @/ C9 }4 b: X
  47.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    1 Q$ R7 k) Z+ U. _
  48.        
      s' E) Z& B4 T" p* `. ~. G7 u
  49. }  i! u' i, q  ~, v
  50.          % u2 `# l  z( [  r8 A% h# O
复制代码
! l0 Z& ~9 y) v8 ~) n/ B  t: p
四.结合DMA接收数据帧
) `# g% F/ H$ a( [) s2 c当单片机从串口上接收数据时,一般我们都是接收一个字节数据,进入一次中断,在中断中处理数据或者做标记,这种方法虽然简单,但是对于大量数据的情况,频繁地进入中断处理数据就占有了CPU的宝贵资源。
$ X5 ]/ |; ^. C这个时候我们可以使用DMA来接收数据,DMA接收数据的好处就是省CPU资源,DMA仅仅在初始化的时候占用一下CPU资源,其他操作都是在DMA的控制器来完成的。. F' v1 {: S: K4 Y( R- X
$ @+ R7 r. x3 x4 P( i
使用背景:单片机从USART2中接收传感器传回的数据帧(12字节),传感器每秒上报一次数据,要求单片机可以收到完整数据并且可以对数据进行处理。/ t0 ^- o4 d1 C
3 o8 j2 O; b5 H9 ]* G
程序框架:以往串口接收数据都是判断数据寄存器非空的,一字节一字节地接收,现在使用DMA,使每一次数据寄存器的值都自动传给内存指定地址(也就是指定的数据缓冲区),当串口接收完一帧数据后,会触发空闲中断,这意味着一帧数据的接收完成,我们只需要在数据缓冲区中对数据进行处理即可。
; J% g6 }! P/ K+ _/ g5 N! f
0 @, b4 C1 e6 J5 u* D5 q& J) k/ [代码:8 O1 J7 g8 R$ C% a( a6 ]- w

  1. : }1 f9 @9 c4 p4 t5 ?6 @1 Y
  2. uint8_t USART2_Rx_Buf[12];
    - s6 w& J' ^( {% _8 Q
  3. / B2 Q  m" s  ?
  4. void USART2_Config( void )* r9 l' f/ P! \1 i3 Y/ Z- k# D
  5. {
      f9 H  C! x8 d1 j. z! ?
  6.         /* 声明各结构体 */$ ^8 a1 |9 c0 W$ e' d2 M' H; ]8 c. t& _
  7.         GPIO_InitTypeDef GPIO_InitStruct;+ \2 v& O! e; J+ t, }
  8.         USART_InitTypeDef USART_InitStruct;
    ; ^5 o4 |" R/ u
  9.         NVIC_InitTypeDef NVIC_InitStruct;8 v* |: l+ P6 R' m3 u7 N' K# Y8 Z' p
  10.         DMA_InitTypeDef DMA_InitStruct;
    ( g. h* T% g3 P* X7 G4 P- h
  11.        
    7 {0 D5 ]$ G' ^) I) [0 I
  12.         /* 打开时钟 */
    # q; ~! K2 u( D9 q5 z. ~* F- E
  13.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );6 N* ~- ~$ Z% d( W# h2 p0 Y' e
  14.         RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );8 v! y9 C' b$ s0 c# W
  15.         RCC_AHBPeriphClockCmd( RCC_AHBPeriph_DMA1, ENABLE );
    / p" ]) M' F: j
  16.         % d7 F' o! j" G+ B- [
  17.         /* GPIO配置 */1 _" q3 c: L& {8 r  B. @7 r. M
  18.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    9 c& E% b4 N6 G( O& L
  19.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2;                 //USART2_Tx:PA2
    % `& g$ [8 _& f% z# w3 c" m
  20.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    / J# C7 H5 c. [% `# G
  21.         GPIO_Init( GPIOA, &GPIO_InitStruct );7 g8 L$ j& l. Z! M2 S! c2 n) q# Z
  22.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;. i$ I; e4 @) L1 {7 s
  23.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3;                //USART2_Rx:PA3
    : Y6 o  G# c# |0 n9 E! `% S. v
  24.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    0 n5 ?2 U9 e  N; B  I  b6 m
  25.        
    6 q" n2 C* d3 ~0 y- |7 k% b* H
  26.         /* 串口配置 */
    ( `2 t! K9 Y' g/ A
  27.         USART_DeInit( USART2 );5 X- b$ U% b. R0 l# }6 i
  28.         USART_InitStruct.USART_BaudRate = 9600;                //波特率:9600
    ! Z3 {- l! J! a  B+ f
  29.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    ' S+ S; D* v6 h' t
  30.         USART_InitStruct.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;
    0 j% C) E% W0 @3 K5 m( ^. ^
  31.         USART_InitStruct.USART_Parity = USART_Parity_No;
    ; f% R9 a* Y' l% @3 e$ }
  32.         USART_InitStruct.USART_StopBits = USART_StopBits_1;
    * Y# ^- ^3 E: q
  33.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;! k5 T- g: _- O  |7 S
  34.         USART_Init( USART2, &USART_InitStruct);
    , R% t/ E! o4 ]" r
  35.         3 E  N; Z3 g" R6 @
  36.         /* 中断配置 */
    " d/ j  _) N. d! e6 I9 m7 j" t
  37.         NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );. |8 w) E$ z/ H$ W! Z- K5 {' e
  38.         NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn;
    + G# B. H, F0 Z  m
  39.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    ' ~$ c& k# y, g1 T
  40.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    $ Q/ ^5 O) q1 r" ]
  41.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;9 X2 e+ x( p9 I$ ~' O* N
  42.         NVIC_Init( &NVIC_InitStruct );6 \, Q: d4 ]: p! R0 c' `4 C
  43.         USART_ITConfig( USART2, USART_IT_IDLE, ENABLE );      //空闲中断
    ( o5 |4 Z6 T& o& X0 E: e
  44.         USART_DMACmd( USART2, USART_DMAReq_Rx, ENABLE );   //开启DMA接收
    ' E! g9 S# \$ t9 D
  45.        
    / D3 y7 R1 r( X& W
  46.         8 V% @( o2 P. D5 U: P) g
  47.         /* 配置DMA传输数据 USART2对应DMA1的通道6 方向:外设到存储器*/        8 ^, [) O" l% a( N, A# J
  48.     DMA_InitStruct.DMA_PeripheralBaseAddr = USART2_BASE+0x04;              // 设置DMA源地址:串口数据寄存器地址*/       
    ! B; h$ ?( k( w4 w
  49.         DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)USART2_Rx_Buf;           // 内存地址(要传输的变量的指针)       
    1 z" r1 B) }; P& d
  50.         DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;                        // 方向:从外设到内存               
      C# d6 J/ C3 `; q) z0 i
  51.         DMA_InitStruct.DMA_BufferSize = 12;                                    // 传输大小        一帧数据12字节                            3 {$ i7 h# r# J5 j; O" N" h, c
  52.         DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;          // 外设地址不增                / }* N8 d* L& J( w" X
  53.         DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;                                    // 内存地址自增               
    9 ^/ w+ P. y  p# u% H
  54.         DMA_InitStruct.DMA_PeripheralDataSize =         DMA_PeripheralDataSize_Byte; // 外设数据单位                ' A7 z5 V& x# T
  55.         DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;           // 内存数据单位         - `& E0 R' [, R! q
  56.         DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;                               //正常 DMA模式,一次或者循环模式, `( V, \3 ?* O# b1 E
  57.         DMA_InitStruct.DMA_Priority = DMA_Priority_Medium;                     // 优先级:中
    # o9 u7 e* y% N
  58.         DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;                              // 禁止内存到内存的传输
    7 X/ y+ f( ~4 ?0 S* V. w
  59.         DMA_Init( DMA1_Channel6, &DMA_InitStruct );
    ! g6 W$ }; G: y& L2 g
  60.         DMA_ClearFlag(DMA1_FLAG_TC5);9 i9 L) U7 p6 S8 e2 G' }5 c& T8 c
  61.         DMA_Cmd( DMA1_Channel6, ENABLE );//使能DMA$ f) J: l) h1 X; j1 u( ^: d
  62.        
    - L( a5 K) Z  y5 f
  63.           I$ j. Z1 Y( T: w$ G( k) {
  64.         /* 使能串口 容易忽略 */8 H$ C2 l* F3 ]
  65.         USART_Cmd( USART2, ENABLE);0 b& W. A* j# [" }; k# o* O* t
  66.         1 Y; X$ N7 {, D
  67. }* w0 {# P& ^9 T4 v

  68. 0 d5 N( ^! F3 U' t  u

  69. * y6 m6 p1 `9 d* f7 ?

  70. ; U0 l( T3 z$ ?5 v
  71. /* 串口空闲中断服务函数 */
    : s0 M0 F( D" v# R
  72. void USART2_IRQHandler( void )
    / P6 t; u7 M+ u1 J" j% H
  73. {
    ! W3 Z8 X5 T( A0 v/ t
  74.         if( USART_GetITStatus( USART2, USART_IT_IDLE ) != RESET )
    * d  K* c/ g7 I. _! e
  75.         {
    1 Y* n" o6 Y  [/ ?  c
  76.                 USART_ReceiveData( USART2 );//象征性接收数据
    4 o) r0 w( s7 v
  77.                 USART_ClearITPendingBit( USART2, USART_IT_IDLE );//清除标志位' _" \5 q$ \7 c. `7 @
  78.                
    # |+ |: C4 A+ i7 U+ H
  79.         }
    2 [5 W4 a! H9 i; @, ^5 N6 G
  80. }
    & B5 B3 J/ A% |$ |; L
  81. //也可以在中断服务函数中扩展更多的功能
    & h# Y2 i  q: w) m
复制代码

" D  n  S/ c8 k/ q1 j4 |0 Q要点:. B/ B/ L$ @# w
要开启串口的空闲中断
" F& H: X7 g* I+ r5 v& ?串口的空闲中断中要象征性读取数据和清除标志位
6 r7 u$ M2 ]; B/ i1 K$ l要开启串口的DMA接收请求' e1 |- P" Q: u
————————————————1 {' V  F4 P: x2 @; E+ r' S% k
版权声明:Aspirant-GQ
& |+ g1 }. F8 s% S$ v  a* w如有侵权请联系删除) @4 E/ u4 Z2 D+ t$ d
4 x6 ]  [4 O, X- y
$ k* ?% _6 U! j0 z9 z6 s

% |2 O5 e- H5 `' @- p1 p: y
赞 收藏 评论0 发布时间:2023-3-18 12:11

举报

0个回答

所属标签

相似技术帖

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版