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

STM32串口发送中断

[复制链接]
万里-363223 发布时间:2014-12-19 08:49

) @$ Z. Q% X4 p* @SECTION 1
  _* I8 [6 R: V, w* w: }# X! X 20141014220925993.jpg
" s# B( f0 n: U) ^9 P4 l; o
SECTION 2
- j2 I! p" i. \6 d( `7 z
先说TC。即Transmission Complete。发送一个字节后才进入中断,这里称为“发送后中断”。和原来8051的TI方式一样,都是发送后才进中断,需要在发送函数中先发送一个字节触发中断。发送函数如下6 `, E9 l6 d$ R3 n) k9 j) I
void USART_SendDataString( u8 *pData )' G, t4 \# W& f0 k
{7 D( A! g! t( O
    pDataByte = pData;
  K) |2 q) p' n( M* X4 s& j  " e; ?; z" R8 Y/ }$ h- i
    USART_ClearFlag(USART1, USART_FLAG_TC);//清除传输完成标志位,否则可能会丢失第1个字节的数据.网友提供./ k: Y1 L& |7 s% i
    , w) Q1 t( h; f. K: ^7 [- Z9 x
    USART_SendData(USART1, *(pDataByte++) ); //必须要++,不然会把第一个字符t发送两次$ S- ~; a- R& S2 ]
}- s, f' c7 M3 K% t5 z
7 b9 U, m9 |0 t1 @' \1 `# M

+ }4 w9 P, ~4 Z5 a' T" }中断处理函数如下0 e2 ~* g4 J3 e; ~0 }0 V
void USART1_IRQHandler(void)9 D* Z# U3 e9 L/ F9 \
{
( h# Y+ h* t+ D% z" I" M) Q    if( USART_GetITStatus(USART1, USART_IT_TC) == SET  )
8 X, \; x) V* i    {8 t$ N0 s" ~8 X' |2 P5 x
        if( *pDataByte == '\0' )//TC需要 读SR+写DR 方可清0,当发送到最后,到'\0'的时候用个if判断关掉# P$ j0 d1 o4 x$ ~0 Y- ~. u+ C
            USART_ClearFlag(USART1, USART_FLAG_TC);//不然TC一直是set, TCIE也是打开的,导致会不停进入中断. clear掉即可,不用关掉TCIE
* I0 I, [* y  }        else
2 i$ m' w/ b1 Y( a            USART_SendData(USART1, *pDataByte++ );) [: y8 ^8 Q0 j$ T* s
    }1 {! T4 q/ X5 x; f# g7 @$ H
4 a3 n  q! K, g: z9 ~% v
}
% _3 w/ d0 P% Z- G- v6 W
% n4 O5 ?% m& W3 P( t3 y其中u8 *pDataByte;是一个外部指针变量" g5 }7 E7 \0 I7 x

# u* g5 k; q) b9 `4 u8 J在中断处理程序中,发送完该字符串后,不用关闭TC的中断使能TCIE,只需要清掉标志位TC;这样就能避免TC == SET 导致反复进入中断了。
+ |" ^# b; h3 d9 ]9 g) x
" u+ h3 w  V9 ~: s
串口初始化函数如下
2 O; c. x9 D+ qvoid USART_Config()1 E/ b; s5 I9 z' Q! v4 ~5 @9 c: S
{( Q" X# [" Z2 E9 R, M# ]& |3 B
  USART_InitTypeDef USART_InitStructure;//定义一个包含串口参数的结构体" l; s! {+ A" [+ Z
  * j+ q' u7 _+ w" U3 L7 f
  USART_InitStructure.USART_BaudRate = 9600; //波特率9600+ B( `' m1 e2 `, Z: ]- a
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据位; D' x( P7 j% B1 T, Z
  USART_InitStructure.USART_StopBits = USART_StopBits_1;//1位停止位% e1 ~, \9 p& [  H
  USART_InitStructure.USART_Parity = USART_Parity_No;//无校验- Y3 n" u( ]0 n; M
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件流控制
4 p# g" Y9 Q& e  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//输入加输出模式2 _, f# J' e4 ]3 [9 e' o0 M1 h7 l6 Z2 q( |
  USART_InitStructure.USART_Clock = USART_Clock_Disable;//时钟关闭. u/ H+ J) _4 \
  USART_InitStructure.USART_CPOL = USART_CPOL_Low;
  g1 m* R5 `7 N+ K/ W1 f  USART_InitStructure.USART_CPHA = USART_CPHA_2Edge;* H" {" c* g' _* X! T4 d4 N
  USART_InitStructure.USART_LastBit = USART_LastBit_Disable;7 `* s7 @) b8 a/ [" c& [% ^+ u) U, l
  USART_Init(USART1, &USART_InitStructure);//设置到USART1
, C. Q3 ]  C) R7 ~  1 G2 E; C! U) Y+ V, y% v  @. i
  USART_ITConfig(USART1, USART_IT_TC, ENABLE);//Tramsimssion Complete后,才产生中断. 开TC中断必须放在这里,否则还是会丢失第一字节8 h3 T6 R$ D3 }# \) M) K! \% N, ~2 ~
% Z+ D( d( n+ p! u4 R; R
  USART_Cmd(USART1, ENABLE); //使能USART13 F. t/ k6 p2 m
}# U* J5 S, q# H+ @' I9 x* A
这里请问一个问题:开TC中断USART_ITConfig()如果放在我的USART_SendDataString()中再开,会丢失字符串的第一字节。必须放在串口初始化函数中才不会丢。不知道为什么??8 x/ u3 H1 R/ r0 w0 S  ?. V2 o0 N

& j1 ^! X/ [& E5 A
这里笔者可以给出解释,你看下SECTION1 就可以知道为什么呢,你这样做的原理和SECTION1讲解的差不多,就相当于延时,而你后面没有丢失数据的主要原因就是你代码中有这么一句 USART_ClearFlag(USART1, USART_FLAG_TC);//清除传输完成标志位,否则可能会丢失第1个字节的数据.网友提供.

  `, I9 p* f6 P6 s* J

" T0 {( ]0 p/ J3 J) L1 ^$ Q
再说判断TXE。即Tx DR Empty,发送寄存器空。当使能TXEIE后,只要Tx DR空了,就会产生中断。所以,发送完字符串后必须关掉,否则会导致重复进入中断。这也是和TC不同之处。
1 C8 j% t- M& J4 m2 E7 [( i: F, x0 f* v# X: v! v3 I* ^/ W
发送函数如下:* [! n3 m# S. z2 ^% t& X' |$ l
void USART_SendDataString( u8 *pData )
7 X: K% v2 N* P% w1 D; Y{
/ r# w' e) g" }$ {2 V: j1 z7 l' k0 D    pDataByte = pData;
3 k5 W: t. p' [' ]# R7 y9 d. J    USART_ITConfig(USART1, USART_IT_TXE, ENABLE);//只要发送寄存器为空,就会一直有中断,因此,要是不发送数据时,把发送中断关闭,只在开始发送时,才打开。
& ^3 w' L; c0 f' E   
3 {! s! i% j2 Q, _}
. ?# |+ w# `0 R- P" b/ w  z( a  Y+ c. k; e2 _. H" X' H
中断处理函数如下:
; X& y+ Z0 u# J2 @void USART1_IRQHandler(void)
% M' H* t0 M7 w{+ t& ~  M: M, }
    if( USART_GetITStatus(USART1, USART_IT_TXE) == SET  )
2 t" V" w+ }( d& S1 Z    {
" N2 M, b. s& N, g: I4 d) l' }% i( e        if( *pDataByte == '\0' )//待发送的字节发到末尾NULL了1 u) ~4 d/ I. z+ h$ J. Q! ]; I
            USART_ITConfig(USART1, USART_IT_TXE, DISABLE);//因为是 发送寄存器空 的中断,所以发完字符串后必须关掉,否则只要空了,就会进中断( w  R+ C! V8 c2 A9 H0 z8 B
        else
( p. K+ {) I5 x. |6 z            USART_SendData(USART1, *pDataByte++ );
) Y6 u( }- C9 ^: U8 g# I* n$ X6 S    }
6 _4 ]; j: C! g; I1 A4 I1 ^3 s) n. W3 m3 }
}: y6 u1 w0 O+ j9 N7 E

, f: ^1 h4 Z* m* Q4 u* E0 u& l# |在串口初始化函数中就不用打开TXE的中断了(是在发送函数中打开的)如下:5 q6 S0 X* T  u0 D0 p6 V
void USART_Config()
6 ^. t$ |: [' Q9 I+ m* F, O{
+ i& {/ u' r: F2 Z% e  USART_InitTypeDef USART_InitStructure;//定义一个包含串口参数的结构体6 M2 [8 q1 C! ]( T3 A
  
$ N8 m0 j& C/ a+ D  USART_InitStructure.USART_BaudRate = 9600; //波特率96005 b2 L; g& @; s
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据位
1 C# R6 I7 u3 d; p; U4 @& R  USART_InitStructure.USART_StopBits = USART_StopBits_1;//1位停止位
: v; A1 e; S2 G+ i9 S6 m+ X3 ?8 I  USART_InitStructure.USART_Parity = USART_Parity_No;//无校验1 ]( q! i. G) B) p* C. F) E; a& ^
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件流控制7 V$ e$ I" |  h, W, k- w* N
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//输入加输出模式! T. ~& [0 @# g% I) N8 q
  USART_InitStructure.USART_Clock = USART_Clock_Disable;//时钟关闭3 i5 [* B) `  X: c- Z. z* D$ e
  USART_InitStructure.USART_CPOL = USART_CPOL_Low;
* [* B# p0 p$ o9 j  USART_InitStructure.USART_CPHA = USART_CPHA_2Edge;) F1 K* |+ c4 Y/ G2 _- Q7 f
  USART_InitStructure.USART_LastBit = USART_LastBit_Disable;, F+ x; k, j* T) y4 ~

# Z3 [( j8 y3 _, }8 _& R+ U  USART_Init(USART1, &USART_InitStructure);//设置到USART1- A) i  d1 k; ?
  4 V3 L, E3 Z; a! F7 m$ h/ n# \1 |4 E/ S! d& [
  USART_Cmd(USART1, ENABLE); //使能USART1* S( ~; W# f6 |
}
$ f4 [# b4 x5 g0 B
( X; j" O+ M6 S/ pSECTION 38 U, [+ L0 P! Z* c$ R
4 `+ c6 r- D7 ]2 ~  ~

& o4 A3 v6 A: q; D* K

在USART的发送端有2个寄存器,一个是程序可以看到的USART_DR寄存器(下图中阴影部分的TDR),另一个是程序看不到的移位寄存器(下图中阴影部分Transmit Shift Register)。* l+ f, S2 f# L8 W
$ B8 p# z5 v( n# d! n
对应USART数据发送有两个标志,一个是TXE=发送数据寄存器空,另一个是TC=发送结束;对照下图,当TDR中的数据传送到移位寄存器后,TXE被设置,此时移位寄存器开始向TX信号线按位传输数据,但因为TDR已经变空,程序可以把下一个要发送的字节(操作USART_DR)写入TDR中,而不必等到移位寄存器中所有位发送结束,所有位发送结束时(送出停止位后)硬件会设置TC标志。8 H5 A) O0 @7 ]  t" D: z# J3 U; t2 }; X
  O$ e7 Z2 _1 o+ v3 }
另一方面,在刚刚初始化好USART还没有发送任何数据时,也会有TXE标志,因为这时发送数据寄存器是空的。
4 w! X! s! O) a6 V, O% b( N/ W% G) n: y7 d! H  x
TXEIE和TCIE的意义很简单,TXEIE允许在TXE标志为'1'时产生中断,而TCIE允许在TC标志为'1'时产生中断。
: A& U- J; i$ ^
2 S1 Q9 U* N) D  K/ y2 I0 b至于什么时候使用哪个标志,需要根据你的需要自己决定。但我认为TXE允许程序有更充裕的时间填写TDR寄存器,保证发送的数据流不间断。TC可以让程序知道发送结束的确切时间,有利于程序控制外部数据流的时序。


5 r1 \; g5 @- n0 x- @/ ^* U

SECTION 4
% L0 V, X  |' K, W

       2014-12-19 08 48 55.png , E, M+ ^$ l( }

) x2 O" D7 B& U  P3 f& r. ^7 G7 ^- r1 _0 m; X4 H
赞 收藏 1 评论17 发布时间:2014-12-19 08:49

举报

17个回答
wjandsq 回答时间:2014-12-21 10:53:00
/**
  g  m5 N5 j, k* K  * @file    usb_endp.c
* h& r6 L$ P, d( B. |1 w( r; y  * @author  wjandcf@gmail.com8 ~( e( r0 ^! q
  * @version V7.0.2
# O2 O+ p2 L7 I  * @date    2014.12.20
: D/ L* e7 U, m: W; K! f  * @brief   Endpoint routines; v. D  X# V; M% E; K$ {& |! D
  *    e* m* f% o+ O
  */
6 ]+ z. y1 y+ g7 q/* Includes ------------------------------------------------------------------*/
+ J( p, p. Q* R; ~. C. Z7 ~#include "usb_lib.h"0 @# H# w' D/ o( n; m5 A
#include "usb_desc.h"
! Z5 l" K: N7 T#include "usb_mem.h"; U/ b7 F/ J0 ?" Q
#include "hw_config.h"" [+ {8 F8 G. `7 B
#include "usb_istr.h"" k1 O# N0 d9 X9 @( C( y
#include "usb_pwr.h"& @1 [  e* X" s
4 H6 Z: B2 ~2 T' t+ m- r
/* Private typedef -----------------------------------------------------------*/
' }9 z( ~7 C8 k( P4 k- H/* Private define ------------------------------------------------------------*/# i% j0 {2 K* \. M

8 P" r- ]8 b3 x* b, g# j/* Interval between sending IN packets in frame number (1 frame = 1ms) */7 h) p& A+ D6 Z
#define VCOMPORT_IN_FRAME_INTERVAL             5
' H' y( T+ Y: ?0 D
" k0 _$ |! _/ V& y% \/* Private macro -------------------------------------------------------------*/
# O3 B8 ?: @& T0 ]/* Private variables ---------------------------------------------------------*/" z6 d5 {- Q  M9 R) X
uint8_t USB_Rx_Buffer[VIRTUAL_COM_PORT_DATA_SIZE];6 @+ f' @' C5 i9 l$ d# `( z8 I# E$ O

0 H4 l( R8 a- Mextern uint8_t VCP1_Tx_Buffer1[];      /* VCP1 DMA发送缓冲1 */
( ~7 A+ M' C; p5 J; G! w5 `extern uint8_t VCP2_Tx_Buffer1[];      /* VCP2 DMA发送缓冲1 */3 M9 @" N$ _8 S' V' u( g7 j8 `% x
extern uint8_t VCP3_Tx_Buffer1[];      /* VCP3 DMA发送缓冲1 */1 P6 k# {  q3 l6 r

0 y3 A5 C( \/ ^6 Gextern uint8_t VCP1_Tx_Buffer2[];      /* VCP1 第二缓冲(临时存放来自PC主机的数据包) */
. D( ^8 u& t( S8 Sextern uint8_t VCP2_Tx_Buffer2[];      /* VCP2 第二缓冲 */
9 q, u9 i7 }+ Q1 Q2 ]1 Gextern uint8_t VCP3_Tx_Buffer2[];      /* VCP3 第二缓冲 */
: n2 ~3 u3 S! g
1 n- c6 Z9 D. X5 P- m5 xextern uint8_t  Flag_VCP1_Tx_Buf_Use;  /* 1: 表示DMA发送已启动,VCP1_Tx_Buffer1被锁定 */# b: h0 l5 P' C1 H9 C; N) r
extern uint8_t  Flag_VCP1_Tx_Buf_Full; /* 1: 表示VCP1_Tx_Buffer2数据可能已放满,暂时不能再从主机接收数据 */
" i7 ~6 D7 V' Z9 m) F8 m$ f) [extern uint16_t VCP1_Tx_Buffer_Cnt;    /* VCP1 第二缓冲 收到的字符总数 */, a  p6 _0 O0 ]6 n/ m
1 B2 y% J; K; r, z1 J2 j
extern uint8_t  Flag_VCP2_Tx_Buf_Use;  /* 1: 表示DMA发送已启动,VCP2_Tx_Buffer1被锁定 */, Y1 m$ j' x) ?6 i- \/ }( ^6 n+ l9 P
extern uint8_t  Flag_VCP2_Tx_Buf_Full; /* 1: 表示VCP2_Tx_Buffer2数据可能已放满,暂时不能再从主机接收数据 */
/ D- |6 x+ b) q/ p+ O7 Nextern uint16_t VCP2_Tx_Buffer_Cnt;    /* VCP2 第二缓冲 收到的字符总数 */
, J2 X6 W- q1 q0 C8 G1 k' P3 ]0 C$ p' g6 |4 u! a6 E
extern uint8_t  Flag_VCP3_Tx_Buf_Use;  /* 1: 表示DMA发送已启动,VCP3_Tx_Buffer1被锁定 */
' w9 ?( |8 F$ v: j* e& i6 d2 kextern uint8_t  Flag_VCP3_Tx_Buf_Full; /* 1: 表示VCP3_Tx_Buffer2数据可能已放满,暂时不能再从主机接收数据 */
" D' x1 m* ^0 Sextern uint16_t VCP3_Tx_Buffer_Cnt;    /* VCP3 第二缓冲 收到的字符总数 */
$ C: P1 T" ^8 z" L! K: }6 x( y
extern uint8_t  VCP1_Rx_Buffer[];
+ `) D" A7 ?3 Q0 v! |extern uint32_t VCP1_Rx_ptr_in;& F' ], |+ w4 |2 n
extern uint32_t VCP1_Rx_ptr_out;- ]& g4 V' k& o& d" z
extern uint32_t VCP1_Rx_length;+ e  n" L/ m3 n4 F8 g$ ?( h
extern uint8_t  CDC1_Tx_State;
$ l( O) j6 o% m- `% ~5 F. {1 ^: ~
, ~$ z$ d! v5 d0 {! Z& h0 vextern uint8_t  VCP2_Rx_Buffer[];
9 V% l6 ^$ N  @extern uint32_t VCP2_Rx_ptr_in;
- O+ a1 O! M! |# |3 dextern uint32_t VCP2_Rx_ptr_out;7 z. k# b6 l) h, u% c, S3 h) l& U) U
extern uint32_t VCP2_Rx_length;
6 v/ k2 d4 T4 P5 v  Y, Bextern uint8_t  CDC2_Tx_State;  b" ^/ K& ?" f9 K9 [: m9 ]" d% c8 I

/ C: T( a& [/ {1 W6 I2 T4 T% Bextern uint8_t  VCP3_Rx_Buffer[];
, w( X9 d! X1 vextern uint32_t VCP3_Rx_ptr_in;: b! ~  e$ E# H1 S( S9 @1 i
extern uint32_t VCP3_Rx_ptr_out;
7 O5 t% f* |) _3 O6 Q* S2 |extern uint32_t VCP3_Rx_length;5 r6 m+ `1 ?4 H/ G4 u, l+ @' q$ P
extern uint8_t  CDC3_Tx_State;! ^4 L0 t2 K  `8 ?8 v% x9 S

/ v- Q3 m& H8 z- }- }- b, a$ {/* Private function prototypes -----------------------------------------------*/5 S: h7 _7 \& j& o4 u' ^6 O
/* Private functions ---------------------------------------------------------*/
0 V4 P% w0 A8 d0 |- x+ T8 O6 Q- q) \
/* USB的IN端点 发送数据到PC主机 */
9 W9 u) W+ W* V4 Y. v#define EPx_IN_Callback(ENDPx, CDCx_Tx_State, VCPx_Rx_Buffer, VCPx_Rx_ptr_out, VCPx_Rx_length) {\
! X3 w* `) s  H5 ^4 A" P; F    uint16_t USB_Tx_ptr;\
  `3 a5 L  [/ ^4 M' W# }( [; S: n    uint16_t USB_Tx_length;\
7 }! t8 ?/ O, J, ~  Z3 A6 T    if (CDCx_Tx_State == 1) {\
7 I1 y4 V  l# o& W        USB_Tx_ptr = VCPx_Rx_ptr_out;\
$ L, @% ]5 ]" u, P# M        if (VCPx_Rx_length == 0) {\7 I  N! k  u5 z6 s. z. P* [1 i
            CDCx_Tx_State = 0;\6 w3 n: ]6 J$ F% ^/ T8 O
            SetEPTxCount(ENDPx,0);\( I: Z. o# [5 G1 d% c" g# r
            SetEPTxValid(ENDPx);\% u% W+ `, q2 R& _+ N7 H  K* {; v
        } else {\6 x2 j7 e# j- K
            if (VCPx_Rx_length > VIRTUAL_COM_PORT_DATA_SIZE) {\
1 b8 ~7 J  J5 n" ]! u' A                USB_Tx_length = VIRTUAL_COM_PORT_DATA_SIZE;\
4 n- b' R7 M- P" H. P2 p# @' _5 g                VCPx_Rx_ptr_out += VIRTUAL_COM_PORT_DATA_SIZE;\
* j* k. y$ V! ^+ i" Q1 Z) w; c                VCPx_Rx_length -= VIRTUAL_COM_PORT_DATA_SIZE;\- l% ?8 N7 ~6 u0 M6 L5 f. V
            } else {\; s3 v6 U/ P9 _: J
                USB_Tx_length = VCPx_Rx_length;\8 B5 r' {- \/ ^1 }" x4 u
                VCPx_Rx_ptr_out += VCPx_Rx_length;\
) [5 ^$ U: c0 y& e7 |                VCPx_Rx_length = 0;\
7 j) ?9 ^" g- @6 v            }\4 P" P+ Q9 b6 Y
            USB_SIL_Write(ENDPx, &VCPx_Rx_Buffer[USB_Tx_ptr], USB_Tx_length);\
3 ], j3 U& ~# l            SetEPTxValid(ENDPx);\
( x- ~8 u6 [5 T6 J$ v- z        }\4 l2 z% E# L' g1 J  G& M# S; |9 ?
    }\6 f, h* M! b/ V% o! N
}; ^& L! K# c9 X$ U/ \& p  e
/* USB的OUT端点 通过物理串口向外发送数据(阻塞方式) */9 L: _, E" M* C5 v( a% ~. z
#define EPx_OUT_Callback(ENDPx, USARTx, GPIOx, GPIO_Pin_x) {\
: J' a$ U( W1 h* f: W5 N2 ]6 A    uint32_t i;\
/ \, d7 j. h# r& @! ]* A) a    uint16_t USB_Rx_Cnt;\
& ^! h( N0 X0 n) m* H  `    USB_Rx_Cnt = USB_SIL_Read(ENDPx | 0x00, USB_Rx_Buffer); \% G4 s( J  Z, d1 _' B5 L4 b  a
    GPIOx->BSRR = GPIO_Pin_x;\) @) }4 u! ^1 l
    for (i = 0; i < USB_Rx_Cnt; i++) {\, C* v+ p3 B$ u/ Q3 `" }
        USARTx->DR = *(USB_Rx_Buffer + i);\
  V0 u2 P& R! l6 ]6 C2 {. O% A        while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET);\
2 }* A. `* B( m    }\
* Z5 y6 }; \3 J    SetEPRxValid(ENDPx);\7 e* h' ^( E3 Y0 ~+ H+ Y
    while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET);\7 ?* s5 U5 Y5 \# `9 }
    USART_ClearFlag(USARTx, USART_FLAG_TC);\4 a% g2 `5 x1 g0 z4 V
    GPIOx->BRR = GPIO_Pin_x;\
$ x4 C7 _& i% {  @}. h, L* Y; _" l( ^2 }

9 i# V8 e. a( d. `+ Y/* USB的OUT端点 通过物理串口向外发送数据(DMA方式) */0 ^8 H3 {. w) E
#define EPx_OUT_Callback_DMA(Flag_VCPx_Tx_Buf_Use, ENDPx, VCPx_Tx_Buffer1,VCPx_Tx_Buffer2,\
; k: y- H* f# `# W" j    GPIOx, GPIO_Pin_x, DMA1_Channelx, VCPx_Tx_Buffer_Cnt, Flag_VCPx_Tx_Buf_Full) {\
$ C/ ?* ]+ p& K1 a. ~' }* t" r    uint16_t USB_Rx_Cnt;\2 N! Q; J! d' ?: ?
    if(Flag_VCPx_Tx_Buf_Use == 0){\: O4 w. t( [7 ^2 |: e. n
        USB_Rx_Cnt = GetEPRxCount(ENDPx & 0x7F);\
5 s, y+ E5 G" d( q1 W6 @        PMAToUserBufferCopy(&VCPx_Tx_Buffer1[0], GetEPRxAddr(ENDPx & 0x7F), USB_Rx_Cnt);\
/ q5 g! \3 {3 g) f" |* }  y' A        SetEPRxValid(ENDPx);\. w* {( R5 @8 U" Z% N/ s' \' }
        GPIOx->BSRR = GPIO_Pin_x;\7 I7 p- j- \1 G: ~  |5 X
        DMA1_Channelx->CNDTR = USB_Rx_Cnt;\
* j& H$ v' ?: O        DMA_Cmd(DMA1_Channelx, ENABLE);\* ^- g: `& l' K5 d
        Flag_VCPx_Tx_Buf_Use = 1;\
3 b% p  ^1 i0 Y, x9 l  p5 \        VCPx_Tx_Buffer_Cnt = 0;\
2 g8 V9 h- E: q. b    } else {\+ Z" E- `9 v, q8 V
        USB_Rx_Cnt = GetEPRxCount(ENDPx & 0x7F);\9 _6 ]! ?1 X- D3 Q- }
        if(VCPx_Tx_Buffer_Cnt < (1024-128)){\
; C. ]$ r  \$ a, U$ n4 y          PMAToUserBufferCopy(&VCPx_Tx_Buffer2[VCPx_Tx_Buffer_Cnt], GetEPRxAddr(ENDPx & 0x7F), USB_Rx_Cnt);\; \4 ]* ^) H- j: o% y- q7 q7 C! ~2 X3 \
          VCPx_Tx_Buffer_Cnt += USB_Rx_Cnt;\3 T& K1 l8 A" L% }# A9 `- w
          SetEPRxValid(ENDPx);\; s3 `2 j3 u: a1 e6 C- ~
        } else {\( S6 R7 c% j7 @8 W! t, z
          PMAToUserBufferCopy(&VCPx_Tx_Buffer2[VCPx_Tx_Buffer_Cnt], GetEPRxAddr(ENDPx & 0x7F), USB_Rx_Cnt);\4 k% `2 a( w) H) r: j
          VCPx_Tx_Buffer_Cnt += USB_Rx_Cnt;\! v7 Y' S& P" p$ s5 a
          Flag_VCPx_Tx_Buf_Full = 1;\4 k  ~/ \: F3 o) h/ g7 j/ l5 e3 L9 J
        }\
8 K+ X# P7 S: a) m    }\
+ _  H& V; j. |}
. r  d- Z' U  P7 R0 I: I/**
8 P4 U+ L0 E: [% ]9 u  Z * Function Name  : EP2_IN_Callback
# H6 x% p% V4 A- \9 n$ M7 s# d" | * Description    :9 _$ B" i1 l/ ^7 W1 T7 m
**/1 {) v4 F& H: H
void EP2_IN_Callback (void) {
% i) K" a9 ]- C    EPx_IN_Callback(ENDP2,CDC1_Tx_State,VCP1_Rx_Buffer,VCP1_Rx_ptr_out,VCP1_Rx_length);8 v. ~3 J& f2 T8 Y* T6 M) U
}
, l! }) h5 x; s1 [, w8 J- p* P2 g/**
) h, |8 Q. e4 i3 a: l2 J7 Z * Function Name  : EP4_IN_Callback
  o6 O, Q, T; w$ {8 a1 W * Description    :) ]' f* J4 I, q. `6 d$ b
**/
7 H# `. p# D& |  O/ ^$ l# U6 qvoid EP4_IN_Callback(void)5 |. _' m: b; p8 R4 I2 o& P9 ]8 O
{1 o1 @  R$ j& b$ J
    EPx_IN_Callback(ENDP4,CDC2_Tx_State,VCP2_Rx_Buffer,VCP2_Rx_ptr_out,VCP2_Rx_length);
4 K% C% I- ?9 e8 ^5 O7 N! ?/ a4 Q}9 ?5 P0 r4 S0 [. w1 M9 }
/**3 C% E5 P1 u: {2 m- m
* Function Name  : EP6_IN_Callback* G' c! M1 e4 z4 l% C' Z# P) {
* Description    : VCP3 向PC主机发送数据/ u, P: ]1 V3 ~5 }- ?+ U8 g$ k
**/
8 ?- H9 q* O/ B5 I( j$ ]void EP6_IN_Callback(void)' K" T; |9 a% W1 h  }4 w" ]
{! a# U! M' B5 f! c7 ~2 x: d% R
    EPx_IN_Callback(ENDP6,CDC3_Tx_State,VCP3_Rx_Buffer,VCP3_Rx_ptr_out,VCP3_Rx_length);  4 m( w* E7 S5 s
}6 o. n. s; U2 A+ z, t# ]/ w0 a
/**) M) Q, S1 ?! J# x! i
* Function Name  : EP2_OUT_Callback
# P: m$ N" n% j' l9 v5 F& i * Description    : VCP1 通过USART1向外送数据
1 g! v7 u' c) t, b2 L) j/ B **/
- a7 N! A" z, ^: K5 g* wvoid EP2_OUT_Callback(void) {* o1 i3 l0 S' A! E/ |! u6 M5 r
#ifdef USB_DMA_SEND; j) v5 _" v7 p: E3 a1 T
    EPx_OUT_Callback_DMA(Flag_VCP1_Tx_Buf_Use, ENDP2, VCP1_Tx_Buffer1,VCP1_Tx_Buffer2,\
4 ]3 H7 C& N* r$ x3 l            GPIOB, GPIO_Pin_9, DMA1_Channel4, VCP1_Tx_Buffer_Cnt, Flag_VCP1_Tx_Buf_Full);$ S4 b8 N& m) h. c! m
#else
; E2 E8 T9 l4 f  k    EPx_OUT_Callback(ENDP2,USART1, GPIOB, GPIO_Pin_9); // DR1 PB9
  o: z3 X9 D8 Z#endif
5 B. X- H, P( y. |2 M1 V}7 {6 G' K4 ^  v. ]/ L+ }
/**
# N- j# r2 X9 j * Function Name  : EP4_OUT_Callback; N, K( _4 k# \% A# e8 G
* Description    : VCP2 通过USART2向外送数据6 d# m" {8 a6 S2 W  g/ z& Q. K# J- Q
* Input          : None.7 V: H5 j' A7 n. e3 s, h
* Output         : None.
! b9 h6 d, x) [+ `; H% i8 ` * Return         : None.
' `6 b" s3 z$ b7 c) b: j **/; L- G- y4 ]" R& \  O
void EP4_OUT_Callback(void)
: J  q. s! z4 q! D4 ?5 g4 ~{4 k) ?1 l4 ~3 G6 {) G9 A+ b" y( l
#ifdef USB_DMA_SEND
/ O! a$ J7 K3 ?    EPx_OUT_Callback_DMA(Flag_VCP2_Tx_Buf_Use, ENDP4, VCP2_Tx_Buffer1,VCP2_Tx_Buffer2,\; L; Y6 y  e; I) k6 l8 g
            GPIOB, GPIO_Pin_8, DMA1_Channel7, VCP2_Tx_Buffer_Cnt, Flag_VCP2_Tx_Buf_Full);& k# P& i6 o8 Z2 I
#else5 I! R8 ^  {& |; R- K( j
    EPx_OUT_Callback(ENDP4,USART2, GPIOB, GPIO_Pin_8); // DR2 PB8% \* r+ R$ ?1 F) X
#endif4 R" ~/ ?& E1 Y% ?, X( s3 o
}
) s8 F) w) w/ A6 M5 @/**
3 g7 U" k6 X$ G5 ?* T+ M! J; J+ A% S * Function Name  : EP6_OUT_Callback
- u/ j/ {: x; T. L$ U& `6 B, d6 D * Description    : VCP3 通过USART3向外送数据
# d* b/ i7 {# V' K! H8 o+ ~# Q& _5 m **// e0 J1 o8 k) |6 g4 D
void EP6_OUT_Callback(void){: R. M1 L  y2 G; y% C' _
#ifdef USB_DMA_SEND
7 ^+ ]: M' x) d    EPx_OUT_Callback_DMA(Flag_VCP3_Tx_Buf_Use, ENDP6, VCP3_Tx_Buffer1,VCP3_Tx_Buffer2,\9 a( X- w$ Q. Y  x
            GPIOA, GPIO_Pin_5, DMA1_Channel2, VCP3_Tx_Buffer_Cnt, Flag_VCP3_Tx_Buf_Full);
8 F' E* S: \) \5 a0 }#else  * d$ @" n) s1 h6 A% x. J; B' h
    EPx_OUT_Callback(ENDP6,USART3,GPIOA,GPIO_Pin_5);  // DR3 PA5
1 B3 q8 Z) B" j2 J4 A, s- Z1 n+ j' L" E#endif+ W8 u! l2 p$ J
}4 B7 a& k0 H' k1 y0 K
/**( _  N7 \: T3 y) l7 ^
* Function Name  : SOF_Callback / INTR_SOFINTR_Callback. S4 O" w* |8 k! S' ~3 B! J
* Description    :3 X, d! }8 r3 s9 Q3 C
**// k7 x7 u( e3 N# g9 ?, }+ `1 s
void SOF_Callback(void)
/ o" U. \5 n8 s' A7 `+ o{
6 {& R" _. o9 {- g7 e    static uint32_t FrameCount = 0;. h: h8 s8 d! p8 H- e) q
    static uint32_t Led_Count = 0;8 W+ e: z) X% S3 o3 f
    if(bDeviceState == CONFIGURED) {( _3 e% p. P* L4 ?5 u0 {( V
        if (FrameCount++ >= VCOMPORT_IN_FRAME_INTERVAL) {
; z- v! v+ l- U3 E& [            /* Reset the frame counter */2 P0 Z9 D: n  S- i% A" W, E
            FrameCount = 0;
* f  o8 W8 s( Z, m% p' U. _( M            /* Check the data to be sent through IN pipe */
, ~/ j2 y* I6 Q$ j3 j, I+ r% P            Handle_USBAsynchXfer();
6 `+ L! O" L0 N        }+ v6 `' e1 e. M+ o0 Z' O6 ^
    }
3 {  L- s$ w1 U& Q' l    if(++Led_Count > 999) {2 ?0 [9 R" n! X: f
        Led_Count = 0;
/ y4 }& V4 b* F' f  I$ [1 U        if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == 0){
# Z8 p" K, t1 t- C3 L, c$ o$ H            GPIOB->BSRR = GPIO_Pin_2; // PB2 H# ?: p) Z+ c+ o# Y. o; K' u3 K
        } else {
' o  b' a3 Y' Z7 f. P0 ~            GPIOB->BRR = GPIO_Pin_2;  // PB2 L/ z# `8 a! u# |/ `' E, J/ |
        }: U  p( C/ Q) H2 a  v. j. j
    }$ I2 @, r* r, c2 j+ u; ^8 U$ x& M
}
3 x9 y  I$ ?* U" d- m1 o+ O  e& a* [1 O/ e- \5 [
万里-363223 回答时间:2014-12-19 08:51:16
SECTION 4
+ ]/ j1 ^5 }$ w* D        总的来说,STM32单片机的串口还是很好理解的,编程也不算复杂。当然我更愿意希望其中断系统和51单片机一样的简单。
& [4 m+ y2 @- M. A8 G/ p        对于接收终端,就是RXNE了,这只在接收完成后才产生,在执行USART_ITConfig(USART1, USART_IT_RXNE, ENABLE)代码时不会进入ISR。但麻烦的就是发送有关的中断了:TXE或者TC,根据资料和测试的结果,TXE在复位后就是置1的,即在执行USART_ITConfig(USART1, USART_IT_TXE,  ENABLE)后会立即产生中断请求。因此这造成一个麻烦的问题:如果没有真正的发送数据,TXE中断都会发生,而且没有休止,这将占用很大部分的CPU时间,甚至影响其他程序的运行!
& ~2 f# a1 O% E" n+ ?$ T+ Q4 @/ d/ W        因此建议的是在初始化时不好启用TXE中断,只在要发送数据(尤其是字符串、数组这样的系列数据)时才启用TXE。在发送完成后立即将其关闭,以免引起不必要的麻烦。
9 w# ]  M1 a9 D" S7 g        对于发送,需要注意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清零。. [! E+ Y) _9 Q6 |* H
        对于发送单个字符可以考虑不用中断,直接以查询方式完成。9 L) y2 A7 f3 c+ y
        对于发送字符串/数组类的数据,唯一要考虑的是只在最后一个字符发送后关闭发送中断,这里可以分为两种情况:对于发送可显示的字符串,其用0x00作为结尾的,因此在ISR中就用0x00作为关闭发送中断(TXE或者TC)的条件;第二种情况就是发送二进制数据,那就是0x00~0xFF中间的任意数据,就不能用0x00来判断结束了,这时必须知道数据的具体长度。1 O! y' b* Y0 V% x5 P* s/ G
       这里简单分析上面代码的执行过程:TXE中断产生于前一个字符从DR送入SR,执行效果是后一个字符送入DR。对于第一种情况,如果是可显示字符,就执行USART_SendData来写DR(也就清零了TXE),当最后一个可显示的字符从DR送入SR之后,产生的TXE中断发现要送入DR的是字符是0x00——这当然不行——此时就关闭TXE中断,字符串发送过程就算结束了。当然这时不能忽略一个隐含的结果:那就是最后一个可显示字符从DR转入SR后TXE是置1的,但关闭了TXE中断,因此只要下次再开启TXE中断就会立即进入ISR。对于第二种情况,其结果和第一种的相同。
( t; a" y6 F  x* o( E0 h. |1 n3 X8 ^         对于第一种情况,其程序可以这么写:其中TXS是保存了要发送数据的字符串,TxCounter1是索引值:
: J, ~0 Z0 n( u+ [  H% u4 mextern __IO uint8_t TxCounter1;
+ J6 L+ ?( P2 ?- Vextern uint8_t *TXS;
4 g9 M0 |. t# W5 K6 `9 [$ textern __IO uint8_t TxLen;
9 ?% x: k4 V! l* k7 qvoid USART1_IRQHandler(void). t% ^$ {+ a- \* X! i6 v
    {! v3 R5 K5 e- y0 G. d
        if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET): R/ `2 d: j5 A
            {                                               
; Y2 Z# P  X  E3 `                if(TXS[TxCounter1]) //如果是可显示字符9 B0 P8 {* b/ O# K; T1 b
                    { USART_SendData(USART1,TXS[TxCounter1++]);}
* P7 b( d8 B  O- A3 r- {: y                else   //发送完成后关闭TXE中断,
0 Q6 G' N' A. Z                    { USART_ITConfig(USART1,USART_IT_TXE,DISABLE);}                                                        
! H8 z# p9 v- [8 h* w7 M3 [            }                   8 t0 N4 ?8 O2 u
    }
- |1 R: {& j( _" ?( i, ]  R        对于第二种情况,和上面的大同小异,其中TXLen表示要发送的二进制数据长度:+ b4 A( |" _, B: d: z, x+ C% k
void USART1_IRQHandler(void)
3 a! V: S0 k6 j3 z5 B4 x) ~    {
; r3 a& P, |* v, |        if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) //对USART_DR的写操作,将该位清零。
: A: U& N' K9 W& j3 R& z+ @. z# f# T            {                                              6 R& X/ m6 N% w% k
                if(TxCounter1<TxLen)9 r* ~* _# y1 M; j8 G! P
                    { USART_SendData(USART1,TXS[TxCounter1++]);}
! _  \4 s$ \- p3 t; ]                else   //发送完成后关闭TXE中断
: h2 v3 m! z) Y7 {                    { USART_ITConfig(USART1,USART_IT_TXE,DISABLE);}                                                         , q9 j5 U) M' D; U( a5 {; b
            }                    
$ i2 w* G) t9 R( A. g    }
3 X- D# Q9 H& }3 v, H) P        事实上第一种情况是第二种的特殊形式,就是说可以用第二种情况去发送可显示的字符——当然没人有闲心去数一句话里有多少个字母空格和标点符号!0 w4 L  W* D) p& J
        在使用时,只要将TXS指向要发送的字符串或者数组,设置TxLen为要发送的数据长度,然后执行USART_ITConfig(USART1, USART_IT_TXE,ENABLE)就立即开始发送过程。用户可以检查TxCounter1来确定发送了多少字节。比如以第二种情况为例:4 f- N1 t/ J" z  n
uint32_t *TXS;) S: m, [/ H- D4 }+ n5 w
uint8_t TxBuffer1[]="0123456789ABCDEF";# _$ y" }( P$ o1 e
uint8_t DST2[]="ASDFGHJKL";: G, ~# J! H. R# l, x# k
__IO uint8_t TxLen = 0x00;
# S" G9 E) ?6 a$ k0 \0 y     TxLen=8;                               //发送8个字符,最终发送的是01234567; l7 [! x  E+ e6 l: ~/ l& h7 @9 {4 @4 h
    TXS=(uint32_t *)TxBuffer1;   //将TXS指向字符串TxBuffer1; A" d- Q$ d# J3 S
    TxCounter1=0;                     //复位索引值
8 L, x( I) _) V+ r- d! v! ^    USART_ITConfig(USART1, USART_IT_TXE,ENABLE);   //启用TXE中断,即开始发送过程
4 |3 h9 W- [  E4 k$ _& j3 K- G2 `    while(TxCounter1!=TxLen);   //等待发送完成  I$ ^$ h7 l: B. r" N0 ~

+ N* I9 H# F5 d6 W4 x    TXS=(uint32_t *)TxBuffer2;   //同上,最终发送的是ASDFGHJK
5 i3 }; O- j, J/ d" L    TxCounter1=0;' h) g  m7 V2 F. Z4 R8 a2 E+ |
    USART_ITConfig(USART1, USART_IT_TXE,ENABLE);
; o  n: N6 }% J9 l8 W+ ]+ p    while(TxCounter1!=TxLen);
! f- ]2 J; J  T9 u! R9 Q8 y" o# n+ B        以上就是我认为的最佳方案,但串口中断方式数据有多长就中断多少次,我认为还是占用不少CPU时间,相比之下DMA方式就好多了,因为DMA发送字符串时最多中断两次(半传输完成,全传输完成),并且将串口变成类似16C550的器件。
wamcncn 回答时间:2014-12-19 13:32:32
万里-363223 发表于 2014-12-19 08:51
+ }. y/ y$ \" B4 HSECTION 4
& D$ c. a5 j& X8 y( o- e# W        总的来说,STM32单片机的串口还是很好理解的,编程也不算复杂。当然我更愿意希望其中断 ...

7 z3 |- w2 f4 w8 a' E强大的同时,复杂也跟着来了,51是基础,STM32是进阶
万里-363223 回答时间:2014-12-19 08:50:11
发帖子,受到字数限制了
废鱼 回答时间:2014-12-19 09:28:07
谢谢楼主分享。
巅峰残狼 回答时间:2014-12-19 13:16:21
太牛了,谢谢分享
wamcncn 回答时间:2014-12-19 13:30:09
学习,楼主总结的不错,谢谢分享
万里-363223 回答时间:2014-12-19 14:25:00
wambob 发表于 2014-12-19 13:32
+ D3 x0 V2 \  _2 k% o强大的同时,复杂也跟着来了,51是基础,STM32是进阶
2 f0 P0 H" A: t2 Y
恩恩,没错,鱼和熊掌不可兼得
小贾-370388 回答时间:2014-12-19 15:30:39
充充电9 J, q9 O: ~7 L( M; H" V
霹雳之火 回答时间:2014-12-19 23:35:32
谢谢分享,楼主辛苦啦,果断顶起
奔跑小蜗牛 回答时间:2014-12-20 08:18:54
.。。。。总结的好细致。。。。受教了。。不过,51终究是51,用起来简单,当然也就没那么强大了,stm32虽然复杂,那只是在配置和工作原理上,都熟悉了,性能绝对够不错,万事开头难,上手了就好了。
万里-363223 回答时间:2014-12-21 09:39:00
奔跑小蜗牛 发表于 2014-12-20 08:186 B" s6 j8 l' @- }9 I( }0 o+ k
.。。。。总结的好细致。。。。受教了。。不过,51终究是51,用起来简单,当然也就没那么强大了,stm32虽然 ...
" }0 b  K+ S4 g. c# R
恩恩,没错,还是STM32爽
wjandsq 回答时间:2014-12-21 10:51:09

STM32的串口通信,最好使用DMA方式发送。

本帖最后由 王建 于 2014-12-21 10:57 编辑
2 u  S1 |; e" L2 i
3 \  g% N" Y$ U/ Z* g% P% v/ u, P至于接收,根据实际情况而定。
wjandsq 回答时间:2014-12-21 10:59:47
补充下,上一段是USB转多路串口(USB-Multiple-CDC)例程中的部分代码,仅支持STM32F103xx系列。
12下一页
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版