第20章 FreeRTOS消息队列

席萌0209

第20章      FreeRTOS消息队列

    本章节为大家讲解FreeRTOS的一个重要的通信机制----消息队列，初学者要熟练掌握，因为消息队列在实际项目中应用较多。
    本章教程配套的例子含Cortex-M3内核的STM32F103和Cortex-M4内核的STM32F407以及F429。
20.1 消息队列
20.2 消息队列API函数
20.3 实验例程说明（任务间通信）
20.4 实验例程说明（中断方式通信）
20.5      总结



20.1 消息队列

20.1.1  消息队列的概念及其作用

      消息队列就是通过RTOS内核提供的服务，任务或中断服务子程序可以将一个消息（注意，FreeRTOS消息队列传递的是实际数据，并不是数据地址，RTX，uCOS-II和uCOS-III是传递的地址）放入到队列。同样，一个或者多个任务可以通过RTOS内核服务从队列中得到消息。通常，先进入消息队列的消息先传给任务，也就是说，任务先得到的是最先进入到消息队列的消息，即先进先出的原则（FIFO），FreeRTOS的消息队列支持FIFO和LIFO两种数据存取方式。
      也许有不理解的初学者会问采用消息队列多麻烦，搞个全局数组不是更简单，其实不然。在裸机编程时，使用全局数组的确比较方便，但是在加上RTOS后就是另一种情况了。相比消息队列，使用全局数组主要有如下四个问题：
    1、使用消息队列可以让RTOS内核有效地管理任务，而全局数组是无法做到的，任务的超时等机制需要用户自己去实现。
    2、使用了全局数组就要防止多任务的访问冲突，而使用消息队列则处理好了这个问题，用户无需担心。
    3、使用消息队列可以有效地解决中断服务程序与任务之间消息传递的问题。
    4、FIFO机制更有利于数据的处理。

20.1.2 FreeRTOS任务间消息队列的实现

      任务间消息队列的实现是指各个任务之间使用消息队列实现任务间的通信。下面我们通过如下的框图来说明一下FreeRTOS消息队列的实现，让大家有一个形象的认识。

运行条件：
1、创建消息队列，可以存放10个消息。
2、创建2个任务Task1和Task2，任务Task1向消息队列放数据，任务Task2从消息队列取数据。
3、FreeRTOS的消息存取采用FIFO方式。
运行过程主要有以下两种情况：
    （1）任务Task1 向消息队列放数据，任务Task2从消息队列取数据，如果放数据的速度快于取数据的速度，那么会出现消息队列存放满的情况，FreeRTOS的消息存放函数xQueueSend支持超时等待，用户可以设置超时等待，直到有空间可以存放消息或者设置的超时时间溢出。
    （2）任务Task1 向消息队列放数据，任务Task2从消息队列取数据，如果放数据的速度慢于取数据的速度，那么会出现消息队列为空的情况，FreeRTOS的消息获取函数xQueueReceive支持超时等待，用户可以设置超时等待，直到消息队列中有消息或者设置的超时时间溢出。

上面就是一个简单的FreeRTOS任务间消息队列通信过程，FIFO方式数据存取过程的动态演示看官方地址：http://www.freertos.org/Embedded-RTOS-Queues.html 里面的GIF图片。

20.1.3 FreeRTOS中断方式消息队列的实现

      FreeRTOS中断方式消息队列的实现是指中断函数和FreeRTOS任务之间使用消息队列。下面我们通过如下的框图来说明一下FreeRTOS消息队列的实现，让大家有一个形象的认识。

运行条件：
1、创建消息队列，可以存放10个消息。
2、创建1个任务Task1和一个串口接收中断。
3、FreeRTOS的消息存取采用FIFO方式。
运行过程主要有以下两种情况：
    （1）中断服务程序向消息队列放数据，任务Task1从消息队列取数据，如果放数据的速度快于取数据的速度，那么会出现消息队列存放满的情况。由于中断服务程序里面的消息队列发送函数xQueueSendFromISR不支持超时设置，所以发送前要通过函数xQueueIsQueueFullFromISR检测消息队列是否满。
    （2）中断服务程序向消息队列放数据，任务Task1从消息队列取数据，如果放数据的速度慢于取数据的速度，那么会出现消息队列存为空的情况。在FreeRTOS的任务中可以通过函数xQueueReceive获取消息，因为此函数可以设置超时等待，直到消息队列中有消息存放或者设置的超时时间溢出。

上面就是一个简单的FreeRTOS中断方式消息队列通信过程。实际应用中，中断方式的消息机制要注意以下四个问题：
    1、中断函数的执行时间越短越好，防止其它低于这个中断优先级的异常不能得到及时响应。
    2、实际应用中，建议不要在中断中实现消息处理，用户可以在中断服务程序里面发送消息通知任务，在任务中实现消息处理，这样可以有效地保证中断服务程序的实时响应。同时此任务也需要设置为高优先级，以便退出中断函数后任务可以得到及时执行。
    3、中断服务程序中一定要调用专用于中断的消息队列函数，即以FromISR结尾的函数。
    4、在操作系统中实现中断服务程序与裸机编程的区别。
        （1）如果FreeRTOS工程的中断函数中没有调用FreeRTOS的消息队列API函数，与裸机编程是一样的。
        （2）如果FreeRTOS工程的中断函数中调用了FreeRTOS的消息队列的API函数，退出的时候要检测是否有高优先级任务就绪，如果有就绪的，需要在退出中断后进行任务切换，这点与裸机编程稍有区别，详见20.4小节实验例程说明（中断方式）：
        （3）另外强烈推荐用户将Cortex-M3内核的STM32F103和Cortex-M4内核的STM32F407，F429的NVIC优先级分组设置为4,即：NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);这样中断优先级的管理将非常方便。
        （4）用户要在FreeRTOS多任务开启前就设置好优先级分组，一旦设置好切记不可再修改。

席萌0209

20.2 消息队列API函数

    使用如下23个函数可以实现FreeRTOS的消息队列：
（1）    xQueueCreateStatic()
（2）    vQueueDelete()
（3）    xQueueSend()
（4）    xQueueSendFromISR()
（5）    xQueueSendToBack()
（6）    xQueueSendToBackFromISR()
（7）    xQueueSendToFront()
（8）    xQueueSendToFrontFromISR()
（9）    xQueueReceive()
（10）    xQueueReceiveFromISR()
（11）    uxQueueMessagesWaiting()
（12）    uxQueueMessagesWaitingFromISR()
（13）    uxQueueSpacesAvailable()
（14）    xQueueReset()
（15）    xQueueOverwrite()
（16）    xQueueOverwriteFromISR()
（17）    xQueuePeek()
（18）    xQueuePeekFromISR()
（19）    vQueueAddToRegistry()
（20）    vQueueUnregisterQueue()
（21）    pcQueueGetName()
（22）    xQueueIsQueueFullFromISR()
（23）    xQueueIsQueueEmptyFromISR()
    关于这23个函数的讲解及其使用方法可以看FreeRTOS在线版手册：

这里我们重点的说以下4个函数：
    （1）    xQueueCreate ()
    （2）    xQueueSend ()
    （3）    xQueueSendFromISR ()
    （4）    xQueueReceive ()
因为本章节配套的例子使用的是这4个函数。

20.2.1 函数xQueueCreate

函数原型：

1. QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength, /* 消息个数 */
2.                              UBaseType_t uxItemSize ); /* 每个消息大小，单位字节 */

复制代码

函数描述：
函数xQueueCreate用于创建消息队列。
    （1）第1个参数是消息队列支持的消息个数。
    （2）第2个参数是每个消息的大小，单位字节。
    （3）返回值，如果创建成功会返回消息队列的句柄，如果由于FreeRTOSConfig.h文件中heap大小不足，无法为此消息队列提供所需的空间会返回NULL。

使用这个函数要注意以下问题：
1.     FreeRTOS的消息传递是数据的复制，而不是传递的数据地址，这点要特别注意。每一次传递都是uxItemSize个字节。
使用举例：

1. static QueueHandle_t xQueue1 = NULL;
2. static QueueHandle_t xQueue2 = NULL;
4. /*
5. *********************************************************************************************************
6. *    函 数 名: AppObjCreate
7. *    功能说明: 创建任务通信机制
8. *    形    参: 无
9. *    返 回 值: 无
10. *********************************************************************************************************
11. */
12. static void AppObjCreate (void)
13. {
14.      /* 创建10个uint8_t型消息队列 */
15.      xQueue1 = xQueueCreate(10, sizeof(uint8_t));
16.     if( xQueue1 == 0 )
17.     {
18.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
19.     }
20.    
21.      /* 创建10个存储指针变量的消息队列，由于CM3/CM4内核是32位机，一个指针变量占用4个字节 */
22.      xQueue2 = xQueueCreate(10, sizeof(struct Msg *));
23.     if( xQueue2 == 0 )
24.     {
25.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
26.     }
27. }

复制代码

20.2.2 函数xQueueSend

函数原型：

1. BaseType_t xQueueSend(
2.                           QueueHandle_t xQueue,       /* 消息队列句柄 */
3.                           const void * pvItemToQueue, /* 要传递数据地址 */
4.                           TickType_t xTicksToWait     /* 等待消息队列有空间的最大等待时间 */
5.                          );

复制代码

函数描述：
函数xQueueSend用于任务中消息发送。
    （1）第1个参数是消息队列句柄。
    （2）第2个参数要传递数据地址，每次发送都是将消息队列创建函数xQueueCreate所指定的单个消息大小复制到消息队列空间中。
    （3）第3个参数是当消息队列已经满时，等待消息队列有空间时的最大等待时间，单位系统时钟节拍。
    （4）返回值，如果消息成功发送返回pdTRUE，否则返回errQUEUE_FULL。

使用这个函数要注意以下问题：
1.     FreeRTOS的消息传递是数据的复制，而不是传递的数据地址。
2.     此函数是用于任务代码中调用的，故不可以在中断服务程序中调用此函数，中断服务程序中使用的是xQueueSendFromISR。
3.     如果消息队列已经满且第三个参数为0，那么此函数会立即返回。
4.     如果用户将FreeRTOSConfig.h文件中的宏定义INCLUDE_vTaskSuspend配置为1且第三个参数配置为portMAX_DELAY，那么此发送函数会永久等待直到消息队列有空间可以使用。
5.     消息队列还有两个函数xQueueSendToBack和xQueueSendToFront，函数xQueueSendToBack实现的是FIFO方式的存取，函数xQueueSendToFront实现的是LIFO方式的读写。我们这里说的函数xQueueSend等效于xQueueSendToBack，即实现的是FIFO方式的存取。
使用举例：

1. static QueueHandle_t xQueue1 = NULL;
2. static QueueHandle_t xQueue2 = NULL;
4. typedef struct Msg
5. {
6.      uint8_t  ucMessageID;
7.      uint16_t usData[2];
8.      uint32_t ulData[2];
9. }MSG_T;
11. MSG_T   g_tMsg; /* 定义一个结构体用于消息队列 */
13. /*
14. *********************************************************************************************************
15. *    函 数 名: vTaskTaskUserIF
16. *    功能说明: 接口消息处理。
17. *    形    参: pvParameters 是在创建该任务时传递的形参
18. *    返 回 值: 无
19. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
20. *********************************************************************************************************
21. */
22. static void vTaskTaskUserIF(void *pvParameters)
23. {
24.      MSG_T   *ptMsg;
25.      uint8_t ucCount = 0;
26.      uint8_t ucKeyCode;
27.    
28.      /* 初始化结构体指针 */
29.      ptMsg = &g_tMsg;
30.    
31.      /* 初始化数组 */
32.      ptMsg->ucMessageID = 0;
33.      ptMsg->ulData[0] = 0;
34.      ptMsg->usData[0] = 0;
36.     while(1)
37.     {
38.          ucKeyCode = bsp_GetKey();
39.         
40.          if (ucKeyCode != KEY_NONE)
41.          {
42.               switch (ucKeyCode)
43.               {                 
44.                    /* K2键按下，向xQueue1发送数据 */
45.                    case KEY_DOWN_K2:
46.                        ucCount++;
47.                   
48.                        /* 向消息队列发数据，如果消息队列满了，等待10个时钟节拍 */
49.                        if( xQueueSend(xQueue1,
50.                                         (void *) &ucCount,
51.                                         (TickType_t)10) != pdPASS )
52.                        {
53.                             /* 发送失败，即使等待了10个时钟节拍 */
54.                             printf("K2键按下，向xQueue1发送数据失败，即使等待了10个时钟节拍\\r\\n");
55.                        }
56.                        else
57.                        {
58.                             /* 发送成功 */
59.                             printf("K2键按下，向xQueue1发送数据成功\\r\\n");                          
60.                        }
61.                        break;
62.                   
63.                    /* K3键按下，向xQueue2发送数据 */
64.                    case KEY_DOWN_K3:
65.                        ptMsg->ucMessageID++;
66.                        ptMsg->ulData[0]++;;
67.                        ptMsg->usData[0]++;
68.                      
69.                         /* 使用消息队列实现指针变量的传递 */
70.                        if(xQueueSend(xQueue2,                  /* 消息队列句柄 */
71.                                       (void *) &ptMsg,           /* 发送结构体指针变量ptMsg的地址 */
72.                                       (TickType_t)10) != pdPASS )
73.                        {
74.                             /* 发送失败，即使等待了10个时钟节拍 */
75.                             printf("K3键按下，向xQueue2发送数据失败，即使等待了10个时钟节拍\\r\\n");
76.                        }
77.                        else
78.                        {
79.                             /* 发送成功 */
80.                             printf("K3键按下，向xQueue2发送数据成功\\r\\n");                          
81.                        }
82.                   
83.                    /* 其他的键值不处理 */
84.                    default:                    
85.                        break;
86.               }
87.          }
88.         
89.          vTaskDelay(20);
90.      }
91. }

复制代码

20.2.3 函数xQueueSendFromISR

函数原型：

1. BaseType_t xQueueSendFromISR
2.            (
3.                QueueHandle_t xQueue,                  /* 消息队列句柄 */
4.                const void *pvItemToQueue,             /* 要传递数据地址 */
5.                BaseType_t *pxHigherPriorityTaskWoken  /* 高优先级任务是否被唤醒的状态保存 */
6.            );

复制代码

函数描述：
函数xQueueSendFromISR用于中断服务程序中消息发送。
    （1）第1个参数是消息队列句柄。
    （2）第2个参数要传递数据地址，每次发送都是将消息队列创建函数xQueueCreate所指定的单个消息大小复制到消息队列空间中。
    （3）第3个参数用于保存是否有高优先级任务准备就绪。如果函数执行完毕后，此参数的数值是pdTRUE，说明有高优先级任务要执行，否则没有。
    （4）返回值，如果消息成功发送返回pdTRUE，否则返回errQUEUE_FULL。

使用这个函数要注意以下问题：
1.     FreeRTOS的消息传递是数据的复制，而不是传递的数据地址。正因为这个原因，用户在创建消息队列时单个消息大小不可太大，因为一定程度上面会增加中断服务程序的执行时间。
2.     此函数是用于中断服务程序中调用的，故不可以在任务代码中调用此函数，任务代码中使用的是xQueueSend。
3.     消息队列还有两个函数xQueueSendToBackFromISR和xQueueSendToFrontFromISR，函数xQueueSendToBackFromISR实现的是FIFO方式的存取，函数xQueueSendToFrontFromISR实现的是LIFO方式的读写。我们这里说的函数xQueueSendFromISR等效于xQueueSendToBackFromISR，即实现的是FIFO方式的存取。
使用举例：

1. static QueueHandle_t xQueue1 = NULL;
2. static QueueHandle_t xQueue2 = NULL;
4. typedef struct Msg
5. {
6.      uint8_t  ucMessageID;
7.      uint16_t usData[2];
8.      uint32_t ulData[2];
9. }MSG_T;
11. MSG_T   g_tMsg; /* 定义一个结构体用于消息队列 */
13. /*
14. *********************************************************************************************************
15. *    函 数 名: TIM1_IRQHandler
16. *    功能说明: 定时器中断。                     
17. *    形    参: 无
18. *    返 回 值: 无
19. *********************************************************************************************************
20. */
21. static uint32_t g_uiCount = 0; /* 设置为全局静态变量，方便数据更新 */
22. static void TIM1_IRQHandler(void)
23. {
24.      BaseType_t xResult;
25.      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
28.      /* 中断消息处理，此处省略 */
29.      ……
30.    
31.      g_uiCount++;
32.    
33.      /* 向消息队列发数据 */
34.      xQueueSendFromISR(xQueue1,
35.                          (void *)&g_uiCount,
36.                          &xHigherPriorityTaskWoken);
38.      /* 如果xHigherPriorityTaskWoken = pdTRUE，那么退出中断后切到当前最高优先级任务执行 */
39.      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
40. }
42. /*
43. *********************************************************************************************************
44. *    函 数 名: TIM2_IRQHandler
45. *    功能说明: 定时器中断。                     
46. *    形    参: 无
47. *    返 回 值: 无
48. *********************************************************************************************************
49. */
50. static void TIM2_IRQHandler (void)
51. {
52.      MSG_T   *ptMsg;
53.      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
55.      /* 中断消息处理，此处省略 */
56.      ……
58.    
59.      /* 初始化结构体指针 */
60.      ptMsg = &g_tMsg;
61.    
62.      /* 初始化数组 */
63.      ptMsg->ucMessageID++;
64.      ptMsg->ulData[0]++;
65.      ptMsg->usData[0]++;
67.      /* 向消息队列发数据 */
68.      xQueueSendFromISR(xQueue2,
69.                          (void *)&ptMsg,
70.                           &xHigherPriorityTaskWoken);
72.      /* 如果xHigherPriorityTaskWoken = pdTRUE，那么退出中断后切到当前最高优先级任务执行 */
73.      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
74. }

复制代码

20.2.4 函数xQueueReceive

函数原型：

1. BaseType_t xQueueReceive(
2.                                QueueHandle_t xQueue,    /* 消息队列句柄 */
3.                                void *pvBuffer,          /* 接收消息队列数据的缓冲地址 */
4.                                TickType_t xTicksToWait  /* 等待消息队列有数据的最大等待时间 */
5.                             );

复制代码

函数描述：
函数xQueueReceive用于接收消息队列中的数据。
    （1）第1个参数是消息队列句柄。
    （2）第2个参数是从消息队列中复制出数据后所储存的缓冲地址，缓冲区空间要大于等于消息队列创建函数xQueueCreate所指定的单个消息大小，否则取出的数据无法全部存储到缓冲区，从而造成内存溢出。
    （3）第3个参数是消息队列为空时，等待消息队列有数据的最大等待时间，单位系统时钟节拍。
    （4）返回值，如果接到到消息返回pdTRUE，否则返回pdFALSE。

使用这个函数要注意以下问题：
1.     此函数是用于任务代码中调用的，故不可以在中断服务程序中调用此函数，中断服务程序使用的是xQueueReceiveFromISR。
2.     如果消息队列为空且第三个参数为0，那么此函数会立即返回。
3.     如果用户将FreeRTOSConfig.h文件中的宏定义INCLUDE_vTaskSuspend配置为1且第三个参数配置为portMAX_DELAY，那么此函数会永久等待直到消息队列有数据。
使用举例：

1. static QueueHandle_t xQueue1 = NULL;
3. /*
4. *********************************************************************************************************
5. *    函 数 名: vTaskMsgPro
6. *    功能说明: 使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue1)
7. *    形    参: pvParameters 是在创建该任务时传递的形参
8. *    返 回 值: 无
9. *   优 先 级: 3
10. *********************************************************************************************************
11. */
12. static void vTaskMsgPro(void *pvParameters)
13. {
14.      BaseType_t xResult;
15.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(300); /* 设置最大等待时间为300ms */
16.      uint8_t ucQueueMsgValue;
17.    
18.     while(1)
19.     {
20.          xResult = xQueueReceive(xQueue1,                   /* 消息队列句柄 */
21.                                  (void *)&ucQueueMsgValue,  /* 存储接收到的数据到变量ucQueueMsgValue中 */
22.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
23.         
24.          if(xResult == pdPASS)
25.          {
26.               /* 成功接收，并通过串口将数据打印出来 */
27.               printf("接收到消息队列数据ucQueueMsgValue = %d\\r\\n", ucQueueMsgValue);
28.          }
29.          else
30.          {
31.               /* 超时 */
32.               bsp_LedToggle(1);
33.               bsp_LedToggle(4);
34.          }
35.     }
36. }

复制代码

席萌0209

20.3 实验例程说明（任务间通信）



20.3.1 STM32F103开发板实验


配套例子：
      V4-315_FreeRTOS实验_消息队列
实验目的：
      1.     学习FreeRTOS的消息队列。
实验内容：
    1.     K1按键按下，串口打印任务执行情况（波特率115200，数据位8，奇偶校验位无，停止位1）。
    2.     K2键按下，向消息队列xQueue1发送数据。
    3.     K3键按下，向消息队列xQueue2发送数据。
    4.     各个任务实现的功能如下：
              vTaskUserIF任务 ：按键消息处理。
              vTaskLED任务    ：使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue2)。
              vTaskMsgPro任务：使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue1)。
              vTaskStart任务   ：启动任务，也是最高优先级任务，这里实现按键扫描。
FreeRTOS的配置：
    FreeRTOSConfig.h文件中的配置如下：

1. /* Ensure stdint is only used by the compiler, and not the assembler. */
2. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
3. #include <stdint.h>
4. extern volatile uint32_t ulHighFrequencyTimerTicks;
5. #endif
7. #define configUSE_PREEMPTION         1
8. #define configUSE_IDLE_HOOK          0
9. #define configUSE_TICK_HOOK          0
10. #define configCPU_CLOCK_HZ           ( ( unsigned long ) 72000000 )  
11. #define configTICK_RATE_HZ           ( ( TickType_t ) 1000 )
12. #define configMAX_PRIORITIES         ( 5 )
13. #define configMINIMAL_STACK_SIZE     ( ( unsigned short ) 128 )
14. #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
15. #define configMAX_TASK_NAME_LEN      ( 16 )
16. #define configUSE_TRACE_FACILITY      1
17. #define configUSE_16_BIT_TICKS       0
18. #define configIDLE_SHOULD_YIELD      1
20. /* Run time and task stats gathering related definitions. */
21. #define configGENERATE_RUN_TIME_STATS                1
22. #define configUSE_STATS_FORMATTING_FUNCTIONS         1
23. #define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()     (ulHighFrequencyTimerTicks = 0ul)
24. #define portGET_RUN_TIME_COUNTER_VALUE()             ulHighFrequencyTimerTicks
25. //#define portALT_GET_RUN_TIME_COUNTER_VALUE           1
27. /* Co-routine definitions. */
28. #define configUSE_CO_ROUTINES            0
29. #define configMAX_CO_ROUTINE_PRIORITIES ( 2 )
31. /* Set the following definitions to 1 to include the API function, or zero
32. to exclude the API function. */
34. #define INCLUDE_vTaskPrioritySet          1
35. #define INCLUDE_uxTaskPriorityGet         1
36. #define INCLUDE_vTaskDelete               1
37. #define INCLUDE_vTaskCleanUpResources      0
38. #define INCLUDE_vTaskSuspend              1
39. #define INCLUDE_vTaskDelayUntil           1
40. #define INCLUDE_vTaskDelay                1
42. /* Cortex-M specific definitions. */
43. #ifdef __NVIC_PRIO_BITS
44.      /* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */
45.      #define configPRIO_BITS              __NVIC_PRIO_BITS
46. #else
47.      #define configPRIO_BITS              4        /* 15 priority levels */
48. #endif
50. /* The lowest interrupt priority that can be used in a call to a "set priority"
51. function. */
52. #define configLIBRARY_LOWEST_INTERRUPT_PRIORITY              0x0f
54. /* The highest interrupt priority that can be used by any interrupt service
55. routine that makes calls to interrupt safe FreeRTOS API functions.  DO NOT CALL
56. INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER
57. PRIORITY THAN THIS! (higher priorities are lower numeric values. */
58. #define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY         0x01

复制代码

几个重要选项说明：
1、#define configUSE_PREEMPTION        1
        使能抢占式调度器
2、#define configCPU_CLOCK_HZ      ( ( unsigned long ) 72000000 )   
        系统主频72MHz。
3、#define configTICK_RATE_HZ              ( ( TickType_t ) 1000 )
        系统时钟节拍1KHz，即1ms。
4、#define configMAX_PRIORITIES          ( 5 )
        定义可供用户使用的最大优先级数，如果这个定义的是5，那么用户可以使用的优先级号是0,1,2,3,4，不包含5，对于这一点，初学者要特别的注意。
5、#define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
        定义堆大小，FreeRTOS内核，用户动态内存申请，任务栈等都需要用这个空间。
6、configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY          0x01
        定义受FreeRTOS管理的最高优先级中断。简单的说就是允许用户在这个中断服务程序里面调用FreeRTOS的API的最高优先级。为了进一步说明这个宏定义的的作用，解释如下：
    （1）使用CM内核的MCU，官方强烈建议将NVIC的优先级分组配置为全抢占式优先级，全部配置为抢占式优先级的好处就是方便管理。
    （2）对于STM32来说，设置NVIC的优先级分组为4时，NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4)就是全部配置为抢占式优先级。又因为STM32的优先级设置仅使用CM内核8bit中的高4bit，即只能区分2^4 = 16种优先级。因此当优先级分组设置为4的时候可供用户选择抢占式优先级为0到15，共16个优先级，配置为0表示最高优先级，配置为15表示最低优先级，不存在子优先级。
    （3）这里配置configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY为0x01表示用户可以在抢占式优先级为1到15的中断里面调用FreeRTOS的API函数，抢占式优先级为0的中断里面是不允许调用的。
   更多关于这个参数说明请参看第12章。
FreeRTOS任务调试信息（按K1按键，串口打印）：

上面截图中打印出来的任务状态字母B, R, D, S对应如下含义：
    #definetskBLOCKED_CHAR          ( 'B' )  任务阻塞
    #definetskREADY_CHAR           ( 'R' ) 任务就绪
    #definetskDELETED_CHAR           ( 'D' )  任务删除
    #definetskSUSPENDED_CHAR   ( 'S' ) 任务挂起
程序设计：
任务栈大小分配：
    vTaskUserIF任务   ：2048字节
    vTaskLED任务     ：2048字节
    vTaskMsgPro任务 ：2048字节
    vTaskStart任务    ：2048字节
    任务栈空间是在任务创建的时候从FreeRTOSConfig.h文件中定义的heap空间中申请的
    #defineconfigTOTAL_HEAP_SIZE        ( ( size_t )( 17 * 1024 ) )
系统栈大小分配：

FreeROTS初始化：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main(void)
10. {
11.      /*
12.        在启动调度前，为了防止初始化STM32外设时有中断服务程序执行，这里禁止全局中断(除了NMI和HardFault)。
13.        这样做的好处是：
14.        1. 防止执行的中断服务程序中有FreeRTOS的API函数。
15.        2. 保证系统正常启动，不受别的中断影响。
16.        3. 关于是否关闭全局中断，大家根据自己的实际情况设置即可。
17.        在移植文件port.c中的函数prvStartFirstTask中会重新开启全局中断。通过指令cpsie i开启，__set_PRIMASK(1)
18.        和cpsie i是等效的。
19.      */
20.      __set_PRIMASK(1);
21.    
22.      /* 硬件初始化 */
23.      bsp_Init();
24.    
25.      /* 1. 初始化一个定时器中断，精度高于滴答定时器中断，这样才可以获得准确的系统信息 仅供调试目的，实际项
26.            目中不要使用，因为这个功能比较影响系统实时性。
27.         2. 为了正确获取FreeRTOS的调试信息，可以考虑将上面的关闭中断指令__set_PRIMASK(1); 注释掉。
28.      */
29.      vSetupSysInfoTest();
30.    
31.      /* 创建任务 */
32.      AppTaskCreate();
34.      /* 创建任务通信机制 */
35.      AppObjCreate();
36.    
37.     /* 启动调度，开始执行任务 */
38.     vTaskStartScheduler();
40.      /*
41.        如果系统正常启动是不会运行到这里的，运行到这里极有可能是用于定时器任务或者空闲任务的
42.        heap空间不足造成创建失败，此要加大FreeRTOSConfig.h文件中定义的heap大小：
43.        #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
44.      */
45.      while(1);
46. }

复制代码

硬件外设初始化
     硬件外设的初始化是在bsp.c文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化硬件设备。只需要调用一次。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。
5. *             全局变量。
6. *    形    参: 无
7. *    返 回 值: 无
8. *********************************************************************************************************
9. */
10. void bsp_Init(void)
11. {
12.      /*
13.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
14.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
16.          系统时钟缺省配置为72MHz，如果需要更改，可以修改 system_stm32f10x.c 文件
17.      */
18.    
19.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
21.      bsp_InitUart();    /* 初始化串口 */
22.      bsp_InitLed();     /* 初始LED指示灯端口 */
23.      bsp_InitKey();     /* 初始化按键 */
24. }

复制代码

FreeRTOS任务创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskCreate
4. *    功能说明: 创建应用任务
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppTaskCreate (void)
10. {
11.     xTaskCreate( vTaskTaskUserIF,   /* 任务函数  */
12.                  "vTaskUserIF",     /* 任务名    */
13.                  512,               /* 任务栈大小，单位word，也就是4字节 */
14.                  NULL,              /* 任务参数  */
15.                  1,                 /* 任务优先级*/
16.                  &xHandleTaskUserIF );  /* 任务句柄  */
17.    
18.    
19.      xTaskCreate( vTaskLED,           /* 任务函数  */
20.                  "vTaskLED",         /* 任务名    */
21.                  512,                /* 任务栈大小，单位word，也就是4字节 */
22.                  NULL,               /* 任务参数  */
23.                  2,                  /* 任务优先级*/
24.                  &xHandleTaskLED ); /* 任务句柄  */
25.    
26.      xTaskCreate( vTaskMsgPro,            /* 任务函数  */
27.                  "vTaskMsgPro",           /* 任务名    */
28.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
29.                  NULL,                    /* 任务参数  */
30.                  3,                       /* 任务优先级*/
31.                  &xHandleTaskMsgPro );  /* 任务句柄  */
32.    
33.    
34.      xTaskCreate( vTaskStart,             /* 任务函数  */
35.                  "vTaskStart",            /* 任务名    */
36.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
37.                  NULL,                    /* 任务参数  */
38.                  4,                       /* 任务优先级*/
39.                  &xHandleTaskStart );   /* 任务句柄  */
40. }

复制代码

FreeRTOS消息队列创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppObjCreate
4. *    功能说明: 创建任务通信机制
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppObjCreate (void)
10. {
11.      /* 创建10个uint8_t型消息队列 */
12.      xQueue1 = xQueueCreate(10, sizeof(uint8_t));
13.     if( xQueue1 == 0 )
14.     {
15.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
16.     }
17.    
18.      /* 创建10个存储指针变量的消息队列，由于CM3/CM4内核是32位机，一个指针变量占用4个字节 */
19.      xQueue2 = xQueueCreate(10, sizeof(struct Msg *));
20.     if( xQueue2 == 0 )
21.     {
22.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
23.     }
24. }

复制代码

四个FreeRTOS任务的实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: vTaskTaskUserIF
4. *    功能说明: 接口消息处理。
5. *    形    参: pvParameters 是在创建该任务时传递的形参
6. *    返 回 值: 无
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
8. *********************************************************************************************************
9. */
10. static void vTaskTaskUserIF(void *pvParameters)
11. {
12.      MSG_T   *ptMsg;
13.      uint8_t ucCount = 0;
14.      uint8_t ucKeyCode;
15.      uint8_t pcWriteBuffer[500];
16.    
17.      /* 初始化结构体指针 */
18.      ptMsg = &g_tMsg;
19.    
20.      /* 初始化数组 */
21.      ptMsg->ucMessageID = 0;
22.      ptMsg->ulData[0] = 0;
23.      ptMsg->usData[0] = 0;
25.     while(1)
26.     {
27.          ucKeyCode = bsp_GetKey();
28.         
29.          if (ucKeyCode != KEY_NONE)
30.          {
31.               switch (ucKeyCode)
32.               {
33.                    /* K1键按下 打印任务执行情况 */
34.                    case KEY_DOWN_K1:         
35.                        printf("=================================================\\r\\n");
36.                        printf("任务名      任务状态 优先级   剩余栈 任务序号\\r\\n");
37.                        vTaskList((char *)&pcWriteBuffer);
38.                        printf("%s\\r\\n", pcWriteBuffer);
39.                   
40.                        printf("\\r\\n任务名       运行计数         使用率\\r\\n");
41.                        vTaskGetRunTimeStats((char *)&pcWriteBuffer);
42.                        printf("%s\\r\\n", pcWriteBuffer);
43.                        break;
44.                   
45.                    /* K2键按下，向xQueue1发送数据 */
46.                    case KEY_DOWN_K2:
47.                        ucCount++;
48.                   
49.                        /* 向消息队列发数据，如果消息队列满了，等待10个时钟节拍 */
50.                        if( xQueueSend(xQueue1,
51.                                         (void *) &ucCount,
52.                                         (TickType_t)10) != pdPASS )
53.                        {
54.                             /* 发送失败，即使等待了10个时钟节拍 */
55.                             printf("K2键按下，向xQueue1发送数据失败，即使等待了10个时钟节拍\\r\\n");
56.                        }
57.                        else
58.                        {
59.                             /* 发送成功 */
60.                             printf("K2键按下，向xQueue1发送数据成功\\r\\n");                          
61.                        }
62.                        break;
63.                   
64.                    /* K3键按下，向xQueue2发送数据 */
65.                    case KEY_DOWN_K3:
66.                        ptMsg->ucMessageID++;
67.                        ptMsg->ulData[0]++;;
68.                        ptMsg->usData[0]++;
69.                      
70.                        /* 使用消息队列实现指针变量的传递 */
71.                        if(xQueueSend(xQueue2,                  /* 消息队列句柄 */
72.                                       (void *) &ptMsg,           /* 发送结构体指针变量ptMsg的地址 */
73.                                       (TickType_t)10) != pdPASS )
74.                        {
75.                             /* 发送失败，即使等待了10个时钟节拍 */
76.                             printf("K3键按下，向xQueue2发送数据失败，即使等待了10个时钟节拍\\r\\n");
77.                        }
78.                        else
79.                        {
80.                             /* 发送成功 */
81.                             printf("K3键按下，向xQueue2发送数据成功\\r\\n");                          
82.                        }
83.                   
84.                    /* 其他的键值不处理 */
85.                    default:                    
86.                        break;
87.               }
88.          }
89.         
90.          vTaskDelay(20);
91.      }
92. }
94. /*
95. *********************************************************************************************************
96. *    函 数 名: vTaskLED
97. *    功能说明: 使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue2)
98. *    形    参: pvParameters 是在创建该任务时传递的形参
99. *    返 回 值: 无
100. *   优 先 级: 2
101. *********************************************************************************************************
102. */
103. static void vTaskLED(void *pvParameters)
104. {
105.      MSG_T *ptMsg;
106.      BaseType_t xResult;
107.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(200); /* 设置最大等待时间为200ms */
108.    
109.     while(1)
110.     {
111.          xResult = xQueueReceive(xQueue2,                   /* 消息队列句柄 */
112.                                  (void *)&ptMsg,            /* 这里获取的是结构体的地址 */
113.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
114.         
115.         
116.          if(xResult == pdPASS)
117.          {
118.               /* 成功接收，并通过串口将数据打印出来 */
119.               printf("接收到消息队列数据ptMsg->ucMessageID = %d\\r\\n", ptMsg->ucMessageID);
120.               printf("接收到消息队列数据ptMsg->ulData[0] = %d\\r\\n", ptMsg->ulData[0]);
121.               printf("接收到消息队列数据ptMsg->usData[0] = %d\\r\\n", ptMsg->usData[0]);
122.          }
123.          else
124.          {
125.               /* 超时 */
126.               bsp_LedToggle(2);
127.               bsp_LedToggle(3);
128.          }
129.     }
130. }
132. /*
133. *********************************************************************************************************
134. *    函 数 名: vTaskMsgPro
135. *    功能说明: 使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue1)
136. *    形    参: pvParameters 是在创建该任务时传递的形参
137. *    返 回 值: 无
138. *   优 先 级: 3
139. *********************************************************************************************************
140. */
141. static void vTaskMsgPro(void *pvParameters)
142. {
143.      BaseType_t xResult;
144.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(300); /* 设置最大等待时间为300ms */
145.      uint8_t ucQueueMsgValue;
146.    
147.     while(1)
148.     {
149.          xResult = xQueueReceive(xQueue1,                   /* 消息队列句柄 */
150.                                  (void *)&ucQueueMsgValue,  /* 存储接收到的数据到变量ucQueueMsgValue中 */
151.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
152.         
153.          if(xResult == pdPASS)
154.          {
155.               /* 成功接收，并通过串口将数据打印出来 */
156.               printf("接收到消息队列数据ucQueueMsgValue = %d\\r\\n", ucQueueMsgValue);
157.          }
158.          else
159.          {
160.               /* 超时 */
161.               bsp_LedToggle(1);
162.               bsp_LedToggle(4);
163.          }
164.     }
165. }
167. /*
168. *********************************************************************************************************
169. *    函 数 名: vTaskStart
170. *    功能说明: 启动任务，也就是最高优先级任务，这里用作按键扫描。
171. *    形    参: pvParameters 是在创建该任务时传递的形参
172. *    返 回 值: 无
173. *   优 先 级: 4
174. *********************************************************************************************************
175. */
176. static void vTaskStart(void *pvParameters)
177. {
178.     while(1)
179.     {
180.          /* 按键扫描 */
181.          bsp_KeyScan();
182.         vTaskDelay(10);
183.     }
184. }

复制代码

席萌0209

20.3.2   STM32F407开发板实验


配套例子：
     V5-315_FreeRTOS实验_消息队列
实验目的：
    1.     学习FreeRTOS的消息队列。
实验内容：
    1.     K1按键按下，串口打印任务执行情况（波特率115200，数据位8，奇偶校验位无，停止位1）。
    2.     K2键按下，向消息队列xQueue1发送数据。
    3.     K3键按下，向消息队列xQueue2发送数据。
    4.     各个任务实现的功能如下：
              vTaskUserIF任务 ：按键消息处理。
              vTaskLED任务    ：使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue2)。
              vTaskMsgPro任务：使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue1)。
              vTaskStart任务   ：启动任务，也是最高优先级任务，这里实现按键扫描。
FreeRTOS的配置：
    FreeRTOSConfig.h文件中的配置如下：

1. /* Ensure stdint is only used by the compiler, and not the assembler. */
2. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
3. #include <stdint.h>
4. extern volatile uint32_t ulHighFrequencyTimerTicks;
6. /* Ensure stdint is only used by the compiler, and not the assembler. */
7. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
8. #include <stdint.h>
9. extern volatile uint32_t ulHighFrequencyTimerTicks;
10. #endif
12. #define configUSE_PREEMPTION         1
13. #define configUSE_IDLE_HOOK          0
14. #define configUSE_TICK_HOOK          0
15. #define configCPU_CLOCK_HZ           ( ( unsigned long ) 168000000 )
16. #define configTICK_RATE_HZ           ( ( TickType_t ) 1000 )
17. #define configMAX_PRIORITIES         ( 5 )
18. #define configMINIMAL_STACK_SIZE     ( ( unsigned short ) 128 )
19. #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 30 * 1024 ) )
20. #define configMAX_TASK_NAME_LEN      ( 16 )
21. #define configUSE_TRACE_FACILITY      1
22. #define configUSE_16_BIT_TICKS       0
23. #define configIDLE_SHOULD_YIELD      1
25. /* Run time and task stats gathering related definitions. */
26. #define configGENERATE_RUN_TIME_STATS                1
27. #define configUSE_STATS_FORMATTING_FUNCTIONS         1
28. #define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()     (ulHighFrequencyTimerTicks = 0ul)
29. #define portGET_RUN_TIME_COUNTER_VALUE()             ulHighFrequencyTimerTicks
30. //#define portALT_GET_RUN_TIME_COUNTER_VALUE           1
32. /* Co-routine definitions. */
33. #define configUSE_CO_ROUTINES             0
34. #define configMAX_CO_ROUTINE_PRIORITIES ( 2 )
36. /* Set the following definitions to 1 to include the API function, or zero
37. to exclude the API function. */
39. #define INCLUDE_vTaskPrioritySet      1
40. #define INCLUDE_uxTaskPriorityGet         1
41. #define INCLUDE_vTaskDelete               1
42. #define INCLUDE_vTaskCleanUpResources 0
43. #define INCLUDE_vTaskSuspend              1
44. #define INCLUDE_vTaskDelayUntil           1
45. #define INCLUDE_vTaskDelay                1
47. /* Cortex-M specific definitions. */
48. #ifdef __NVIC_PRIO_BITS
49.      /* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */
50.      #define configPRIO_BITS              __NVIC_PRIO_BITS
51. #else
52.      #define configPRIO_BITS              4        /* 15 priority levels */
53. #endif
55. /* The lowest interrupt priority that can be used in a call to a "set priority"
56. function. */
57. #define configLIBRARY_LOWEST_INTERRUPT_PRIORITY              0x0f
59. /* The highest interrupt priority that can be used by any interrupt service
60. routine that makes calls to interrupt safe FreeRTOS API functions.  DO NOT CALL
61. INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER
62. PRIORITY THAN THIS! (higher priorities are lower numeric values. */
63. #define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY    0x01

复制代码

几个重要选项说明：
1、#define configUSE_PREEMPTION        1
        使能抢占式调度器
2、#define configCPU_CLOCK_HZ      ( ( unsigned long ) 168000000 )
        系统主频168MHz。
3、#define configTICK_RATE_HZ              ( ( TickType_t ) 1000 )
        系统时钟节拍1KHz，即1ms。
4、#define configMAX_PRIORITIES          ( 5 )
        定义可供用户使用的最大优先级数，如果这个定义的是5，那么用户可以使用的优先级号是0,1,2,3,4，不包含5，对于这一点，初学者要特别的注意。
5、#define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 30 * 1024 ) )
        定义堆大小，FreeRTOS内核，用户动态内存申请，任务栈等都需要用这个空间。
6、configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY          0x01
        定义受FreeRTOS管理的最高优先级中断。简单的说就是允许用户在这个中断服务程序里面调用FreeRTOS的API的最高优先级。为了进一步说明这个宏定义的的作用，解释如下：
    （1）使用CM内核的MCU，官方强烈建议将NVIC的优先级分组配置为全抢占式优先级，全部配置为抢占式优先级的好处就是方便管理。
     （2）对于STM32来说，设置NVIC的优先级分组为4时，NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4)就是全部配置为抢占式优先级。又因为STM32的优先级设置仅使用CM内核8bit中的高4bit，即只能区分2^4 = 16种优先级。因此当优先级分组设置为4的时候可供用户选择抢占式优先级为0到15，共16个优先级，配置为0表示最高优先级，配置为15表示最低优先级，不存在子优先级。
     （3）这里配置configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY为0x01表示用户可以在抢占式优先级为1到15的中断里面调用FreeRTOS的API函数，抢占式优先级为0的中断里面是不允许调用的。
    更多关于这个参数说明请参看第12章。
FreeRTOS任务调试信息（按K1按键，串口打印）：

上面截图中打印出来的任务状态字母B, R, D, S对应如下含义：
    #definetskBLOCKED_CHAR          ( 'B' )  任务阻塞
    #definetskREADY_CHAR           ( 'R' ) 任务就绪
    #definetskDELETED_CHAR           ( 'D' )  任务删除
    #definetskSUSPENDED_CHAR   ( 'S' ) 任务挂起
程序设计：
任务栈大小分配：
    vTaskUserIF任务   ：2048字节
    vTaskLED任务     ：2048字节
    vTaskMsgPro任务 ：2048字节
    vTaskStart任务    ：2048字节
    任务栈空间是在任务创建的时候从FreeRTOSConfig.h文件中定义的heap空间中申请的
    #defineconfigTOTAL_HEAP_SIZE        ( ( size_t )( 30 * 1024 ) )
系统栈大小分配：

FreeROTS初始化：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main(void)
10. {
11.      /*
12.        在启动调度前，为了防止初始化STM32外设时有中断服务程序执行，这里禁止全局中断(除了NMI和HardFault)。
13.        这样做的好处是：
14.        1. 防止执行的中断服务程序中有FreeRTOS的API函数。
15.        2. 保证系统正常启动，不受别的中断影响。
16.        3. 关于是否关闭全局中断，大家根据自己的实际情况设置即可。
17.        在移植文件port.c中的函数prvStartFirstTask中会重新开启全局中断。通过指令cpsie i开启，__set_PRIMASK(1)
18.        和cpsie i是等效的。
19.      */
20.      __set_PRIMASK(1);
21.    
22.      /* 硬件初始化 */
23.      bsp_Init();
24.    
25.      /* 1. 初始化一个定时器中断，精度高于滴答定时器中断，这样才可以获得准确的系统信息 仅供调试目的，实际项
26.            目中不要使用，因为这个功能比较影响系统实时性。
27.         2. 为了正确获取FreeRTOS的调试信息，可以考虑将上面的关闭中断指令__set_PRIMASK(1); 注释掉。
28.      */
29.      vSetupSysInfoTest();
30.    
31.      /* 创建任务 */
32.      AppTaskCreate();
33.    
34.      /* 创建任务通信机制 */
35.      AppObjCreate();
37.     /* 启动调度，开始执行任务 */
38.     vTaskStartScheduler();
40.      /*
41.        如果系统正常启动是不会运行到这里的，运行到这里极有可能是用于定时器任务或者空闲任务的
42.        heap空间不足造成创建失败，此要加大FreeRTOSConfig.h文件中定义的heap大小：
43.        #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
44.      */
45.      while(1);
46. }

复制代码

硬件外设初始化
    硬件外设的初始化是在bsp.c文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void bsp_Init(void)
10. {
11.      /*
12.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
13.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
15.          系统时钟缺省配置为168MHz，如果需要更改，可以修改 system_stm32f4xx.c 文件
16.      */
17.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/
18.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
20.      bsp_InitUart();    /* 初始化串口 */
21.      bsp_InitKey();     /* 初始化按键变量 */
22.      bsp_InitLed();     /* 初始LED指示灯端口 */
23. }

复制代码

FreeRTOS任务创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskCreate
4. *    功能说明: 创建应用任务
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppTaskCreate (void)
10. {
11.     xTaskCreate( vTaskTaskUserIF,   /* 任务函数  */
12.                  "vTaskUserIF",     /* 任务名    */
13.                  512,               /* 任务栈大小，单位word，也就是4字节 */
14.                  NULL,              /* 任务参数  */
15.                  1,                 /* 任务优先级*/
16.                  &xHandleTaskUserIF );  /* 任务句柄  */
17.    
18.    
19.      xTaskCreate( vTaskLED,           /* 任务函数  */
20.                  "vTaskLED",         /* 任务名    */
21.                  512,                /* 任务栈大小，单位word，也就是4字节 */
22.                  NULL,               /* 任务参数  */
23.                  2,                  /* 任务优先级*/
24.                  &xHandleTaskLED ); /* 任务句柄  */
25.    
26.      xTaskCreate( vTaskMsgPro,            /* 任务函数  */
27.                  "vTaskMsgPro",           /* 任务名    */
28.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
29.                  NULL,                    /* 任务参数  */
30.                  3,                       /* 任务优先级*/
31.                  &xHandleTaskMsgPro );  /* 任务句柄  */
32.    
33.    
34.      xTaskCreate( vTaskStart,             /* 任务函数  */
35.                  "vTaskStart",            /* 任务名    */
36.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
37.                  NULL,                    /* 任务参数  */
38.                  4,                       /* 任务优先级*/
39.                  &xHandleTaskStart );   /* 任务句柄  */
40. }

复制代码

FreeRTOS消息队列创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppObjCreate
4. *    功能说明: 创建任务通信机制
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppObjCreate (void)
10. {
11.      /* 创建10个uint8_t型消息队列 */
12.      xQueue1 = xQueueCreate(10, sizeof(uint8_t));
13.     if( xQueue1 == 0 )
14.     {
15.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
16.     }
17.    
18.      /* 创建10个存储指针变量的消息队列，由于CM3/CM4内核是32位机，一个指针变量占用4个字节 */
19.      xQueue2 = xQueueCreate(10, sizeof(struct Msg *));
20.     if( xQueue2 == 0 )
21.     {
22.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
23.     }
24. }

复制代码

四个FreeRTOS任务的实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: vTaskTaskUserIF
4. *    功能说明: 接口消息处理。
5. *    形    参: pvParameters 是在创建该任务时传递的形参
6. *    返 回 值: 无
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
8. *********************************************************************************************************
9. */
10. static void vTaskTaskUserIF(void *pvParameters)
11. {
12.      MSG_T   *ptMsg;
13.      uint8_t ucCount = 0;
14.      uint8_t ucKeyCode;
15.      uint8_t pcWriteBuffer[500];
16.    
17.      /* 初始化结构体指针 */
18.      ptMsg = &g_tMsg;
19.    
20.      /* 初始化数组 */
21.      ptMsg->ucMessageID = 0;
22.      ptMsg->ulData[0] = 0;
23.      ptMsg->usData[0] = 0;
25.     while(1)
26.     {
27.          ucKeyCode = bsp_GetKey();
28.         
29.          if (ucKeyCode != KEY_NONE)
30.          {
31.               switch (ucKeyCode)
32.               {
33.                    /* K1键按下 打印任务执行情况 */
34.                    case KEY_DOWN_K1:         
35.                        printf("=================================================\\r\\n");
36.                        printf("任务名      任务状态 优先级   剩余栈 任务序号\\r\\n");
37.                        vTaskList((char *)&pcWriteBuffer);
38.                        printf("%s\\r\\n", pcWriteBuffer);
39.                   
40.                        printf("\\r\\n任务名       运行计数         使用率\\r\\n");
41.                        vTaskGetRunTimeStats((char *)&pcWriteBuffer);
42.                        printf("%s\\r\\n", pcWriteBuffer);
43.                        break;
44.                   
45.                    /* K2键按下，向xQueue1发送数据 */
46.                    case KEY_DOWN_K2:
47.                        ucCount++;
48.                   
49.                        /* 向消息队列发数据，如果消息队列满了，等待10个时钟节拍 */
50.                        if( xQueueSend(xQueue1,
51.                                         (void *) &ucCount,
52.                                         (TickType_t)10) != pdPASS )
53.                        {
54.                             /* 发送失败，即使等待了10个时钟节拍 */
55.                             printf("K2键按下，向xQueue1发送数据失败，即使等待了10个时钟节拍\\r\\n");
56.                        }
57.                        else
58.                        {
59.                             /* 发送成功 */
60.                             printf("K2键按下，向xQueue1发送数据成功\\r\\n");                          
61.                        }
62.                        break;
63.                   
64.                    /* K3键按下，向xQueue2发送数据 */
65.                    case KEY_DOWN_K3:
66.                        ptMsg->ucMessageID++;
67.                        ptMsg->ulData[0]++;;
68.                        ptMsg->usData[0]++;
69.                      
70.                        /* 使用消息队列实现指针变量的传递 */
71.                        if(xQueueSend(xQueue2,                  /* 消息队列句柄 */
72.                                       (void *) &ptMsg,           /* 发送结构体指针变量ptMsg的地址 */
73.                                       (TickType_t)10) != pdPASS )
74.                        {
75.                             /* 发送失败，即使等待了10个时钟节拍 */
76.                             printf("K3键按下，向xQueue2发送数据失败，即使等待了10个时钟节拍\\r\\n");
77.                        }
78.                        else
79.                        {
80.                             /* 发送成功 */
81.                             printf("K3键按下，向xQueue2发送数据成功\\r\\n");                          
82.                        }
83.                  
84.                    /* 其他的键值不处理 */
85.                    default:                    
86.                        break;
87.               }
88.          }
89.         
90.          vTaskDelay(20);
91.      }
92. }
94. /*
95. *********************************************************************************************************
96. *    函 数 名: vTaskLED
97. *    功能说明: 使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue2)
98. *    形    参: pvParameters 是在创建该任务时传递的形参
99. *    返 回 值: 无
100. *   优 先 级: 2
101. *********************************************************************************************************
102. */
103. static void vTaskLED(void *pvParameters)
104. {
105.      MSG_T *ptMsg;
106.      BaseType_t xResult;
107.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(200); /* 设置最大等待时间为200ms */
108.    
109.     while(1)
110.     {
111.          xResult = xQueueReceive(xQueue2,                   /* 消息队列句柄 */
112.                                  (void *)&ptMsg,            /* 这里获取的是结构体的地址 */
113.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
114.         
115.         
116.          if(xResult == pdPASS)
117.          {
118.               /* 成功接收，并通过串口将数据打印出来 */
119.               printf("接收到消息队列数据ptMsg->ucMessageID = %d\\r\\n", ptMsg->ucMessageID);
120.               printf("接收到消息队列数据ptMsg->ulData[0] = %d\\r\\n", ptMsg->ulData[0]);
121.               printf("接收到消息队列数据ptMsg->usData[0] = %d\\r\\n", ptMsg->usData[0]);
122.          }
123.          else
124.          {
125.               /* 超时 */
126.               bsp_LedToggle(2);
127.               bsp_LedToggle(3);
128.          }
129.     }
130. }
132. /*
133. *********************************************************************************************************
134. *    函 数 名: vTaskMsgPro
135. *    功能说明: 使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue1)
136. *    形    参: pvParameters 是在创建该任务时传递的形参
137. *    返 回 值: 无
138. *   优 先 级: 3
139. *********************************************************************************************************
140. */
141. static void vTaskMsgPro(void *pvParameters)
142. {
143.      BaseType_t xResult;
144.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(300); /* 设置最大等待时间为300ms */
145.      uint8_t ucQueueMsgValue;
146.    
147.     while(1)
148.     {
149.          xResult = xQueueReceive(xQueue1,                   /* 消息队列句柄 */
150.                                  (void *)&ucQueueMsgValue,  /* 存储接收到的数据到变量ucQueueMsgValue中 */
151.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
152.         
153.          if(xResult == pdPASS)
154.          {
155.               /* 成功接收，并通过串口将数据打印出来 */
156.               printf("接收到消息队列数据ucQueueMsgValue = %d\\r\\n", ucQueueMsgValue);
157.          }
158.          else
159.          {
160.               /* 超时 */
161.               bsp_LedToggle(1);
162.               bsp_LedToggle(4);
163.          }
164.     }
165. }
167. /*
168. *********************************************************************************************************
169. *    函 数 名: vTaskStart
170. *    功能说明: 启动任务，也就是最高优先级任务，这里用作按键扫描。
171. *    形    参: pvParameters 是在创建该任务时传递的形参
172. *    返 回 值: 无
173. *   优 先 级: 4
174. *********************************************************************************************************
175. */
176. static void vTaskStart(void *pvParameters)
177. {
178.     while(1)
179.     {
180.          /* 按键扫描 */
181.          bsp_KeyScan();
182.         vTaskDelay(10);
183.     }
184. }

复制代码

席萌0209

20.3.3 STM32F429开发板实验


配套例子：
    V6-315_FreeRTOS实验_消息队列
实验目的：
    1.     学习FreeRTOS的消息队列。
实验内容：
    1.     K1按键按下，串口打印任务执行情况（波特率115200，数据位8，奇偶校验位无，停止位1）。
    2.     K2键按下，向消息队列xQueue1发送数据。
    3.     K3键按下，向消息队列xQueue2发送数据。
    4.     各个任务实现的功能如下：
              vTaskUserIF任务 ：按键消息处理。
              vTaskLED任务    ：使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue2)。
              vTaskMsgPro任务：使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue1)。
              vTaskStart任务   ：启动任务，也是最高优先级任务，这里实现按键扫描。
FreeRTOS的配置：
    FreeRTOSConfig.h文件中的配置如下：

1. /* Ensure stdint is only used by the compiler, and not the assembler. */
2. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
3. #include <stdint.h>
4. extern volatile uint32_t ulHighFrequencyTimerTicks;
5. #endif
7. #define configUSE_PREEMPTION         1
8. #define configUSE_IDLE_HOOK          0
9. #define configUSE_TICK_HOOK          0
10. #define configCPU_CLOCK_HZ           ( ( unsigned long ) 168000000 )
11. #define configTICK_RATE_HZ           ( ( TickType_t ) 1000 )
12. #define configMAX_PRIORITIES         ( 5 )
13. #define configMINIMAL_STACK_SIZE     ( ( unsigned short ) 128 )
14. #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 30 * 1024 ) )
15. #define configMAX_TASK_NAME_LEN      ( 16 )
16. #define configUSE_TRACE_FACILITY      1
17. #define configUSE_16_BIT_TICKS       0
18. #define configIDLE_SHOULD_YIELD      1
20. /* Run time and task stats gathering related definitions. */
21. #define configGENERATE_RUN_TIME_STATS                1
22. #define configUSE_STATS_FORMATTING_FUNCTIONS         1
23. #define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()     (ulHighFrequencyTimerTicks = 0ul)
24. #define portGET_RUN_TIME_COUNTER_VALUE()             ulHighFrequencyTimerTicks
25. //#define portALT_GET_RUN_TIME_COUNTER_VALUE           1
27. /* Co-routine definitions. */
28. #define configUSE_CO_ROUTINES            0
29. #define configMAX_CO_ROUTINE_PRIORITIES ( 2 )
31. /* Set the following definitions to 1 to include the API function, or zero
32. to exclude the API function. */
34. #define INCLUDE_vTaskPrioritySet          1
35. #define INCLUDE_uxTaskPriorityGet         1
36. #define INCLUDE_vTaskDelete               1
37. #define INCLUDE_vTaskCleanUpResources      0
38. #define INCLUDE_vTaskSuspend              1
39. #define INCLUDE_vTaskDelayUntil           1
40. #define INCLUDE_vTaskDelay                1
42. /* Cortex-M specific definitions. */
43. #ifdef __NVIC_PRIO_BITS
44.      /* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */
45.      #define configPRIO_BITS              __NVIC_PRIO_BITS
46. #else
47.      #define configPRIO_BITS              4        /* 15 priority levels */
48. #endif
50. /* The lowest interrupt priority that can be used in a call to a "set priority"
51. function. */
52. #define configLIBRARY_LOWEST_INTERRUPT_PRIORITY              0x0f
54. /* The highest interrupt priority that can be used by any interrupt service
55. routine that makes calls to interrupt safe FreeRTOS API functions.  DO NOT CALL
56. INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER
57. PRIORITY THAN THIS! (higher priorities are lower numeric values. */
58. #define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY         0x01

复制代码

几个重要选项说明：
1、#define configUSE_PREEMPTION        1
        使能抢占式调度器
2、#define configCPU_CLOCK_HZ      ( ( unsigned long ) 168000000 )
        系统主频168MHz。
3、#define configTICK_RATE_HZ              ( ( TickType_t ) 1000 )
        系统时钟节拍1KHz，即1ms。
4、#define configMAX_PRIORITIES          ( 5 )
        定义可供用户使用的最大优先级数，如果这个定义的是5，那么用户可以使用的优先级号是0,1,2,3,4，不包含5，对于这一点，初学者要特别的注意。
5、#define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 30 * 1024 ) )
        定义堆大小，FreeRTOS内核，用户动态内存申请，任务栈等都需要用这个空间。
6、configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY          0x01
        定义受FreeRTOS管理的最高优先级中断。简单的说就是允许用户在这个中断服务程序里面调用FreeRTOS的API的最高优先级。为了进一步说明这个宏定义的的作用，解释如下：
    （1）使用CM内核的MCU，官方强烈建议将NVIC的优先级分组配置为全抢占式优先级，全部配置为抢占式优先级的好处就是方便管理。
    （2）对于STM32来说，设置NVIC的优先级分组为4时，NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4)就是全部配置为抢占式优先级。又因为STM32的优先级设置仅使用CM内核8bit中的高4bit，即只能区分2^4 = 16种优先级。因此当优先级分组设置为4的时候可供用户选择抢占式优先级为0到15，共16个优先级，配置为0表示最高优先级，配置为15表示最低优先级，不存在子优先级。
    （3）这里配置configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY为0x01表示用户可以在抢占式优先级为1到15的中断里面调用FreeRTOS的API函数，抢占式优先级为0的中断里面是不允许调用的。
    更多关于这个参数说明请参看第12章。
FreeRTOS任务调试信息（按K1按键，串口打印）：

上面截图中打印出来的任务状态字母B, R, D, S对应如下含义：
    #definetskBLOCKED_CHAR          ( 'B' )  任务阻塞
    #definetskREADY_CHAR           ( 'R' ) 任务就绪
    #definetskDELETED_CHAR           ( 'D' )  任务删除
    #definetskSUSPENDED_CHAR   ( 'S' ) 任务挂起
程序设计：
任务栈大小分配：
    vTaskUserIF任务   ：2048字节
    vTaskLED任务     ：2048字节
    vTaskMsgPro任务 ：2048字节
    vTaskStart任务    ：2048字节
    任务栈空间是在任务创建的时候从FreeRTOSConfig.h文件中定义的heap空间中申请的
    #defineconfigTOTAL_HEAP_SIZE        ( ( size_t )( 30 * 1024 ) )
系统栈大小分配：

FreeROTS初始化：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main(void)
10. {
11.      /*
12.        在启动调度前，为了防止初始化STM32外设时有中断服务程序执行，这里禁止全局中断(除了NMI和HardFault)。
13.        这样做的好处是：
14.        1. 防止执行的中断服务程序中有FreeRTOS的API函数。
15.        2. 保证系统正常启动，不受别的中断影响。
16.        3. 关于是否关闭全局中断，大家根据自己的实际情况设置即可。
17.        在移植文件port.c中的函数prvStartFirstTask中会重新开启全局中断。通过指令cpsie i开启，__set_PRIMASK(1)
18.        和cpsie i是等效的。
19.      */
20.      __set_PRIMASK(1);
21.    
22.      /* 硬件初始化 */
23.      bsp_Init();
24.    
25.      /* 1. 初始化一个定时器中断，精度高于滴答定时器中断，这样才可以获得准确的系统信息 仅供调试目的，实际项
26.            目中不要使用，因为这个功能比较影响系统实时性。
27.         2. 为了正确获取FreeRTOS的调试信息，可以考虑将上面的关闭中断指令__set_PRIMASK(1); 注释掉。
28.      */
29.      vSetupSysInfoTest();
30.    
31.      /* 创建任务 */
32.      AppTaskCreate();
33.    
34.      /* 创建任务通信机制 */
35.      AppObjCreate();
37.     /* 启动调度，开始执行任务 */
38.     vTaskStartScheduler();
40.      /*
41.        如果系统正常启动是不会运行到这里的，运行到这里极有可能是用于定时器任务或者空闲任务的
42.        heap空间不足造成创建失败，此要加大FreeRTOSConfig.h文件中定义的heap大小：
43.        #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
44.      */
45.      while(1);
46. }

复制代码

硬件外设初始化
    硬件外设的初始化是在bsp.c文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void bsp_Init(void)
10. {
11.      /*
12.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
13.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
15.          系统时钟缺省配置为168MHz，如果需要更改，可以修改 system_stm32f4xx.c 文件
16.      */
17.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/
18.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
19.    
20.      SystemCoreClockUpdate();    /* 根据PLL配置更新系统时钟频率变量 SystemCoreClock */
22.      bsp_InitUart();    /* 初始化串口 */
23.      bsp_InitKey();     /* 初始化按键变量 */
24.      bsp_InitExtIO();   /* FMC总线上扩展了32位输出IO, 操作LED等外设必须初始化 */
25.      bsp_InitLed();     /* 初始LED指示灯端口 */
26. }

复制代码

FreeRTOS任务创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskCreate
4. *    功能说明: 创建应用任务
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppTaskCreate (void)
10. {
11.     xTaskCreate( vTaskTaskUserIF,   /* 任务函数  */
12.                  "vTaskUserIF",      /* 任务名    */
13.                  512,               /* 任务栈大小，单位word，也就是4字节 */
14.                  NULL,              /* 任务参数  */
15.                  1,                 /* 任务优先级*/
16.                  &xHandleTaskUserIF );  /* 任务句柄  */
17.    
18.    
19.      xTaskCreate( vTaskLED,           /* 任务函数  */
20.                  "vTaskLED",         /* 任务名    */
21.                  512,                /* 任务栈大小，单位word，也就是4字节 */
22.                  NULL,               /* 任务参数  */
23.                  2,                  /* 任务优先级*/
24.                  &xHandleTaskLED ); /* 任务句柄  */
25.    
26.      xTaskCreate( vTaskMsgPro,            /* 任务函数  */
27.                  "vTaskMsgPro",           /* 任务名    */
28.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
29.                  NULL,                    /* 任务参数  */
30.                  3,                       /* 任务优先级*/
31.                  &xHandleTaskMsgPro );  /* 任务句柄  */
32.    
33.    
34.      xTaskCreate( vTaskStart,             /* 任务函数  */
35.                  "vTaskStart",            /* 任务名    */
36.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
37.                  NULL,                    /* 任务参数  */
38.                  4,                       /* 任务优先级*/
39.                  &xHandleTaskStart );   /* 任务句柄  */
40. }

复制代码

FreeRTOS消息队列创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppObjCreate
4. *    功能说明: 创建任务通信机制
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppObjCreate (void)
10. {
11.      /* 创建10个uint8_t型消息队列 */
12.      xQueue1 = xQueueCreate(10, sizeof(uint8_t));
13.     if( xQueue1 == 0 )
14.     {
15.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
16.     }
17.    
18.      /* 创建10个存储指针变量的消息队列，由于CM3/CM4内核是32位机，一个指针变量占用4个字节 */
19.      xQueue2 = xQueueCreate(10, sizeof(struct Msg *));
20.     if( xQueue2 == 0 )
21.     {
22.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
23.     }
24. }

复制代码

四个FreeRTOS任务的实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: vTaskTaskUserIF
4. *    功能说明: 接口消息处理。
5. *    形    参: pvParameters 是在创建该任务时传递的形参
6. *    返 回 值: 无
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
8. *********************************************************************************************************
9. */
10. static void vTaskTaskUserIF(void *pvParameters)
11. {
12.      MSG_T   *ptMsg;
13.      uint8_t ucCount = 0;
14.      uint8_t ucKeyCode;
15.      uint8_t pcWriteBuffer[500];
16.    
17.      /* 初始化结构体指针 */
18.      ptMsg = &g_tMsg;
19.    
20.      /* 初始化数组 */
21.      ptMsg->ucMessageID = 0;
22.      ptMsg->ulData[0] = 0;
23.      ptMsg->usData[0] = 0;
25.     while(1)
26.     {
27.          ucKeyCode = bsp_GetKey();
28.         
29.          if (ucKeyCode != KEY_NONE)
30.          {
31.               switch (ucKeyCode)
32.               {
33.                    /* K1键按下 打印任务执行情况 */
34.                    case KEY_DOWN_K1:         
35.                        printf("=================================================\\r\\n");
36.                        printf("任务名      任务状态 优先级   剩余栈 任务序号\\r\\n");
37.                        vTaskList((char *)&pcWriteBuffer);
38.                        printf("%s\\r\\n", pcWriteBuffer);
39.                   
40.                        printf("\\r\\n任务名       运行计数         使用率\\r\\n");
41.                        vTaskGetRunTimeStats((char *)&pcWriteBuffer);
42.                        printf("%s\\r\\n", pcWriteBuffer);
43.                        break;
44.                   
45.                    /* K2键按下，向xQueue1发送数据 */
46.                    case KEY_DOWN_K2:
47.                        ucCount++;
48.                   
49.                        /* 向消息队列发数据，如果消息队列满了，等待10个时钟节拍 */
50.                        if( xQueueSend(xQueue1,
51.                                         (void *) &ucCount,
52.                                         (TickType_t)10) != pdPASS )
53.                        {
54.                             /* 发送失败，即使等待了10个时钟节拍 */
55.                             printf("K2键按下，向xQueue1发送数据失败，即使等待了10个时钟节拍\\r\\n");
56.                        }
57.                        else
58.                        {
59.                             /* 发送成功 */
60.                             printf("K2键按下，向xQueue1发送数据成功\\r\\n");                          
61.                        }
62.                        break;
63.                   
64.                    /* K3键按下，向xQueue2发送数据 */
65.                    case KEY_DOWN_K3:
66.                        ptMsg->ucMessageID++;
67.                        ptMsg->ulData[0]++;;
68.                        ptMsg->usData[0]++;
69.                      
70.                        /* 使用消息队列实现指针变量的传递 */
71.                        if(xQueueSend(xQueue2,                  /* 消息队列句柄 */
72.                                       (void *) &ptMsg,           /* 发送结构体指针变量ptMsg的地址 */
73.                                       (TickType_t)10) != pdPASS )
74.                        {
75.                             /* 发送失败，即使等待了10个时钟节拍 */
76.                             printf("K3键按下，向xQueue2发送数据失败，即使等待了10个时钟节拍\\r\\n");
77.                        }
78.                        else
79.                        {
80.                             /* 发送成功 */
81.                             printf("K3键按下，向xQueue2发送数据成功\\r\\n");                          
82.                        }
83.                   
84.                    /* 其他的键值不处理 */
85.                    default:                    
86.                        break;
87.               }
88.          }
89.         
90.          vTaskDelay(20);
91.      }
92. }
94. /*
95. *********************************************************************************************************
96. *    函 数 名: vTaskLED
97. *    功能说明: 使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue2)
98. *    形    参: pvParameters 是在创建该任务时传递的形参
99. *    返 回 值: 无
100. *   优 先 级: 2
101. *********************************************************************************************************
102. */
103. static void vTaskLED(void *pvParameters)
104. {
105.      MSG_T *ptMsg;
106.      BaseType_t xResult;
107.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(200); /* 设置最大等待时间为200ms */
108.    
109.     while(1)
110.     {
111.          xResult = xQueueReceive(xQueue2,                   /* 消息队列句柄 */
112.                                  (void *)&ptMsg,            /* 这里获取的是结构体的地址 */
113.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
114.         
115.         
116.          if(xResult == pdPASS)
117.          {
118.               /* 成功接收，并通过串口将数据打印出来 */
119.               printf("接收到消息队列数据ptMsg->ucMessageID = %d\\r\\n", ptMsg->ucMessageID);
120.               printf("接收到消息队列数据ptMsg->ulData[0] = %d\\r\\n", ptMsg->ulData[0]);
121.               printf("接收到消息队列数据ptMsg->usData[0] = %d\\r\\n", ptMsg->usData[0]);
122.          }
123.          else
124.          {
125.               /* 超时 */
126.               bsp_LedToggle(2);
127.               bsp_LedToggle(3);
128.          }
129.     }
130. }
132. /*
133. *********************************************************************************************************
134. *    函 数 名: vTaskMsgPro
135. *    功能说明: 使用函数xQueueReceive接收任务vTaskTaskUserIF发送的消息队列数据(xQueue1)
136. *    形    参: pvParameters 是在创建该任务时传递的形参
137. *    返 回 值: 无
138. *   优 先 级: 3
139. *********************************************************************************************************
140. */
141. static void vTaskMsgPro(void *pvParameters)
142. {
143.      BaseType_t xResult;
144.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(300); /* 设置最大等待时间为300ms */
145.      uint8_t ucQueueMsgValue;
146.    
147.     while(1)
148.     {
149.          xResult = xQueueReceive(xQueue1,                   /* 消息队列句柄 */
150.                                  (void *)&ucQueueMsgValue,  /* 存储接收到的数据到变量ucQueueMsgValue中 */
151.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
152.         
153.          if(xResult == pdPASS)
154.          {
155.               /* 成功接收，并通过串口将数据打印出来 */
156.               printf("接收到消息队列数据ucQueueMsgValue = %d\\r\\n", ucQueueMsgValue);
157.          }
158.          else
159.          {
160.               /* 超时 */
161.               bsp_LedToggle(1);
162.               bsp_LedToggle(4);
163.          }
164.     }
165. }
167. /*
168. *********************************************************************************************************
169. *    函 数 名: vTaskStart
170. *    功能说明: 启动任务，也就是最高优先级任务，这里用作按键扫描。
171. *    形    参: pvParameters 是在创建该任务时传递的形参
172. *    返 回 值: 无
173. *   优 先 级: 4
174. *********************************************************************************************************
175. */
176. static void vTaskStart(void *pvParameters)
177. {
178.     while(1)
179.     {
180.          /* 按键扫描 */
181.          bsp_KeyScan();
182.         vTaskDelay(10);
183.     }
184. }

复制代码

席萌0209

20.4 实验例程说明（中断方式）



20.4.1 STM32F103开发板实验


配套例子：
    V4-316_FreeRTOS实验_消息队列（中断方式）
实验目的：
    1.     学习FreeRTOS的消息队列（中断方式）。
实验内容：
    1.     K1按键按下，串口打印任务执行情况（波特率115200，数据位8，奇偶校验位无，停止位1）。
    2.     K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息。
    3.     K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息。
    4.     任务vTaskMsgPro只有接收到bit0和bit1都被设置了才执行串口打印消息。
    5.     各个任务实现的功能如下：
              vTaskUserIF任务   ：按键消息处理。
              vTaskLED任务     ：使用函数xQueueReceive接定时器中断发送的消息队列数据。
              vTaskMsgPro任务 ：使用函数xQueueReceive接定时器中断发送的消息队列数据。
              vTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。
FreeRTOS的配置：
    FreeRTOSConfig.h文件中的配置如下：

1. /* Ensure stdint is only used by the compiler, and not the assembler. */
2. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
3. #include <stdint.h>
4. extern volatile uint32_t ulHighFrequencyTimerTicks;
5. #endif
7. #define configUSE_PREEMPTION         1
8. #define configUSE_IDLE_HOOK          0
9. #define configUSE_TICK_HOOK          0
10. #define configCPU_CLOCK_HZ           ( ( unsigned long ) 72000000 )  
11. #define configTICK_RATE_HZ           ( ( TickType_t ) 1000 )
12. #define configMAX_PRIORITIES         ( 6 )
13. #define configMINIMAL_STACK_SIZE     ( ( unsigned short ) 128 )
14. #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
15. #define configMAX_TASK_NAME_LEN      ( 16 )
16. #define configUSE_TRACE_FACILITY      1
17. #define configUSE_16_BIT_TICKS       0
18. #define configIDLE_SHOULD_YIELD      1
20. /* Run time and task stats gathering related definitions. */
21. #define configGENERATE_RUN_TIME_STATS                1
22. #define configUSE_STATS_FORMATTING_FUNCTIONS         1
23. #define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()     (ulHighFrequencyTimerTicks = 0ul)
24. #define portGET_RUN_TIME_COUNTER_VALUE()             ulHighFrequencyTimerTicks
25. //#define portALT_GET_RUN_TIME_COUNTER_VALUE           1
27. /* Co-routine definitions. */
28. #define configUSE_CO_ROUTINES            0
29. #define configMAX_CO_ROUTINE_PRIORITIES ( 2 )
31. /* Set the following definitions to 1 to include the API function, or zero
32. to exclude the API function. */
34. #define INCLUDE_vTaskPrioritySet          1
35. #define INCLUDE_uxTaskPriorityGet         1
36. #define INCLUDE_vTaskDelete               1
37. #define INCLUDE_vTaskCleanUpResources      0
38. #define INCLUDE_vTaskSuspend              1
39. #define INCLUDE_xTaskResumeFromISR        1
40. #define INCLUDE_vTaskDelayUntil           1
41. #define INCLUDE_vTaskDelay                1
43. /* Cortex-M specific definitions. */
44. #ifdef __NVIC_PRIO_BITS
45.      /* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */
46.      #define configPRIO_BITS              __NVIC_PRIO_BITS
47. #else
48.      #define configPRIO_BITS              4        /* 15 priority levels */
49. #endif
51. /* The lowest interrupt priority that can be used in a call to a "set priority"
52. function. */
53. #define configLIBRARY_LOWEST_INTERRUPT_PRIORITY              0x0f
55. /* The highest interrupt priority that can be used by any interrupt service
56. routine that makes calls to interrupt safe FreeRTOS API functions.  DO NOT CALL
57. INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER
58. PRIORITY THAN THIS! (higher priorities are lower numeric values. */
59. #define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY         0x01

复制代码

几个重要选项说明：
1、#define configUSE_PREEMPTION        1
        使能抢占式调度器
2、#define configCPU_CLOCK_HZ      ( ( unsigned long ) 72000000 )   
        系统主频72MHz。
3、#define configTICK_RATE_HZ              ( ( TickType_t ) 1000 )
        系统时钟节拍1KHz，即1ms。
4、#define configMAX_PRIORITIES          ( 6 )
        定义可供用户使用的最大优先级数，如果这个定义的是6，那么用户可以使用的优先级号是0,1,2,3,4,5不包含6，对于这一点，初学者要特别的注意。
5、#define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
        定义堆大小，FreeRTOS内核，用户动态内存申请，任务栈等都需要用这个空间。
6、configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY          0x01
        定义受FreeRTOS管理的最高优先级中断。简单的说就是允许用户在这个中断服务程序里面调用FreeRTOS的API的最高优先级。为了进一步说明这个宏定义的的作用，解释如下：
    （1）使用CM内核的MCU，官方强烈建议将NVIC的优先级分组配置为全抢占式优先级，全部配置为抢占式优先级的好处就是方便管理。
    （2）对于STM32来说，设置NVIC的优先级分组为4时，NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4)就是全部配置为抢占式优先级。又因为STM32的优先级设置仅使用CM内核8bit中的高4bit，即只能区分2^4 = 16种优先级。因此当优先级分组设置为4的时候可供用户选择抢占式优先级为0到15，共16个优先级，配置为0表示最高优先级，配置为15表示最低优先级，不存在子优先级。
    （3）这里配置configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY为0x01表示用户可以在抢占式优先级为1到15的中断里面调用FreeRTOS的API函数，抢占式优先级为0的中断里面是不允许调用的。
    更多关于这个参数说明请参看第12章。
FreeRTOS任务调试信息（按K1按键，串口打印）：

上面截图中打印出来的任务状态字母B, R, D, S对应如下含义：
    #definetskBLOCKED_CHAR          ( 'B' )  任务阻塞
    #definetskREADY_CHAR           ( 'R' ) 任务就绪
    #definetskDELETED_CHAR           ( 'D' )  任务删除
    #definetskSUSPENDED_CHAR   ( 'S' ) 任务挂起
程序设计：
任务栈大小分配：
    vTaskUserIF任务   ：2048字节
    vTaskLED任务     ：2048字节
    vTaskMsgPro任务 ：2048字节
    vTaskStart任务    ：2048字节
    任务栈空间是在任务创建的时候从FreeRTOSConfig.h文件中定义的heap空间中申请的
    #defineconfigTOTAL_HEAP_SIZE        ( ( size_t )( 17 * 1024 ) )
系统栈大小分配：

FreeROTS初始化：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main(void)
10. {
11.      /*
12.        在启动调度前，为了防止初始化STM32外设时有中断服务程序执行，这里禁止全局中断(除了NMI和HardFault)。
13.        这样做的好处是：
14.        1. 防止执行的中断服务程序中有FreeRTOS的API函数。
15.        2. 保证系统正常启动，不受别的中断影响。
16.        3. 关于是否关闭全局中断，大家根据自己的实际情况设置即可。
17.        在移植文件port.c中的函数prvStartFirstTask中会重新开启全局中断。通过指令cpsie i开启，__set_PRIMASK(1)
18.        和cpsie i是等效的。
19.      */
20.      __set_PRIMASK(1);
21.    
22.      /* 硬件初始化 */
23.      bsp_Init();
24.    
25.      /* 1. 初始化一个定时器中断，精度高于滴答定时器中断，这样才可以获得准确的系统信息 仅供调试目的，实际项
26.            目中不要使用，因为这个功能比较影响系统实时性。
27.         2. 为了正确获取FreeRTOS的调试信息，可以考虑将上面的关闭中断指令__set_PRIMASK(1); 注释掉。
28.      */
29.      vSetupSysInfoTest();
30.    
31.      /* 创建任务 */
32.      AppTaskCreate();
34.      /* 创建任务通信机制 */
35.      AppObjCreate();
36.    
37.     /* 启动调度，开始执行任务 */
38.     vTaskStartScheduler();
40.      /*
41.        如果系统正常启动是不会运行到这里的，运行到这里极有可能是用于定时器任务或者空闲任务的
42.        heap空间不足造成创建失败，此要加大FreeRTOSConfig.h文件中定义的heap大小：
43.        #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
44.      */
45.      while(1);
46. }

复制代码

硬件外设初始化
    硬件外设的初始化是在bsp.c文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化硬件设备。只需要调用一次。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。
5. *             全局变量。
6. *    形    参: 无
7. *    返 回 值: 无
8. *********************************************************************************************************
9. */
10. void bsp_Init(void)
11. {
12.      /*
13.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
14.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
16.          系统时钟缺省配置为72MHz，如果需要更改，可以修改 system_stm32f10x.c 文件
17.      */
18.    
19.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
21.      bsp_InitUart();    /* 初始化串口 */
22.      bsp_InitLed();     /* 初始LED指示灯端口 */
23.      bsp_InitKey();     /* 初始化按键 */
25.      bsp_InitHardTimer(); /* 初始化TIM2定时器 */
26. }

复制代码

FreeRTOS任务创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskCreate
4. *    功能说明: 创建应用任务
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppTaskCreate (void)
10. {
11.     xTaskCreate( vTaskTaskUserIF,   /* 任务函数  */
12.                  "vTaskUserIF",     /* 任务名    */
13.                  512,               /* 任务栈大小，单位word，也就是4字节 */
14.                  NULL,              /* 任务参数  */
15.                  1,                 /* 任务优先级*/
16.                  &xHandleTaskUserIF );  /* 任务句柄  */
17.    
18.    
19.      xTaskCreate( vTaskLED,           /* 任务函数  */
20.                  "vTaskLED",         /* 任务名    */
21.                  512,                /* 任务栈大小，单位word，也就是4字节 */
22.                  NULL,               /* 任务参数  */
23.                  2,                  /* 任务优先级*/
24.                  &xHandleTaskLED ); /* 任务句柄  */
25.    
26.      xTaskCreate( vTaskMsgPro,            /* 任务函数  */
27.                  "vTaskMsgPro",           /* 任务名    */
28.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
29.                  NULL,                    /* 任务参数  */
30.                  3,                       /* 任务优先级*/
31.                  &xHandleTaskMsgPro );  /* 任务句柄  */
32.    
33.    
34.      xTaskCreate( vTaskStart,             /* 任务函数  */
35.                  "vTaskStart",            /* 任务名    */
36.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
37.                  NULL,                    /* 任务参数  */
38.                  4,                       /* 任务优先级*/
39.                  &xHandleTaskStart );   /* 任务句柄  */
40. }

复制代码

FreeRTOS消息队列创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppObjCreate
4. *    功能说明: 创建任务通信机制
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppObjCreate (void)
10. {
11.      /* 创建10个uint8_t型消息队列 */
12.      xQueue1 = xQueueCreate(10, sizeof(uint8_t));
13.     if( xQueue1 == 0 )
14.     {
15.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
16.     }
17.    
18.      /* 创建10个存储指针变量的消息队列，由于CM3/CM4内核是32位机，一个指针变量占用4个字节 */
19.      xQueue2 = xQueueCreate(10, sizeof(struct Msg *));
20.     if( xQueue2 == 0 )
21.     {
22.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
23.     }
24. }

复制代码

四个FreeRTOS任务的实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: vTaskTaskUserIF
4. *    功能说明: 接口消息处理。
5. *    形    参: pvParameters 是在创建该任务时传递的形参
6. *    返 回 值: 无
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
8. *********************************************************************************************************
9. */
10. static void vTaskTaskUserIF(void *pvParameters)
11. {
12.      uint8_t ucKeyCode;
13.      uint8_t pcWriteBuffer[500];
15.     while(1)
16.     {
17.          ucKeyCode = bsp_GetKey();
18.         
19.          if (ucKeyCode != KEY_NONE)
20.          {
21.               switch (ucKeyCode)
22.               {
23.                    /* K1键按下 打印任务执行情况 */
24.                    case KEY_DOWN_K1:         
25.                        printf("=================================================\\r\\n");
26.                        printf("任务名      任务状态 优先级   剩余栈 任务序号\\r\\n");
27.                        vTaskList((char *)&pcWriteBuffer);
28.                        printf("%s\\r\\n", pcWriteBuffer);
29.                   
30.                        printf("\\r\\n任务名       运行计数         使用率\\r\\n");
31.                        vTaskGetRunTimeStats((char *)&pcWriteBuffer);
32.                        printf("%s\\r\\n", pcWriteBuffer);
33.                        break;
34.                   
35.                    /* K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息 */
36.                    case KEY_DOWN_K2:
37.                        printf("K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息
38. \\r\\n");
39.                        bsp_StartHardTimer(1 ,50000, (void *)TIM_CallBack1);
40.                        break;
41.                   
42.                    /* K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息 */
43.                    case KEY_DOWN_K3:
44.                        printf("K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息
45. \\r\\n");
46.                        bsp_StartHardTimer(2 ,50000, (void *)TIM_CallBack2);
47.                        break;
49.                    /* 其他的键值不处理 */
50.                    default:                    
51.                        break;
52.               }
53.          }
54.         
55.          vTaskDelay(20);
56.      }
57. }
59. /*
60. *********************************************************************************************************
61. *    函 数 名: vTaskLED
62. *    功能说明: 使用函数xQueueReceive接定时器中断发送的消息队列数据  
63. *    形    参: pvParameters 是在创建该任务时传递的形参
64. *    返 回 值: 无
65. *   优 先 级: 2
66. *********************************************************************************************************
67. */
68. static void vTaskLED(void *pvParameters)
69. {
70.      MSG_T *ptMsg;
71.      BaseType_t xResult;
72.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(200); /* 设置最大等待时间为200ms */
73.    
74.    
75.     while(1)
76.     {
77.          xResult = xQueueReceive(xQueue2,                   /* 消息队列句柄 */
78.                                  (void *)&ptMsg,           /* 这里获取的是结构体的地址 */
79.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
80.         
81.         
82.          if(xResult == pdPASS)
83.          {
84.               /* 成功接收，并通过串口将数据打印出来 */
85.               printf("接收到消息队列数据ptMsg->ucMessageID = %d\\r\\n", ptMsg->ucMessageID);
86.               printf("接收到消息队列数据ptMsg->ulData[0] = %d\\r\\n", ptMsg->ulData[0]);
87.               printf("接收到消息队列数据ptMsg->usData[0] = %d\\r\\n", ptMsg->usData[0]);
88.          }
89.          else
90.          {
91.               /* 超时 */
92.               bsp_LedToggle(2);
93.               bsp_LedToggle(3);
94.          }
95.     }
96. }
98. /*
99. *********************************************************************************************************
100. *    函 数 名: vTaskMsgPro
101. *    功能说明: 使用函数xQueueReceive接定时器中断发送的消息队列数据
102. *    形    参: pvParameters 是在创建该任务时传递的形参
103. *    返 回 值: 无
104. *   优 先 级: 3
105. *********************************************************************************************************
106. */
107. static void vTaskMsgPro(void *pvParameters)
108. {
109.      BaseType_t xResult;
110.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(300); /* 设置最大等待时间为300ms */
111.      uint8_t ucQueueMsgValue;
112.    
113.     while(1)
114.     {
115.          xResult = xQueueReceive(xQueue1,                   /* 消息队列句柄 */
116.                                  (void *)&ucQueueMsgValue,  /* 存储接收到的数据到变量ucQueueMsgValue中 */
117.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
118.         
119.          if(xResult == pdPASS)
120.          {
121.               /* 成功接收，并通过串口将数据打印出来 */
122.               printf("接收到消息队列数据ucQueueMsgValue = %d\\r\\n", ucQueueMsgValue);
123.          }
124.          else
125.          {
126.               /* 超时 */
127.               bsp_LedToggle(1);
128.               bsp_LedToggle(4);
129.          }
130.     }
131. }
133. /*
134. *********************************************************************************************************
135. *    函 数 名: vTaskStart
136. *    功能说明: 启动任务，也就是最高优先级任务，这里用作按键扫描。
137. *    形    参: pvParameters 是在创建该任务时传递的形参
138. *    返 回 值: 无
139. *   优 先 级: 4
140. *********************************************************************************************************
141. */
142. static void vTaskStart(void *pvParameters)
143. {
144.     while(1)
145.     {
146.          /* 按键扫描 */
147.          bsp_KeyScan();
148.         vTaskDelay(10);
149.     }
150. }

复制代码

定时器中断回调函数中给任务发送消息队列数据：
    定时器中断的初始化和中断函数在bsp_timer.c 文件中实现，这个不是教程的重点，故不作介绍。 这里主要关心函数xQueueSendFromISR在中断服务程序中的使用方法。

1. /*
2. *********************************************************************************************************
3. *    函 数 名: TIM_CallBack1和TIM_CallBack2
4. *    功能说明: 定时器中断的回调函数，此函数被bsp_StartHardTimer所调用。                        
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static uint32_t g_uiCount = 0; /* 设置为全局静态变量，方便数据更新 */
10. static void TIM_CallBack1(void)
11. {
12.      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
13.    
14.      g_uiCount++;
15.    
16.      /* 向消息队列发数据 */
17.      xQueueSendFromISR(xQueue1,
18.                          (void *)&g_uiCount,
19.                          &xHigherPriorityTaskWoken);
21.      /* 如果xHigherPriorityTaskWoken = pdTRUE，那么退出中断后切到当前最高优先级任务执行 */
22.      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
23. }
25. static void TIM_CallBack2(void)
26. {
27.      MSG_T   *ptMsg;
28.      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
29.    
30.      /* 初始化结构体指针 */
31.      ptMsg = &g_tMsg;
32.    
33.      /* 初始化数组 */
34.      ptMsg->ucMessageID++;
35.      ptMsg->ulData[0]++;
36.      ptMsg->usData[0]++;
38.      /* 向消息队列发数据 */
39.      xQueueSendFromISR(xQueue2,
40.                          (void *)&ptMsg,
41.                           &xHigherPriorityTaskWoken);
43.      /* 如果xHigherPriorityTaskWoken = pdTRUE，那么退出中断后切到当前最高优先级任务执行 */
44.      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
45. }

复制代码

席萌0209

20.4.2 STM32F407开发板实验


配套例子：
     V5-316_FreeRTOS实验_消息队列（中断方式）
实验目的：
     1.     学习FreeRTOS的消息队列（中断方式）。
实验内容：
    1.     K1按键按下，串口打印任务执行情况（波特率115200，数据位8，奇偶校验位无，停止位1）。
    2.     K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息。
    3.     K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息。
    4.     任务vTaskMsgPro只有接收到bit0和bit1都被设置了才执行串口打印消息。
    5.     各个任务实现的功能如下：
              vTaskUserIF任务   ：按键消息处理。
              vTaskLED任务     ：使用函数xQueueReceive接定时器中断发送的消息队列数据。
              vTaskMsgPro任务 ：使用函数xQueueReceive接定时器中断发送的消息队列数据。
              vTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。
FreeRTOS的配置：
    FreeRTOSConfig.h文件中的配置如下：

1. /* Ensure stdint is only used by the compiler, and not the assembler. */
2. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
3. #include <stdint.h>
4. extern volatile uint32_t ulHighFrequencyTimerTicks;
6. /* Ensure stdint is only used by the compiler, and not the assembler. */
7. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
8. #include <stdint.h>
9. extern volatile uint32_t ulHighFrequencyTimerTicks;
10. #endif
12. #define configUSE_PREEMPTION         1
13. #define configUSE_IDLE_HOOK          0
14. #define configUSE_TICK_HOOK          0
15. #define configCPU_CLOCK_HZ           ( ( unsigned long ) 168000000 )
16. #define configTICK_RATE_HZ           ( ( TickType_t ) 1000 )
17. #define configMAX_PRIORITIES         ( 6 )
18. #define configMINIMAL_STACK_SIZE     ( ( unsigned short ) 128 )
19. #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 30 * 1024 ) )
20. #define configMAX_TASK_NAME_LEN      ( 16 )
21. #define configUSE_TRACE_FACILITY      1
22. #define configUSE_16_BIT_TICKS       0
23. #define configIDLE_SHOULD_YIELD      1
25. /* Run time and task stats gathering related definitions. */
26. #define configGENERATE_RUN_TIME_STATS                1
27. #define configUSE_STATS_FORMATTING_FUNCTIONS         1
28. #define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()     (ulHighFrequencyTimerTicks = 0ul)
29. #define portGET_RUN_TIME_COUNTER_VALUE()             ulHighFrequencyTimerTicks
30. //#define portALT_GET_RUN_TIME_COUNTER_VALUE           1
32. /* Co-routine definitions. */
33. #define configUSE_CO_ROUTINES             0
34. #define configMAX_CO_ROUTINE_PRIORITIES ( 2 )
36. /* Set the following definitions to 1 to include the API function, or zero
37. to exclude the API function. */
39. #define INCLUDE_vTaskPrioritySet          1
40. #define INCLUDE_uxTaskPriorityGet         1
41. #define INCLUDE_vTaskDelete               1
42. #define INCLUDE_vTaskCleanUpResources      0
43. #define INCLUDE_vTaskSuspend              1
44. #define INCLUDE_xTaskResumeFromISR        1
45. #define INCLUDE_vTaskDelayUntil           1
46. #define INCLUDE_vTaskDelay                1
49. /* Cortex-M specific definitions. */
50. #ifdef __NVIC_PRIO_BITS
51.      /* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */
52.      #define configPRIO_BITS              __NVIC_PRIO_BITS
53. #else
54.      #define configPRIO_BITS              4        /* 15 priority levels */
55. #endif
57. /* The lowest interrupt priority that can be used in a call to a "set priority"
58. function. */
59. #define configLIBRARY_LOWEST_INTERRUPT_PRIORITY              0x0f
61. /* The highest interrupt priority that can be used by any interrupt service
62. routine that makes calls to interrupt safe FreeRTOS API functions.  DO NOT CALL
63. INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER
64. PRIORITY THAN THIS! (higher priorities are lower numeric values. */
65. #define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY    0x01

复制代码

几个重要选项说明：
1、#define configUSE_PREEMPTION        1
        使能抢占式调度器
2、#define configCPU_CLOCK_HZ      ( ( unsigned long ) 168000000 )
        系统主频168MHz。
3、#define configTICK_RATE_HZ              ( ( TickType_t ) 1000 )
        系统时钟节拍1KHz，即1ms。
4、#define configMAX_PRIORITIES          ( 6 )
        定义可供用户使用的最大优先级数，如果这个定义的是6，那么用户可以使用的优先级号是0,1,2,3,4,5不包含6，对于这一点，初学者要特别的注意。
5、#define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 30 * 1024 ) )
        定义堆大小，FreeRTOS内核，用户动态内存申请，任务栈等都需要用这个空间。
6、configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY          0x01
        定义受FreeRTOS管理的最高优先级中断。简单的说就是允许用户在这个中断服务程序里面调用FreeRTOS的API的最高优先级。为了进一步说明这个宏定义的的作用，解释如下：
    （1）使用CM内核的MCU，官方强烈建议将NVIC的优先级分组配置为全抢占式优先级，全部配置为抢占式优先级的好处就是方便管理。
    （2）对于STM32来说，设置NVIC的优先级分组为4时，NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4)就是全部配置为抢占式优先级。又因为STM32的优先级设置仅使用CM内核8bit中的高4bit，即只能区分2^4 = 16种优先级。因此当优先级分组设置为4的时候可供用户选择抢占式优先级为0到15，共16个优先级，配置为0表示最高优先级，配置为15表示最低优先级，不存在子优先级。
    （3）这里配置configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY为0x01表示用户可以在抢占式优先级为1到15的中断里面调用FreeRTOS的API函数，抢占式优先级为0的中断里面是不允许调用的。
    更多关于这个参数说明请参看第12章。
FreeRTOS任务调试信息（按K1按键，串口打印）：

上面截图中打印出来的任务状态字母B, R, D, S对应如下含义：
    #definetskBLOCKED_CHAR          ( 'B' )  任务阻塞
    #definetskREADY_CHAR           ( 'R' ) 任务就绪
    #definetskDELETED_CHAR           ( 'D' )  任务删除
     #definetskSUSPENDED_CHAR   ( 'S' ) 任务挂起
程序设计：
任务栈大小分配：
    vTaskUserIF任务   ：2048字节
    vTaskLED任务     ：2048字节
    vTaskMsgPro任务 ：2048字节
    vTaskStart任务    ：2048字节
    任务栈空间是在任务创建的时候从FreeRTOSConfig.h文件中定义的heap空间中申请的
    #defineconfigTOTAL_HEAP_SIZE        ( ( size_t )( 30 * 1024 ) )
系统栈大小分配：

FreeROTS初始化：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main(void)
10. {
11.      /*
12.        在启动调度前，为了防止初始化STM32外设时有中断服务程序执行，这里禁止全局中断(除了NMI和HardFault)。
13.        这样做的好处是：
14.        1. 防止执行的中断服务程序中有FreeRTOS的API函数。
15.        2. 保证系统正常启动，不受别的中断影响。
16.        3. 关于是否关闭全局中断，大家根据自己的实际情况设置即可。
17.        在移植文件port.c中的函数prvStartFirstTask中会重新开启全局中断。通过指令cpsie i开启，__set_PRIMASK(1)
18.        和cpsie i是等效的。
19.      */
20.      __set_PRIMASK(1);
21.    
22.      /* 硬件初始化 */
23.      bsp_Init();
24.    
25.      /* 1. 初始化一个定时器中断，精度高于滴答定时器中断，这样才可以获得准确的系统信息 仅供调试目的，实际项
26.            目中不要使用，因为这个功能比较影响系统实时性。
27.         2. 为了正确获取FreeRTOS的调试信息，可以考虑将上面的关闭中断指令__set_PRIMASK(1); 注释掉。
28.      */
29.      vSetupSysInfoTest();
30.    
31.      /* 创建任务 */
32.      AppTaskCreate();
34. /* 创建任务通信机制 */
35.      AppObjCreate();
36.    
37.     /* 启动调度，开始执行任务 */
38.     vTaskStartScheduler();
40.      /*
41.        如果系统正常启动是不会运行到这里的，运行到这里极有可能是用于定时器任务或者空闲任务的
42.        heap空间不足造成创建失败，此要加大FreeRTOSConfig.h文件中定义的heap大小：
43.        #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
44.      */
45.      while(1);
46. }

复制代码

硬件外设初始化
    硬件外设的初始化是在bsp.c文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void bsp_Init(void)
10. {
11.      /*
12.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
13.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
15.          系统时钟缺省配置为168MHz，如果需要更改，可以修改 system_stm32f4xx.c 文件
16.      */
17.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/
18.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
20.      bsp_InitUart();    /* 初始化串口 */
21.      bsp_InitKey();     /* 初始化按键变量 */
22.      bsp_InitLed();     /* 初始LED指示灯端口 */
24. bsp_InitHardTimer(); /* 初始化TIM2定时器 */
25. }

复制代码

FreeRTOS任务创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskCreate
4. *    功能说明: 创建应用任务
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppTaskCreate (void)
10. {
11.     xTaskCreate( vTaskTaskUserIF,   /* 任务函数  */
12.                  "vTaskUserIF",     /* 任务名    */
13.                  512,               /* 任务栈大小，单位word，也就是4字节 */
14.                  NULL,              /* 任务参数  */
15.                  1,                 /* 任务优先级*/
16.                  &xHandleTaskUserIF );  /* 任务句柄  */
17.    
18.    
19.      xTaskCreate( vTaskLED,           /* 任务函数  */
20.                  "vTaskLED",         /* 任务名    */
21.                  512,                /* 任务栈大小，单位word，也就是4字节 */
22.                  NULL,               /* 任务参数  */
23.                  2,                  /* 任务优先级*/
24.                  &xHandleTaskLED ); /* 任务句柄  */
25.    
26.      xTaskCreate( vTaskMsgPro,            /* 任务函数  */
27.                  "vTaskMsgPro",           /* 任务名    */
28.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
29.                  NULL,                    /* 任务参数  */
30.                  3,                       /* 任务优先级*/
31.                  &xHandleTaskMsgPro );  /* 任务句柄  */
32.    
33.    
34.      xTaskCreate( vTaskStart,             /* 任务函数  */
35.                  "vTaskStart",            /* 任务名    */
36.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
37.                  NULL,                    /* 任务参数  */
38.                  4,                       /* 任务优先级*/
39.                  &xHandleTaskStart );   /* 任务句柄  */
40. }

复制代码

FreeRTOS消息队列创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppObjCreate
4. *    功能说明: 创建任务通信机制
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppObjCreate (void)
10. {
11.      /* 创建10个uint8_t型消息队列 */
12.      xQueue1 = xQueueCreate(10, sizeof(uint8_t));
13.     if( xQueue1 == 0 )
14.     {
15.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
16.     }
17.    
18.      /* 创建10个存储指针变量的消息队列，由于CM3/CM4内核是32位机，一个指针变量占用4个字节 */
19.      xQueue2 = xQueueCreate(10, sizeof(struct Msg *));
20.     if( xQueue2 == 0 )
21.     {
22.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
23.     }
24. }

复制代码

四个FreeRTOS任务的实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: vTaskTaskUserIF
4. *    功能说明: 接口消息处理。
5. *    形    参: pvParameters 是在创建该任务时传递的形参
6. *    返 回 值: 无
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
8. *********************************************************************************************************
9. */
10. static void vTaskTaskUserIF(void *pvParameters)
11. {
12.      uint8_t ucKeyCode;
13.      uint8_t pcWriteBuffer[500];
15.     while(1)
16.     {
17.          ucKeyCode = bsp_GetKey();
18.         
19.          if (ucKeyCode != KEY_NONE)
20.          {
21.               switch (ucKeyCode)
22.               {
23.                    /* K1键按下 打印任务执行情况 */
24.                    case KEY_DOWN_K1:         
25.                        printf("=================================================\\r\\n");
26.                        printf("任务名      任务状态 优先级   剩余栈 任务序号\\r\\n");
27.                        vTaskList((char *)&pcWriteBuffer);
28.                        printf("%s\\r\\n", pcWriteBuffer);
29.                   
30.                        printf("\\r\\n任务名       运行计数         使用率\\r\\n");
31.                        vTaskGetRunTimeStats((char *)&pcWriteBuffer);
32.                        printf("%s\\r\\n", pcWriteBuffer);
33.                        break;
34.                   
35.                    /* K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息 */
36.                    case KEY_DOWN_K2:
37.                        printf("K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息
38. \\r\\n");
39.                        bsp_StartHardTimer(1 ,50000, (void *)TIM_CallBack1);
40.                        break;
41.                   
42.                    /* K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息 */
43.                    case KEY_DOWN_K3:
44.                        printf("K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息
45. \\r\\n");
46.                        bsp_StartHardTimer(2 ,50000, (void *)TIM_CallBack2);
47.                        break;
49.                    /* 其他的键值不处理 */
50.                    default:                    
51.                        break;
52.               }
53.          }
54.         
55.          vTaskDelay(20);
56.      }
57. }
59. /*
60. *********************************************************************************************************
61. *    函 数 名: vTaskLED
62. *    功能说明: 使用函数xQueueReceive接定时器中断发送的消息队列数据  
63. *    形    参: pvParameters 是在创建该任务时传递的形参
64. *    返 回 值: 无
65. *   优 先 级: 2
66. *********************************************************************************************************
67. */
68. static void vTaskLED(void *pvParameters)
69. {
70.      MSG_T *ptMsg;
71.      BaseType_t xResult;
72.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(200); /* 设置最大等待时间为200ms */
73.    
74.    
75.     while(1)
76.     {
77.          xResult = xQueueReceive(xQueue2,                   /* 消息队列句柄 */
78.                                  (void *)&ptMsg,           /* 这里获取的是结构体的地址 */
79.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
80.         
81.         
82.          if(xResult == pdPASS)
83.          {
84.               /* 成功接收，并通过串口将数据打印出来 */
85.               printf("接收到消息队列数据ptMsg->ucMessageID = %d\\r\\n", ptMsg->ucMessageID);
86.               printf("接收到消息队列数据ptMsg->ulData[0] = %d\\r\\n", ptMsg->ulData[0]);
87.               printf("接收到消息队列数据ptMsg->usData[0] = %d\\r\\n", ptMsg->usData[0]);
88.          }
89.          else
90.          {
91.               /* 超时 */
92.               bsp_LedToggle(2);
93.               bsp_LedToggle(3);
94.          }
95.     }
96. }
98. /*
99. *********************************************************************************************************
100. *    函 数 名: vTaskMsgPro
101. *    功能说明: 使用函数xQueueReceive接定时器中断发送的消息队列数据
102. *    形    参: pvParameters 是在创建该任务时传递的形参
103. *    返 回 值: 无
104. *   优 先 级: 3
105. *********************************************************************************************************
106. */
107. static void vTaskMsgPro(void *pvParameters)
108. {
109.      BaseType_t xResult;
110.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(300); /* 设置最大等待时间为300ms */
111.      uint8_t ucQueueMsgValue;
112.    
113.     while(1)
114.     {
115.          xResult = xQueueReceive(xQueue1,                   /* 消息队列句柄 */
116.                                  (void *)&ucQueueMsgValue,  /* 存储接收到的数据到变量ucQueueMsgValue中 */
117.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
118.         
119.          if(xResult == pdPASS)
120.          {
121.               /* 成功接收，并通过串口将数据打印出来 */
122.               printf("接收到消息队列数据ucQueueMsgValue = %d\\r\\n", ucQueueMsgValue);
123.          }
124.          else
125.          {
126.               /* 超时 */
127.               bsp_LedToggle(1);
128.               bsp_LedToggle(4);
129.          }
130.     }
131. }
133. /*
134. *********************************************************************************************************
135. *    函 数 名: vTaskStart
136. *    功能说明: 启动任务，也就是最高优先级任务，这里用作按键扫描。
137. *    形    参: pvParameters 是在创建该任务时传递的形参
138. *    返 回 值: 无
139. *   优 先 级: 4
140. *********************************************************************************************************
141. */
142. static void vTaskStart(void *pvParameters)
143. {
144.     while(1)
145.     {
146.          /* 按键扫描 */
147.          bsp_KeyScan();
148.         vTaskDelay(10);
149.     }
150. }

复制代码

定时器中断回调函数中给任务发送消息队列数据：
    定时器中断的初始化和中断函数在bsp_timer.c 文件中实现，这个不是教程的重点，故不作介绍。 这里主要关心函数xQueueSendFromISR在中断服务程序中的使用方法。

1. /*
2. *********************************************************************************************************
3. *    函 数 名: TIM_CallBack1和TIM_CallBack2
4. *    功能说明: 定时器中断的回调函数，此函数被bsp_StartHardTimer所调用。                        
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static uint32_t g_uiCount = 0; /* 设置为全局静态变量，方便数据更新 */
10. static void TIM_CallBack1(void)
11. {
12.      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
13.    
14.      g_uiCount++;
15.    
16.      /* 向消息队列发数据 */
17.      xQueueSendFromISR(xQueue1,
18.                          (void *)&g_uiCount,
19.                          &xHigherPriorityTaskWoken);
21.      /* 如果xHigherPriorityTaskWoken = pdTRUE，那么退出中断后切到当前最高优先级任务执行 */
22.      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
23. }
25. static void TIM_CallBack2(void)
26. {
27.      MSG_T   *ptMsg;
28.      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
29.    
30.      /* 初始化结构体指针 */
31.      ptMsg = &g_tMsg;
32.    
33.      /* 初始化数组 */
34.      ptMsg->ucMessageID++;
35.      ptMsg->ulData[0]++;
36.      ptMsg->usData[0]++;
38.      /* 向消息队列发数据 */
39.      xQueueSendFromISR(xQueue2,
40.                          (void *)&ptMsg,
41.                           &xHigherPriorityTaskWoken);
43.      /* 如果xHigherPriorityTaskWoken = pdTRUE，那么退出中断后切到当前最高优先级任务执行 */
44.      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
45. }

复制代码

席萌0209

20.4.3 STM32F429开发板实验


配套例子：
    V4-316_FreeRTOS实验_消息队列（中断方式）
实验目的：
   1.     学习FreeRTOS的消息队列（中断方式）。
实验内容：
     1.     K1按键按下，串口打印任务执行情况（波特率115200，数据位8，奇偶校验位无，停止位1）。
    2.     K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息。
    3.     K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息。
    4.     任务vTaskMsgPro只有接收到bit0和bit1都被设置了才执行串口打印消息。
    5.     各个任务实现的功能如下：
              vTaskUserIF任务   ：按键消息处理。
              vTaskLED任务     ：使用函数xQueueReceive接定时器中断发送的消息队列数据。
              vTaskMsgPro任务 ：使用函数xQueueReceive接定时器中断发送的消息队列数据。
              vTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。
FreeRTOS的配置：
    FreeRTOSConfig.h文件中的配置如下：

1. /* Ensure stdint is only used by the compiler, and not the assembler. */
2. #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
3. #include <stdint.h>
4. extern volatile uint32_t ulHighFrequencyTimerTicks;
5. #endif
7. #define configUSE_PREEMPTION         1
8. #define configUSE_IDLE_HOOK          0
9. #define configUSE_TICK_HOOK          0
10. #define configCPU_CLOCK_HZ           ( ( unsigned long ) 168000000 )
11. #define configTICK_RATE_HZ           ( ( TickType_t ) 1000 )
12. #define configMAX_PRIORITIES         ( 5 )
13. #define configMINIMAL_STACK_SIZE     ( ( unsigned short ) 128 )
14. #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 30 * 1024 ) )
15. #define configMAX_TASK_NAME_LEN      ( 16 )
16. #define configUSE_TRACE_FACILITY      1
17. #define configUSE_16_BIT_TICKS       0
18. #define configIDLE_SHOULD_YIELD      1
20. /* Run time and task stats gathering related definitions. */
21. #define configGENERATE_RUN_TIME_STATS                1
22. #define configUSE_STATS_FORMATTING_FUNCTIONS         1
23. #define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()     (ulHighFrequencyTimerTicks = 0ul)
24. #define portGET_RUN_TIME_COUNTER_VALUE()             ulHighFrequencyTimerTicks
25. //#define portALT_GET_RUN_TIME_COUNTER_VALUE           1
27. /* Co-routine definitions. */
28. #define configUSE_CO_ROUTINES            0
29. #define configMAX_CO_ROUTINE_PRIORITIES ( 2 )
31. /* Set the following definitions to 1 to include the API function, or zero
32. to exclude the API function. */
34. #define INCLUDE_vTaskPrioritySet          1
35. #define INCLUDE_uxTaskPriorityGet         1
36. #define INCLUDE_vTaskDelete               1
37. #define INCLUDE_vTaskCleanUpResources      0
38. #define INCLUDE_vTaskSuspend              1
39. #define INCLUDE_xTaskResumeFromISR        1
40. #define INCLUDE_vTaskDelayUntil           1
41. #define INCLUDE_vTaskDelay                1
43. /* Cortex-M specific definitions. */
44. #ifdef __NVIC_PRIO_BITS
45.      /* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */
46.      #define configPRIO_BITS              __NVIC_PRIO_BITS
47. #else
48.      #define configPRIO_BITS              4        /* 15 priority levels */
49. #endif
51. /* The lowest interrupt priority that can be used in a call to a "set priority"
52. function. */
53. #define configLIBRARY_LOWEST_INTERRUPT_PRIORITY              0x0f
55. /* The highest interrupt priority that can be used by any interrupt service
56. routine that makes calls to interrupt safe FreeRTOS API functions.  DO NOT CALL
57. INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER
58. PRIORITY THAN THIS! (higher priorities are lower numeric values. */
59. #define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY         0x01

复制代码

几个重要选项说明：
1、#define configUSE_PREEMPTION        1
        使能抢占式调度器
2、#define configCPU_CLOCK_HZ      ( ( unsigned long ) 168000000 )
        系统主频168MHz。
3、#define configTICK_RATE_HZ              ( ( TickType_t ) 1000 )
        系统时钟节拍1KHz，即1ms。
4、#define configMAX_PRIORITIES          ( 5 )
        定义可供用户使用的最大优先级数，如果这个定义的是5，那么用户可以使用的优先级号是0,1,2,3,4，不包含5，对于这一点，初学者要特别的注意。
5、#define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 30 * 1024 ) )
        定义堆大小，FreeRTOS内核，用户动态内存申请，任务栈等都需要用这个空间。
6、configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY          0x01
        定义受FreeRTOS管理的最高优先级中断。简单的说就是允许用户在这个中断服务程序里面调用FreeRTOS的API的最高优先级。为了进一步说明这个宏定义的的作用，解释如下：
    （1）使用CM内核的MCU，官方强烈建议将NVIC的优先级分组配置为全抢占式优先级，全部配置为抢占式优先级的好处就是方便管理。
    （2）对于STM32来说，设置NVIC的优先级分组为4时，NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4)就是全部配置为抢占式优先级。又因为STM32的优先级设置仅使用CM内核8bit中的高4bit，即只能区分2^4 = 16种优先级。因此当优先级分组设置为4的时候可供用户选择抢占式优先级为0到15，共16个优先级，配置为0表示最高优先级，配置为15表示最低优先级，不存在子优先级。
    （3）这里配置configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY为0x01表示用户可以在抢占式优先级为1到15的中断里面调用FreeRTOS的API函数，抢占式优先级为0的中断里面是不允许调用的。
更多关于这个参数说明请参看第12章。
FreeRTOS任务调试信息（按K1按键，串口打印）：

上面截图中打印出来的任务状态字母B, R, D, S对应如下含义：
    #definetskBLOCKED_CHAR          ( 'B' )  任务阻塞
    #definetskREADY_CHAR           ( 'R' ) 任务就绪
    #definetskDELETED_CHAR           ( 'D' )  任务删除
    #definetskSUSPENDED_CHAR   ( 'S' ) 任务挂起
程序设计：
任务栈大小分配：
    vTaskUserIF任务   ：2048字节
    vTaskLED任务     ：2048字节
    vTaskMsgPro任务 ：2048字节
    vTaskStart任务    ：2048字节
    任务栈空间是在任务创建的时候从FreeRTOSConfig.h文件中定义的heap空间中申请的
    #defineconfigTOTAL_HEAP_SIZE        ( ( size_t )( 30 * 1024 ) )
系统栈大小分配：

FreeROTS初始化：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main(void)
10. {
11.      /*
12.        在启动调度前，为了防止初始化STM32外设时有中断服务程序执行，这里禁止全局中断(除了NMI和HardFault)。
13.        这样做的好处是：
14.        1. 防止执行的中断服务程序中有FreeRTOS的API函数。
15.        2. 保证系统正常启动，不受别的中断影响。
16.        3. 关于是否关闭全局中断，大家根据自己的实际情况设置即可。
17.        在移植文件port.c中的函数prvStartFirstTask中会重新开启全局中断。通过指令cpsie i开启，__set_PRIMASK(1)
18.        和cpsie i是等效的。
19.      */
20.      __set_PRIMASK(1);
21.    
22.      /* 硬件初始化 */
23.      bsp_Init();
24.    
25.      /* 1. 初始化一个定时器中断，精度高于滴答定时器中断，这样才可以获得准确的系统信息 仅供调试目的，实际项
26.            目中不要使用，因为这个功能比较影响系统实时性。
27.         2. 为了正确获取FreeRTOS的调试信息，可以考虑将上面的关闭中断指令__set_PRIMASK(1); 注释掉。
28.      */
29.      vSetupSysInfoTest();
30.    
31.      /* 创建任务 */
32.      AppTaskCreate();
34. /* 创建任务通信机制 */
35.      AppObjCreate();
36.    
37.     /* 启动调度，开始执行任务 */
38.     vTaskStartScheduler();
40.      /*
41.        如果系统正常启动是不会运行到这里的，运行到这里极有可能是用于定时器任务或者空闲任务的
42.        heap空间不足造成创建失败，此要加大FreeRTOSConfig.h文件中定义的heap大小：
43.        #define configTOTAL_HEAP_SIZE        ( ( size_t ) ( 17 * 1024 ) )
44.      */
45.      while(1);
46. }

复制代码

硬件外设初始化
    硬件外设的初始化是在bsp.c文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void bsp_Init(void)
10. {
11.      /*
12.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
13.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
15.          系统时钟缺省配置为168MHz，如果需要更改，可以修改 system_stm32f4xx.c 文件
16.      */
17.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/
18.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
19.    
20.      SystemCoreClockUpdate();    /* 根据PLL配置更新系统时钟频率变量 SystemCoreClock */
22.      bsp_InitUart();    /* 初始化串口 */
23.      bsp_InitKey();     /* 初始化按键变量 */
24.      bsp_InitExtIO();   /* FMC总线上扩展了32位输出IO, 操作LED等外设必须初始化 */
25.      bsp_InitLed();     /* 初始LED指示灯端口 */
27. bsp_InitHardTimer(); /* 初始化TIM2定时器 */
28. }

复制代码

FreeRTOS任务创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskCreate
4. *    功能说明: 创建应用任务
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppTaskCreate (void)
10. {
11.     xTaskCreate( vTaskTaskUserIF,   /* 任务函数  */
12.                  "vTaskUserIF",     /* 任务名    */
13.                  512,               /* 任务栈大小，单位word，也就是4字节 */
14.                  NULL,              /* 任务参数  */
15.                  1,                 /* 任务优先级*/
16.                  &xHandleTaskUserIF );  /* 任务句柄  */
17.    
18.    
19.      xTaskCreate( vTaskLED,           /* 任务函数  */
20.                  "vTaskLED",         /* 任务名    */
21.                  512,                /* 任务栈大小，单位word，也就是4字节 */
22.                  NULL,               /* 任务参数  */
23.                  2,                  /* 任务优先级*/
24.                  &xHandleTaskLED ); /* 任务句柄  */
25.    
26.      xTaskCreate( vTaskMsgPro,            /* 任务函数  */
27.                  "vTaskMsgPro",           /* 任务名    */
28.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
29.                  NULL,                    /* 任务参数  */
30.                  3,                       /* 任务优先级*/
31.                  &xHandleTaskMsgPro );  /* 任务句柄  */
32.    
33.    
34.      xTaskCreate( vTaskStart,             /* 任务函数  */
35.                  "vTaskStart",            /* 任务名    */
36.                  512,                     /* 任务栈大小，单位word，也就是4字节 */
37.                  NULL,                    /* 任务参数  */
38.                  4,                       /* 任务优先级*/
39.                  &xHandleTaskStart );   /* 任务句柄  */
40. }

复制代码

FreeRTOS消息队列创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppObjCreate
4. *    功能说明: 创建任务通信机制
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppObjCreate (void)
10. {
11.      /* 创建10个uint8_t型消息队列 */
12.      xQueue1 = xQueueCreate(10, sizeof(uint8_t));
13.     if( xQueue1 == 0 )
14.     {
15.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
16.     }
17.    
18.      /* 创建10个存储指针变量的消息队列，由于CM3/CM4内核是32位机，一个指针变量占用4个字节 */
19.      xQueue2 = xQueueCreate(10, sizeof(struct Msg *));
20.     if( xQueue2 == 0 )
21.     {
22.         /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
23.     }
24. }

复制代码

四个FreeRTOS任务的实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: vTaskTaskUserIF
4. *    功能说明: 接口消息处理。
5. *    形    参: pvParameters 是在创建该任务时传递的形参
6. *    返 回 值: 无
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
8. *********************************************************************************************************
9. */
10. static void vTaskTaskUserIF(void *pvParameters)
11. {
12.      uint8_t ucKeyCode;
13.      uint8_t pcWriteBuffer[500];
15.     while(1)
16.     {
17.          ucKeyCode = bsp_GetKey();
18.         
19.          if (ucKeyCode != KEY_NONE)
20.          {
21.               switch (ucKeyCode)
22.               {
23.                    /* K1键按下 打印任务执行情况 */
24.                    case KEY_DOWN_K1:         
25.                        printf("=================================================\\r\\n");
26.                        printf("任务名      任务状态 优先级   剩余栈 任务序号\\r\\n");
27.                        vTaskList((char *)&pcWriteBuffer);
28.                        printf("%s\\r\\n", pcWriteBuffer);
29.                   
30.                        printf("\\r\\n任务名       运行计数         使用率\\r\\n");
31.                        vTaskGetRunTimeStats((char *)&pcWriteBuffer);
32.                        printf("%s\\r\\n", pcWriteBuffer);
33.                        break;
34.                   
35.                    /* K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息 */
36.                    case KEY_DOWN_K2:
37.                        printf("K2键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskMsgPro发送消息
38. \\r\\n");
39.                        bsp_StartHardTimer(1 ,50000, (void *)TIM_CallBack1);
40.                        break;
41.                   
42.                    /* K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息 */
43.                    case KEY_DOWN_K3:
44.                        printf("K3键按下，启动单次定时器中断，50ms后在定时器中断给任务vTaskLED发送消息
45. \\r\\n");
46.                        bsp_StartHardTimer(2 ,50000, (void *)TIM_CallBack2);
47.                        break;
49.                    /* 其他的键值不处理 */
50.                    default:                    
51.                        break;
52.               }
53.          }
54.         
55.          vTaskDelay(20);
56.      }
57. }
59. /*
60. *********************************************************************************************************
61. *    函 数 名: vTaskLED
62. *    功能说明: 使用函数xQueueReceive接定时器中断发送的消息队列数据  
63. *    形    参: pvParameters 是在创建该任务时传递的形参
64. *    返 回 值: 无
65. *   优 先 级: 2
66. *********************************************************************************************************
67. */
68. static void vTaskLED(void *pvParameters)
69. {
70.      MSG_T *ptMsg;
71.      BaseType_t xResult;
72.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(200); /* 设置最大等待时间为200ms */
73.    
74.    
75.     while(1)
76.     {
77.          xResult = xQueueReceive(xQueue2,                   /* 消息队列句柄 */
78.                                  (void *)&ptMsg,           /* 这里获取的是结构体的地址 */
79.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
80.         
81.         
82.          if(xResult == pdPASS)
83.          {
84.               /* 成功接收，并通过串口将数据打印出来 */
85.               printf("接收到消息队列数据ptMsg->ucMessageID = %d\\r\\n", ptMsg->ucMessageID);
86.               printf("接收到消息队列数据ptMsg->ulData[0] = %d\\r\\n", ptMsg->ulData[0]);
87.               printf("接收到消息队列数据ptMsg->usData[0] = %d\\r\\n", ptMsg->usData[0]);
88.          }
89.          else
90.          {
91.               /* 超时 */
92.               bsp_LedToggle(2);
93.               bsp_LedToggle(3);
94.          }
95.     }
96. }
98. /*
99. *********************************************************************************************************
100. *    函 数 名: vTaskMsgPro
101. *    功能说明: 使用函数xQueueReceive接定时器中断发送的消息队列数据
102. *    形    参: pvParameters 是在创建该任务时传递的形参
103. *    返 回 值: 无
104. *   优 先 级: 3
105. *********************************************************************************************************
106. */
107. static void vTaskMsgPro(void *pvParameters)
108. {
109.      BaseType_t xResult;
110.      const TickType_t xMaxBlockTime = pdMS_TO_TICKS(300); /* 设置最大等待时间为300ms */
111.      uint8_t ucQueueMsgValue;
112.    
113.     while(1)
114.     {
115.          xResult = xQueueReceive(xQueue1,                   /* 消息队列句柄 */
116.                                  (void *)&ucQueueMsgValue,  /* 存储接收到的数据到变量ucQueueMsgValue中 */
117.                                  (TickType_t)xMaxBlockTime);/* 设置阻塞时间 */
118.         
119.          if(xResult == pdPASS)
120.          {
121.               /* 成功接收，并通过串口将数据打印出来 */
122.               printf("接收到消息队列数据ucQueueMsgValue = %d\\r\\n", ucQueueMsgValue);
123.          }
124.          else
125.          {
126.               /* 超时 */
127.               bsp_LedToggle(1);
128.               bsp_LedToggle(4);
129.          }
130.     }
131. }
133. /*
134. *********************************************************************************************************
135. *    函 数 名: vTaskStart
136. *    功能说明: 启动任务，也就是最高优先级任务，这里用作按键扫描。
137. *    形    参: pvParameters 是在创建该任务时传递的形参
138. *    返 回 值: 无
139. *   优 先 级: 4
140. *********************************************************************************************************
141. */
142. static void vTaskStart(void *pvParameters)
143. {
144.     while(1)
145.     {
146.          /* 按键扫描 */
147.          bsp_KeyScan();
148.         vTaskDelay(10);
149.     }
150. }

复制代码

定时器中断回调函数中给任务发送消息队列数据：
    定时器中断的初始化和中断函数在bsp_timer.c 文件中实现，这个不是教程的重点，故不作介绍。 这里主要关心函数xQueueSendFromISR在中断服务程序中的使用方法。

1. /*
2. *********************************************************************************************************
3. *    函 数 名: TIM_CallBack1和TIM_CallBack2
4. *    功能说明: 定时器中断的回调函数，此函数被bsp_StartHardTimer所调用。                        
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static uint32_t g_uiCount = 0; /* 设置为全局静态变量，方便数据更新 */
10. static void TIM_CallBack1(void)
11. {
12.      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
13.    
14.      g_uiCount++;
15.    
16.      /* 向消息队列发数据 */
17.      xQueueSendFromISR(xQueue1,
18.                          (void *)&g_uiCount,
19.                          &xHigherPriorityTaskWoken);
21.      /* 如果xHigherPriorityTaskWoken = pdTRUE，那么退出中断后切到当前最高优先级任务执行 */
22.      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
23. }
25. static void TIM_CallBack2(void)
26. {
27.      MSG_T   *ptMsg;
28.      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
29.    
30.      /* 初始化结构体指针 */
31.      ptMsg = &g_tMsg;
32.    
33.      /* 初始化数组 */
34.      ptMsg->ucMessageID++;
35.      ptMsg->ulData[0]++;
36.      ptMsg->usData[0]++;
38.      /* 向消息队列发数据 */
39.      xQueueSendFromISR(xQueue2,
40.                          (void *)&ptMsg,
41.                           &xHigherPriorityTaskWoken);
43.      /* 如果xHigherPriorityTaskWoken = pdTRUE，那么退出中断后切到当前最高优先级任务执行 */
44.      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
45. }

复制代码

席萌0209

20.5 总结

    本章节就为大家讲解了消息队列的使用，在实际项目中，消息队列用到的地方非常多，希望初学者认真学习并掌握。