|
SECTION 1
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; " 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 中断处理函数如下0 e2 ~* g4 J3 e; ~0 }0 V void USART1_IRQHandler(void)9 D* Z# U3 e9 L/ F9 \ { if( USART_GetITStatus(USART1, USART_IT_TC) == SET ) {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 else 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 } 其中u8 *pDataByte;是一个外部指针变量" g5 }7 E7 \0 I7 x 在中断处理程序中,发送完该字符串后,不用关闭TC的中断使能TCIE,只需要清掉标志位TC;这样就能避免TC == SET 导致反复进入中断了。 " u+ h3 w V9 ~: s 串口初始化函数如下 void 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;//无硬件流控制 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; 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 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 这里笔者可以给出解释,你看下SECTION1 就可以知道为什么呢,你这样做的原理和SECTION1讲解的差不多,就相当于延时,而你后面没有丢失数据的主要原因就是你代码中有这么一句 USART_ClearFlag(USART1, USART_FLAG_TC);//清除传输完成标志位,否则可能会丢失第1个字节的数据.网友提供. , x0 f* v# X: v! v3 I* ^/ W 发送函数如下:* [! n3 m# S. z2 ^% t& X' |$ l void USART_SendDataString( u8 *pData ) { pDataByte = pData; USART_ITConfig(USART1, USART_IT_TXE, ENABLE);//只要发送寄存器为空,就会一直有中断,因此,要是不发送数据时,把发送中断关闭,只在开始发送时,才打开。 } ( a Y+ c. k; e2 _. H" X' H 中断处理函数如下: void USART1_IRQHandler(void) {+ t& ~ M: M, } if( USART_GetITStatus(USART1, USART_IT_TXE) == SET ) { 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 USART_SendData(USART1, *pDataByte++ ); } 1 ^3 s) n. W3 m3 } }: y6 u1 w0 O+ j9 N7 E 在串口初始化函数中就不用打开TXE的中断了(是在发送函数中打开的)如下:5 q6 S0 X* T u0 D0 p6 V void USART_Config() { USART_InitTypeDef USART_InitStructure;//定义一个包含串口参数的结构体6 M2 [8 q1 C! ]( T3 A USART_InitStructure.USART_BaudRate = 9600; //波特率96005 b2 L; g& @; s USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据位 USART_InitStructure.USART_StopBits = USART_StopBits_1;//1位停止位 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; 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 ~ 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 | } SECTION 38 U, [+ L0 P! Z* c$ R 4 `+ c6 r- D7 ]2 ~ ~ 在USART的发送端有2个寄存器,一个是程序可以看到的USART_DR寄存器(下图中阴影部分的TDR),另一个是程序看不到的移位寄存器(下图中阴影部分Transmit Shift Register)。* l+ f, S2 f# L8 W
SECTION 4
& r. ^7 G7 ^- r1 _0 m; X4 H |
微信公众号
手机版
* @file usb_endp.c
* @author wjandcf@gmail.com8 ~( e( r0 ^! q
* @version V7.0.2
* @date 2014.12.20
* @brief Endpoint routines; v. D X# V; M% E; K$ {& |! D
* e* m* f% o+ O
*/
/* Includes ------------------------------------------------------------------*/
#include "usb_lib.h"0 @# H# w' D/ o( n; m5 A
#include "usb_desc.h"
#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 -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/# i% j0 {2 K* \. M
/* Interval between sending IN packets in frame number (1 frame = 1ms) */7 h) p& A+ D6 Z
#define VCOMPORT_IN_FRAME_INTERVAL 5
/* Private macro -------------------------------------------------------------*/
/* 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
extern uint8_t VCP1_Tx_Buffer1[]; /* VCP1 DMA发送缓冲1 */
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
extern uint8_t VCP1_Tx_Buffer2[]; /* VCP1 第二缓冲(临时存放来自PC主机的数据包) */
extern uint8_t VCP2_Tx_Buffer2[]; /* VCP2 第二缓冲 */
extern uint8_t VCP3_Tx_Buffer2[]; /* VCP3 第二缓冲 */
extern 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数据可能已放满,暂时不能再从主机接收数据 */
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数据可能已放满,暂时不能再从主机接收数据 */
extern uint16_t VCP2_Tx_Buffer_Cnt; /* VCP2 第二缓冲 收到的字符总数 */
' g6 |4 u! a6 E
extern uint8_t Flag_VCP3_Tx_Buf_Use; /* 1: 表示DMA发送已启动,VCP3_Tx_Buffer1被锁定 */
extern uint8_t Flag_VCP3_Tx_Buf_Full; /* 1: 表示VCP3_Tx_Buffer2数据可能已放满,暂时不能再从主机接收数据 */
extern uint16_t VCP3_Tx_Buffer_Cnt; /* VCP3 第二缓冲 收到的字符总数 */
" L! K: }6 x( y
extern uint8_t VCP1_Rx_Buffer[];
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;
extern uint8_t VCP2_Rx_Buffer[];
extern uint32_t VCP2_Rx_ptr_in;
extern 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;
extern uint8_t CDC2_Tx_State; b" ^/ K& ?" f9 K9 [: m9 ]" d% c8 I
extern uint8_t VCP3_Rx_Buffer[];
extern uint32_t VCP3_Rx_ptr_in;: b! ~ e$ E# H1 S( S9 @1 i
extern uint32_t VCP3_Rx_ptr_out;
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
/* Private function prototypes -----------------------------------------------*/5 S: h7 _7 \& j& o4 u' ^6 O
/* Private functions ---------------------------------------------------------*/
0 |- x+ T8 O6 Q- q) \
/* USB的IN端点 发送数据到PC主机 */
#define EPx_IN_Callback(ENDPx, CDCx_Tx_State, VCPx_Rx_Buffer, VCPx_Rx_ptr_out, VCPx_Rx_length) {\
uint16_t USB_Tx_ptr;\
uint16_t USB_Tx_length;\
if (CDCx_Tx_State == 1) {\
USB_Tx_ptr = VCPx_Rx_ptr_out;\
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) {\
USB_Tx_length = VIRTUAL_COM_PORT_DATA_SIZE;\
VCPx_Rx_ptr_out += VIRTUAL_COM_PORT_DATA_SIZE;\
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;\
VCPx_Rx_length = 0;\
}\4 P" P+ Q9 b6 Y
USB_SIL_Write(ENDPx, &VCPx_Rx_Buffer[USB_Tx_ptr], USB_Tx_length);\
SetEPTxValid(ENDPx);\
}\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) {\
uint32_t i;\
uint16_t USB_Rx_Cnt;\
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);\
while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET);\
}\
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;\
}. h, L* Y; _" l( ^2 }
/* 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,\
GPIOx, GPIO_Pin_x, DMA1_Channelx, VCPx_Tx_Buffer_Cnt, Flag_VCPx_Tx_Buf_Full) {\
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);\
PMAToUserBufferCopy(&VCPx_Tx_Buffer1[0], GetEPRxAddr(ENDPx & 0x7F), USB_Rx_Cnt);\
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;\
DMA_Cmd(DMA1_Channelx, ENABLE);\* ^- g: `& l' K5 d
Flag_VCPx_Tx_Buf_Use = 1;\
VCPx_Tx_Buffer_Cnt = 0;\
} 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)){\
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
}\
}\
}
/**
* Function Name : EP2_IN_Callback
* Description :9 _$ B" i1 l/ ^7 W1 T7 m
**/1 {) v4 F& H: H
void EP2_IN_Callback (void) {
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
}
/**
* Function Name : EP4_IN_Callback
* Description :) ]' f* J4 I, q. `6 d$ b
**/
void 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);
}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
**/
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
* Description : VCP1 通过USART1向外送数据
**/
void 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,\
GPIOB, GPIO_Pin_9, DMA1_Channel4, VCP1_Tx_Buffer_Cnt, Flag_VCP1_Tx_Buf_Full);$ S4 b8 N& m) h. c! m
#else
EPx_OUT_Callback(ENDP2,USART1, GPIOB, GPIO_Pin_9); // DR1 PB9
#endif
}7 {6 G' K4 ^ v. ]/ L+ }
/**
* 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.
* Return : None.
**/; L- G- y4 ]" R& \ O
void EP4_OUT_Callback(void)
{4 k) ?1 l4 ~3 G6 {) G9 A+ b" y( l
#ifdef USB_DMA_SEND
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
}
/**
* Function Name : EP6_OUT_Callback
* Description : VCP3 通过USART3向外送数据
**// e0 J1 o8 k) |6 g4 D
void EP6_OUT_Callback(void){: R. M1 L y2 G; y% C' _
#ifdef USB_DMA_SEND
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);
#else * d$ @" n) s1 h6 A% x. J; B' h
EPx_OUT_Callback(ENDP6,USART3,GPIOA,GPIO_Pin_5); // DR3 PA5
#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)
{
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) {
/* Reset the frame counter */2 P0 Z9 D: n S- i% A" W, E
FrameCount = 0;
/* Check the data to be sent through IN pipe */
Handle_USBAsynchXfer();
}+ v6 `' e1 e. M+ o0 Z' O6 ^
}
if(++Led_Count > 999) {2 ?0 [9 R" n! X: f
Led_Count = 0;
if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == 0){
GPIOB->BSRR = GPIO_Pin_2; // PB2 H# ?: p) Z+ c+ o# Y. o; K' u3 K
} else {
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
}
+ O e& a* [1 O/ e- \5 [
总的来说,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清零。. [! 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。对于第二种情况,其结果和第一种的相同。
对于第一种情况,其程序可以这么写:其中TXS是保存了要发送数据的字符串,TxCounter1是索引值:
extern __IO uint8_t TxCounter1;
extern uint8_t *TXS;
extern __IO uint8_t TxLen;
void 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
{
if(TXS[TxCounter1]) //如果是可显示字符9 B0 P8 {* b/ O# K; T1 b
{ USART_SendData(USART1,TXS[TxCounter1++]);}
else //发送完成后关闭TXE中断,
{ USART_ITConfig(USART1,USART_IT_TXE,DISABLE);}
} 8 t0 N4 ?8 O2 u
}
对于第二种情况,和上面的大同小异,其中TXLen表示要发送的二进制数据长度:+ b4 A( |" _, B: d: z, x+ C% k
void USART1_IRQHandler(void)
{
if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) //对USART_DR的写操作,将该位清零。
{ 6 R& X/ m6 N% w% k
if(TxCounter1<TxLen)9 r* ~* _# y1 M; j8 G! P
{ USART_SendData(USART1,TXS[TxCounter1++]);}
else //发送完成后关闭TXE中断
{ USART_ITConfig(USART1,USART_IT_TXE,DISABLE);} , q9 j5 U) M' D; U( a5 {; b
}
}
事实上第一种情况是第二种的特殊形式,就是说可以用第二种情况去发送可显示的字符——当然没人有闲心去数一句话里有多少个字母空格和标点符号!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;
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; //复位索引值
USART_ITConfig(USART1, USART_IT_TXE,ENABLE); //启用TXE中断,即开始发送过程
while(TxCounter1!=TxLen); //等待发送完成 I$ ^$ h7 l: B. r" N0 ~
TXS=(uint32_t *)TxBuffer2; //同上,最终发送的是ASDFGHJK
TxCounter1=0;' h) g m7 V2 F. Z4 R8 a2 E+ |
USART_ITConfig(USART1, USART_IT_TXE,ENABLE);
while(TxCounter1!=TxLen);
以上就是我认为的最佳方案,但串口中断方式数据有多长就中断多少次,我认为还是占用不少CPU时间,相比之下DMA方式就好多了,因为DMA发送字符串时最多中断两次(半传输完成,全传输完成),并且将串口变成类似16C550的器件。
强大的同时,复杂也跟着来了,51是基础,STM32是进阶
恩恩,没错,鱼和熊掌不可兼得
恩恩,没错,还是STM32爽
STM32的串口通信,最好使用DMA方式发送。
至于接收,根据实际情况而定。