准备工作

  1. GD32开发板。案例是以梁山派为开发板。
  2. Windows系统的电脑。当前是以Win11的电脑来实现案例的。
  3. Keil开发工具。并且已经安装好GD32依赖环境。
  4. FreeRTOS源码包。下载地址为: https://github.com/FreeRTOS/FreeRTOS/releases

033.png
当前以FreeRTOSv202212.01版本为例。也是目前的最新版本。

移植流程

项目基础环境准备

参考: https://www.yuque.com/icheima/osa819/uvhcdkzgmrus22iy#HJokw
新建项目名称为：FreeRTOSTemplate
项目结构如下：
034.png
确保以下配置信息的正确性：

  1. Target的配置

035.png

  1. Output的配置

036.png

  1. C/C++(AC6)配置

037.png

  1. Debug配置

038.png

FreeRTOS移植

FreeRTOS源码裁剪

  1. 源码解压

039.png

  1. 进入FreeRTOS/Source目录。此目录就是我们要移植的源码。

040.png

  1. 在你新建的FreeRTOSTemplate工程目录下，新建一个文件夹FreeRTOS,将以上源码拷贝到这个文件夹中。

041.png

  1. 删除不必要的文件。来到portable目录只保留GCC和MemManag目录

042.png

源码目录构建

  1. 新建两个Group：FreeRTOS_Core和FreeRTOS_Port

043.png

  1. FreeRTOS_Core添加源码。源码为FreeRTOS根目录下的c文件

044.png
045.png

  1. FreeRTOS_Port添加源码。源码为FreeRTOS/portable/MemMang下的heap_4.c。源码为FreeRTOS/portable/GCC/ARM_CM4F下的port.c

046.png047.png

  1. 添加头文件支持。将FreeRTOS/include和FreeRTOS/portable/GCC/ARM_CM4F添加到头文件依赖中。

048.png

FreeRTOSConfig.h文件缺失解决

编译项目，会出现以下错误：
049.png
来到FreeRTOS源码目录中，找到FreeRTOSv202212.01\FreeRTOS\Demo\CORTEX_M4F_STM32F407ZG-SK目录中的FreeRTOSConfig.h文件，进行拷贝。
050.png
将FreeRTOSConfig.h文件拷贝到项目目录中的FreeRTOS目录下
051.png
添加头文件引入。将FreeRTOS目录添加到include path中。
052.png

SystemCoreClock问题解决

编译项目，会出现以下错误：
053.png
来到FreeRTOSConfig.h文件中，观察以下内容:
054.png

  1. SystemCoreClock其实是有的
  2. SystemCoreClock在编译预处理前没有被定义出来。原因是extern uint32_t SystemCoreClock;这一段没有进入编译，因为在编译预处理前不满足#ifdef __ICCARM__这个条件。编译器c语言条件不满足。我们将以上代码进行修改。
    1. #ifdef __ICCARM__
    2.  #include <stdint.h>
    3.  extern uint32_t SystemCoreClock;
    4. #endif
    1. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
    2.  #include <stdint.h>
    3.  extern uint32_t SystemCoreClock;
    4. #endif

    xxx_Handler问题解决

    编译项目，会出现以下错误：
    055.png
    来到gd32f4xx_it.c文件中。修改三个函数SVC_Handler,PendSV_Handler,SysTick_Handler,将函数通过宏定义包裹: ```c

    ifndef SYS_SUPPORT_OS

endif

  1. 修改后如下：
  2. ```c
  3. #ifndef SYS_SUPPORT_OS
  4. void SVC_Handler(void)
  5. {
  6. }
  7. #endif
  9. ...
  11. #ifndef SYS_SUPPORT_OS
  12. void PendSV_Handler(void)
  13. {
  14. }
  15. #endif
  17. ...
  19. #ifndef SYS_SUPPORT_OS
  20. void SysTick_Handler(void)
  21. {
  22.     delay_decrement();
  23. }
  24. #endif

配置C/C++(AC6)中的define为：USE_STDPERIPH_DRIVER,GD32F470,SYS_SUPPORT_OS
056.png

vApplicationXXXHook问题解决

编译项目，会出现以下错误：
057.png
修改FreeRTOSConfig.h中的配置：

  1. #define configCHECK_FOR_STACK_OVERFLOW    0
  1. #define configUSE_IDLE_HOOK                0
  1. #define configUSE_TICK_HOOK                0
  1. #define configUSE_MALLOC_FAILED_HOOK    0

Systick硬件delay

修改systick.c源码，修改如下

  1. #ifndef SYS_SUPPORT_OS
  2. void delay_1ms(uint32_t count)
  3. {
  4.     delay = count;
  6.     while(0U != delay) {
  7.     }
  8. }
  9. void delay_decrement(void)
  10. {
  11.     if(0U != delay) {
  12.         delay--;
  13.     }
  14. }
  15. #else
  16. void delay_1us(uint32_t count) {
  17.         uint32_t ticks;
  18.         uint32_t told, tnow, reload, tcnt = 0;
  19.         reload = SysTick->LOAD;
  20.         ticks = count * (SystemCoreClock / 1000000);
  21.         told = SysTick->VAL;
  23.         while(1) {
  24.                 tnow=SysTick->VAL;
  25.                 if(tnow != told) {
  26.                         if(tnow<told) tcnt+=told-tnow;
  27.                         else tcnt+=reload-tnow+told;
  28.                         told=tnow;
  30.                         if(tcnt>=ticks)break;
  31.                 }
  32.         }
  34. }
  35. void delay_1ms(uint32_t count)
  36. {
  37.     uint32_t i;
  38.     for (i=0; i<count; i++)
  39.     {
  40.         delay_1us(1000);
  41.     }
  42. }
  43. #endif

LED点亮测试

009.png
开启任务，点亮PE3和PD7
在main.c中编写代码如下：

  1. #include "gd32f4xx.h"
  2. #include "systick.h"
  3. #include <stdio.h>
  4. #include "main.h"
  5. #include "FreeRTOS.h"
  6. #include "task.h"
  8. TaskHandle_t            StartTask_Handler;
  9. TaskHandle_t            Task1_Handler;
  10. TaskHandle_t            Task2_Handler;
  12. void task1(void *pvParameters) {
  13.     while(1) {
  14.         vTaskDelay(300);
  15.         gpio_bit_set(GPIOE, GPIO_PIN_3);
  16.         vTaskDelay(300);
  17.         gpio_bit_reset(GPIOE, GPIO_PIN_3);
  18.     }
  19. }
  21. void task2(void *pvParameters) {
  22.     while(1) {
  23.         vTaskDelay(1000);
  24.         gpio_bit_set(GPIOD, GPIO_PIN_7);
  25.         vTaskDelay(1000);
  26.         gpio_bit_reset(GPIOD, GPIO_PIN_7);
  27.     }
  28. }
  30. void start_task(void *pvParameters) {
  31.     taskENTER_CRITICAL();
  33.     xTaskCreate((TaskFunction_t)task1, 
  34.                                 (const char*   )"task1",
  35.                                 50,
  36.                                 NULL,
  37.                                 2, 
  38.                                 (TaskHandle_t*  )&Task1_Handler);
  39.     xTaskCreate((TaskFunction_t)task2, 
  40.                                 (const char*   )"task2",
  41.                                 50,
  42.                                 NULL,
  43.                                 2, 
  44.                                 (TaskHandle_t*  )&Task2_Handler);
  45.     vTaskDelete(StartTask_Handler);
  47.     taskEXIT_CRITICAL();
  48. }
  50. void GPIO_config() {
  51.         // 1. 时钟初始化
  52.         rcu_periph_clock_enable(RCU_GPIOE);
  53.         // 2. 配置GPIO 输入输出模式
  54.         gpio_mode_set(GPIOE, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_3);
  55.         // 3. 配置GPIO 模式的操作方式
  56.         gpio_output_options_set(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, GPIO_PIN_3);
  58.         // 1. 时钟初始化
  59.         rcu_periph_clock_enable(RCU_GPIOD);
  60.         // 2. 配置GPIO 输入输出模式
  61.         gpio_mode_set(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_7);
  62.         // 3. 配置GPIO 模式的操作方式
  63.         gpio_output_options_set(GPIOD, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, GPIO_PIN_7);
  64. }
  67. int main(void)
  68. {
  69.         systick_config();
  70.         GPIO_config();
  72.         xTaskCreate((TaskFunction_t)start_task, 
  73.                                 (const char*   )"start_task",
  74.                                 128,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
  75.                                 NULL,
  76.                                 1, 
  77.                                 (TaskHandle_t*  )&StartTask_Handler);
  78.         vTaskStartScheduler();
  80.         while(1) {}
  81. }

HelloWorld

实现多任务串口打印功能。
开发流程：

  1. 通过模板创建项目
  2. 添加串口支持库
  3. 添加所需要c依赖，以及包含所需要h头
  4. 运行测试，查看效果。 ```c

    include “gd32f4xx.h”

    include “systick.h”

    include

    include “main.h”

    include “FreeRTOS.h”

    include “task.h”

    include “Usart0.h”

TaskHandle_t StartTask_Handler; TaskHandle_t Task1_Handler; TaskHandle_t Task2_Handler;

void task1(void *pvParameters) { while(1) { vTaskDelay(500); printf(“task 1\n”); } }

void task2(void *pvParameters) { while(1) { vTaskDelay(1000); printf(“task 2\n”); } }

void start_task(void *pvParameters) { taskENTER_CRITICAL();

  1. xTaskCreate((TaskFunction_t)task1, 
  2.                             (const char*   )"task1",
  3.                             50,
  4.                             NULL,
  5.                             2, 
  6.                             (TaskHandle_t*  )&Task1_Handler);
  7. xTaskCreate((TaskFunction_t)task2, 
  8.                             (const char*   )"task2",
  9.                             50,
  10.                             NULL,
  11.                             2, 
  12.                             (TaskHandle_t*  )&Task2_Handler);
  13. vTaskDelete(StartTask_Handler);
  15. taskEXIT_CRITICAL();

}

void Usart0_recv(uint8_t *data, uint32_t len) { printf(“recv: %s\n”, data); }

int main(void) { nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2); systick_config(); Usart0_init();

  1.     xTaskCreate((TaskFunction_t)start_task, 
  2.                             (const char*   )"start_task",
  3.                             128,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
  4.                             NULL,
  5.                             1, 
  6.                             (TaskHandle_t*  )&StartTask_Handler);
  7.     vTaskStartScheduler();
  9.     while(1) {}

}

  1. ```c
  2. #ifndef __USART0_H__
  3. #define __USART0_H__
  5. #include "gd32f4xx.h"
  6. #include "systick.h"
  8. #define USART0_RECV_CALLBACK 1
  10. void Usart0_init();
  11. void Usart0_send_data(uint8_t data);
  12. void Usart0_send_string(char *data);
  14. #if USART0_RECV_CALLBACK
  15. extern void Usart0_recv(uint8_t *data, uint32_t len);
  16. #endif
  18. #endif
  1. #include "Usart0.h"
  2. #include <stdio.h>
  4. #define USART0_RECV_LEN    4096
  5. static uint8_t usart0_recv_buff[USART0_RECV_LEN];   // 接收缓冲区
  6. static uint32_t usart0_recv_len = 0;
  8. void Usart0_init() {
  9.     uint32_t usartx = USART0;
  10.     uint32_t usartx_rcu = RCU_USART0;
  11.     uint32_t usartx_irqn = USART0_IRQn;
  13.     uint32_t tx_gpio_rcu = RCU_GPIOA;
  14.     uint32_t tx_gpio_port = GPIOA;
  15.     uint32_t tx_gpio_pin = GPIO_PIN_9;
  17.     uint32_t rx_gpio_rcu = RCU_GPIOA;
  18.     uint32_t rx_gpio_port = GPIOA;
  19.     uint32_t rx_gpio_pin = GPIO_PIN_10;
  20.     ////////// gpio config ///////////////
  21.     // 配置时钟
  22.     rcu_periph_clock_enable(tx_gpio_rcu);
  23.     rcu_periph_clock_enable(rx_gpio_rcu);
  24.     // 配置模式
  25.     gpio_mode_set(tx_gpio_port, GPIO_MODE_AF, GPIO_PUPD_PULLUP, tx_gpio_pin);
  26.     gpio_mode_set(rx_gpio_port, GPIO_MODE_AF, GPIO_PUPD_PULLUP, rx_gpio_pin);
  27.     // 配置复用功能
  28.     gpio_af_set(tx_gpio_port, GPIO_AF_7, tx_gpio_pin);
  29.     gpio_af_set(rx_gpio_port, GPIO_AF_7, rx_gpio_pin);
  30.     // 配置输出参数
  31.     gpio_output_options_set(tx_gpio_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, tx_gpio_pin);
  32.     gpio_output_options_set(rx_gpio_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, rx_gpio_pin);
  34.     ////////// usart config /////////////
  35.     // 串口时钟
  36.     rcu_periph_clock_enable(usartx_rcu);
  37.     // USART复位
  38.     usart_deinit(usartx);
  39.     usart_baudrate_set(usartx, 115200);// 波特率
  40.     usart_parity_config(usartx, USART_PM_NONE);// 校验位
  41.     usart_word_length_set(usartx, USART_WL_8BIT);// 数据位数
  42.     usart_stop_bit_set(usartx, USART_STB_1BIT);// 停止位
  43.     usart_data_first_config(usartx, USART_MSBF_LSB);// 先发送高位还是低位
  45.     // 发送功能配置
  46.     usart_transmit_config(usartx, USART_TRANSMIT_ENABLE);
  47.     // 接收功能配置
  48.     usart_receive_config(usartx, USART_RECEIVE_ENABLE);
  49.     // 接收中断配置
  50.     nvic_irq_enable(usartx_irqn, 2, 2);
  51.     // usart int rbne
  52.     usart_interrupt_enable(usartx, USART_INT_RBNE);
  53.     usart_interrupt_enable(usartx, USART_INT_IDLE);
  55.     // 使能串口
  56.     usart_enable(usartx);
  57. }
  59. void Usart0_send_data(uint8_t data) {
  60.     //通过USART发送
  61.     usart_data_transmit(USART0, data);
  62.     //判断缓冲区是否已经空了
  63.     while(RESET == usart_flag_get(USART0, USART_FLAG_TBE));
  64. }
  66. //发送字符串
  67. void Usart0_send_string(char *data) {
  68.     while(data && *data) {
  69.         Usart0_send_data((uint8_t)(*data));
  70.         data++;
  71.     }
  72. }
  76. void USART0_IRQHandler(void) {
  77.     if ((usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) == SET) {
  78.         uint16_t value = usart_data_receive(USART0);
  79.         usart0_recv_buff[usart0_recv_len] = value;
  80.         usart0_recv_len++;
  81.         // 接收到单个byte，可以在此处处理接收到value。TODO:
  82.     }
  83.     if (usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE) == SET) {
  84.         //读取缓冲区,清空缓冲区
  85.         usart_data_receive(USART0);
  86.         usart0_recv_buff[usart0_recv_len] = '\0';
  88.         // 接收停止时，缓冲区中的数据，可以在此处处理缓存数据。TODO:
  89. #if USART0_RECV_CALLBACK
  90.                 Usart0_recv(usart0_recv_buff, usart0_recv_len);
  91. #endif
  93.         usart0_recv_len = 0;
  94.     }
  95. }
  97. int fputc(int ch, FILE *f){
  98.     Usart0_send_data((uint8_t)ch);
  99.     return ch;
  100. }