STM32串口发送中断

[复制链接]

万里-363223 发布时间：2014-12-19 08:49

文章
文章封面:	-
文章简介:	-

SECTION 1

SECTION 2

5 B M: @% u- i0 I+ A3 X

先说TC。即Transmission Complete。发送一个字节后才进入中断，这里称为“发送后中断”。和原来8051的TI方式一样，都是发送后才进中断，需要在发送函数中先发送一个字节触发中断。发送函数如下
void USART_SendDataString( u8 *pData )
{
pDataByte = pData;

USART_ClearFlag(USART1, USART_FLAG_TC);//清除传输完成标志位,否则可能会丢失第1个字节的数据.网友提供.

USART_SendData(USART1, *(pDataByte++) ); //必须要++，不然会把第一个字符t发送两次
}

中断处理函数如下
void USART1_IRQHandler(void)
{
if( USART_GetITStatus(USART1, USART_IT_TC) == SET  )
{
      if( *pDataByte == '\0' )//TC需要读SR+写DR 方可清0,当发送到最后,到'\0'的时候用个if判断关掉
         USART_ClearFlag(USART1, USART_FLAG_TC);//不然TC一直是set, TCIE也是打开的,导致会不停进入中断. clear掉即可,不用关掉TCIE
      else
         USART_SendData(USART1, *pDataByte++ );
}

}

其中u8 *pDataByte;是一个外部指针变量

在中断处理程序中，发送完该字符串后，不用关闭TC的中断使能TCIE，只需要清掉标志位TC；这样就能避免TC == SET 导致反复进入中断了。

串口初始化函数如下
void USART_Config()
{
  USART_InitTypeDef USART_InitStructure;//定义一个包含串口参数的结构体

  USART_InitStructure.USART_BaudRate = 9600; //波特率9600
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据位
  USART_InitStructure.USART_StopBits = USART_StopBits_1;//1位停止位
  USART_InitStructure.USART_Parity = USART_Parity_No;//无校验
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件流控制
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//输入加输出模式
  USART_InitStructure.USART_Clock = USART_Clock_Disable;//时钟关闭
  USART_InitStructure.USART_CPOL = USART_CPOL_Low;
  USART_InitStructure.USART_CPHA = USART_CPHA_2Edge;
  USART_InitStructure.USART_LastBit = USART_LastBit_Disable;
  USART_Init(USART1, &USART_InitStructure);//设置到USART1

  USART_ITConfig(USART1, USART_IT_TC, ENABLE);//Tramsimssion Complete后，才产生中断. 开TC中断必须放在这里,否则还是会丢失第一字节

  USART_Cmd(USART1, ENABLE); //使能USART1
}
这里请问一个问题：开TC中断USART_ITConfig()如果放在我的USART_SendDataString()中再开，会丢失字符串的第一字节。必须放在串口初始化函数中才不会丢。不知道为什么？？

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

再说判断TXE。即Tx DR Empty，发送寄存器空。当使能TXEIE后，只要Tx DR空了，就会产生中断。所以，发送完字符串后必须关掉，否则会导致重复进入中断。这也是和TC不同之处。

发送函数如下：
void USART_SendDataString( u8 *pData )
{
pDataByte = pData;
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);//只要发送寄存器为空，就会一直有中断，因此，要是不发送数据时，把发送中断关闭，只在开始发送时，才打开。

}

中断处理函数如下：
void USART1_IRQHandler(void)
{
if( USART_GetITStatus(USART1, USART_IT_TXE) == SET  )
{
      if( *pDataByte == '\0' )//待发送的字节发到末尾NULL了
         USART_ITConfig(USART1, USART_IT_TXE, DISABLE);//因为是发送寄存器空的中断，所以发完字符串后必须关掉，否则只要空了，就会进中断
      else
         USART_SendData(USART1, *pDataByte++ );
}

}

在串口初始化函数中就不用打开TXE的中断了（是在发送函数中打开的）如下：
void USART_Config()
{
  USART_InitTypeDef USART_InitStructure;//定义一个包含串口参数的结构体

  USART_InitStructure.USART_BaudRate = 9600; //波特率9600
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据位
  USART_InitStructure.USART_StopBits = USART_StopBits_1;//1位停止位
  USART_InitStructure.USART_Parity = USART_Parity_No;//无校验
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件流控制
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//输入加输出模式
  USART_InitStructure.USART_Clock = USART_Clock_Disable;//时钟关闭
  USART_InitStructure.USART_CPOL = USART_CPOL_Low;
  USART_InitStructure.USART_CPHA = USART_CPHA_2Edge;
  USART_InitStructure.USART_LastBit = USART_LastBit_Disable;

  USART_Init(USART1, &USART_InitStructure);//设置到USART1

  USART_Cmd(USART1, ENABLE); //使能USART1
}

SECTION 3

在USART的发送端有2个寄存器，一个是程序可以看到的USART_DR寄存器(下图中阴影部分的TDR)，另一个是程序看不到的移位寄存器(下图中阴影部分Transmit Shift Register)。( I3 Z* k% h4 u4 t# i1 Z$ _

/ {1 e# U8 t. d+ b* J# h7 Q对应USART数据发送有两个标志，一个是TXE=发送数据寄存器空，另一个是TC=发送结束；对照下图，当TDR中的数据传送到移位寄存器后，TXE被设置，此时移位寄存器开始向TX信号线按位传输数据，但因为TDR已经变空，程序可以把下一个要发送的字节(操作USART_DR)写入TDR中，而不必等到移位寄存器中所有位发送结束，所有位发送结束时(送出停止位后)硬件会设置TC标志。' P" g( S7 o& u7 x
0 v. a6 d; u6 _& [9 E! k
另一方面，在刚刚初始化好USART还没有发送任何数据时，也会有TXE标志，因为这时发送数据寄存器是空的。
, ]# a1 |: L3 q8 j8 ]8 {0 M7 t
" t$ r- t1 O7 S, m! p2 _TXEIE和TCIE的意义很简单，TXEIE允许在TXE标志为'1'时产生中断，而TCIE允许在TC标志为'1'时产生中断。5 u' d' Z$ A. `/ j/ j" S

8 [, ~! t+ a" R+ G至于什么时候使用哪个标志，需要根据你的需要自己决定。但我认为TXE允许程序有更充裕的时间填写TDR寄存器，保证发送的数据流不间断。TC可以让程序知道发送结束的确切时间，有利于程序控制外部数据流的时序。

% Z" _- L, i, y0 s' v& n g4 r4 e' P, p

SECTION 4
! ?6 ?( Z/ x, M( k* m. ?

赞收藏 1 评论17 发布时间：2014-12-19 08:49

17个回答

wjandsq 回答时间：2014-12-21 10:53:00

/**
  * @file usb_endp.c
  * @author  wjandcf@gmail.com
  * @version V7.0.2
  * @date 2014.12.20
  * @brief Endpoint routines
  *
  */
/* Includes ------------------------------------------------------------------*/
#include "usb_lib.h"
#include "usb_desc.h"
#include "usb_mem.h"
#include "hw_config.h"
#include "usb_istr.h"
#include "usb_pwr.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/

/* Interval between sending IN packets in frame number (1 frame = 1ms) */
#define VCOMPORT_IN_FRAME_INTERVAL          5

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
uint8_t USB_Rx_Buffer[VIRTUAL_COM_PORT_DATA_SIZE];

extern uint8_t VCP1_Tx_Buffer1[];    /* VCP1 DMA发送缓冲1 */
extern uint8_t VCP2_Tx_Buffer1[];    /* VCP2 DMA发送缓冲1 */
extern uint8_t VCP3_Tx_Buffer1[];    /* VCP3 DMA发送缓冲1 */

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被锁定 */
extern uint8_t  Flag_VCP1_Tx_Buf_Full; /* 1: 表示VCP1_Tx_Buffer2数据可能已放满，暂时不能再从主机接收数据 */
extern uint16_t VCP1_Tx_Buffer_Cnt; /* VCP1 第二缓冲收到的字符总数 */

extern uint8_t  Flag_VCP2_Tx_Buf_Use;  /* 1: 表示DMA发送已启动，VCP2_Tx_Buffer1被锁定 */
extern uint8_t  Flag_VCP2_Tx_Buf_Full; /* 1: 表示VCP2_Tx_Buffer2数据可能已放满，暂时不能再从主机接收数据 */
extern uint16_t VCP2_Tx_Buffer_Cnt; /* VCP2 第二缓冲收到的字符总数 */

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 第二缓冲收到的字符总数 */

extern uint8_t  VCP1_Rx_Buffer[];
extern uint32_t VCP1_Rx_ptr_in;
extern uint32_t VCP1_Rx_ptr_out;
extern uint32_t VCP1_Rx_length;
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;
extern uint32_t VCP2_Rx_length;
extern uint8_t  CDC2_Tx_State;

extern uint8_t  VCP3_Rx_Buffer[];
extern uint32_t VCP3_Rx_ptr_in;
extern uint32_t VCP3_Rx_ptr_out;
extern uint32_t VCP3_Rx_length;
extern uint8_t  CDC3_Tx_State;

/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/

/* 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) {\
         CDCx_Tx_State = 0;\
         SetEPTxCount(ENDPx,0);\
         SetEPTxValid(ENDPx);\
      } else {\
         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;\
         } else {\
            USB_Tx_length = VCPx_Rx_length;\
            VCPx_Rx_ptr_out += VCPx_Rx_length;\
            VCPx_Rx_length = 0;\
         }\
         USB_SIL_Write(ENDPx, &VCPx_Rx_Buffer[USB_Tx_ptr], USB_Tx_length);\
         SetEPTxValid(ENDPx);\
      }\
}\
}
/* USB的OUT端点通过物理串口向外发送数据(阻塞方式) */
#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); \
GPIOx->BSRR = GPIO_Pin_x;\
for (i = 0; i < USB_Rx_Cnt; i++) {\
      USARTx->DR = *(USB_Rx_Buffer + i);\
      while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET);\
}\
SetEPRxValid(ENDPx);\
while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET);\
USART_ClearFlag(USARTx, USART_FLAG_TC);\
GPIOx->BRR = GPIO_Pin_x;\
}

/* USB的OUT端点通过物理串口向外发送数据(DMA方式) */
#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;\
if(Flag_VCPx_Tx_Buf_Use == 0){\
      USB_Rx_Cnt = GetEPRxCount(ENDPx & 0x7F);\
      PMAToUserBufferCopy(&VCPx_Tx_Buffer1[0], GetEPRxAddr(ENDPx & 0x7F), USB_Rx_Cnt);\
      SetEPRxValid(ENDPx);\
      GPIOx->BSRR = GPIO_Pin_x;\
      DMA1_Channelx->CNDTR = USB_Rx_Cnt;\
      DMA_Cmd(DMA1_Channelx, ENABLE);\
      Flag_VCPx_Tx_Buf_Use = 1;\
      VCPx_Tx_Buffer_Cnt = 0;\
} else {\
      USB_Rx_Cnt = GetEPRxCount(ENDPx & 0x7F);\
      if(VCPx_Tx_Buffer_Cnt < (1024-128)){\
      PMAToUserBufferCopy(&VCPx_Tx_Buffer2[VCPx_Tx_Buffer_Cnt], GetEPRxAddr(ENDPx & 0x7F), USB_Rx_Cnt);\
      VCPx_Tx_Buffer_Cnt += USB_Rx_Cnt;\
      SetEPRxValid(ENDPx);\
      } else {\
      PMAToUserBufferCopy(&VCPx_Tx_Buffer2[VCPx_Tx_Buffer_Cnt], GetEPRxAddr(ENDPx & 0x7F), USB_Rx_Cnt);\
      VCPx_Tx_Buffer_Cnt += USB_Rx_Cnt;\
      Flag_VCPx_Tx_Buf_Full = 1;\
      }\
}\
}
/**
* Function Name  : EP2_IN_Callback
* Description :
**/
void EP2_IN_Callback (void) {
EPx_IN_Callback(ENDP2,CDC1_Tx_State,VCP1_Rx_Buffer,VCP1_Rx_ptr_out,VCP1_Rx_length);
}
/**
* Function Name  : EP4_IN_Callback
* Description :
**/
void EP4_IN_Callback(void)
{
EPx_IN_Callback(ENDP4,CDC2_Tx_State,VCP2_Rx_Buffer,VCP2_Rx_ptr_out,VCP2_Rx_length);
}
/**
* Function Name  : EP6_IN_Callback
* Description : VCP3 向PC主机发送数据
**/
void EP6_IN_Callback(void)
{
EPx_IN_Callback(ENDP6,CDC3_Tx_State,VCP3_Rx_Buffer,VCP3_Rx_ptr_out,VCP3_Rx_length);
}
/**
* Function Name  : EP2_OUT_Callback
* Description : VCP1 通过USART1向外送数据
**/
void EP2_OUT_Callback(void) {
#ifdef USB_DMA_SEND
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);
#else
EPx_OUT_Callback(ENDP2,USART1, GPIOB, GPIO_Pin_9); // DR1 PB9
#endif
}
/**
* Function Name  : EP4_OUT_Callback
* Description : VCP2 通过USART2向外送数据
* Input       : None.
* Output       : None.
* Return       : None.
**/
void EP4_OUT_Callback(void)
{
#ifdef USB_DMA_SEND
EPx_OUT_Callback_DMA(Flag_VCP2_Tx_Buf_Use, ENDP4, VCP2_Tx_Buffer1,VCP2_Tx_Buffer2,\
         GPIOB, GPIO_Pin_8, DMA1_Channel7, VCP2_Tx_Buffer_Cnt, Flag_VCP2_Tx_Buf_Full);
#else
EPx_OUT_Callback(ENDP4,USART2, GPIOB, GPIO_Pin_8); // DR2 PB8
#endif
}
/**
* Function Name  : EP6_OUT_Callback
* Description : VCP3 通过USART3向外送数据
**/
void EP6_OUT_Callback(void){
#ifdef USB_DMA_SEND
EPx_OUT_Callback_DMA(Flag_VCP3_Tx_Buf_Use, ENDP6, VCP3_Tx_Buffer1,VCP3_Tx_Buffer2,\
         GPIOA, GPIO_Pin_5, DMA1_Channel2, VCP3_Tx_Buffer_Cnt, Flag_VCP3_Tx_Buf_Full);
#else
EPx_OUT_Callback(ENDP6,USART3,GPIOA,GPIO_Pin_5);  // DR3 PA5
#endif
}
/**
* Function Name  : SOF_Callback / INTR_SOFINTR_Callback
* Description :
**/
void SOF_Callback(void)
{
static uint32_t FrameCount = 0;
static uint32_t Led_Count = 0;
if(bDeviceState == CONFIGURED) {
      if (FrameCount++ >= VCOMPORT_IN_FRAME_INTERVAL) {
         /* Reset the frame counter */
         FrameCount = 0;
         /* Check the data to be sent through IN pipe */
         Handle_USBAsynchXfer();
      }
}
if(++Led_Count > 999) {
      Led_Count = 0;
      if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == 0){
         GPIOB->BSRR = GPIO_Pin_2; // PB2 H
      } else {
         GPIOB->BRR = GPIO_Pin_2;  // PB2 L
      }
}
}

赞评论

万里-363223 回答时间：2014-12-19 08:51:16

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是索引值：
extern __IO uint8_t TxCounter1;
extern uint8_t *TXS;
extern __IO uint8_t TxLen;
void USART1_IRQHandler(void)
{
      if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)
         {
            if(TXS[TxCounter1]) //如果是可显示字符
                  { USART_SendData(USART1,TXS[TxCounter1++]);}
            else //发送完成后关闭TXE中断，
                  { USART_ITConfig(USART1,USART_IT_TXE,DISABLE);}
         }
}
      对于第二种情况，和上面的大同小异，其中TXLen表示要发送的二进制数据长度：
void USART1_IRQHandler(void)
{
      if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) //对USART_DR的写操作，将该位清零。
         {
            if(TxCounter1<TxLen)
                  { USART_SendData(USART1,TXS[TxCounter1++]);}
            else //发送完成后关闭TXE中断
                  { USART_ITConfig(USART1,USART_IT_TXE,DISABLE);}
         }
}
      事实上第一种情况是第二种的特殊形式，就是说可以用第二种情况去发送可显示的字符——当然没人有闲心去数一句话里有多少个字母空格和标点符号！
      在使用时，只要将TXS指向要发送的字符串或者数组，设置TxLen为要发送的数据长度，然后执行USART_ITConfig(USART1, USART_IT_TXE,ENABLE)就立即开始发送过程。用户可以检查TxCounter1来确定发送了多少字节。比如以第二种情况为例：
uint32_t *TXS;
uint8_t TxBuffer1[]="0123456789ABCDEF";
uint8_t DST2[]="ASDFGHJKL";
__IO uint8_t TxLen = 0x00;
   TxLen=8;                            //发送8个字符，最终发送的是01234567
TXS=(uint32_t *)TxBuffer1; //将TXS指向字符串TxBuffer1
TxCounter1=0;                   //复位索引值
USART_ITConfig(USART1, USART_IT_TXE,ENABLE); //启用TXE中断，即开始发送过程
while(TxCounter1!=TxLen); //等待发送完成

TXS=(uint32_t *)TxBuffer2; //同上，最终发送的是ASDFGHJK
TxCounter1=0;
USART_ITConfig(USART1, USART_IT_TXE,ENABLE);
while(TxCounter1!=TxLen);
      以上就是我认为的最佳方案，但串口中断方式数据有多长就中断多少次，我认为还是占用不少CPU时间，相比之下DMA方式就好多了，因为DMA发送字符串时最多中断两次（半传输完成，全传输完成），并且将串口变成类似16C550的器件。