RTOS中的事件标志组验证

yangdongdeboke

已于 2023-12-20 09:18:53 修改

阅读量971

点赞数 33

文章标签： RTOS stm32cube 事件标志组

于 2023-12-20 07:30:00 首次发布

本文链接：https://blog.csdn.net/weixin_51374594/article/details/135033512

版权

我们在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；同时该标志位清零。

yangdongdeboke

关注

33
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
RTOS中的事件标志组验证

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

扫一扫