学习目标

  1. 掌握封装抽取流程

  2. 掌握抽取封装策略

    学习内容

    开发流程

  3. 在文件系统中，创建中间件功能文件目录

  4. 在keil工程中，创建分组管理中间件
  5. 编写中间件逻辑

  6. 使用中间件

    文件目录创建

    在工程根目录，创建Middleware目录，在这个目录中，创建具体的功能目录，当前是做串口功能，我们新建usart。
    188.png

    分组创建

  7. 创建Middleware分组。右键进入Manage Project Items

创建Middleware.gif

  1. 创建头文件和c文件

189.png
创建头文件
创建Usart0.h.gif
创建c文件
创建Usart0.c.gif
添加include引入
添加Include.gif

接口定义

发送功能定义

  1. void Usart0_init();
  2. void Usart0_send_data(uint8_t data);
  3. void Usart0_send_string(char *data);

接收回调定义

  1. #define USART0_RECV_CALLBACK 1
  3. #if USART0_RECV_CALLBACK
  4. extern void Usart0_recv(uint8_t *data, uint32_t len);
  5. #endif
  1. ...
  2. // TODO: g_recv_buff为接收的数据，g_recv_length为接收的长度            
  3. #if USART0_RECV_CALLBACK
  4. Usart0_recv(g_recv_buff, g_recv_length);
  5. #endif
  6. ...
  • 通过宏定义做开关

系统printf打印定义

  1. #define USART0_PRINTF                 1
  3. #if    USART0_PRINTF
  4. #include <stdio.h>
  5. #endif
  1. #if USART0_PRINTF
  2. //重写fputc方法  调用printf,会自动调用这个方法实现打印
  3. int fputc(int ch, FILE *f) {
  4.     Usart0_send_data((uint8_t)ch);
  5.     return ch;
  6. }
  7. #endif

完整代码

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

练习题

  1. 实现串口驱动定义