14.1 硬件初始化

板级初始化->所有的初始化函数都在这里运行

  1. /***********************************************************************
  2. * @ 函数名  ： BSP_Init
  3. * @ 功能说明： 板级外设初始化，所有板子上的初始化均可放在这个函数里面
  4. * @ 参数    ：   
  5. * @ 返回值  ： 无
  6. *********************************************************************/
  7. static void BSP_Init(void)
  8. {
  9.     /*
  10.     * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
  11.     * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
  12.     * 都统一用这个优先级分组，千万不要再分组，切忌。
  13.     */
  14.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
  17.     /* LED初始化 */
  18.     LED_GPIO_Init();
  20.     /* 串口初始化 */
  21.     USART_Config();
  22. }

在硬件初始化好之后，对硬件进行测试：

  1. static void BSP_Init(void)
  2. {
  3.     /*
  4.      * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
  5.      * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
  6.      * 都统一用这个优先级分组，千万不要再分组，切忌。
  7.      */
  8.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
  11.     /* LED初始化 */
  12.     LED_GPIO_Init();
  14.     LED1_ON;
  15.     /* 程序停止在这里 */
  16.     while(1);
  18.     /* 串口初始化 */
  19.     USART_Config();
  20. }

结果：如果LED点亮，说明程序没有问题。

14.2 创建单任务-SRAM静态内存

这里，我们创建一个单任务，任务使用的栈和任务控制块都使用静态内存，即预先定义好的全局变量，这些预先定义好的全局变量都存在内部的 SRAM 中。

14.2.1 定义任务函数

任务实际上就是一个无限循环且不带返回值的 C 函数。目前，我们创建一个这样的任务，让开发板上面的 LED 灯以 500ms 的频率闪烁。

  1. /**********************************************************************
  2.   * @ 函数名  ： LED_Task
  3.   * @ 功能说明： LED_Task任务主体
  4.   * @ 参数    ：   
  5.   * @ 返回值  ： 无
  6.   ********************************************************************/
  7. static void LED_Task(void* parameter)
  8. {    
  9.     while (1)
  10.     {
  11.         LED1_ON;
  12.         vTaskDelay(500);   /* 延时500个tick */
  13.         printf("LED_Task Running,LED1_ON\r\n");
  15.         LED1_OFF;     
  16.         vTaskDelay(500);   /* 延时500个tick */                 
  17.         printf("LED_Task Running,LED1_OFF\r\n");
  18.     }
  19. }
  1. 任务必须是一个死循环，否则任务将通过 LR 返回，如果 LR 指向了非法的内存就会产生 HardFault_Handler，而 FreeRTOS 指向一个死循环，那么任务返回之后就在死循环中执行，这样子的任务是不安全的，所以避免这种情况，任务一般都是死循环并且无返回值的。我们的 AppTaskCreate 任务，执行一次之后就进行删除，则不影响系统运行，所以，只执行一次的任务在执行完毕要记得及时删除。
  2. 任务里面的延时函数必须使用 FreeRTOS 里面提供的延时函数，并不能使用我们裸机编程中的那种延时。这两种的延时的区别是 FreeRTOS 里面的延时是阻塞延时，即调用 vTaskDelay()函数的时候，当前任务会被挂起，调度器会切换到其它就绪的任务，从而实现多任务。如果还是使用裸机编程中的那种延时，那么整个任务就成为了一个死循环，如果恰好该任务的优先级是最高的，那么系统永远都是在这个任务中运行，比它优先级更低的任务无法运行，根本无法实现多任务。

14.2.2 空闲任务与定时器任务堆栈函数实现

使用了静态创建任务的时候， configSUPPORT_STATIC_ALLOCATION 这个宏定 义 必 须为 1 （在 FreeRTOSConfig.h 文 件 中 ） ， 并且 我 们需 要 实 现两 个 函数 ：vApplicationGetIdleTaskMemory()与 vApplicationGetTimerTaskMemory()，这两个函数是用户设定的空闲（Idle）任务与定时器（Timer）任务的堆栈大小，必须由用户自己分配，而不能是动态分配。

  1. /* 空闲任务任务堆栈 */
  2. static StackType_t Idle_Task_Stack[configMINIMAL_STACK_SIZE];
  3. /* 定时器任务堆栈 */
  4. static StackType_t Timer_Task_Stack[configTIMER_TASK_STACK_DEPTH];
  6. /* 空闲任务控制块 */
  7. static StaticTask_t Idle_Task_TCB;    
  8. /* 定时器任务控制块 */
  9. static StaticTask_t Timer_Task_TCB;
  11. /**
  12.   **********************************************************************
  13.   * @brief  获取空闲任务的任务堆栈和任务控制块内存
  14.     *                    ppxTimerTaskTCBBuffer    :        任务控制块内存
  15.     *                    ppxTimerTaskStackBuffer    :    任务堆栈内存
  16.     *                    pulTimerTaskStackSize    :        任务堆栈大小
  17.   * @author  fire
  18.   * @version V1.0
  19.   * @date    2018-xx-xx
  20.   **********************************************************************
  21.   */ 
  22. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, 
  23.                                    StackType_t **ppxIdleTaskStackBuffer, 
  24.                                    uint32_t *pulIdleTaskStackSize)
  25. {
  26.     *ppxIdleTaskTCBBuffer = &Idle_Task_TCB;/* 任务控制块内存 */
  27.     *ppxIdleTaskStackBuffer = Idle_Task_Stack;/* 任务堆栈内存 */
  28.     *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;/* 任务堆栈大小 */
  29. }
  31. /**
  32.   *********************************************************************
  33.   * @brief  获取定时器任务的任务堆栈和任务控制块内存
  34.     *                    ppxTimerTaskTCBBuffer    :        任务控制块内存
  35.     *                    ppxTimerTaskStackBuffer    :    任务堆栈内存
  36.     *                    pulTimerTaskStackSize    :        任务堆栈大小
  37.   * @author  fire
  38.   * @version V1.0
  39.   * @date    2018-xx-xx
  40.   **********************************************************************
  41.   */ 
  42. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, 
  43.                                     StackType_t **ppxTimerTaskStackBuffer, 
  44.                                     uint32_t *pulTimerTaskStackSize)
  45. {
  46.     *ppxTimerTaskTCBBuffer = &Timer_Task_TCB;/* 任务控制块内存 */
  47.     *ppxTimerTaskStackBuffer = Timer_Task_Stack;/* 任务堆栈内存 */
  48.     *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;/* 任务堆栈大小 */
  49. }

14.2.3 定义任务栈

在freeRTOS中，任务独立。静态创建需要创建一个栈，也就是全局变量。栈运用的是RAM，能创建多少任务和RAM是有关的。

  1. /* AppTaskCreate 任务任务堆栈 */
  2. static StackType_t AppTaskCreate_Stack[128];
  4. /* LED 任务堆栈 */
  5. static StackType_t LED_Task_Stack[128];

在大多数系统中需要做栈空间地址对齐，在 FreeRTOS 中是以 8 字节大小对齐，并且会检查堆栈是否已经对齐，其中 portBYTE_ALIGNMENT 是在 portmacro.h 里面定义的一个宏，其值为 8，就是配置为按 8 字节对齐，当然用户可以选择按 1、 2、 4、 8、 16、 32 等字节对齐，目前默认为 8。
注意：实际就是设置对应的掩码。

  1. #define portBYTE_ALIGNMENT
  3. #if portBYTE_ALIGNMENT == 8
  4.     #define portBYTE_ALIGNMENT_MASK ( 0x0007 )
  5. #endif
  7. pxTopOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );
  8. pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) &( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
  10. /* 检查计算出的堆栈顶部的对齐方式是否正确。 */
  11. configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack &( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );

14.2.4 定义任务控制块

任务控制块就是一个结构体，里面有非常多的成员，这些成员共同描述了任务的全部信息。

  1. /* AppTaskCreate 任务控制块 */
  2. static StaticTask_t AppTaskCreate_TCB;
  4. /* AppTaskCreate 任务控制块 */
  5. static StaticTask_t LED_Task_TCB;

14.2.5 静态创建任务

一个任务的三要素是任务主体函数，任务栈，任务控制块，那么怎么样把这三个要素联合在一起？ FreeRTOS 里面有一个叫静态任务创建函数 xTaskCreateStatic()，它就是干这个活的。 它将任务主体函数， 任务栈（静态的）和任务控制块（静态的）这三者联系在一起，让任务可以随时被系统启动。

  1.     AppTaskCreate_Handle = xTaskCreateStatic((TaskFunction_t )AppTaskCreate,        //任务函数
  2.                                              (const char*     )"AppTaskCreate",        //任务名称
  3.                                              (uint32_t         )128,                    //任务堆栈大小
  4.                                              (void*         )NULL,                    //传递给任务函数的参数
  5.                                              (UBaseType_t     )3,                     //任务优先级
  6.                                              (StackType_t*   )AppTaskCreate_Stack,    //任务堆栈
  7.                                              (StaticTask_t*  )&AppTaskCreate_TCB);    //任务控制块

同理创建LED闪烁的任务

14.2.6 启动任务

FreeRTOS 中启动任务调度器的函数是 vTaskStartScheduler()。

  1. /* 启动任务，开启调度 */
  2. vTaskStartScheduler();

14.2.7 main.c函数

该节比较简单，贴个代码就OK了

  1. /* 包含头文件 ----------------------------------------------------------------*//* Includes ------------------------------------------------------------------*/
  2. #include "stm32f10x.h"
  3. /* FreeRTOS头文件 */
  4. #include "FreeRTOS.h"
  5. #include "task.h"
  6. /* 开发板硬件bsp头文件 */
  7. #include "bsp_usart.h"
  8. #include "bsp_led.h"
  10. /* 私有类型定义 --------------------------------------------------------------*/
  11. /* 私有宏定义 ----------------------------------------------------------------*/
  12. /* 私有变量 ------------------------------------------------------------------*/
  14. /* 
  15.  * 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
  16.  * 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
  17.  * 这个句柄可以为NULL。
  18.  */
  19.  /* 创建任务句柄 */
  20. static TaskHandle_t AppTaskCreate_Handle;
  21. /* LED任务句柄 */
  22. static TaskHandle_t LED_Task_Handle;    
  24. /* 空闲任务任务堆栈 */
  25. static StackType_t Idle_Task_Stack[configMINIMAL_STACK_SIZE];
  26. /* 定时器任务堆栈 */
  27. static StackType_t Timer_Task_Stack[configTIMER_TASK_STACK_DEPTH];
  29. /* 空闲任务控制块 */
  30. static StaticTask_t Idle_Task_TCB;    
  31. /* 定时器任务控制块 */
  32. static StaticTask_t Timer_Task_TCB;
  34. /* AppTaskCreate 任务任务堆栈 */
  35. static StackType_t AppTaskCreate_Stack[128];
  36. /* AppTaskCreate 任务控制块 */
  37. static StaticTask_t AppTaskCreate_TCB;
  39. /* LED 任务堆栈 */
  40. static StackType_t LED_Task_Stack[128];
  41. /* AppTaskCreate 任务控制块 */
  42. static StaticTask_t LED_Task_TCB;
  44. /* 扩展变量 ------------------------------------------------------------------*/
  45. /* 私有函数原形 --------------------------------------------------------------*/
  46. static void BSP_Init(void);
  47. static void LED_Task(void* parameter);
  48. static void AppTaskCreate(void);
  50. /* 函数体 --------------------------------------------------------------------*/
  52. /**
  53.   * 函数功能: 主函数.
  54.   * 输入参数: 无
  55.   * 返 回 值: 无
  56.   * 说    明: 无
  57.   */
  58. int main(void)
  59. {
  60.     BSP_Init();
  62.       /* 创建LED_Task任务 */
  63.     AppTaskCreate_Handle = xTaskCreateStatic((TaskFunction_t )AppTaskCreate,        //任务函数
  64.                                              (const char*     )"AppTaskCreate",        //任务名称
  65.                                              (uint32_t         )128,                    //任务堆栈大小
  66.                                              (void*         )NULL,                    //传递给任务函数的参数
  67.                                              (UBaseType_t     )3,                     //任务优先级
  68.                                              (StackType_t*   )AppTaskCreate_Stack,    //任务堆栈
  69.                                              (StaticTask_t*  )&AppTaskCreate_TCB);    //任务控制块  
  70.     if ( NULL != AppTaskCreate_Handle)    /* 创建成功 */
  71.     {
  72.         vTaskStartScheduler();            /* 启动任务，开启调度 */
  73.     }
  75. }
  77. /***********************************************************************
  78.   * @ 函数名  ： AppTaskCreate
  79.   * @ 功能说明： 为了方便管理，所有的任务创建函数都放在这个函数里面
  80.   * @ 参数    ： 无  
  81.   * @ 返回值  ： 无
  82.   **********************************************************************/
  83. static void AppTaskCreate(void)
  84. {
  85.   taskENTER_CRITICAL();           //进入临界区
  87.   /* 创建LED_Task任务 */
  88.     LED_Task_Handle = xTaskCreateStatic((TaskFunction_t    )LED_Task,        //任务函数
  89.                                                             (const char*     )"LED_Task",        //任务名称
  90.                                                             (uint32_t         )128,                    //任务堆栈大小
  91.                                                             (void*               )NULL,                //传递给任务函数的参数
  92.                                                             (UBaseType_t     )4,                 //任务优先级
  93.                                                             (StackType_t*   )LED_Task_Stack,    //任务堆栈
  94.                                                             (StaticTask_t*  )&LED_Task_TCB);    //任务控制块   
  96.     if(NULL != LED_Task_Handle)/* 创建成功 */
  97.         printf("LED_Task任务创建成功!\n");
  98.     else
  99.         printf("LED_Task任务创建失败!\n");
  101.   vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
  103.   taskEXIT_CRITICAL();            //退出临界区
  104. }
  107. /**********************************************************************
  108.   * @ 函数名  ： LED_Task
  109.   * @ 功能说明： LED_Task任务主体
  110.   * @ 参数    ：   
  111.   * @ 返回值  ： 无
  112.   ********************************************************************/
  113. static void LED_Task(void* parameter)
  114. {    
  115.     while (1)
  116.     {
  117.         LED1_ON;
  118.         vTaskDelay(500);   /* 延时500个tick */
  119.         printf("LED_Task Running,LED1_ON\r\n");
  121.         LED1_OFF;     
  122.         vTaskDelay(500);   /* 延时500个tick */                 
  123.         printf("LED_Task Running,LED1_OFF\r\n");
  124.     }
  125. }
  127. /***********************************************************************
  128.   * @ 函数名  ： BSP_Init
  129.   * @ 功能说明： 板级外设初始化，所有板子上的初始化均可放在这个函数里面
  130.   * @ 参数    ：   
  131.   * @ 返回值  ： 无
  132.   *********************************************************************/
  133. static void BSP_Init(void)
  134. {
  135.     /*
  136.      * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
  137.      * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
  138.      * 都统一用这个优先级分组，千万不要再分组，切忌。
  139.      */
  140.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
  143.     /* LED初始化 */
  144.     LED_GPIO_Init();
  146.     LED1_ON;
  147.     /* 程序停止在这里 */
  148.     while(1);
  150.     /* 串口初始化 */
  151.     USART_Config();
  152. }
  154. /**
  155.   **********************************************************************
  156.   * @brief  获取空闲任务的任务堆栈和任务控制块内存
  157.     *                    ppxTimerTaskTCBBuffer    :        任务控制块内存
  158.     *                    ppxTimerTaskStackBuffer    :    任务堆栈内存
  159.     *                    pulTimerTaskStackSize    :        任务堆栈大小
  160.   * @author  fire
  161.   * @version V1.0
  162.   * @date    2018-xx-xx
  163.   **********************************************************************
  164.   */ 
  165. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, 
  166.                                    StackType_t **ppxIdleTaskStackBuffer, 
  167.                                    uint32_t *pulIdleTaskStackSize)
  168. {
  169.     *ppxIdleTaskTCBBuffer = &Idle_Task_TCB;/* 任务控制块内存 */
  170.     *ppxIdleTaskStackBuffer = Idle_Task_Stack;/* 任务堆栈内存 */
  171.     *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;/* 任务堆栈大小 */
  172. }
  174. /**
  175.   *********************************************************************
  176.   * @brief  获取定时器任务的任务堆栈和任务控制块内存
  177.     *                    ppxTimerTaskTCBBuffer    :        任务控制块内存
  178.     *                    ppxTimerTaskStackBuffer    :    任务堆栈内存
  179.     *                    pulTimerTaskStackSize    :        任务堆栈大小
  180.   * @author  fire
  181.   * @version V1.0
  182.   * @date    2018-xx-xx
  183.   **********************************************************************
  184.   */ 
  185. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, 
  186.                                     StackType_t **ppxTimerTaskStackBuffer, 
  187.                                     uint32_t *pulTimerTaskStackSize)
  188. {
  189.     *ppxTimerTaskTCBBuffer = &Timer_Task_TCB;/* 任务控制块内存 */
  190.     *ppxTimerTaskStackBuffer = Timer_Task_Stack;/* 任务堆栈内存 */
  191.     *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;/* 任务堆栈大小 */
  192. }

14.3 下载验证

在当前这个例程， 任务的栈， 任务的控制块用的都是静态内存， 必须由用户预先定义，这种方法我们在使用 FreeRTOS 的时候用的比较少，通常的方法是在任务创建的时候动态的分配任务栈和任务控制块的内存空间，