串口模板V1.0

源码

  1. #ifndef __USART0_H__
  2. #define __USART0_H__
  4. #include "gd32f4xx.h"
  5. #include <stdio.h>
  7. #define USART0_RX_ENABLE    1
  9. void Usart0_init();
  10. void Usart0_send_byte(uint8_t data);
  11. void Usart0_send_string(char* data);
  13. #if USART0_RX_ENABLE
  14. extern void Usart0_recv(uint8_t* data, uint32_t len);
  15. #endif
  17. #endif
  1. #include "Usart0.h"
  3. #if USART0_RX_ENABLE
  4. #define USART_RECEIVE_LENGTH  1024
  5. //串口接收缓冲区大小
  6. uint8_t g_recv_buff[USART_RECEIVE_LENGTH];   // 接收缓冲区
  7. //接收到字符存放的位置
  8. uint32_t g_recv_length = 0;
  9. #endif
  11. //1. 初始化
  12. void Usart0_init() {
  13.     // 哪个串口
  14.     uint32_t usartx = USART0;
  15.     uint32_t usartx_rcu = RCU_USART0;
  16.     uint32_t usartx_irq = USART0_IRQn;
  18.     // 波特率
  19.     uint32_t usartx_p_baudrate = 115200;
  21.     // tx和rx，用了哪个引脚
  22.     uint32_t usartx_tx_port_rcu = RCU_GPIOA;
  23.     uint32_t usartx_tx_port = GPIOA;
  24.     uint32_t usartx_tx_pin = GPIO_PIN_9;
  25.     // 复用功能编号
  26.     uint32_t usartx_tx_af = GPIO_AF_7;
  28.     // tx和rx，用了哪个引脚
  29.     uint32_t usartx_rx_port_rcu = RCU_GPIOA;
  30.     uint32_t usartx_rx_port = GPIOA;
  31.     uint32_t usartx_rx_pin = GPIO_PIN_10;
  32.     // 复用功能编号
  33.     uint32_t usartx_rx_af = GPIO_AF_7;
  36.     /*************** gpio *****************/
  37.     // TX
  38.     // 配置时钟
  39.     rcu_periph_clock_enable(usartx_tx_port_rcu);
  40.     // 配置模式: 复用功能
  41.     gpio_mode_set(usartx_tx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_tx_pin);
  42.     // 配置复用功能
  43.     gpio_af_set(usartx_tx_port, usartx_tx_af, usartx_tx_pin);
  44.     gpio_output_options_set(usartx_tx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_tx_pin);
  46.     // RX
  47.     // 配置时钟
  48.     rcu_periph_clock_enable(usartx_rx_port_rcu);
  49.     gpio_mode_set(usartx_rx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_rx_pin);
  50.     gpio_af_set(usartx_rx_port, usartx_rx_af, usartx_rx_pin);
  51.     // 配置输出参数
  52.     gpio_output_options_set(usartx_rx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_rx_pin);
  54.     /*************** usart ****************/
  55.     // 串口时钟
  56.     rcu_periph_clock_enable(usartx_rcu);
  57.     // USART复位
  58.     usart_deinit(usartx);
  60.     // 波特率
  61.     usart_baudrate_set(usartx, usartx_p_baudrate);
  62.     // 校验位
  63.     usart_parity_config(usartx, USART_PM_NONE);
  64.     // 数据位数
  65.     usart_word_length_set(usartx, USART_WL_8BIT);
  66.     // 停止位
  67.     usart_stop_bit_set(usartx, USART_STB_1BIT);
  68.     // 先发送高位还是低位
  69.     usart_data_first_config(usartx, USART_MSBF_LSB);
  71.     // 发送功能配置
  72.     usart_transmit_config(usartx, USART_TRANSMIT_ENABLE);
  74.     #if USART0_RX_ENABLE
  75.     // 接收功能配置
  76.     usart_receive_config(usartx, USART_RECEIVE_ENABLE);
  77.     // 接收中断配置
  78.     nvic_irq_enable(usartx_irq, 2, 2);
  79.     // usart int rbne
  80.     usart_interrupt_enable(usartx, USART_INT_RBNE);
  81.     usart_interrupt_enable(usartx, USART_INT_IDLE);
  82.     #endif
  84.     // 使能串口
  85.     usart_enable(usartx);
  86. }
  88. //2. 发送
  89. void Usart0_send_byte(uint8_t data) {
  90.     //通过USART发送
  91.     usart_data_transmit(USART0, data);
  93.     //判断缓冲区是否已经空了
  94.     //FlagStatus state = usart_flag_get(USART_NUM,USART_FLAG_TBE);
  95.     while(RESET == usart_flag_get(USART0, USART_FLAG_TBE));
  96. }
  97. void Usart0_send_string(char* data) {
  99.     while(data && *data) {
  100.         Usart0_send_byte((uint8_t)(*data));
  101.         data++;
  102.     }
  103. }
  105. // printf打印功能
  106. int fputc(int ch, FILE *f){
  107.     Usart0_send_byte((uint8_t)ch);
  108.     return ch;
  109. }
  112. #if USART0_RX_ENABLE
  113. // 名称不能随意改，串口0的中断，就是这个名字
  114. void USART0_IRQHandler(void) {
  115.     if ((usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) == SET) {
  116.         uint16_t value = usart_data_receive(USART0);
  117.         g_recv_buff[g_recv_length] = value;        
  118.         g_recv_length++;
  119.     }
  120.     if (usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE) == SET) {
  121.         //读取缓冲区,清空缓冲区
  122.         usart_data_receive(USART0);
  123.         g_recv_buff[g_recv_length] = '\0';
  125.         // TODO: g_recv_buff为接收的数据，g_recv_length为接收的长度
  126.         // printf("recv: %s\r\n", g_recv_buff);
  127.         Usart0_recv(g_recv_buff, g_recv_length);
  130.         g_recv_length = 0;
  131.     }
  132. }
  133. #endif

使用

  1. Usart0_init();
  1. Usart0_send_byte(0x00);
  1. Usart0_send_string("");

串口底层

初始化

  1. // 哪个串口
  2. uint32_t usartx = USART0;
  3. uint32_t usartx_rcu = RCU_USART0;
  4. uint32_t usartx_irq = USART0_IRQn;
  6. // 波特率
  7. uint32_t usartx_p_baudrate = 115200;
  9. // tx和rx，用了哪个引脚
  10. uint32_t usartx_tx_port_rcu = RCU_GPIOA;
  11. uint32_t usartx_tx_port = GPIOA;
  12. uint32_t usartx_tx_pin = GPIO_PIN_9;
  13. // 复用功能编号
  14. uint32_t usartx_tx_af = GPIO_AF_7;
  16. // tx和rx，用了哪个引脚
  17. uint32_t usartx_rx_port_rcu = RCU_GPIOA;
  18. uint32_t usartx_rx_port = GPIOA;
  19. uint32_t usartx_rx_pin = GPIO_PIN_10;
  20. // 复用功能编号
  21. uint32_t usartx_rx_af = GPIO_AF_7;
  24. /*************** gpio *****************/
  25. // TX
  26. // 配置时钟
  27. rcu_periph_clock_enable(usartx_tx_port_rcu);
  28. // 配置模式: 复用功能
  29. gpio_mode_set(usartx_tx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_tx_pin);
  30. // 配置复用功能
  31. gpio_af_set(usartx_tx_port, usartx_tx_af, usartx_tx_pin);
  32. gpio_output_options_set(usartx_tx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_tx_pin);
  34. // RX
  35. // 配置时钟
  36. rcu_periph_clock_enable(usartx_rx_port_rcu);
  37. gpio_mode_set(usartx_rx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, usartx_rx_pin);
  38. gpio_af_set(usartx_rx_port, usartx_rx_af, usartx_rx_pin);
  39. // 配置输出参数
  40. gpio_output_options_set(usartx_rx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, usartx_rx_pin);
  42. /*************** usart ****************/
  43. // 串口时钟
  44. rcu_periph_clock_enable(usartx_rcu);
  45. // USART复位
  46. usart_deinit(usartx);
  48. // 波特率
  49. usart_baudrate_set(usartx, usartx_p_baudrate);
  50. // 校验位
  51. usart_parity_config(usartx, USART_PM_NONE);
  52. // 数据位数
  53. usart_word_length_set(usartx, USART_WL_8BIT);
  54. // 停止位
  55. usart_stop_bit_set(usartx, USART_STB_1BIT);
  56. // 先发送高位还是低位
  57. usart_data_first_config(usartx, USART_MSBF_LSB);
  59. // 发送功能配置
  60. usart_transmit_config(usartx, USART_TRANSMIT_ENABLE);
  62. // 接收功能配置
  63. usart_receive_config(usartx, USART_RECEIVE_ENABLE);
  64. // 接收中断配置
  65. nvic_irq_enable(usartx_irq, 2, 2);
  66. // usart int rbne
  67. usart_interrupt_enable(usartx, USART_INT_RBNE);
  68. usart_interrupt_enable(usartx, USART_INT_IDLE);
  70. // 使能串口
  71. usart_enable(usartx);

发送字节

  1. static void send_byte(uint8_t data) {
  2.     //通过USART发送
  3.     usart_data_transmit(USART0, data);
  5.     //判断缓冲区是否已经空了
  6.     //FlagStatus state = usart_flag_get(USART_NUM,USART_FLAG_TBE);
  7.     while(RESET == usart_flag_get(USART0, USART_FLAG_TBE));
  8. }

发送字符串

  1. static void send_string(char* data) {
  2.     while(data && *data){
  3.         send_byte((uint8_t)(*data));
  4.         data++;
  5.     }
  6. }

配置Printf

  1. int fputc(int ch, FILE *f){
  2.     send_byte((uint8_t)ch);
  3.     return ch;
  4. }

中断接收

  1. void USART0_IRQHandler(void) {
  2.     if ((usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) == SET) {
  3.         uint16_t value = usart_data_receive(USART0);
  4.         g_recv_buff[g_recv_length] = value;        
  5.         g_recv_length++;
  6.     }
  7.     if (usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE) == SET) {
  8.         //读取缓冲区,清空缓冲区
  9.         usart_data_receive(USART0);
  10.         g_recv_buff[g_recv_length] = '\0';
  12.         // TODO: g_recv_buff为接收的数据，g_recv_length为接收的长度
  13.         printf("recv: %s\r\n", g_recv_buff);
  15.         g_recv_length = 0;
  16.     }
  17. }