RTOS中的事件标志组验证

? ? 我们在stm32f103c8t6单片机上验证RTOS中事件标志组API函数的功能，利用stm32cube进行RTOS的配置。裸机的时钟源默认是 SysTick，但是开启 FreeRTOS 后，FreeRTOS会占用 SysTick （用来生成1ms 定时，用于任务调度），所以我们开启TIM2当做裸机的时钟源，为其他总线提供另外的时钟源。

验证的功能比较简单，这里我们依旧选择V1 版本的内核的，但是这个版本没办法自己创建事件，但是我们可以手动创建。

一、验证的思路以及需要使用的函数

1.验证思路

创建2个任务：Task1，Task2。

任务要求如下：

Task1：如果按下KEY1，则将第0位置1；如果按下KEY2，则将第1位置1。Task2：如果KEY1和KEY2都按下，等待事件标志位成功，返回等待到的事件标志位；等待事件标志位 失败，返回事件组中的事件标志位。

2.需要用到的函数

创建事件标志组

EventGroupHandle_t xEventGroupCreate( void );

返回值： 成功，返回对应事件标志组的句柄； 失败，返回 NULL 。

设置事件标志位

EventBits_t xEventGroupSetBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );

xEventGroup：对应事件组句柄。

uxBitsToSet：指定要在事件组中设置的一个或多个位的按位值。

返回值：设置之后事件组中的事件标志位值。

.等待事件标志位

EventBits_t xEventGroupWaitBits( const EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait );

xEventGroup：对应的事件标志组句柄

uxBitsToWaitFor：指定事件组中要等待的一个或多个事件位的按位值

xClearOnExit：pdTRUE——清除对应事件位，pdFALSE——不清除

xWaitForAllBits：pdTRUE——所有等待事件位全为1（逻辑与），pdFALSE——等待的事件位有一个为1（逻辑或）

xTicksToWait：超时

返回值：等待的事件标志位值：等待事件标志位成功，返回等待到的事件标志位 其他值：等待事件标志位 失败，返回事件组中的事件标志位

这里要说明一下，等待事件标志位函数有清除标志位的功能，但是他清除标志位是发生在等待事件标志位成功后，而不是一上来就给事件清零。所以大家不要有什么误解，这个到后面的现象里我会给大家解释。

二、stm32cube的配置

SYS

RCC

GPIO

PA0对应按键1，PA1对应按键2；PB8对应LED1,PB9对应LED2

RTOS

在Tasks and Queues中配置我们的2个任务

其实就是相当于stm32cube帮我们调用了并封装了xTaskCreate()函数。

两个任务的名字分别是

Task1,Task2;

四个任务的入口函数名字分别是

StartTask1,StartTask2;

其余配置相同，如下图

三、代码部分

usart.c

#include "stdio.h"

int fputc(int ch, FILE *f)

{?????

?????? unsigned char temp[1]={ch};

?????? HAL_UART_Transmit(&huart1,temp,1,0xffff);?

?????? return ch;

}

同时打开“魔术棒”，勾选Use MicroLIB,点击OK。这样就可以进行串口打印了。

freertos.c

#include "FreeRTOS.h"

#include "task.h"

#include "main.h"

#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/

/* USER CODE BEGIN Includes */

#include "stdio.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/

/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/

/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/

/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN Variables */

EventGroupHandle_t GroupHandle_t;

/* USER CODE END Variables */

osThreadId TaskKEY1Handle;

osThreadId TaskKEY2Handle;

/* Private function prototypes -----------------------------------------------*/

/* USER CODE BEGIN FunctionPrototypes */

/* USER CODE END FunctionPrototypes */

void StartKEY1(void const * argument);

void StartKEY2(void const * argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/* GetIdleTaskMemory prototype (linked to static allocation support) */

void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );

/* USER CODE BEGIN GET_IDLE_TASK_MEMORY */

static StaticTask_t xIdleTaskTCBBuffer;

static StackType_t xIdleStack[configMINIMAL_STACK_SIZE];

void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )

{

? *ppxIdleTaskTCBBuffer = &xIdleTaskTCBBuffer;

? *ppxIdleTaskStackBuffer = &xIdleStack[0];

? *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;

? /* place for user code */

}

/* USER CODE END GET_IDLE_TASK_MEMORY */

/**

? * @brief? FreeRTOS initialization

? * @param? None

? * @retval None

? */

void MX_FREERTOS_Init(void) {

? /* USER CODE BEGIN Init */

? /* USER CODE END Init */

? /* USER CODE BEGIN RTOS_MUTEX */

? /* add mutexes, ... */

? /* USER CODE END RTOS_MUTEX */

? /* USER CODE BEGIN RTOS_SEMAPHORES */

? /* add semaphores, ... */

? /* USER CODE END RTOS_SEMAPHORES */

? /* USER CODE BEGIN RTOS_TIMERS */

? /* start timers, add new ones, ... */

? /* USER CODE END RTOS_TIMERS */

? /* USER CODE BEGIN RTOS_QUEUES */

? /* add queues, ... */

? /* USER CODE END RTOS_QUEUES */

? /* Create the thread(s) */

? /* definition and creation of TaskKEY1 */

? osThreadDef(TaskKEY1, StartKEY1, osPriorityNormal, 0, 128);

? TaskKEY1Handle = osThreadCreate(osThread(TaskKEY1), NULL);

? /* definition and creation of TaskKEY2 */

? osThreadDef(TaskKEY2, StartKEY2, osPriorityNormal, 0, 128);

? TaskKEY2Handle = osThreadCreate(osThread(TaskKEY2), NULL);

? /* USER CODE BEGIN RTOS_THREADS */

?????? GroupHandle_t=xEventGroupCreate();

? /* add threads, ... */

? /* USER CODE END RTOS_THREADS */

}

/* USER CODE BEGIN Header_StartKEY1 */

/**

? * @brief? Function implementing the TaskKEY1 thread.

? * @param? argument: Not used

? * @retval None

? */

/* USER CODE END Header_StartKEY1 */

void StartKEY1(void const * argument)

{

? /* USER CODE BEGIN StartKEY1 */

? /* Infinite loop */

? for(;;)

? {

??? if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)==GPIO_PIN_RESET)

????????????? {

???????????????????? osDelay(20);//软件消除按键抖动

???????????????????? if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)==GPIO_PIN_RESET)

???????????????????? {

????????????? ??? xEventGroupSetBits(GroupHandle_t,0x01);

???????????????????? }

???????????????????? while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)==GPIO_PIN_RESET);

????????????? }

????????????? if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1)==GPIO_PIN_RESET)

????????????? {

???????????????????? osDelay(20);//软件消除按键抖动

???????????????????? if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1)==GPIO_PIN_RESET)

???????????????????? {

????????????? ??? xEventGroupSetBits(GroupHandle_t,0x02);

???????????????????? }

???????????????????? while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1)==GPIO_PIN_RESET);

????????????? }

??? osDelay(10);

? }

? /* USER CODE END StartKEY1 */

}

/* USER CODE BEGIN Header_StartKEY2 */

/**

* @brief Function implementing the TaskKEY2 thread.

* @param argument: Not used

* @retval None

*/

/* USER CODE END Header_StartKEY2 */

void StartKEY2(void const * argument)

{

? /* USER CODE BEGIN StartKEY2 */

?????? EventBits_t event_bit;

? /* Infinite loop */

? for(;;)

? {

????????????? event_bit=xEventGroupWaitBits(GroupHandle_t,0x01 | 0x02,pdTRUE,pdTRUE,1000);

????????????? printf("返回值%d\r\n",event_bit);

??? osDelay(10);

? }

? /* USER CODE END StartKEY2 */

}

首先创建事件函数的返回句柄GroupHandle_t，作为全局变量，类型和创建事件函数的返回值保持一致，即EventGroupHandle_t 。

接着在StartKEY1（）里，当我们判断KEY1按下时，我们调用设置事件标志位函数xEventGroupSetBits(GroupHandle_t,0x01);将第0位设置为1。当我们判断KEY2按下时，我们调用设置事件标志位函数xEventGroupSetBits(GroupHandle_t,0x02);将第1位设置为1。

下面细说 等待事件标志位函数

xEventGroupWaitBits(GroupHandle_t,0x01 | 0x02,pdTRUE,pdTRUE,100)

第一个参数xEventGroup：对应的事件标志组句柄，也就是我们自己定义的全局变量GroupHandle_t

第二个参数uxBitsToWaitFor：指定事件组中要等待的一个或多个事件位的按位值，在我们的程序里，我们写的是第0位和第1位，写法是0x01 | 0x02。“|”的作用就相当于与英语中的and

第三个参数xClearOnExit：pdTRUE——清除对应事件位，pdFALSE——不清除。如果你选择pdTRUE，注意这里的清除是发生在等待事件标志位成功。要不然你想想，这别还在循环的不断积累状态，结果你倒好，刚来一个状态，你给清0了，这合适吗？这不合适，所以清0一定是等到等待事件标志位成功才发生的。

第四个参数xWaitForAllBits：pdTRUE——所有等待事件位全为1（逻辑与），pdFALSE——等待的事件位有一个为1（逻辑或）。意思就是如果你选pdTRUE，那么你选择的标志位必须都为1，才可以让等待事件标志位成功；如果你选择的是pdFALSE，那么你选择的标志位只要有一个是1，就可以让等待事件标志位成功。

第五个参数xTicksToWait：自己设置的阻塞时间，最大可以设置为portMAX_DELAY，就是直到事件标志位成功才结束阻塞。

这个函数的返回值也是情况的

如果你在第四个参数里选择pdTRUE

那么如果你等待事件标志位成功，返回等待到的事件标志位；等待事件标志位失败，返回事件组中的事件标志位。

以我们的程序为例，我们的第0位是0x01，第一位是0x02，若等待事件标志位成功，则返回两个位的和，即0x01+0x02=0x03，对应十进制也就是3，同时将所有你所选的标志位清0。

如果等待事件标志位失败，比如你只按下KEY1,则返回0x01，也就是1；如果你只按下KEY2,则返回0x02，也就是2。

如果你在第四个参数里选择pdFALSE

那么无论你按下KEY1还是KEY2，都可以成功返回，同时会将对应的标志位清0。

下图是等待事件标志位函数的第四个参数为pdTRUE时的情况，和我们的分析是一样的。当我只按下KEY1时，返回失败等待事件标志位，1；同时该标志位并没有清零，当我再按下KEY2后，返回成功等待事件标志位，3；同时所有选择的标志位都清零。当我只按下KEY2时，返回失败等待事件标志位，2；同时该标志位并没有清零，当我再按下KEY1后，返回成功等待事件标志位，3；同时所有选择的标志位都清零。

下图是等待事件标志位函数的第四个参数为pdFALSE时的情况，和我们的分析是一样的。

当我只按下KEY1或只按下KEY2时，返回成功等待事件标志位，1或者2；同时该标志位清零。