学习目标

  1. 掌握串口初始化流程
  2. 掌握串口接收逻辑
  3. 了解中断接收逻辑

  4. 熟练掌握串口开发流程

    学习内容

    需求

    181.png
    串口接收PC机发送的数据。

    串口数据接收

    1. static void USART_config() {
    2.  uint32_t usartx_tx_rcu = RCU_GPIOA;
    3.  uint32_t usartx_tx_port = GPIOA;
    4.  uint32_t usartx_tx_pin = GPIO_PIN_9;
    5.  uint32_t usartx_tx_af = GPIO_AF_7;
    7.  uint32_t usartx_rx_rcu = RCU_GPIOA;
    8.  uint32_t usartx_rx_port = GPIOA;
    9.  uint32_t usartx_rx_pin = GPIO_PIN_10;
    10.  uint32_t usartx_rx_af = GPIO_AF_7;
    12.  uint32_t usartx = USART0;
    13.  uint32_t usartx_rcu = RCU_USART0;
    14.  uint32_t usartx_irqn = USART0_IRQn;
    16.  uint32_t usartx_p_baudrate = 115200;
    17.  uint32_t usartx_p_parity = USART_PM_NONE;
    18.  uint32_t usartx_p_wl = USART_WL_8BIT;
    19.  uint32_t usartx_p_stop_bit = USART_STB_1BIT;
    20.  uint32_t usartx_p_data_first = USART_MSBF_LSB;
    22.  /************** gpio config **************/
    23.  // tx
    24.  rcu_periph_clock_enable(usartx_tx_rcu);    // 配置时钟
    25.  gpio_mode_set(usartx_tx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_tx_pin);
    26.  gpio_af_set(usartx_tx_port, usartx_tx_af, usartx_tx_pin);
    27.  gpio_output_options_set(usartx_tx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_tx_pin);
    28.  // rx
    29.  rcu_periph_clock_enable(usartx_rx_rcu); // 配置时钟
    30.  gpio_mode_set(usartx_rx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_rx_pin);
    31.  gpio_af_set(usartx_rx_port, usartx_rx_af, usartx_rx_pin);
    32.  gpio_output_options_set(usartx_rx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_rx_pin);
    34.  /************** usart config **************/
    35.  // 串口时钟
    36.  rcu_periph_clock_enable(RCU_USART0);
    37.  // USART复位
    38.  usart_deinit(usartx);
    40.  usart_baudrate_set(usartx, usartx_p_baudrate);    // 波特率
    41.  usart_parity_config(usartx, usartx_p_parity); // 校验位
    42.  usart_word_length_set(usartx, usartx_p_wl); // 数据位数
    43.  usart_stop_bit_set(usartx, usartx_p_stop_bit); // 停止位
    44.  usart_data_first_config(usartx, usartx_p_data_first); // 先发送高位还是低位
    46.  // 发送功能配置
    47.  usart_transmit_config(usartx, USART_TRANSMIT_ENABLE); 
    49.  // 接收功能配置
    50.  usart_receive_config(usartx, USART_RECEIVE_ENABLE);
    51.  // 接收中断配置
    52.  nvic_irq_enable(usartx_irqn, 2, 2);
    53.  // usart int rbne
    54.  usart_interrupt_enable(usartx, USART_INT_RBNE);
    55.  usart_interrupt_enable(usartx, USART_INT_IDLE);
    57.  // 使能串口
    58.  usart_enable(usartx); 
    59. }

    ```c

    define USART_RECEIVE_LENGTH 1024

    //串口接收缓冲区大小 uint8_t g_recv_buff[USART_RECEIVE_LENGTH]; // 接收缓冲区 //接收到字符存放的位置 int g_recv_length = 0;

void USART0_IRQHandler(void) { if ((usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) == SET) { uint16_t value = usart_data_receive(USART0); g_recv_buff[g_recv_length] = value;
g_recv_length++; } if (usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE) == SET) { //读取缓冲区,清空缓冲区 usart_data_receive(USART0); g_recv_buff[g_recv_length] = ‘\0’;

  1.     // TODO: g_recv_buff为接收的数据，g_recv_length为接收的长度
  3.     g_recv_length = 0;
  4. }

}

  1. <a name="KBf1M"></a>
  2. ### 中断函数
  4. 1. 中断函数的名称是在CMSIS的汇编接口中定义的
  6. ![182.png](https://cdn.nlark.com/yuque/0/2023/png/27903758/1691665548744-8b682765-4a38-4990-b186-9b210ba3de40.png#averageHue=%23eeedec&clientId=u5bc733c2-08d2-4&from=ui&id=u37668828&originHeight=57&originWidth=1138&originalType=binary&ratio=1&rotation=0&showTitle=false&size=16241&status=done&style=none&taskId=ue855c04c-3a37-448d-a9e9-9a39443d69e&title=)<br />![183.png](https://cdn.nlark.com/yuque/0/2023/png/27903758/1691665563474-706cb574-625f-44f0-9fc6-68e3a8e1b86e.png#averageHue=%23042030&clientId=u5bc733c2-08d2-4&from=ui&id=ub995c6ab&originHeight=93&originWidth=971&originalType=binary&ratio=1&rotation=0&showTitle=false&size=21904&status=done&style=none&taskId=u75c350a0-5f26-405f-a3f2-9cecc5ade85&title=)
  8. 2. 中断触发需要进行配置
  9. ```c
  10. ......
  11. // 接收功能配置
  12. usart_receive_config(usartx, USART_RECEIVE_ENABLE);
  13. // 接收中断配置
  14. nvic_irq_enable(usartx_irqn, 2, 2);
  15. // usart int rbne
  16. usart_interrupt_enable(usartx, USART_INT_RBNE);
  17. usart_interrupt_enable(usartx, USART_INT_IDLE);
  18. ......

串口接收流程（了解）

寄存器与电路。

  1. 数据接收缓存寄存器（接收和发送其实公用一个寄存器）
  2. 状态寄存器

外部通过串口发送数据到MCU中来时，首先会把高低电平进行转换为单个byte，接着存储到这个缓存寄存器，存储一个byte的时候，会改变寄存器状态，然后会触发中断，我们在中断中，我们就知道接收到了一个byte，我们就可以去数据接收缓存寄存器中取数据，取完后，接收方又去存，这样周而复始的进行接收。知道外部不发送数据了，这个时候如果长期没有收到数据，就会触发闲置寄存器标记。

完整示例

  1. #include "gd32f4xx.h"
  2. #include "systick.h"
  3. #include <stdio.h>
  4. #include "main.h"
  6. /**
  7. PA9        TXD
  8. PA10    RXD
  9. **/
  11. #define USART_RECEIVE_LENGTH  1024
  12. //串口接收缓冲区大小
  13. uint8_t g_recv_buff[USART_RECEIVE_LENGTH];   // 接收缓冲区
  14. //接收到字符存放的位置
  15. int g_recv_length = 0;
  17. static void USART_config() {
  18.     uint32_t usartx_tx_rcu = RCU_GPIOA;
  19.     uint32_t usartx_tx_port = GPIOA;
  20.     uint32_t usartx_tx_pin = GPIO_PIN_9;
  21.     uint32_t usartx_tx_af = GPIO_AF_7;
  23.     uint32_t usartx_rx_rcu = RCU_GPIOA;
  24.     uint32_t usartx_rx_port = GPIOA;
  25.     uint32_t usartx_rx_pin = GPIO_PIN_10;
  26.     uint32_t usartx_rx_af = GPIO_AF_7;
  28.     uint32_t usartx = USART0;
  29.     uint32_t usartx_rcu = RCU_USART0;
  30.     uint32_t usartx_irqn = USART0_IRQn;
  32.     uint32_t usartx_p_baudrate = 115200;
  33.     uint32_t usartx_p_parity = USART_PM_NONE;
  34.     uint32_t usartx_p_wl = USART_WL_8BIT;
  35.     uint32_t usartx_p_stop_bit = USART_STB_1BIT;
  36.     uint32_t usartx_p_data_first = USART_MSBF_LSB;
  38.     /************** gpio config **************/
  39.     // tx
  40.     rcu_periph_clock_enable(usartx_tx_rcu);    // 配置时钟
  41.     gpio_mode_set(usartx_tx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_tx_pin);
  42.     gpio_af_set(usartx_tx_port, usartx_tx_af, usartx_tx_pin);
  43.     gpio_output_options_set(usartx_tx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_tx_pin);
  44.     // rx
  45.     rcu_periph_clock_enable(usartx_rx_rcu); // 配置时钟
  46.     gpio_mode_set(usartx_rx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_rx_pin);
  47.     gpio_af_set(usartx_rx_port, usartx_rx_af, usartx_rx_pin);
  48.     //gpio_output_options_set(usartx_rx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_rx_pin);
  50.     /************** usart config **************/
  51.     // 串口时钟
  52.     rcu_periph_clock_enable(RCU_USART0);
  53.     // USART复位
  54.     usart_deinit(usartx);
  56.     usart_baudrate_set(usartx, usartx_p_baudrate);    // 波特率
  57.     usart_parity_config(usartx, usartx_p_parity); // 校验位
  58.     usart_word_length_set(usartx, usartx_p_wl); // 数据位数
  59.     usart_stop_bit_set(usartx, usartx_p_stop_bit); // 停止位
  60.     usart_data_first_config(usartx, usartx_p_data_first); // 先发送高位还是低位
  62.     // 发送功能配置
  63.     usart_transmit_config(usartx, USART_TRANSMIT_ENABLE); 
  65.     // 接收功能配置
  66.     usart_receive_config(usartx, USART_RECEIVE_ENABLE);
  67.     // 接收中断配置
  68.     nvic_irq_enable(usartx_irqn, 2, 2);
  69.     // usart int rbne
  70.     usart_interrupt_enable(usartx, USART_INT_RBNE);
  71.     usart_interrupt_enable(usartx, USART_INT_IDLE);
  73.     // 使能串口
  74.     usart_enable(usartx); 
  75. }
  77. //发送一byte数据
  78. static void send_data(uint8_t data) {
  79.     //通过USART发送
  80.     usart_data_transmit(USART0, data);
  81.     //判断缓冲区是否已经空了
  82.     //FlagStatus state = usart_flag_get(USART_NUM,USART_FLAG_TBE);
  83.     while(RESET == usart_flag_get(USART0, USART_FLAG_TBE));
  84. }
  86. void USART0_IRQHandler(void) {
  87.     if ((usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) == SET) {
  88.         uint16_t value = usart_data_receive(USART0);
  89.         g_recv_buff[g_recv_length] = value;        
  90.         g_recv_length++;
  91.     }
  92.     if (usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE) == SET) {
  93.         //读取缓冲区,清空缓冲区
  94.         usart_data_receive(USART0);
  95.         g_recv_buff[g_recv_length] = '\0';
  97.         // TODO: g_recv_buff为接收的数据，g_recv_length为接收的长度
  98.         printf("%s", g_recv_buff);
  100.         g_recv_length = 0;
  101.     }
  102. }
  104. //发送字符串
  105. static void send_string(char *data){
  106.     //满足: 1.data指针不为空  2.发送的数据不是\0结束标记
  107.     while(data && *data){
  108.         send_data((uint8_t)(*data));
  109.         data++;
  110.     }
  111. }
  113. //重写fputc方法  调用printf,会自动调用这个方法实现打印
  114. int fputc(int ch, FILE *f){
  115.     send_data((uint8_t)ch);
  116.     return ch;
  117. }
  120. int main(void)
  121. {
  122.     systick_config();
  123.     USART_config();
  125.     while(1) {
  126.     }
  127. }