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

RTOS中的事件标志组验证_第1张图片

GPIO

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

RTOS

RTOS中的事件标志组验证_第2张图片

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

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

两个任务的名字分别是

Task1,Task2;

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

StartTask1,StartTask2;

其余配置相同,如下图

RTOS中的事件标志组验证_第3张图片

三、代码部分

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;同时所有选择的标志位都清零。

RTOS中的事件标志组验证_第4张图片

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

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

RTOS中的事件标志组验证_第5张图片

你可能感兴趣的:(RTOS,stm32cube,事件标志组)