FrereRTOS事件组

学校组织秋游，组长在等待：

• 张三：我到了
• 李四：我到了
• 王五：我到了
• 组长说：好，大家都到齐了，出发！

秋游回来第二天就要提交一篇心得报告，组长在焦急等待：张三、李四、王五谁先写好就交谁的。

在这个日常生活场景中：

• 出发：要等待这3个人都到齐，他们是"与"的关系
• 交报告：只需等待这3人中的任何一个，他们是"或"的关系

在FreeRTOS中，可以使用事件组(event group)来解决这些问题。

本章涉及如下内容：

• 事件组的概念与操作函数
• 事件组的优缺点
• 怎么设置、等待、清除事件组中的位
• 使用事件组来同步多个任务

一、事件组概念与操作

1、事件组的概念

事件组可以简单地认为就是一个整数：

• 每一位表示一个事件
• 每一位事件的含义由程序员决定，比如：Bit0表示用来串口是否就绪，Bit1表示按键是否被按下
• 这些位，值为1表示事件发生了，值为0表示事件没发生
• 一个或多个任务、ISR都可以去写这些位；一个或多个任务、ISR都可以去读这些位
• 可以等待某一位、某些位中的任意一个，也可以等待多位

事件组用一个整数来表示，其中的高8位留给内核使用，只能用其他的位来表示事件。那么这个整数是多少位的？

• 如果configUSE_16_BIT_TICKS是1，那么这个整数就是16位的，低8位用来表示事件
• 如果configUSE_16_BIT_TICKS是0，那么这个整数就是32位的，低24位用来表示事件
• 如果configUSE_16_BIT_TICKS是用来表示Tick Count的，怎么会影响事件组？这只是基于效率来考虑
• 如果configUSE_16_BIT_TICKS是1，就表示该处理器使用16位更高效，所以事件组也使用16位
• 如果configUSE_16_BIT_TICKS是0，就表示该处理器使用32位更高效，所以事件组也使用32位

2、事件组的操作

事件组和队列、信号量等不太一样，主要集中在2个地方：

• 唤醒谁？
  • 队列、信号量：事件发生时，只会唤醒一个任务
  • 事件组：事件发生时，会唤醒所有符号条件的任务，简单地说它有"广播"的作用
• 是否清除事件？
  • 队列、信号量：是消耗型的资源，队列的数据被读走就没了；信号量被获取后就减少了
  • 事件组：被唤醒的任务有两个选择，可以让事件保留不动，也可以清除事件

以上图为列，事件组的常规操作如下：

• 先创建事件组
• 任务C、D等待事件：
  • 等待什么事件？可以等待某一位、某些位中的任意一个，也可以等待多位。简单地说就是"或"、"与"的关系。
  • 得到事件时，要不要清除？可选择清除、不清除。
• 任务A、B产生事件：设置事件组里的某一位、某些位

二、事件组函数

1、创建

使用事件组之前，要先创建，得到一个句柄；使用事件组时，要使用句柄来表明使用哪个事件组。

有两种创建方法：动态分配内存、静态分配内存。函数原型如下：

/* 创建一个事件组，返回它的句柄。* 此函数内部会分配事件组结构体 * 返回值: 返回句柄，非NULL表示成功*/
EventGroupHandle_t xEventGroupCreate( void );/* 创建一个事件组，返回它的句柄。* 此函数无需动态分配内存，所以需要先有一个StaticEventGroup_t结构体，并传入它的指针* 返回值: 返回句柄，非NULL表示成功*/
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer );

2、删除

对于动态创建的事件组，不再需要它们时，可以删除它们以回收内存。

vEventGroupDelete可以用来删除事件组，函数原型如下：

/** xEventGroup: 事件组句柄，你要删除哪个事件组*/
void vEventGroupDelete( EventGroupHandle_t xEventGroup )

3、设置事件

可以设置事件组的某个位、某些位，使用的函数有2个：

• 在任务中使用xEventGroupSetBits()
• 在ISR中使用xEventGroupSetBitsFromISR()

有一个或多个任务在等待事件，如果这些事件符合这些任务的期望，那么任务还会被唤醒。

函数原型如下：

/* 设置事件组中的位* xEventGroup: 哪个事件组* uxBitsToSet: 设置哪些位? *              如果uxBitsToSet的bitX, bitY为1, 那么事件组中的bitX, bitY被设置为1*               可以用来设置多个位，比如 0x15 就表示设置bit4, bit2, bit0* 返回值: 返回原来的事件值(没什么意义, 因为很可能已经被其他任务修改了)*/
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToSet );/* 设置事件组中的位* xEventGroup: 哪个事件组* uxBitsToSet: 设置哪些位? *              如果uxBitsToSet的bitX, bitY为1, 那么事件组中的bitX, bitY被设置为1*               可以用来设置多个位，比如 0x15 就表示设置bit4, bit2, bit0* pxHigherPriorityTaskWoken: 有没有导致更高优先级的任务进入就绪态? pdTRUE-有, pdFALSE-没有* 返回值: pdPASS-成功, pdFALSE-失败*/
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToSet,BaseType_t * pxHigherPriorityTaskWoken );

值得注意的是，ISR中的函数，比如队列函数xQueueSendToBackFromISR、信号量函数xSemaphoreGiveFromISR，它们会唤醒某个任务，最多只会唤醒1个任务。

但是设置事件组时，有可能导致多个任务被唤醒，这会带来很大的不确定性。所以xEventGroupSetBitsFromISR函数不是直接去设置事件组，而是给一个FreeRTOS后台任务(daemon task)发送队列数据，由这个任务来设置事件组。

如果后台任务的优先级比当前被中断的任务优先级高，xEventGroupSetBitsFromISR会设置**pxHigherPriorityTaskWoken*为pdTRUE。

如果daemon task成功地把队列数据发送给了后台任务，那么xEventGroupSetBitsFromISR的返回值就是pdPASS。

4、等待事件

使用xEventGroupWaitBits来等待事件，可以等待某一位、某些位中的任意一个，也可以等待多位；等到期望的事件后，还可以清除某些位。

函数原型如下：

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

先引入一个概念：unblock condition。一个任务在等待事件发生时，它处于阻塞状态；当期望的时间发生时，这个状态就叫"unblock condition"，非阻塞条件，或称为"非阻塞条件成立"；当"非阻塞条件成立"后，该任务就可以变为就绪态。

函数参数说明列表如下：

参数	说明
xEventGroup	等待哪个事件组？
uxBitsToWaitFor	等待哪些位？哪些位要被测试？
xWaitForAllBits	怎么测试？是"AND"还是"OR"？ pdTRUE: 等待的位，全部为1; pdFALSE: 等待的位，某一个为1即可
xClearOnExit	函数提出前是否要清除事件？ pdTRUE: 清除uxBitsToWaitFor指定的位 pdFALSE: 不清除
xTicksToWait	如果期待的事件未发生，阻塞多久。 可以设置为0：判断后即刻返回； 可设置为portMAX_DELAY：一定等到成功才返回； 可以设置为期望的Tick Count，一般用*pdMS_TO_TICKS()*把ms转换为Tick Count
返回值	返回的是事件值， 如果期待的事件发生了，返回的是"非阻塞条件成立"时的事件值； 如果是超时退出，返回的是超时时刻的事件值。

举例如下：

事件组的值	uxBitsToWaitFor	xWaitForAllBits	说明
0100	0101	pdTRUE	任务期望bit0,bit2都为1， 当前值只有bit2满足，任务进入阻塞态； 当事件组中bit0,bit2都为1时退出阻塞态
0100	0110	pdFALSE	任务期望bit1,bit2某一个为1， 当前值满足，所以任务成功退出
0100	0110	pdTRUE	任务期望bit1,bit2都为1， 当前值不满足，任务进入阻塞态； 当事件组中bit1,bit2都为1时退出阻塞态

你可以使用*xEventGroupWaitBits()等待期望的事件，它发生之后再使用xEventGroupClearBits()*来清除。但是这两个函数之间，有可能被其他任务或中断抢占，它们可能会修改事件组。

可以使用设置xClearOnExit为pdTRUE，使得对事件组的测试、清零都在*xEventGroupWaitBits()*函数内部完成，这是一个原子操作。

5、同步点

有一个事情需要多个任务协同，比如：

• 任务A：炒菜
• 任务B：买酒
• 任务C：摆台
• A、B、C做好自己的事后，还要等别人做完；大家一起做完，才可开饭

使用*xEventGroupSync()*函数可以同步多个任务：

• 可以设置某位、某些位，表示自己做了什么事
• 可以等待某位、某些位，表示要等等其他任务
• 期望的时间发生后，*xEventGroupSync()*才会成功返回
• xEventGroupSync成功返回后，会清除事件

xEventGroupSync函数原型如下：

EventBits_t xEventGroupSync(    EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToSet,const EventBits_t uxBitsToWaitFor,TickType_t xTicksToWait );

参数列表如下：

参数	说明
xEventGroup	哪个事件组？
uxBitsToSet	要设置哪些事件？我完成了哪些事件？ 比如0x05(二进制为0101)会导致事件组的bit0,bit2被设置为1
uxBitsToWaitFor	等待那个位、哪些位？ 比如0x15(二级制10101)，表示要等待bit0,bit2,bit4都为1
xTicksToWait	如果期待的事件未发生，阻塞多久。 可以设置为0：判断后即刻返回； 可设置为portMAX_DELAY：一定等到成功才返回； 可以设置为期望的Tick Count，一般用*pdMS_TO_TICKS()*把ms转换为Tick Count
返回值	返回的是事件值， 如果期待的事件发生了，返回的是"非阻塞条件成立"时的事件值； 如果是超时退出，返回的是超时时刻的事件值。

三、示例：广播

本节代码为：23_eventgroup_broadcast，主要看nwatch\game2.c。

car1运行到终点后，会设置bit0事件；car2、car3都等待bit0事件。car1设置bit0事件时，会通知到car2、car3，这就是一个广播作用。

创建事件组，代码如下：

void car_game(void)
{int i,j;int x;g_framebuffer = LCD_GetFrameBuffer(&g_xres, &g_yres, &g_bpp);draw_init();draw_end();xEventCar = xEventGroupCreate();//创建事件组/* 绘制路标	*/for(i=0;i<3;i++){for(j=0;j<8;j++){draw_bitmap(16*j, 16+17*i, roadMarking, 8, 1, NOINVERT, 0);draw_flushArea(16*j, 16+17*i, 8, 1);		}}#if 0/* 显示三辆小车 */for(i=0;i<3;i++){draw_bitmap(cars[i].x, cars[i].y, carImg, 15, 16, NOINVERT, 0);draw_flushArea(cars[i].x, cars[i].y, 15, 16);	}
#endifxTaskCreate(car1_task, "car1task", 128, &cars[0], osPriorityNormal, NULL);	xTaskCreate(car2_task, "car2task", 128, &cars[1], osPriorityNormal+2, NULL);	xTaskCreate(car3_task, "car3task", 128, &cars[2], osPriorityNormal+2, NULL);	//car2和car3优先级一样后 car1到达最右边后设置事件组 car2和car3得到事件组后一起运行 若优先级不同 则优先级高的先运行 到最右边后再到另一个运行
}

car2等待事件，代码如下：

void car2_task(void *params)
{struct car *car = params;struct ir_Data idata;/* 创建自己的队列 */QueueHandle_t xQueueIR = xQueueCreate(10,sizeof(struct ir_Data));/* 注册队列 */RegisterQueueHandle(xQueueIR);/* 初始化小车 */ShowCar(car);/* 等待bit0事件 */xEventGroupWaitBits(xEventCar,(1<<0),pdTRUE,pdFALSE,portMAX_DELAY);while(1){
//		/* 读取按键值  */
//		xQueueReceive(xQueueIR,&idata,portMAX_DELAY);//		/* 控制汽车往右移动 */
//		if(idata.data == car->control_key)
//		{if(car->x < g_xres - CAR_LENGTH){/* 隐藏汽车 */HideCar(car);/* 调整位置 */car->x += 1	;//每次按下右移5个单位if(car->x > g_xres - CAR_LENGTH)//超过屏幕分辨率（128）car->x = g_xres - CAR_LENGTH;//到达最大位置处/* 重新显示汽车 */ShowCar(car);/* 这里的delay函数主要是小车的显示延时频率 调用vTaskDelay为阻塞状态 会卡死等待 当执行到调用vTaskDelay的任务时 其他任务能正常运行 调用mdelay则会占用CPU资源 当执行调用mdelay的任务时 其他低优先级任务无法得以运行*///vTaskDelay(50);mdelay(50 );if(car->x == g_xres - CAR_LENGTH){/* 汽车到达最右边 释放信号量 *///xSemaphoreGive(xSemTicks);//car2没有获取信号量 所以当其运行完毕自杀后car1继续运行vTaskDelete(NULL);}}
//		}}
}

car3等待事件，代码如下：

void car3_task(void *params)
{struct car *car = params;struct ir_Data idata;/* 创建自己的队列 */QueueHandle_t xQueueIR = xQueueCreate(10,sizeof(struct ir_Data));/* 注册队列 */RegisterQueueHandle(xQueueIR);/* 初始化小车 */ShowCar(car);/* 等待bit0事件 */xEventGroupWaitBits(xEventCar,(1<<0),pdTRUE,pdFALSE,portMAX_DELAY);while(1){
//		/* 读取按键值  */
//		xQueueReceive(xQueueIR,&idata,portMAX_DELAY);//		/* 控制汽车往右移动 */
//		if(idata.data == car->control_key)
//		{if(car->x < g_xres - CAR_LENGTH){/* 隐藏汽车 */HideCar(car);/* 调整位置 */car->x += 1	;//每次按下右移5个单位if(car->x > g_xres - CAR_LENGTH)//超过屏幕分辨率（128）car->x = g_xres - CAR_LENGTH;//到达最大位置处/* 重新显示汽车 */ShowCar(car);//vTaskDelay(50);mdelay(50 );if(car->x == g_xres - CAR_LENGTH){/* 汽车到达最右边 释放信号量 *///xSemaphoreGive(xSemTicks);vTaskDelete(NULL);}}
//		}}
}

car1运行到终点后，设置事件，代码如下：

void car1_task(void *params)
{struct car *car = params;struct ir_Data idata;/* 创建自己的队列 */QueueHandle_t xQueueIR = xQueueCreate(10,sizeof(struct ir_Data));/* 注册队列 */RegisterQueueHandle(xQueueIR);/* 初始化小车 */ShowCar(car);while(1){
//		/* 读取按键值  */
//		xQueueReceive(xQueueIR,&idata,portMAX_DELAY);//		/* 控制汽车往右移动 */
//		if(idata.data == car->control_key)
//		{if(car->x < g_xres - CAR_LENGTH){/* 隐藏汽车 */HideCar(car);/* 调整位置 */car->x += 1	;//每次按下右移5个单位if(car->x > g_xres - CAR_LENGTH)//超过屏幕分辨率（128）car->x = g_xres - CAR_LENGTH;//到达最大位置处/* 重新显示汽车 */ShowCar(car);vTaskDelay(50);if(car->x == g_xres - CAR_LENGTH){/* 汽车到达最右边 释放信号量 *///xSemaphoreGive(xSemTicks);/* 设置bit0 事件组 */xEventGroupSetBits(xEventCar,(1<<0));vTaskDelete(NULL);}}
//		}}
}

实验现象：car1运行到终点后，car2、car3同时启动。

四、示例：等待一个任意事件

本节代码为：24_eventgroup_or，主要看nwatch\game2.c。

car1运行到终点后，会设置bit0事件；car2运行到终点后，会设置bit1事件；car3等待bit0、bit1的任意一个事件

car1运行到终点后，设置事件，代码如下：

car1运行到终点后，设置事件，代码如下：

void car1_task(void *params)
{struct car *car = params;struct ir_Data idata;/* 创建自己的队列 */QueueHandle_t xQueueIR = xQueueCreate(10,sizeof(struct ir_Data));/* 注册队列 */RegisterQueueHandle(xQueueIR);/* 初始化小车 */ShowCar(car);/* 获得信号量 *///xSemaphoreTake(xSemTicks,portMAX_DELAY);//car1获得信号量开始运行while(1){
//		/* 读取按键值  */
//		xQueueReceive(xQueueIR,&idata,portMAX_DELAY);//		/* 控制汽车往右移动 */
//		if(idata.data == car->control_key)
//		{if(car->x < g_xres - CAR_LENGTH){/* 隐藏汽车 */HideCar(car);/* 调整位置 */car->x += 1	;//每次按下右移5个单位if(car->x > g_xres - CAR_LENGTH)//超过屏幕分辨率（128）car->x = g_xres - CAR_LENGTH;//到达最大位置处/* 重新显示汽车 */ShowCar(car);vTaskDelay(50);//50ms后开始运行if(car->x == g_xres - CAR_LENGTH){/* 汽车到达最右边 释放信号量 *///xSemaphoreGive(xSemTicks);/* 设置bit0 事件组 */xEventGroupSetBits(xEventCar,(1<<0));vTaskDelete(NULL);}}
//		}}
}

car2等待事件，代码如下：

void car2_task(void *params)
{struct car *car = params;struct ir_Data idata;/* 创建自己的队列 */QueueHandle_t xQueueIR = xQueueCreate(10,sizeof(struct ir_Data));/* 注册队列 */RegisterQueueHandle(xQueueIR);/* 初始化小车 */ShowCar(car);/* 获得信号量 *///xSemaphoreTake(xSemTicks,portMAX_DELAY);/* 等待bit0事件 */
//	xEventGroupWaitBits(xEventCar,(1<<0),pdTRUE,pdFALSE,portMAX_DELAY);while(1){
//		/* 读取按键值  */
//		xQueueReceive(xQueueIR,&idata,portMAX_DELAY);//		/* 控制汽车往右移动 */
//		if(idata.data == car->control_key)
//		{if(car->x < g_xres - CAR_LENGTH){/* 隐藏汽车 */HideCar(car);/* 调整位置 */car->x += 1	;//每次按下右移5个单位if(car->x > g_xres - CAR_LENGTH)//超过屏幕分辨率（128）car->x = g_xres - CAR_LENGTH;//到达最大位置处/* 重新显示汽车 */ShowCar(car);vTaskDelay(20);//20ms后开始运行//mdelay(50 );if(car->x == g_xres - CAR_LENGTH){/* 汽车到达最右边 释放信号量 *///xSemaphoreGive(xSemTicks);//car2没有获取信号量 所以当其运行完毕自杀后car1继续运行/* 设置bit1 事件组 */xEventGroupSetBits(xEventCar,(1<<1));vTaskDelete(NULL);}}
//		}}
}

car3等待bit0、bit1事件，实验“或”的关系（倒数第2个参数），代码如下：

void car3_task(void *params)
{struct car *car = params;struct ir_Data idata;/* 创建自己的队列 */QueueHandle_t xQueueIR = xQueueCreate(10,sizeof(struct ir_Data));/* 注册队列 */RegisterQueueHandle(xQueueIR);/* 初始化小车 */ShowCar(car);/* 获得信号量 *///xSemaphoreTake(xSemTicks,portMAX_DELAY);/* 等待bit0 or bit1事件(or或者and取决于第四个参数 pdFLASE为or pdTRUE为and) *//* 若这里是or 当car1先到时释放事件bit0 此时car3等到事件组则开始运行 car2停止运行 直到car3运行完毕 才到car2继续运行 *//* 若这里是and 必须car1和car2运行完毕释放bit哦和bit1事件后car3才能运行	*/xEventGroupWaitBits(xEventCar,(1<<0)|(1<<1),pdTRUE,pdTRUE,portMAX_DELAY);while(1){
//		/* 读取按键值  */
//		xQueueReceive(xQueueIR,&idata,portMAX_DELAY);//		/* 控制汽车往右移动 */
//		if(idata.data == car->control_key)
//		{if(car->x < g_xres - CAR_LENGTH){/* 隐藏汽车 */HideCar(car);/* 调整位置 */car->x += 1	;//每次按下右移5个单位if(car->x > g_xres - CAR_LENGTH)//超过屏幕分辨率（128）car->x = g_xres - CAR_LENGTH;//到达最大位置处/* 重新显示汽车 */ShowCar(car);//vTaskDelay(50);mdelay(50 );if(car->x == g_xres - CAR_LENGTH){/* 汽车到达最右边 释放信号量 *///xSemaphoreGive(xSemTicks);vTaskDelete(NULL);}}
//		}}
}

五、示例: 等待多个事件都发生

本节代码为：25_eventgroup_and，主要看nwatch\game2.c。

使用遥控器控制car1、car2。car1运行到终点后，会设置bit0事件；car2运行到终点后，会设置bit1事件；car3等待bit0、bit1的所有事件

跟24_eventgroup_or相比，只是car3的代码发生了变化。car3等待bit0、bit1事件，实验“与”的关系（倒数第2个参数），代码如下：

225     /* 等待事件:bit0 or bit1 */
226     xEventGroupWaitBits(g_xEventCar, (1<<0)|(1<<1), pdTRUE, pdTRUE, portMAX_DELAY);

实验现象：实验遥控器的1、2控制car1、car2，它们都到达终点后，car3才会启动。