21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › USART实现串口通讯
返回列表 发新帖我要提问

[STM32F1] USART实现串口通讯

[复制链接]
1523|7
 楼主| gaoyang9992006 发表于 2016-3-28 19:42 | 显示全部楼层 |阅读模式
USART, 串口通讯, IO, pi, GPIO

STM32F10x 系列单片机中都包含了USART 模块，所谓USART，就是通用同步异步收发器。通用同步异步收发器(USART)提供了一种灵活的方法与使用工业标准NRZ异步串行数据格式的外部设备之间进行全双工数据交换。它支持同步单向通信和半双工单线通信，也支持LIN(局部互连网)，智能卡协议和IrDA(红外数据组织)SIR ENDEC规范，以及调制解调器(CTS/RTS)操作。它还允许多处理器通信。


从前面的介绍可知USART模块功能非常的强大。这里我只简单讲讲如何用USART模块来实现标准EIA-232 串口通讯。


用过单片机的人肯定都接触过串口，设置串口无非就是设置波特率、数据位、停止位、奇偶校验位。发送接收也就三种基本方式，轮询、中断和DMA。STM32F10x 的USART 模块也不过如此。所以我重点讲讲我在调试代码时犯得各种错误，那些很容易得到的代码就不详细的讲解了。


首先说说我的硬件环境。还是那块神舟4号开发板，用的是串口2，对应的是USART2。默认情况下USART2是连接到IO端口A的，但是我这里需要将USART的管腿重定向到IO端口D上。具体的管腿的关系参见下表。这个表是从STM32参考手册上拷下来的。

初始化USART的代码很简单。USART2 连接到APB1 总线上了，先要打开USART2的时钟，然后设置波特率一类的参数。

复制
  1. USART_InitTypeDef USART_InitStructure;
    


  2. 

  3. RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
    

  4. USART_InitStructure.USART_BaudRate = 9600;
    

  5. USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    

  6. USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  7. USART_InitStructure.USART_Parity = USART_Parity_No;
    

  8. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    

  9. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    

  10. USART_Init(USART2, &USART_InitStructure );

这样设置了还不能使用。因为我们将USART2 重定向了。重定向操作需要写复用重映射和调试I/O配置寄存器(AFIO_MAPR)。GPIO_PinRemapConfig() 可以完成这项任务。

GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);

这样操作还不够。STM32参考手册上有这么一段话：

对寄存器AFIO_EVCR，AFIO_MAPR和AFIO_EXTICRX进行读写操作前，应当首先打开AFIO的时钟。参考第6.3.7节APB2外设时钟使能寄存器(RCC_APB2ENR)。

所以需要先打开AFIO的时钟。因此，USART2的重定向需要两步操作：

  • RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);  
  • GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);  

我原以为这样就能工作了，可是结果还是什么都没有输出。没办法只能继续研究。在读GPIO的相关章节时看到下图让我恍然大悟。


USART2的输入输出都是借用PD口管腿，PD 口的时钟却还没给。用到的几个IO 端口也没有设置相应的输入输出状态。在读到8.1.9 复用功能配置这一小节时发现了如下的表格。


按照上面给出的配置，写好程序：

复制
  1. GPIO_InitTypeDef GPIO_InitStructure;
    

  2. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD , ENABLE);
    

  3. /* Configure USART Tx as alternate function push-pull */
    

  4. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  5. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    

  6. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  7. GPIO_Init(GPIOD, &GPIO_InitStructure);
    

  8.         
    

  9. /* Configure USART Rx as input floating */
    

  10. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  11. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    

  12. GPIO_Init(GPIOD, &GPIO_InitStructure);

再次测试，一切正常。

发送一个字符的函数可以这么写：

void UART_PutChar(USART_TypeDef* USARTx, uint8_t Data)
{
        while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET ) {};
        USART_SendData (USARTx, Data);
}
这个函数可以手工优化一下，里面的两个函数调用都可以去掉，甚至于这个函数可以用汇编来实现或者写成inline 函数。不过这里只是个示例代码，没有考虑这些。


发送字符串的函数如下：

void UART_PutStr (USART_TypeDef* USARTx, uint8_t *str)
{
    while (0 != *str)
    {
        UART_PutChar(USARTx, *str);
        str++;
    }
}
上面串口初始化的代码可以放到一个函数中：
复制
  1. void USART2_init(void)
    

  2. {
    

  3.         GPIO_InitTypeDef GPIO_InitStructure;
    

  4.         USART_InitTypeDef USART_InitStructure;
    


  5. 

  6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_AFIO, ENABLE);
    

  7.         
    

  8.         /* Configure USART Tx as alternate function push-pull */
    

  9.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  10.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    

  11.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  12.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    

  13.         
    

  14.         /* Configure USART Rx as input floating */
    

  15.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    

  17.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    

  18.         
    

  19.         GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);
    

  20.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
    


  21. 

  22.         USART_InitStructure.USART_BaudRate = 9600;
    

  23.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    

  24.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  25.         USART_InitStructure.USART_Parity = USART_Parity_No;
    

  26.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    

  27.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    

  28.         USART_Init(USART2, &USART_InitStructure ); 
    


  29. 

  30.     USART_Cmd(USART2, ENABLE);
    

  31. }
接收字符的函数与发送字符的函数差不多，但是这种轮询方式效率很低，不建议使用。下次写一篇介绍如何用中断方式发送接收串口数据，中断方式的效率会高很多。


回复

收藏2 举报

相关帖子
 楼主| gaoyang9992006 发表于 2016-3-28 19:43 | 显示全部楼层

这次讲讲利用串口收发中断来进行串口通讯。STM32 上为每个串口分配了一个中断。也就是说无论是发送完成还是收到数据或是数据溢出都产生同一个中断。程序需在中断处理函数中读取状态寄存器(USART_SR)来判断当前的是什么中断。下面的中断映像图给出了这些中断源是如何汇合成最终的中断信号的。图中也给出了如何控制每一个单独的中断源是否起作用。


另外，Cortex-M3 内核中还有个NVIC，可以控制这里的中断信号是否触发中断处理函数的执行，还有这些外部中断的级别。关于NVIC 可以参考《ARM CortexM3 权威指南》，里面讲解的非常详细。

简单的说，为了开启中断，我们需要如下的代码：

复制
  1. NVIC_InitTypeDef NVIC_InitStructure;
    

  2. NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    

  3. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    

  4. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    

  5. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    

  6. NVIC_Init(&NVIC_InitStructure);
    


  7. 

  8. USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断
    

  9. USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送中断

这里多说一句，串口的发送中断有两个，分别是：

  • l发送数据寄存器空中断（TXE）
  • l发送完成中断（TC）

一般来说我们会使用发送数据寄存器空中断，用这个中断发送的效率会高一些。

中断处理函数的框架如下，如果检测到错误就清除错误，收到数了就处理。发完当前数据了就发下一个。

复制
  1. void USART1_IRQHandler(void)
    

  2. {
    

  3.     unsigned int data;
    


  4. 

  5.     if(USART1->SR & 0x0F) 
    

  6.     {
    

  7.         // See if we have some kind of error, Clear interrupt   
    

  8.         data = USART1->DR;
    

  9.     }
    

  10.     else if(USART1->SR & USART_FLAG_RXNE) //Receive Data Reg Full Flag
    

  11.     {  
    

  12.         data = USART1->DR;
    

  13.         // 对收到的数据进行处理，或者干些其他的事  
    

  14.     }
    

  15.     else if(USART1->SR & USART_FLAG_TXE) 
    

  16.     {
    

  17.         { // 可以发送数据了，如果没有数据需要发送，就在这里关闭发送中断
    

  18.             USART1->DR =  something;        // Yes, Send character                      
    

  19.         }                                           
    

  20.     }  
    

  21. }   


回复

收藏2 举报

 楼主| gaoyang9992006 发表于 2016-3-28 19:48 | 显示全部楼层
下面给一个利用环形缓冲区的串口驱动程序。
复制
  1. #ifndef _COM_BUFFERED_H_
    

  2. #define _COM_BUFFERED_H_
    


  3. 

  4. #define  COM1                   0
    

  5. #define  COM2                   1
    


  6. 

  7. #define  COM_RX_BUF_SIZE        64                /* Number of characters in Rx ring buffer             */
    

  8. #define  COM_TX_BUF_SIZE        64                /* Number of characters in Tx ring buffer             */
    


  9. 

  10. #define  COM_NO_ERR             0                /* Function call was successful                       */
    

  11. #define  COM_BAD_CH             1                /* Invalid communications port channel                */
    

  12. #define  COM_RX_EMPTY           2                /* Rx buffer is empty, no character available         */
    

  13. #define  COM_TX_FULL            3                /* Tx buffer is full, could not deposit character     */
    

  14. #define  COM_TX_EMPTY           4                /* If the Tx buffer is empty.                         */
    


  15. 


  16. 

  17. /************************************************************
    

  18.  * function : COMGetCharB 
    

  19.  * parameter: char port, port can be COM1 / COM2
    

  20.  * parameter: char* err   is a pointer to where an error code will be placed:
    

  21.  *                   *err is set to COM_NO_ERR   if a character is available
    

  22.  *                   *err is set to COM_RX_EMPTY if the Rx buffer is empty
    

  23.  *                   *err is set to COM_BAD_CH   if you have specified an invalid channel
    

  24.  * return   : char
    

  25.  * usage    : This function is called by your application to obtain a character from the communications
    

  26.  *               channel.
    

  27.  * changelog: 
    

  28.  *************************************************************/
    

  29. unsigned char  COMGetCharB (unsigned char ch, unsigned char *err);
    


  30. 

  31. /************************************************************
    

  32.  * function : COMPutCharB 
    

  33.  * parameter: char port, port can be COM1 / COM2
    

  34.  * return   :    COMM_NO_ERR   if the function was successful (the buffer was not full)
    

  35.  *               COMM_TX_FULL  if the buffer was full
    

  36.  *               COMM_BAD_CH   if you have specified an incorrect channel
    


  37. 

  38.  * usage    : This function is called by your application to send a character on the communications
    

  39.  *               channel.  The character to send is first inserted into the Tx buffer and will be sent by
    

  40.  *               the Tx ISR.  If this is the first character placed into the buffer, the Tx ISR will be
    

  41.  *               enabled.  If the Tx buffer is full, the character will not be sent (i.e. it will be lost)
    

  42.  * changelog: 
    

  43.  *************************************************************/
    

  44. unsigned char COMPutCharB (unsigned char port, unsigned char c);
    


  45. 

  46. /************************************************************
    

  47.  * function : COMBufferInit 
    

  48.  * parameter: 
    

  49.  * return   :    
    

  50.  * usage    : This function is called by your application to initialize the communications module.  You
    

  51.  *             must call this function before calling any other functions.
    

  52.  * changelog: 
    

  53.  *************************************************************/
    

  54. void  COMBufferInit (void);
    


  55. 

  56. /************************************************************
    

  57.  * function : COMBufferIsEmpty 
    

  58.  * parameter: char port, port can be COM1 / COM2
    

  59.  * return   : char
    

  60.  * usage    : This function is called by your application to see 
    

  61.  *            if any character is available from the communications channel.
    

  62.  *            If at least one character is available, the function returns
    

  63.  *            FALSE(0) otherwise, the function returns TRUE(1).
    

  64.  * changelog: 
    

  65.  *************************************************************/
    

  66. unsigned char  COMBufferIsEmpty (unsigned char port);
    


  67. 

  68. /************************************************************
    

  69.  * function : COMBufferIsFull 
    

  70.  * parameter: char port, port can be COM1 / COM2
    

  71.  * return   : char
    

  72.  * usage    : This function is called by your application to see if any more characters can be placed
    

  73.  *             in the Tx buffer.  In other words, this function check to see if the Tx buffer is full.
    

  74.  *             If the buffer is full, the function returns TRUE otherwise, the function returns FALSE.
    

  75.  * changelog: 
    

  76.  *************************************************************/
    

  77. unsigned char COMBufferIsFull (unsigned char port);
    


  78. 

  79. #endif
复制
  1. /*
    

  2.  * file: com_buffered.c
    

  3.  * author: Li Yuan
    

  4.  * platform: STM32F107
    

  5.  * date: 2013-5-5
    

  6.  * version: 0.0.1
    

  7.  * description: UART Ring Buffer                            
    

  8. **/
    


  9. 

  10. #include "stm32f10x_usart.h"
    

  11. #include "com_buffered.h"
    


  12. 

  13. #define OS_ENTER_CRITICAL()     __set_PRIMASK(1)
    

  14. #define OS_EXIT_CRITICAL()      __set_PRIMASK(0)   
    

  15.     
    

  16. /**
    

  17.  *        Enables Transmiter interrupt.
    

  18. **/
    

  19. static void COMEnableTxInt(unsigned char port)
    

  20. {
    

  21.         static USART_TypeDef* map[2] = {USART1, USART2};
    

  22.         USART_ITConfig(map[port], USART_IT_TXE, ENABLE);        
    

  23. }
    

  24. /*
    

  25. *********************************************************************************************************
    

  26. *                                               DATA TYPES
    

  27. *********************************************************************************************************
    

  28. */
    

  29. typedef struct {
    

  30.     short  RingBufRxCtr;                   /* Number of characters in the Rx ring buffer              */
    

  31.     unsigned char  *RingBufRxInPtr;                 /* Pointer to where next character will be inserted        */
    

  32.     unsigned char  *RingBufRxOutPtr;                /* Pointer from where next character will be extracted     */
    

  33.     unsigned char   RingBufRx[COM_RX_BUF_SIZE];     /* Ring buffer character storage (Rx)                      */
    

  34.     short  RingBufTxCtr;                   /* Number of characters in the Tx ring buffer              */
    

  35.     unsigned char  *RingBufTxInPtr;                 /* Pointer to where next character will be inserted        */
    

  36.     unsigned char  *RingBufTxOutPtr;                /* Pointer from where next character will be extracted     */
    

  37.     unsigned char   RingBufTx[COM_TX_BUF_SIZE];     /* Ring buffer character storage (Tx)                      */
    

  38. } COM_RING_BUF;
    


  39. 

  40. /*
    

  41. *********************************************************************************************************
    

  42. *                                            GLOBAL VARIABLES
    

  43. *********************************************************************************************************
    

  44. */
    


  45. 

  46. COM_RING_BUF  COM1Buf;
    

  47. COM_RING_BUF  COM2Buf;
    


  48. 


  49. 

  50. /************************************************************
    

  51.  * function : COMGetCharB 
    

  52.  * parameter: char port, port can be COM1 / COM2
    

  53.  * parameter: char* err   is a pointer to where an error code will be placed:
    

  54.  *                   *err is set to COM_NO_ERR   if a character is available
    

  55.  *                   *err is set to COM_RX_EMPTY if the Rx buffer is empty
    

  56.  *                   *err is set to COM_BAD_CH   if you have specified an invalid channel
    

  57.  * return   : char
    

  58.  * usage    : This function is called by your application to obtain a character from the communications
    

  59.  *               channel.
    

  60.  * changelog: 
    

  61.  *************************************************************/
    

  62. unsigned char  COMGetCharB (unsigned char port, unsigned char *err)
    

  63. {
    

  64. //    unsigned char cpu_sr;
    

  65.     
    

  66.     unsigned char c;
    

  67.     COM_RING_BUF *pbuf;
    


  68. 

  69.     switch (port) 
    

  70.     {                                          /* Obtain pointer to communications channel */
    

  71.         case COM1:
    

  72.              pbuf = &COM1Buf;
    

  73.              break;
    


  74. 

  75.         case COM2:
    

  76.              pbuf = &COM2Buf;
    

  77.              break;
    


  78. 

  79.         default:
    

  80.              *err = COM_BAD_CH;
    

  81.              return (0);
    

  82.     }
    

  83.     OS_ENTER_CRITICAL();
    

  84.     if (pbuf->RingBufRxCtr > 0)                            /* See if buffer is empty                   */
    

  85.     {                                                      
    

  86.         pbuf->RingBufRxCtr--;                              /* No, decrement character count            */
    

  87.         c = *pbuf->RingBufRxOutPtr++;                      /* Get character from buffer                */
    

  88.         if (pbuf->RingBufRxOutPtr == &pbuf->RingBufRx[COM_RX_BUF_SIZE]) 
    

  89.         {      
    

  90.             pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];   /* Wrap OUT pointer     */
    

  91.         }
    

  92.         OS_EXIT_CRITICAL();
    

  93.         *err = COM_NO_ERR;
    

  94.         return (c);
    

  95.     } else {
    

  96.         OS_EXIT_CRITICAL();
    

  97.         *err = COM_RX_EMPTY;
    

  98.         c    = 0;                                        /* Buffer is empty, return 0              */
    

  99.         return (c);
    

  100.     }
    

  101. }
    


  102. 


  103. 

  104. /************************************************************
    

  105.  * function : COMPutCharB 
    

  106.  * parameter: char port, port can be COM1 / COM2
    

  107.  * return   :    COMM_NO_ERR   if the function was successful (the buffer was not full)
    

  108.  *               COMM_TX_FULL  if the buffer was full
    

  109.  *               COMM_BAD_CH   if you have specified an incorrect channel
    


  110. 

  111.  * usage    : This function is called by your application to send a character on the communications
    

  112.  *               channel.  The character to send is first inserted into the Tx buffer and will be sent by
    

  113.  *               the Tx ISR.  If this is the first character placed into the buffer, the Tx ISR will be
    

  114.  *               enabled.  If the Tx buffer is full, the character will not be sent (i.e. it will be lost)
    

  115.  * changelog: 
    

  116.  *            1.first implimented by liyuan 2010.11.5
    

  117.  *************************************************************/
    

  118. unsigned char COMPutCharB (unsigned char port, unsigned char c)
    

  119. {
    

  120. //    unsigned char cpu_sr;
    

  121.     
    

  122.     COM_RING_BUF *pbuf;
    

  123.     switch (port) 
    

  124.     {                                                     /* Obtain pointer to communications channel */
    

  125.         case COM1:
    

  126.              pbuf = &COM1Buf;
    

  127.              break;
    


  128. 

  129.         case COM2:
    

  130.              pbuf = &COM2Buf;
    

  131.              break;
    


  132. 

  133.         default:
    

  134.              return (COM_BAD_CH);
    

  135.     }
    


  136. 

  137.     OS_ENTER_CRITICAL();
    

  138.     if (pbuf->RingBufTxCtr < COM_TX_BUF_SIZE) {           /* See if buffer is full                    */
    

  139.         pbuf->RingBufTxCtr++;                              /* No, increment character count            */
    

  140.         *pbuf->RingBufTxInPtr++ = c;                       /* Put character into buffer                */
    

  141.         if (pbuf->RingBufTxInPtr == &pbuf->RingBufTx[COM_TX_BUF_SIZE]) { /* Wrap IN pointer           */
    

  142.             pbuf->RingBufTxInPtr = &pbuf->RingBufTx[0];
    

  143.         }
    

  144.         if (pbuf->RingBufTxCtr == 1) {                     /* See if this is the first character       */
    

  145.             COMEnableTxInt(port);                          /* Yes, Enable Tx interrupts                */
    

  146.             OS_EXIT_CRITICAL();
    

  147.         } else {
    

  148.             OS_EXIT_CRITICAL();
    

  149.         }
    

  150.         return (COM_NO_ERR);
    

  151.     } else {
    

  152.         OS_EXIT_CRITICAL();
    

  153.         return (COM_TX_FULL);
    

  154.     }
    

  155. }
    


  156. 

  157. /************************************************************
    

  158.  * function : COMBufferInit 
    

  159.  * parameter: 
    

  160.  * return   :    
    

  161.  * usage    : This function is called by your application to initialize the communications module.  You
    

  162.  *             must call this function before calling any other functions.
    

  163.  * changelog: 
    

  164.  *************************************************************/
    

  165. void  COMBufferInit (void)
    

  166. {
    

  167.     COM_RING_BUF *pbuf;
    


  168. 

  169.     pbuf                  = &COM1Buf;                     /* Initialize the ring buffer for COM0     */
    

  170.     pbuf->RingBufRxCtr    = 0;
    

  171.     pbuf->RingBufRxInPtr  = &pbuf->RingBufRx[0];
    

  172.     pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];
    

  173.     pbuf->RingBufTxCtr    = 0;
    

  174.     pbuf->RingBufTxInPtr  = &pbuf->RingBufTx[0];
    

  175.     pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];
    


  176. 

  177.     pbuf                  = &COM2Buf;                     /* Initialize the ring buffer for COM1     */
    

  178.     pbuf->RingBufRxCtr    = 0;
    

  179.     pbuf->RingBufRxInPtr  = &pbuf->RingBufRx[0];
    

  180.     pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];
    

  181.     pbuf->RingBufTxCtr    = 0;
    

  182.     pbuf->RingBufTxInPtr  = &pbuf->RingBufTx[0];
    

  183.     pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];
    

  184. }
    


  185. 

  186. /************************************************************
    

  187.  * function : COMBufferIsEmpty 
    

  188.  * parameter: char port, port can be COM1 / COM2
    

  189.  * return   : char
    

  190.  * usage    : This function is called by your application to see 
    

  191.  *            if any character is available from the communications channel.
    

  192.  *            If at least one character is available, the function returns
    

  193.  *            FALSE(0) otherwise, the function returns TRUE(1).
    

  194.  * changelog: 
    

  195.  *************************************************************/
    

  196. unsigned char  COMBufferIsEmpty (unsigned char port)
    

  197. {
    

  198. //    unsigned char cpu_sr;
    

  199.     
    

  200.     unsigned char empty;
    

  201.     COM_RING_BUF *pbuf;
    

  202.     switch (port) 
    

  203.     {                                                     /* Obtain pointer to communications channel */
    

  204.         case COM1:
    

  205.              pbuf = &COM1Buf;
    

  206.              break;
    


  207. 

  208.         case COM2:
    

  209.              pbuf = &COM2Buf;
    

  210.              break;
    


  211. 

  212.         default:
    

  213.              return (1);
    

  214.     }
    

  215.     OS_ENTER_CRITICAL();
    

  216.     if (pbuf->RingBufRxCtr > 0)
    

  217.     {                                                      /* See if buffer is empty                   */
    

  218.         empty = 0;                                         /* Buffer is NOT empty                      */
    

  219.     } 
    

  220.     else 
    

  221.     {
    

  222.         empty = 1;                                         /* Buffer is empty                          */
    

  223.     }
    

  224.     OS_EXIT_CRITICAL();
    

  225.     return (empty);
    

  226. }
    


  227. 


  228. 

  229. /************************************************************
    

  230.  * function : COMBufferIsFull 
    

  231.  * parameter: char port, port can be COM1 / COM2
    

  232.  * return   : char
    

  233.  * usage    : This function is called by your application to see if any more characters can be placed
    

  234.  *             in the Tx buffer.  In other words, this function check to see if the Tx buffer is full.
    

  235.  *             If the buffer is full, the function returns TRUE otherwise, the function returns FALSE.
    

  236.  * changelog: 
    

  237.  *************************************************************/
    

  238. unsigned char COMBufferIsFull (unsigned char port)
    

  239. {
    

  240. //    unsigned char cpu_sr;
    

  241.     
    

  242.     char full;
    

  243.     COM_RING_BUF *pbuf;
    

  244.     switch (port) 
    

  245.     {                                                     /* Obtain pointer to communications channel */
    

  246.         case COM1:
    

  247.              pbuf = &COM1Buf;
    

  248.              break;
    


  249. 

  250.         case COM2:
    

  251.              pbuf = &COM2Buf;
    

  252.              break;
    


  253. 

  254.         default:
    

  255.              return (1);
    

  256.     }
    

  257.     OS_ENTER_CRITICAL();
    

  258.     if (pbuf->RingBufTxCtr < COM_TX_BUF_SIZE) {           /* See if buffer is full                    */
    

  259.         full = 0;                                      /* Buffer is NOT full                       */
    

  260.     } else {
    

  261.         full = 1;                                       /* Buffer is full                           */
    

  262.     }
    

  263.     OS_EXIT_CRITICAL();
    

  264.     return (full);
    

  265. }
    


  266. 


  267. 

  268. // This function is called by the Rx ISR to insert a character into the receive ring buffer.
    

  269. static void  COMPutRxChar (unsigned char port, unsigned char c)
    

  270. {
    

  271.     COM_RING_BUF *pbuf;
    


  272. 

  273.     switch (port) 
    

  274.     {                                                     /* Obtain pointer to communications channel */
    

  275.         case COM1:
    

  276.              pbuf = &COM1Buf;
    

  277.              break;
    


  278. 

  279.         case COM2:
    

  280.              pbuf = &COM2Buf;
    

  281.              break;
    


  282. 

  283.         default:
    

  284.              return;
    

  285.     }
    

  286.     if (pbuf->RingBufRxCtr < COM_RX_BUF_SIZE) {           /* See if buffer is full                    */
    

  287.         pbuf->RingBufRxCtr++;                              /* No, increment character count            */
    

  288.         *pbuf->RingBufRxInPtr++ = c;                       /* Put character into buffer                */
    

  289.         if (pbuf->RingBufRxInPtr == &pbuf->RingBufRx[COM_RX_BUF_SIZE]) { /* Wrap IN pointer           */
    

  290.             pbuf->RingBufRxInPtr = &pbuf->RingBufRx[0];
    

  291.         }
    

  292.     }
    

  293. }
    


  294. 


  295. 

  296. // This function is called by the Tx ISR to extract the next character from the Tx buffer.
    

  297. //    The function returns FALSE if the buffer is empty after the character is extracted from
    

  298. //    the buffer.  This is done to signal the Tx ISR to disable interrupts because this is the
    

  299. //    last character to send.
    

  300. static unsigned char COMGetTxChar (unsigned char port, unsigned char *err)
    

  301. {
    

  302.     unsigned char c;
    

  303.     COM_RING_BUF *pbuf;
    


  304. 

  305.     switch (port) 
    

  306.     {                                          /* Obtain pointer to communications channel */
    

  307.         case COM1:
    

  308.              pbuf = &COM1Buf;
    

  309.              break;
    


  310. 

  311.         case COM2:
    

  312.              pbuf = &COM2Buf;
    

  313.              break;
    


  314. 

  315.         default:
    

  316.              *err = COM_BAD_CH;
    

  317.              return (0);
    

  318.     }
    

  319.     if (pbuf->RingBufTxCtr > 0) {                          /* See if buffer is empty                   */
    

  320.         pbuf->RingBufTxCtr--;                              /* No, decrement character count            */
    

  321.         c = *pbuf->RingBufTxOutPtr++;                      /* Get character from buffer                */
    

  322.         if (pbuf->RingBufTxOutPtr == &pbuf->RingBufTx[COM_TX_BUF_SIZE]) 
    

  323.         {     
    

  324.             pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];   /* Wrap OUT pointer     */
    

  325.         }
    

  326.         *err = COM_NO_ERR;
    

  327.         return (c);                                        /* Characters are still available           */
    

  328.     } else {
    

  329.         *err = COM_TX_EMPTY;
    

  330.         return (0);                                      /* Buffer is empty                          */
    

  331.     }
    

  332. }
    


  333. 


  334. 

  335. void USART1_IRQHandler(void)
    

  336. {
    

  337.     unsigned int data;
    

  338.     unsigned char err;
    


  339. 

  340.     if(USART1->SR & 0x0F) 
    

  341.     {
    

  342.         // See if we have some kind of error   
    

  343.         // Clear interrupt (do nothing about it!)    
    

  344.         data = USART1->DR;
    

  345.     }
    

  346.     else if(USART1->SR & USART_FLAG_RXNE) //Receive Data Reg Full Flag
    

  347.     {  
    

  348.         data = USART1->DR;
    

  349.         COMPutRxChar(COM1, data);                    // Insert received character into buffer     
    

  350.     }
    

  351.     else if(USART1->SR & USART_FLAG_TXE) 
    

  352.     {
    

  353.         data = COMGetTxChar(COM1, &err);             // Get next character to send.               
    

  354.         if (err == COM_TX_EMPTY) 
    

  355.         {                                            // Do we have anymore characters to send ?   
    

  356.                                                      // No,  Disable Tx interrupts                
    

  357.             //USART_ITConfig(USART1, USART_IT_TXE| USART_IT_TC, ENABLE);
    

  358.                         USART1->CR1 &= ~USART_FLAG_TXE | USART_FLAG_TC;
    

  359.         } 
    

  360.         else 
    

  361.         {
    

  362.             USART1->DR = data;        // Yes, Send character                      
    

  363.         }                                           
    

  364.     }  
    

  365. }    
    


  366. 

  367. void USART2_IRQHandler(void)
    

  368. {
    

  369.     unsigned int data;
    

  370.     unsigned char err;
    


  371. 

  372.     if(USART2->SR & 0x0F) 
    

  373.     {
    

  374.         // See if we have some kind of error   
    

  375.         // Clear interrupt (do nothing about it!)    
    

  376.         data = USART2->DR;
    

  377.     }
    

  378.     else if(USART2->SR & USART_FLAG_RXNE) //Receive Data Reg Full Flag
    

  379.     {  
    

  380.         data = USART2->DR;
    

  381.         COMPutRxChar(COM2, data);                    // Insert received character into buffer     
    

  382.     }
    

  383.     else if(USART2->SR & USART_FLAG_TXE) 
    

  384.     {
    

  385.         data = COMGetTxChar(COM2, &err);             // Get next character to send.               
    

  386.         if (err == COM_TX_EMPTY) 
    

  387.         {                                            // Do we have anymore characters to send ?   
    

  388.                                                      // No,  Disable Tx interrupts                
    

  389.             //USART_ITConfig(USART2, USART_IT_TXE| USART_IT_TC, ENABLE);
    

  390.                         USART2->CR1 &= ~USART_FLAG_TXE | USART_FLAG_TC;
    

  391.         } 
    

  392.         else 
    

  393.         {
    

  394.             USART2->DR = data;        // Yes, Send character                      
    

  395.         }                                           
    

  396.     }  
    

  397. }


回复

收藏2 举报

 楼主| gaoyang9992006 发表于 2016-3-28 19:50 | 显示全部楼层
下面给个例子主程序，来演示如何使用上面的串口驱动代码。
复制
  1. #include "misc.h"
    

  2. #include "stm32f10x.h"
    

  3. #include "com_buffered.h"
    


  4. 

  5. void UART_PutStrB (unsigned char port, uint8_t *str)
    

  6. {
    

  7.     while (0 != *str)
    

  8.     {
    

  9.         COMPutCharB(port, *str);
    

  10.         str++;
    

  11.     }
    

  12. }
    


  13. 

  14. void USART1_Init(void)
    

  15. {
    

  16.         GPIO_InitTypeDef GPIO_InitStructure;
    

  17.         USART_InitTypeDef USART_InitStructure;
    

  18.         NVIC_InitTypeDef NVIC_InitStructure;
    


  19. 

  20.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);
    

  21.         
    

  22.         /* Configure USART Tx as alternate function push-pull */
    

  23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  24.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    

  25.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  26.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    

  27.         
    

  28.         /* Configure USART Rx as input floating */
    

  29.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    

  31.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  32. 

  33.         USART_InitStructure.USART_BaudRate = 9600;
    

  34.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    

  35.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  36.         USART_InitStructure.USART_Parity = USART_Parity_No;
    

  37.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    

  38.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    

  39.         USART_Init(USART1, &USART_InitStructure ); 
    


  40. 

  41.         USART_Cmd(USART1, ENABLE);
    


  42. 

  43.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    

  44.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    

  45.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    

  46.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    

  47.         NVIC_Init(&NVIC_InitStructure);
    

  48. }
    


  49. 

  50. void USART2_Init(void)
    

  51. {
    

  52.         GPIO_InitTypeDef GPIO_InitStructure;
    

  53.         USART_InitTypeDef USART_InitStructure;
    

  54.         NVIC_InitTypeDef NVIC_InitStructure;
    


  55. 

  56.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_AFIO, ENABLE);
    

  57.         
    

  58.         /* Configure USART Tx as alternate function push-pull */
    

  59.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  60.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    

  61.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  62.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    

  63.         
    

  64.         /* Configure USART Rx as input floating */
    

  65.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  66.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    

  67.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    

  68.         
    

  69.         GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);
    

  70.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
    


  71. 

  72.         USART_InitStructure.USART_BaudRate = 9600;
    

  73.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    

  74.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  75.         USART_InitStructure.USART_Parity = USART_Parity_No;
    

  76.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    

  77.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    

  78.         USART_Init(USART2, &USART_InitStructure ); 
    


  79. 

  80.         USART_Cmd(USART2, ENABLE);
    


  81. 

  82.         NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    

  83.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    

  84.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    

  85.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    

  86.         NVIC_Init(&NVIC_InitStructure);
    

  87. }
    


  88. 


  89. 

  90. int main(void)
    

  91. {
    

  92.         unsigned char c;
    

  93.         unsigned char err;
    

  94.         
    

  95.         USART1_Init();
    

  96.         USART2_Init();        
    

  97.         COMBufferInit();
    

  98.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    

  99.         USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    


  100. 

  101.         UART_PutStrB(COM1, "Hello World!\n");
    

  102.         for(;;)
    

  103.         {
    

  104.                 c = COMGetCharB(COM1, &err);
    

  105.                 if(err == COM_NO_ERR)
    

  106.                 {
    

  107.                         COMPutCharB(COM1, c);
    

  108.                 }
    

  109.         }        
    

  110. }


回复

收藏2 举报

稳稳の幸福 发表于 2016-3-28 21:17 | 显示全部楼层
NVIC 依照优先级处理所有支持的异常，所有异常在“处理器模式”处理。NVIC 结构支持32(IRQ[31:0]) 个离散中断，每个中断可以支持 4 级离散中断优先级。所有的中断和大多数系统异常可以配置为不同优先级。当中断发生时，NVIC 将比较新中断与当前中断的优先级，如果新中断优先级高，则立即处理新中断。当接受任何中断时，ISR的开始地址可从内存的向量表中取得。不需要确定哪个中断被响应，也不要软件分配相关中断服务程序（ISR）的开始地址。当获取中断入口地址时，NVIC 将自动保存处理状态到栈中，包括以下寄存器“PC, PSR, LR, R0~R3, R12” 的值。在ISR结束时，NVIC 将从栈中恢复相关寄存器的值，进行正常操作，因此花费少量且确定的时间处理中断请求。NVIC 支持末尾连锁 ”TailChaining”，有效处理背对背中断 ”back-to-back interrupts”，即无需保存和恢复当前状态从而减少在切换当前ISR时的延迟时间。NVIC 还支持迟到 “Late Arrival”，改善同时发生的ISR的效率。当较高优先级中断请求发生在当前ISR开始执行之前（保持处理器状态和获取起始地址阶段），NVIC 将立即处理更高优先级的中断，从而提高了实时性。
回复

收藏2 举报

豆腐块 发表于 2016-3-28 21:36 | 显示全部楼层
一般来说我们会使用发送数据寄存器空中断，用这个中断发送的效率会高一些
回复

收藏2 举报

 楼主| gaoyang9992006 发表于 2016-3-28 22:37 | 显示全部楼层
本文主要 讨论了其中的一种方法，大家都知道实现串口的方法，以及形式太多了。
回复

收藏2 举报

yklstudent 发表于 2016-3-29 09:19 | 显示全部楼层
楼主的代码结构挺好的，学习下
回复

收藏2 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

gaoyang9992006 Image
个人签名：如果你觉得我的分享或者答复还可以，请给我点赞，谢谢。

2052

主题

16403

帖子

222

粉丝
快速回复 在线客服 返回列表 返回顶部