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

【经验分享】STM32串口中断的一些资料

[复制链接]
STMCU小助手 发布时间:2022-1-23 22:20
在研究STM32串口接收发送中断的时候找到不少不错的资料,现在备份在这里。以供自己查阅,以及方便其他人。
TC ====TXE
顺便预告下最近会写个有关串口处理数据的帖子,从查询和中断方面以及数据处理的方式,从队列以及FIFO方面写起。

2 T* R7 Q3 m% I; E+ g( C
SECTION 1
  1. /*
    , v- v1 V& R0 R- }+ [
  2. 调试STM32串口过程中发现一个奇怪的问题,初始化串口1口,使能串口发送完成中断后,立刻就进入了发送完成中断。( _* g$ ^/ P, S9 G8 @3 i
  3. 仔细的查阅了STM32手册中的串口部分的介绍:" T4 a/ \4 i. a% |' z4 ?
  4.          
    , A& z4 O+ b  t7 [( u
  5. 以下是字符发送的配置过程,注意第6点,在设置USART_CR1中的TE位时,会发送一个空闲帧作为第一次数据发送,所以即便你执行了USART_ClearFlag(USART1, USART_FLAG_TC); (这个函数肯定在空闲帧数据发送完成前执行),所以当空闲帧发送完后,就进入发送完成中断。
      z2 K" y( q7 p( M
  6.          
    ! _2 F0 y  _+ u8 H& Z
  7. 配置步骤:
    ; e8 x! W; H/ N: U+ ^
  8. 1.  通过在USART_CR1寄存器上置位UE位来激活USART
    & h/ p/ M6 K0 I. c! a% c4 u
  9. 2.  编程USART_CR1的M位来定义字长。
    0 i! O6 W! `4 m; H9 g
  10. 3.  在USART_CR2中编程停止位的位数。
    + }1 E" L) _- V6 m) w  n) F$ T7 g3 q
  11. 4.  如果采用多缓冲器通信,配置USART_CR3中的DMA使能位(DMAT)。按多缓冲器通信中+ _+ V: m* V8 g$ o9 r; k; T* _" t; F3 x+ {
  12. 的描述配置DMA寄存器。
      j1 E' }, \0 {4 ^
  13. 5.  利用USART_BRR寄存器选择要求的波特率。
    . \" _7 J# _- z/ [: F) v; y' l
  14. 6.  设置USART_CR1中的TE位,发送一个空闲帧作为第一次数据发送。
    $ H2 ]- Z# c& v) o
  15. 7.  把要发送的数据写进USART_DR寄存器(此动作清除TXE位)。在只有一个缓冲器的情况, G4 t) M6 ?6 M; f; i3 }5 v/ Q7 F
  16. 下,对每个待发送的数据重复步骤7。2 {& o- A) i* Q& N
  17. 8.  在USART_DR寄存器中写入最后一个数据字后,要等待TC=1,它表示最后一个数据帧的
    6 j* P7 ^, j, N3 T
  18. 传输结束。当需要关闭USART或需要进入停机模式之前,需要确认传输结束,避免破坏
    0 m7 {4 E5 {' X$ d' {
  19. 最后一次传输。
    1 [0 z/ c% U2 Y- [% f
  20. */
    ( x2 b' j7 n" W4 {1 F: D+ ~
  21. //解决的办法:
    $ [, ]/ o: ^7 I' }  |: b% M
  22. //方法一
    0 W  b  K, t! }7 c+ P2 g- e
  23. //在执行
    , o8 T8 R2 t! H. b0 \
  24. USART_ITConfig(USART1, USART_IT_TC, ENABLE);
    7 i) |3 [" v, @4 m! A
  25. //之前,先延时一段时间,基本上比一个字符发送的时间长一点就可以了,然后再执行
    4 |2 o' w  b6 B# d! P
  26. USART_ClearFlag(USART1, USART_FLAG_TC);
    ' G- w+ a/ c  _* Z! z- |
  27.           + ^8 D# S7 C; B! O8 q. @* N0 a
  28. //方法二:
    % B- N3 L2 |. o/ y6 v3 V7 o
  29. //在执行4 d" Q  u# Y. @" i: _# f5 s5 \
  30. USART_ITConfig(USART1, USART_IT_TC, ENABLE);3 E9 p) g8 S" e9 Y
  31. while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET)
    $ g4 l$ }, E, E4 f% u. e+ ~  I8 D
  32. {
    ! r' {5 W* O4 w& C$ q: P4 ]  d
  33.         ; //等待空闲帧发送完成后  再清零发送标志
    7 }) \1 n, E% \5 D! |; l
  34. }" f% h8 D* c+ M
  35. USART_ClearFlag(USART1,USART_FLAG_TC);
复制代码
1 v& h9 Q8 P7 ]* R

; L& p3 I; u1 X! k2 F$ {* {( T* Q
SECTION 2

; `( y( `% k0 S2 a
先说TC。即Transmission Complete。发送一个字节后才进入中断,这里称为“发送后中断”。和原来8051的TI方式一样,都是发送后才进中断,需要在发送函数中先发送一个字节触发中断。发送函数如下2 d( z; |9 _3 \
+ b2 k4 i; }; P' j1 O& J, }* U$ z
  1. /*******
    % w  c* A% ]+ Z4 @' p+ @3 _
  2. 功能:中断方式发送字符串.采用判断TC的方式.即 判断 发送后中断 位.
    # U: |! T0 ~/ p, g1 g: v9 R5 d$ i# `
  3. 输入:字符串的首地址
    , a5 G; y7 j1 X: L3 e6 @0 s: p
  4. 输出:无) w, m) S. C: k4 m" T/ q- M  H0 H
  5. *******/
    6 y) h# l; r+ d' d  p1 L1 d
  6. void USART_SendDataString( u8 *pData )& p9 N- k4 U, E7 B, o& G
  7. {6 s% n5 k, }2 N5 F  l4 k3 `
  8.     pDataByte = pData;2 [. j) I8 G+ F0 s5 Y; D% z% M8 N& T
  9.   
    3 D* j+ ?* A0 ~: w$ ?
  10.     USART_ClearFlag(USART1, USART_FLAG_TC);//清除传输完成标志位,否则可能会丢失第1个字节的数据.网友提供., g) d3 r) X6 `* b5 H
  11.    
    7 N. d+ C5 t7 p  W" V9 W0 C7 G, ^
  12.     USART_SendData(USART1, *(pDataByte++) ); //必须要++,不然会把第一个字符t发送两次
    4 k/ b6 q4 [8 `
  13. }
复制代码

* h- c; U  W7 r' z4 G中断处理函数如下0 B9 b. }% H* x2 K/ t+ ]( S
  1. /********% ~6 D: I* z) {; w6 b2 x) i0 r
  2. * Function Name  : USART1_IRQHandler8 @3 K- H3 n2 j& Y8 E& Q
  3. * Description    : This function handles USART1 global interrupt request.9 C# z& U. o- p  c' A* `* n. D
  4. * Input          : None  d" j/ G9 e0 F. I5 y) _2 D
  5. * Output         : None7 H, W6 J( f: n! _! c
  6. * Return         : None
    4 m( M' ]( z9 M( s! [- E, r
  7. *********/. ]3 J3 Q6 }: i; q
  8. void USART1_IRQHandler(void)
      B4 d3 W; \8 N3 _5 S9 T' p
  9. {5 `* x$ L/ @  Y( g. i
  10.     if( USART_GetITStatus(USART1, USART_IT_TC) == SET  )6 |) {# P: i8 Q5 ~% E! }" d
  11.     {
    - j4 U; O/ [/ O: P6 n* l
  12.         if( *pDataByte == '\0' )//TC需要 读SR+写DR 方可清0,当发送到最后,到'\0'的时候用个if判断关掉# Z+ h: P0 a' z# A+ J
  13.             USART_ClearFlag(USART1, USART_FLAG_TC);//不然TC一直是set, TCIE也是打开的,导致会不停进入中断. clear掉即可,不用关掉TCIE
      [- v1 I6 V: T# |0 s
  14.         else( l$ R& {4 _% }1 b7 t2 B# y
  15.             USART_SendData(USART1, *pDataByte++ );/ O+ F# L) N( f( @; ^% ]. u2 M9 v/ t
  16.     }/ v$ U! e) d. l9 c$ {3 i
  17.   J, }; w# {7 H( T' F
  18. }
复制代码
% E% ~8 C; f  P, M! [4 L# _4 C2 W& ?
其中u8 *pDataByte;是一个外部指针变量. L) v& g6 o5 \% c4 Y8 k  p

$ v* x0 L. g6 Y, e. S" C在中断处理程序中,发送完该字符串后,不用关闭TC的中断使能TCIE,只需要清掉标志位TC;这样就能避免TC == SET 导致反复进入中断了。
9 A8 `# T* H2 ]. }
串口初始化函数如下, Q; T" e. ]% x
7 j6 _+ W8 _1 j+ F6 F: ?& O
  1. /*********
    1 c" X  Q6 X) z1 M+ F
  2. 名称:  USART_Config' w1 N% Y4 Q" [: ^
  3. 功能:  设置串口参数8 j! X5 h: q3 }4 _& F$ g
  4. 输入:  无
    , w% V0 ~* _6 Q! m& Z. _
  5. 输出:  无
    ) {. L; I, \& W# v
  6. 返回:  无/ B7 E' j' i5 C6 I/ {/ B& `- |
  7. **********/% _( v4 Y+ h- C4 |$ Q
  8. void USART_Config()4 Y6 w9 A0 n1 L4 ~5 l, m
  9. {
    2 W- r; w6 M& H
  10.   USART_InitTypeDef USART_InitStructure;//定义一个包含串口参数的结构体
    # _; r' m  ]: A7 N
  11.   
    ' @5 o; A: K6 E: ]! f/ T
  12.   USART_InitStructure.USART_BaudRate = 9600; //波特率9600
    , o) j4 O% e; t- q# ?
  13.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据位. P. F1 c6 z% i6 F' m: k- A2 P
  14.   USART_InitStructure.USART_StopBits = USART_StopBits_1;//1位停止位
    ( M( i1 K% a4 z; q$ z" A
  15.   USART_InitStructure.USART_Parity = USART_Parity_No;//无校验5 v, _7 o1 V' N+ r
  16.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件流控制* g1 C* u% H* v# ?, E6 b
  17.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//输入加输出模式+ w- n# E2 ]6 q6 ~$ y' f
  18.   USART_InitStructure.USART_Clock = USART_Clock_Disable;//时钟关闭
    * a- m+ c! I' Q8 r0 Z& f9 w+ [
  19.   USART_InitStructure.USART_CPOL = USART_CPOL_Low;$ K7 `, t. r  E7 L+ q% @, i2 A- {
  20.   USART_InitStructure.USART_CPHA = USART_CPHA_2Edge;, [& z- x0 {1 Q; A. a/ D
  21.   USART_InitStructure.USART_LastBit = USART_LastBit_Disable;
    $ u+ y# K' \* a" D! I; T) X
  22.   USART_Init(USART1, &USART_InitStructure);//设置到USART1
      l8 f1 t2 ~, b8 w! e1 O6 S2 |+ Y7 L
  23.   9 X! C7 b1 x4 f8 d
  24.   USART_ITConfig(USART1, USART_IT_TC, ENABLE);//Tramsimssion Complete后,才产生中断. 开TC中断必须放在这里,否则还是会丢失第一字节
    - b4 D2 m, o9 M3 k* ?3 i1 Q: }

  25. % Y6 N2 c% m, n5 P( c: m( x" a" Q. l
  26.   USART_Cmd(USART1, ENABLE); //使能USART1
    4 k/ B) k$ B2 R4 W1 [$ D0 A
  27. }
复制代码

9 D  r( Q& [5 M9 z" }这里请问一个问题:开TC中断USART_ITConfig()如果放在我的USART_SendDataString()中再开,会丢失字符串的第一字节。必须放在串口初始化函数中才不会丢。不知道为什么??
: q7 O- {! Y% d1 c! F
这里笔者可以给出解释,你看下SECTION1 就可以知道为什么呢,你这样做的原理和SECTION1讲解的差不多,就相当于延时,而你后面没有丢失数据的主要原因就是你代码中有这么一句 USART_ClearFlag(USART1, USART_FLAG_TC);//清除传输完成标志位,否则可能会丢失第1个字节的数据.网友提供.
5 A; x- b: p$ o1 b  j* p+ w
" J4 ?) T8 X0 B4 G+ b, L
再说判断TXE。即Tx DR Empty,发送寄存器空。当使能TXEIE后,只要Tx DR空了,就会产生中断。所以,发送完字符串后必须关掉,否则会导致重复进入中断。这也是和TC不同之处。7 m9 B, D& R; s3 Q: V9 f5 l3 N* a

# [5 g  s6 `% H/ @5 e! C# j0 Q9 z发送函数如下:3 U  I# F; I# U7 E# s. S% o
  1. /*******
    / a6 u' o/ }5 ~$ M$ {  o
  2. 功能:中断方式发送字符串.采用判断TC的方式.即 判断 发送后中断 位.  [& e1 I+ \$ G$ x0 i$ b
  3. 输入:字符串的首地址) r3 V3 J- S8 t- U2 r5 O: w; \/ I7 ]
  4. 输出:无7 Z" W; t+ U. m! R
  5. *******/
    + J1 Y7 P- I; j8 I0 @
  6. void USART_SendDataString( u8 *pData )
    8 w2 x6 I$ U: e. B8 E0 C. B
  7. {- P& k+ Z/ `$ n
  8.     pDataByte = pData;
    ; i* l% l- L$ j1 g
  9.     USART_ITConfig(USART1, USART_IT_TXE, ENABLE);//只要发送寄存器为空,就会一直有中断,因此,要是不发送数据时,把发送中断关闭,只在开始发送时,才打开。 ' x4 m. q2 x' d& n
  10.    
    , a" a+ t9 a: A+ `. n# y
  11. }7 R: Q& q! c' s/ U2 i) v
复制代码

* p& }4 T7 y3 Y( d4 P中断处理函数如下:9 |, T- P8 P+ D( T# |
0 d5 X% a6 B3 ~
  1. /********- f2 i# S7 X( v  G* R3 U
  2. * Function Name  : USART1_IRQHandler
    / ]3 z" Z. ?. I1 ]0 T- a# U5 L- }
  3. * Description    : This function handles USART1 global interrupt request.3 `7 {* a/ d; e
  4. * Input          : None( E, _6 D7 k7 |: b/ F- x
  5. * Output         : None
    / i3 K6 e! \5 Y, m: x# R) \' N3 l
  6. * Return         : None" [& Q6 v, ]' M" R% X8 C
  7. ********/
    ; M) D- s8 Y$ Q. |& r0 T$ a4 a
  8. void USART1_IRQHandler(void)
    % x/ k0 L+ k6 ?" F5 \
  9. {
    / u  |- X. o7 K* ?: _# c
  10.     if( USART_GetITStatus(USART1, USART_IT_TXE) == SET  )+ V8 Z- a+ B7 ^2 t' i+ f/ a- Q
  11.     {- n9 g% L; B& l( [# s+ `" y3 o
  12.         if( *pDataByte == '\0' )//待发送的字节发到末尾NULL了9 N' N8 R. Y! j! g3 m
  13.             USART_ITConfig(USART1, USART_IT_TXE, DISABLE);//因为是 发送寄存器空 的中断,所以发完字符串后必须关掉,否则只要空了,就会进中断
    : l5 j# D3 @4 ~
  14.         else
    + F  {( {# y) {/ f' B# L- y
  15.             USART_SendData(USART1, *pDataByte++ );0 n/ J7 [5 J$ v, g7 ^" J
  16.     }7 b4 u$ E* N  K- b+ ?8 N

  17. $ ^6 Z8 A9 _3 H6 b, q( H! M
  18. }
复制代码

) q% s/ t# _; ^1 n4 e在串口初始化函数中就不用打开TXE的中断了(是在发送函数中打开的)如下:. I3 m% A) U5 v+ K) I+ x. y  `6 ~
  1. /************
    ( a. {1 ^6 ?1 i, A! R
  2. 名称:  USART_Config
    ! C. R& N0 m1 {: A7 O7 F* I
  3. 功能:  设置串口参数# u! ^1 R! X( n  X
  4. 输入:  无9 e& A; U& }0 S, ]8 w0 q2 m( c* W3 c
  5. 输出:  无0 ^' j- U' z7 H8 r
  6. 返回:  无  Y& M" E- T) S* x$ F
  7. ************/
    ( q* P+ C/ }# w8 y3 G; K. {4 ?
  8. void USART_Config()/ m- V: V) U( t6 P- Y( _" T" w
  9. {. \' T# T; e5 X( e2 N
  10.   USART_InitTypeDef USART_InitStructure;//定义一个包含串口参数的结构体
    2 x/ J7 c# Y. P+ G
  11.   
    2 F- z9 K5 I/ P+ S( k; X1 U! m
  12.   USART_InitStructure.USART_BaudRate = 9600; //波特率9600
    3 A7 f3 e% @. @1 t+ Y; J; D1 ^( Y
  13.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据位' V/ v1 D. t2 C5 w2 |4 @2 O: u
  14.   USART_InitStructure.USART_StopBits = USART_StopBits_1;//1位停止位7 k& Z3 S3 u7 U% Q) R% V, b
  15.   USART_InitStructure.USART_Parity = USART_Parity_No;//无校验! f  r# R  {3 w) `
  16.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件流控制$ b: C! |8 W0 g/ R$ U
  17.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//输入加输出模式
    , Y5 P7 R9 {% i0 M- B: y5 s
  18.   USART_InitStructure.USART_Clock = USART_Clock_Disable;//时钟关闭
    # m" c7 U, q, I$ w: B& G8 d( ~
  19.   USART_InitStructure.USART_CPOL = USART_CPOL_Low;" A  V' C) w! l! R
  20.   USART_InitStructure.USART_CPHA = USART_CPHA_2Edge;+ l- L1 Y$ Y6 _
  21.   USART_InitStructure.USART_LastBit = USART_LastBit_Disable;: Q3 G* u" l4 ^3 [9 }
  22. + ?1 U8 K* r6 \" |' u6 T
  23.   USART_Init(USART1, &USART_InitStructure);//设置到USART1% [0 F8 ~% M% q) C. U0 [
  24.   / N7 W2 X+ Q' H
  25.   USART_Cmd(USART1, ENABLE); //使能USART1
    2 Z' u, B0 h+ d. e; v9 Y" }
  26. <div align="left">}</div>
复制代码

9 M1 p8 [! M0 @
SECTION 3
4 f; n  i6 U% \( J* P4 z
3 v' z/ x1 J, z0 W
在USART的发送端有2个寄存器,一个是程序可以看到的USART_DR寄存器(下图中阴影部分的TDR),另一个是程序看不到的移位寄存器(下图中阴影部分Transmit Shift Register)。
0 e* k7 |0 B- ~/ C& b- ?7 R; p  i- a! `2 o( f0 c
对应USART数据发送有两个标志,一个是TXE=发送数据寄存器空,另一个是TC=发送结束;对照下图,当TDR中的数据传送到移位寄存器后,TXE被设置,此时移位寄存器开始向TX信号线按位传输数据,但因为TDR已经变空,程序可以把下一个要发送的字节(操作USART_DR)写入TDR中,而不必等到移位寄存器中所有位发送结束,所有位发送结束时(送出停止位后)硬件会设置TC标志。9 @2 F! b" X4 x" R; e  k- q3 f$ A
/ e7 m" K& R3 P0 f
另一方面,在刚刚初始化好USART还没有发送任何数据时,也会有TXE标志,因为这时发送数据寄存器是空的。
0 @1 U' j$ ~0 W' ]) d7 ?3 g2 y5 L% i  R- @( ]+ }: K
TXEIE和TCIE的意义很简单,TXEIE允许在TXE标志为'1'时产生中断,而TCIE允许在TC标志为'1'时产生中断。
' o3 S+ ~$ D, d, v' E8 v8 S
  A$ V- S1 [% ]+ {! G至于什么时候使用哪个标志,需要根据你的需要自己决定。但我认为TXE允许程序有更充裕的时间填写TDR寄存器,保证发送的数据流不间断。TC可以让程序知道发送结束的确切时间,有利于程序控制外部数据流的时序。

/ S. H+ O' k# c# K' L- R
SECTION 4
        总的来说,STM32单片机的串口还是很好理解的,编程也不算复杂。当然我更愿意希望其中断系统和51单片机一样的简单。
        对于接收终端,就是RXNE了,这只在接收完成后才产生,在执行USART_ITConfig(USART1, USART_IT_RXNE, ENABLE)代码时不会进入ISR。但麻烦的就是发送有关的中断了:TXE或者TC,根据资料和测试的结果,TXE在复位后就是置1的,即在执行USART_ITConfig(USART1, USART_IT_TXE,  ENABLE)后会立即产生中断请求。因此这造成一个麻烦的问题:如果没有真正的发送数据,TXE中断都会发生,而且没有休止,这将占用很大部分的CPU时间,甚至影响其他程序的运行!
        因此建议的是在初始化时不好启用TXE中断,只在要发送数据(尤其是字符串、数组这样的系列数据)时才启用TXE。在发送完成后立即将其关闭,以免引起不必要的麻烦。
        对于发送,需要注意TXE和TC的差别——这里简单描述一下,假设串口数据寄存器是DR、串口移位寄存器是SR以及TXD引脚TXDpin,其关系是DR->SR->TXDpin。当DR中的数据转移到SR中时TXE置1,如果有数据写入DR时就能将TXE置0;如果SR中的数据全部通过TXDpin移出并且没有数据进入DR,则TC置1。并且需要注意TXE只能通过写DR来置0,不能直接将其清零,而TC可以直接将其写1清零。
        对于发送单个字符可以考虑不用中断,直接以查询方式完成。
        对于发送字符串/数组类的数据,唯一要考虑的是只在最后一个字符发送后关闭发送中断,这里可以分为两种情况:对于发送可显示的字符串,其用0x00作为结尾的,因此在ISR中就用0x00作为关闭发送中断(TXE或者TC)的条件;第二种情况就是发送二进制数据,那就是0x00~0xFF中间的任意数据,就不能用0x00来判断结束了,这时必须知道数据的具体长度。
       这里简单分析上面代码的执行过程:TXE中断产生于前一个字符从DR送入SR,执行效果是后一个字符送入DR。对于第一种情况,如果是可显示字符,就执行USART_SendData来写DR(也就清零了TXE),当最后一个可显示的字符从DR送入SR之后,产生的TXE中断发现要送入DR的是字符是0x00——这当然不行——此时就关闭TXE中断,字符串发送过程就算结束了。当然这时不能忽略一个隐含的结果:那就是最后一个可显示字符从DR转入SR后TXE是置1的,但关闭了TXE中断,因此只要下次再开启TXE中断就会立即进入ISR。对于第二种情况,其结果和第一种的相同。
         对于第一种情况,其程序可以这么写:其中TXS是保存了要发送数据的字符串,TxCounter1是索引值:
  1. <div align="left">extern __IO uint8_t TxCounter1;& W  W# D' a4 `6 J2 }
  2. extern uint8_t *TXS;$ o. B: K4 w6 `5 Z& q
  3. extern __IO uint8_t TxLen; </div><div align="left">void USART1_IRQHandler(void)
    ! M- C3 ?7 e' {, K  H% ^% E8 ~
  4.     {- T9 }! N0 ^1 o! B, R8 l4 f
  5.         if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)
    ( }4 b9 ^; I& O' y' Y) \9 i
  6.             {                                               
    , M$ j, ^1 z6 A/ R/ A% B6 f
  7.                 if(TXS[TxCounter1]) //如果是可显示字符. S' X- u% s+ d# x" X9 t
  8.                     { USART_SendData(USART1,TXS[TxCounter1++]);}; n$ H% w% |' ?! E4 W( t
  9.                 else   //发送完成后关闭TXE中断,
    ) S2 @: r; Y6 Y1 l9 l/ F
  10.                     { USART_ITConfig(USART1,USART_IT_TXE,DISABLE);}                                                        
    8 F( V5 ]% c$ N
  11.             }                   . p! a8 m0 k; o: F; z. f
  12.     }</div><div align="left">        对于第二种情况,和上面的大同小异,其中TXLen表示要发送的二进制数据长度:</div><div align="left">void USART1_IRQHandler(void)
    : M1 j  P* c: N3 Z/ [
  13.     {' O$ o! _! |* V. Y
  14.         if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) //对USART_DR的写操作,将该位清零。* i+ p3 ^, e0 K5 [+ D4 q, P; P% ?  N
  15.             {                                             
    $ K" O% M2 K; Y# A$ \3 K; {6 r
  16.                 if(TxCounter1<TxLen)
    ) U% D0 f7 f" P% o; G. E
  17.                     { USART_SendData(USART1,TXS[TxCounter1++]);}$ ~# L, ^3 s( S$ ?2 [! V5 A
  18.                 else   //发送完成后关闭TXE中断  ~* _! C! c& C, k5 Z8 @
  19.                     { USART_ITConfig(USART1,USART_IT_TXE,DISABLE);}                                                         
    9 C( s1 v8 ]8 N7 J  z9 l5 e" a' Z
  20.             }                    ; I* ?, e* M8 m1 [
  21.     }</div>
复制代码
' S+ g, o, W9 X0 B" x; i- G$ J' |
        事实上第一种情况是第二种的特殊形式,就是说可以用第二种情况去发送可显示的字符——当然没人有闲心去数一句话里有多少个字母空格和标点符号!
        在使用时,只要将TXS指向要发送的字符串或者数组,设置TxLen为要发送的数据长度,然后执行USART_ITConfig(USART1, USART_IT_TXE,ENABLE)就立即开始发送过程。用户可以检查TxCounter1来确定发送了多少字节。比如以第二种情况为例:
  1. <div align="left">uint32_t *TXS;- I7 {; P9 E8 v3 F
  2. uint8_t TxBuffer1[]="0123456789ABCDEF";
    ; b9 e& L( o' g9 ^8 ?8 G4 h! l
  3. uint8_t DST2[]="ASDFGHJKL";
    - N# |5 m# U5 x7 E) v* a
  4. __IO uint8_t TxLen = 0x00;</div><div align="left">     TxLen=8;                               //发送8个字符,最终发送的是01234567) d6 w3 L: F3 h' T$ o$ I
  5.     TXS=(uint32_t *)TxBuffer1;   //将TXS指向字符串TxBuffer1: h7 `, U- S, v
  6.     TxCounter1=0;                     //复位索引值
    " I( M4 s' h! Y' G
  7.     USART_ITConfig(USART1, USART_IT_TXE,ENABLE);   //启用TXE中断,即开始发送过程
    5 c- D' E2 w0 j( U* t3 ^( u; D5 _
  8.     while(TxCounter1!=TxLen);   //等待发送完成
    # p" M) I6 a% i0 t5 G

  9. 5 X3 a+ P6 X3 }$ }. v7 S. ?
  10.     TXS=(uint32_t *)TxBuffer2;   //同上,最终发送的是ASDFGHJK) ?, O2 r5 r$ s- w0 ~
  11.     TxCounter1=0;
    ( m- J- G: u, S% ?4 M
  12.     USART_ITConfig(USART1, USART_IT_TXE,ENABLE);
    8 x+ j8 N+ L7 [9 @7 U% X
  13.     while(TxCounter1!=TxLen);</div>
复制代码
9 M3 _! y  k' a+ k* [* U
        以上就是我认为的最佳方案,但串口中断方式数据有多长就中断多少次,我认为还是占用不少CPU时间,相比之下DMA方式就好多了,因为DMA发送字符串时最多中断两次(半传输完成,全传输完成),并且将串口变成类似16C550的器件。
" l  T8 b# X& W0 c

, e% y8 l9 ?! y1 u0 M" {8 J
赞 收藏 评论0 发布时间:2022-1-23 22:20

举报

0个回答

所属标签

相似技术帖

官网相关资源

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