UCOSIII事件标志组
前面讲述了UCOSIII的信号量、互斥信号量，它们都可以完成任务的同步。但是有时候一个任务可能需要和多个事件同步，这个时候就需要使用事件标志组。事件标志组与任务之间有两种同步机制：
- “或”同步：等待多个事件时，任何一个事件发生 ，任务都被同步，这个就称为“或”同步；
- “与”同步：当所有的事件都发生时任务才被同步，这种同步机制被称为“与”同步。
在UCOSIII中事件标志组为OS_FLAG_GRP，如果需要使用事件标志组的时候需要将宏OS_CFG_FLAG_EN置1。
这两种同步机制如下图所示：
- 在UCOSIII中事件标志组是OS_FLAG_GRP，在os.h文件中有定义，事件标志组中也包含了一串任务，这些任务都在等待着事件标志组中的部分（或全部）事件标志被置1或被清零，在使用之前，必须创建事件标志组；
- 任务和ISR（中断服务程序）都可以发布事件标志，但是，只有任务可以创建、删除事件标志组以及取消其他任务对事件标志组的等待；
- 任务可以通过调用函数OSFlagPend()等待事件标志组中的任意个事件标志，调用函数OSFlagPend()的时候可以设置一个超时时间，如果过了超时时间请求的事件还没有被发布，那么任务就会重新进入就绪态；
- 我们可以设置同步机制为“或”同步还是“与”同步。
UCOSIII事件标志组API函数
| 函数 | 说明 |
| OSFlagCreate() | 创建事件标志组 |
| OSFlagDel() | 删除事件标志组 |
| OSFlagPend() | 等待事件标志组 |
| OSFlagPendAbort() | 取消等待事件标志组 |
| OSFlagPendGetFlagsRdy() | 获取使任务就绪的事件标志 |
| OSFlagPost() | 向事件标志组发布标志 |
创建事件标志组
在使用事件标志组之前，需要调用函数OSFlagCreate()创建一个事件标志组，OSFlagCreate()函数原型如下：
void OSFlagCreate (OS_FLAG_GRP *p_grp, //指向事件标志组
CPU_CHAR *p_name, //事件标志组的名字
OS_FLAGS flags, //定义事件标志组的初始值
OS_ERR *p_err)
{
CPU_SR_ALLOC();
OS_CRITICAL_ENTER();
p_grp->Type = OS_OBJ_TYPE_FLAG; /* Set to event flag group type */
p_grp->NamePtr = p_name;
p_grp->Flags = flags; /* Set to desired initial value */
p_grp->TS = (CPU_TS)0;
OS_PendListInit(&p_grp->PendList);
OSFlagQty++;
OS_CRITICAL_EXIT_NO_SCHED();
*p_err = OS_ERR_NONE;
}
我们可以先看看事件标志组的结构体OS_FLAG_GRP：
struct os_flag_grp { /* Event Flag Group */
/* ------------------ GENERIC MEMBERS ------------------ */
OS_OBJ_TYPE Type; /* Should be set to OS_OBJ_TYPE_FLAG */
CPU_CHAR *NamePtr; /* 事件标志组的名称 */
OS_PEND_LIST PendList; /* 等待事件标志组的任务组 */
#if OS_CFG_DBG_EN > 0u
OS_FLAG_GRP *DbgPrevPtr;
OS_FLAG_GRP *DbgNextPtr;
CPU_CHAR *DbgNamePtr;
#endif
/* ------------------ SPECIFIC MEMBERS ------------------ */
OS_FLAGS Flags; /* 8, 16 or 32 bit flags */
CPU_TS TS; /* Timestamp of when last post occurred */
};
事件标志组的结构体和之前的信号量、互斥信号量、消息队列比较类似，关键的一个成员变量是Flags：
typedef CPU_INT32U OS_FLAGS; /* Event flags, 8/16/<32> */
我们可以看到定义，Flags是一个32位无符号的整型。我们在OSFlagCreate()函数中的flags参数的值就是赋值给它的，那么它代表的含义是什么呢？
Flags是32位，它的每一位都代表着一个任务的状态，每个任务有1和0两种状态。也就是说，我们可以同时最多完成一个任务和32个任务的任务同步！我们可以设置：Falgs的第0、1两个任务为1的时候，完成任务同步，也就是说，Flags变成0x03的时候，完成同步。当然，OSFlagCreate()函数中的flags参数只是确定一个初始值。
等待事件标志组
等待一个事件标志组需要调用函数OSFlagPend()，函数原型如下：
OS_FLAGS OSFlagPend (OS_FLAG_GRP *p_grp, //指向事件标志组
OS_FLAGS flags, //bit序列
OS_TICK timeout, //指定等待事件标志组的超时时间(时钟节拍数)
OS_OPT opt, //决定任务等待的条件
CPU_TS *p_ts, //指向一个时间戳
OS_ERR *p_err)
{
CPU_BOOLEAN consume;
OS_FLAGS flags_rdy;
OS_OPT mode;
OS_PEND_DATA pend_data;
CPU_SR_ALLOC();
if ((opt & OS_OPT_PEND_FLAG_CONSUME) != (OS_OPT)0) { /* See if we need to consume the flags */
consume = DEF_TRUE;
} else {
consume = DEF_FALSE;
}
if (p_ts != (CPU_TS *)0) {
*p_ts = (CPU_TS)0; /* Initialize the returned timestamp */
}
mode = opt & OS_OPT_PEND_FLAG_MASK;
CPU_CRITICAL_ENTER();
switch (mode) {
case OS_OPT_PEND_FLAG_SET_ALL: /* See if all required flags are set */
flags_rdy = (OS_FLAGS)(p_grp->Flags & flags); /* Extract only the bits we want */
if (flags_rdy == flags) { /* Must match ALL the bits that we want */
if (consume == DEF_TRUE) { /* See if we need to consume the flags */
p_grp->Flags &= ~flags_rdy; /* Clear ONLY the flags that we wanted */
}
OSTCBCurPtr->FlagsRdy = flags_rdy; /* Save flags that were ready */
if (p_ts != (CPU_TS *)0) {
*p_ts = p_grp->TS;
}
CPU_CRITICAL_EXIT(); /* Yes, condition met, return to caller */
*p_err = OS_ERR_NONE;
return (flags_rdy);
} else { /* Block task until events occur or timeout */
if ((opt & OS_OPT_PEND_NON_BLOCKING) != (OS_OPT)0) {
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_PEND_WOULD_BLOCK; /* Specified non-blocking so task would block */
return ((OS_FLAGS)0);
} else { /* Specified blocking so check is scheduler is locked */
if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) { /* See if called with scheduler locked ... */
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_SCHED_LOCKED; /* ... can't PEND when locked */
return ((OS_FLAGS)0);
}
}
OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT(); /* Lock the scheduler/re-enable interrupts */
OS_FlagBlock(&pend_data,
p_grp,
flags,
opt,
timeout);
OS_CRITICAL_EXIT_NO_SCHED();
}
break;
case OS_OPT_PEND_FLAG_SET_ANY:
flags_rdy = (OS_FLAGS)(p_grp->Flags & flags); /* Extract only the bits we want */
if (flags_rdy != (OS_FLAGS)0) { /* See if any flag set */
if (consume == DEF_TRUE) { /* See if we need to consume the flags */
p_grp->Flags &= ~flags_rdy; /* Clear ONLY the flags that we got */
}
OSTCBCurPtr->FlagsRdy = flags_rdy; /* Save flags that were ready */
if (p_ts != (CPU_TS *)0) {
*p_ts = p_grp->TS;
}
CPU_CRITICAL_EXIT(); /* Yes, condition met, return to caller */
*p_err = OS_ERR_NONE;
return (flags_rdy);
} else { /* Block task until events occur or timeout */
if ((opt & OS_OPT_PEND_NON_BLOCKING) != (OS_OPT)0) {
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_PEND_WOULD_BLOCK; /* Specified non-blocking so task would block */
return ((OS_FLAGS)0);
} else { /* Specified blocking so check is scheduler is locked */
if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) { /* See if called with scheduler locked ... */
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_SCHED_LOCKED; /* ... can't PEND when locked */
return ((OS_FLAGS)0);
}
}
OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT(); /* Lock the scheduler/re-enable interrupts */
OS_FlagBlock(&pend_data,
p_grp,
flags,
opt,
timeout);
OS_CRITICAL_EXIT_NO_SCHED();
}
break;
default:
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_OPT_INVALID;
return ((OS_FLAGS)0);
}
OSSched(); /* Find next HPT ready to run */
CPU_CRITICAL_ENTER();
switch (OSTCBCurPtr->PendStatus) {
case OS_STATUS_PEND_OK: /* We got the vent flags */
if (p_ts != (CPU_TS *)0) {
*p_ts = OSTCBCurPtr->TS;
}
*p_err = OS_ERR_NONE;
break;
case OS_STATUS_PEND_ABORT: /* Indicate that we aborted */
if (p_ts != (CPU_TS *)0) {
*p_ts = OSTCBCurPtr->TS;
}
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_PEND_ABORT;
return ((OS_FLAGS)0);
case OS_STATUS_PEND_TIMEOUT: /* Indicate that we didn't get semaphore within timeout */
if (p_ts != (CPU_TS *)0) {
*p_ts = (CPU_TS )0;
}
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_TIMEOUT;
return ((OS_FLAGS)0);
case OS_STATUS_PEND_DEL: /* Indicate that object pended on has been deleted */
if (p_ts != (CPU_TS *)0) {
*p_ts = OSTCBCurPtr->TS;
}
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_OBJ_DEL;
return ((OS_FLAGS)0);
default:
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_STATUS_INVALID;
return ((OS_FLAGS)0);
}
flags_rdy = OSTCBCurPtr->FlagsRdy;
if (consume == DEF_TRUE) { /* See if we need to consume the flags */
switch (mode) {
case OS_OPT_PEND_FLAG_SET_ALL:
case OS_OPT_PEND_FLAG_SET_ANY: /* Clear ONLY the flags we got */
p_grp->Flags &= ~flags_rdy;
break;
default:
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_OPT_INVALID;
return ((OS_FLAGS)0);
}
}
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_NONE; /* Event(s) must have occurred */
return (flags_rdy);
}
flags：bit序列，任务需要等待事件标志组的哪个位就把这个序列对应的位置1，根据设置这个序列可以是8bit、16bit或者32bit。比如任务需要等待时间标志组的bit0和bit1时（无论是等待置位还是清零），flag是的值就为0X03。
opt：决定任务等待的条件是所有标志置位、所有标志清零、任意一个标志置位还是任意一个标志清零，具体的定义如下。
OS_OPT_PEND_FLAG_CLR_ALL：等待事件标志组所有的位清零； OS_OPT_PEND_FLAG_CLR_ANY：等待事件标志组中任意一个标志清零； OS_OPT_PEND_FLAG_SET_ALL：等待事件标志组中所有的位置位； OS_OPT_PEND_FLAG_SET_ANY：等待事件标志组中任意一个标志置位。
调用上面四个选项的时候还可以搭配下面三个选项：
OS_OPT_PEND_FLAG_CONSUME：用来设置是否继续保留该事件标志的状态； OS_OPT_PEND_NON_BLOCKING：标志组不满足条件时不挂起任务； OS_OPT_PEND_BLOCKING：标志组不满足条件时挂起任务。
这里应该注意选项OS_OPT_PEND_FLAG_CONSUME的使用方法，如果我们希望任务等待事件标志组的任意一个标志置位，并在满足条件后将对应的标志清零那么就可以搭配使用选项OS_OPT_PEND_FLAG_CONSUME。
OSFlagPend()允许将事件标志组里事件标志的“与或”组合状态设置成任务的等待条件。任务等待的条件可以是标志组里任意一个标志置位或清零，也可以是所有事件标志都置位或清零。如果任务等待的事件标志组不满足设置的条件，那么该任务被置位挂起状态，直到等待的事件标志组满足条件、指定的超时时间到、事件标志被删除或另一个任务终止了该任务的挂起状态。
向事件标志组发布标志
调用函数OSFlagPost()可以对事件标志组进行置位或清零，函数原型如下：
OS_FLAGS OSFlagPost (OS_FLAG_GRP *p_grp, //指向事件标志组
OS_FLAGS flags, //决定对哪些位清零和置位
OS_OPT opt, //决定对标志位的操作
OS_ERR *p_err)
{
OS_FLAGS flags_cur;
CPU_TS ts;
ts = OS_TS_GET(); /* Get timestamp */
flags_cur = OS_FlagPost(p_grp,
flags,
opt,
ts,
p_err);
return (flags_cur);
}
flags：决定对哪些位清零和置位，当opt参数为OS_OPT_POST_FLAG_SET的时，参数flags中置位的位就会在事件标志组中对应的位也将被置位；当opt为OS_OPT_POST_FLAG_CLR的时候参数flags中置位的位在事件标志组中对应的位将被清零。
opt：决定对flags选定的标志位的操作，有两种选项可供选择。OS_OPT_POST_FLAG_SET：对标志位进行置位操作；OS_OPT_POST_FLAG_CLR：对标志位进行清零操作。
这个函数的返回值时当前的flags值，通过该返回值，可以查到此时本任务在flags中的哪一个位有没有被置位，或者其他还有哪些任务在flags中的标志。
一般情况下，需要进行置位或者清零的标志由一个掩码确定（参数flags）。OSFlagPost()修改完事件标志后，将检查并使那些等待条件已经满足的任务进入就绪态。该函数可以对已经置位或清零的标志进行重复置位和清零操作。
UCOSIII实际例程
时间标志组实验
例程要求：设计一个程序，只有按下KEY0和KEY1（不需要同时按下）时任务flagsprocess_task任务才能执行。
例子：
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "lcd.h"
#include "key.h"
#include "malloc.h"
#include "sram.h"
#include "beep.h"
#include "includes.h"
//UCOSIII中以下优先级用户程序不能使用，ALIENTEK
//将这些优先级分配给了UCOSIII的5个系统内部任务
//优先级0：中断服务服务管理任务 OS_IntQTask()
//优先级1：时钟节拍任务 OS_TickTask()
//优先级2：定时任务 OS_TmrTask()
//优先级OS_CFG_PRIO_MAX-2：统计任务 OS_StatTask()
//优先级OS_CFG_PRIO_MAX-1：空闲任务 OS_IdleTask()
//任务优先级
#define START_TASK_PRIO 3
//任务堆栈大小
#define START_STK_SIZE 128
//任务控制块
OS_TCB StartTaskTCB;
//任务堆栈
CPU_STK START_TASK_STK[START_STK_SIZE];
//任务函数
void start_task(void *p_arg);
//任务优先级
#define MAIN_TASK_PRIO 4
//任务堆栈大小
#define MAIN_STK_SIZE 128
//任务控制块
OS_TCB Main_TaskTCB;
//任务堆栈
CPU_STK MAIN_TASK_STK[MAIN_STK_SIZE];
void main_task(void *p_arg);
//任务优先级
#define FLAGSPROCESS_TASK_PRIO 5
//任务堆栈大小
#define FLAGSPROCESS_STK_SIZE 128
//任务控制块
OS_TCB Flagsprocess_TaskTCB;
//任务堆栈
CPU_STK FLAGSPROCESS_TASK_STK[FLAGSPROCESS_STK_SIZE];
//任务函数
void flagsprocess_task(void *p_arg);
//LCD刷屏时使用的颜色
int lcd_discolor[14]={ WHITE, BLACK, BLUE, BRED,
GRED, GBLUE, RED, MAGENTA,
GREEN, CYAN, YELLOW,BROWN,
BRRED, GRAY };
////////////////////////事件标志组//////////////////////////////
#define KEY0_FLAG 0x01
#define KEY1_FLAG 0x02
#define KEYFLAGS_VALUE 0X00
OS_FLAG_GRP EventFlags; //定义一个事件标志组
//加载主界面
void ucos_load_main_ui(void)
{
POINT_COLOR = RED;
LCD_ShowString(30,10,200,16,16,"ALIENTEK STM32F1");
LCD_ShowString(30,30,200,16,16,"UCOSIII Examp 12-1");
LCD_ShowString(30,50,200,16,16,"Event Flags");
LCD_ShowString(30,70,200,16,16,"ATOM@ALIENTEK");
LCD_ShowString(30,90,200,16,16,"2015/3/19");
POINT_COLOR = BLACK;
LCD_DrawRectangle(5,130,234,314); //画矩形
POINT_COLOR = BLUE;
LCD_ShowString(30,110,220,16,16,"Event Flags Value:0");
}
int main(void) //主函数
{
OS_ERR err;
CPU_SR_ALLOC();
delay_init(); //时钟初始化
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//中断分组配置
uart_init(115200); //串口初始化
LED_Init(); //LED初始化
LCD_Init(); //LCD初始化
KEY_Init(); //按键初始化
BEEP_Init(); //初始化蜂鸣器
FSMC_SRAM_Init(); //初始化SRAM
my_mem_init(SRAMIN);//初始化内部RAM
ucos_load_main_ui();//加载主UI
OSInit(&err); //初始化UCOSIII
OS_CRITICAL_ENTER(); //进入临界区
//创建开始任务
OSTaskCreate((OS_TCB * )&StartTaskTCB, //任务控制块
(CPU_CHAR * )"start task", //任务名字
(OS_TASK_PTR )start_task, //任务函数
(void * )0, //传递给任务函数的参数
(OS_PRIO )START_TASK_PRIO, //任务优先级
(CPU_STK * )&START_TASK_STK[0], //任务堆栈基地址
(CPU_STK_SIZE)START_STK_SIZE/10, //任务堆栈深度限位
(CPU_STK_SIZE)START_STK_SIZE, //任务堆栈大小
(OS_MSG_QTY )0, //任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息
(OS_TICK )0, //当使能时间片轮转时的时间片长度，为0时为默认长度，
(void * )0, //用户补充的存储区
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR, //任务选项
(OS_ERR * )&err); //存放该函数错误时的返回值
OS_CRITICAL_EXIT(); //退出临界区
OSStart(&err); //开启UCOSIII
}
void start_task(void *p_arg) //开始任务函数
{
OS_ERR err;
CPU_SR_ALLOC();
p_arg = p_arg;
CPU_Init();
#if OS_CFG_STAT_TASK_EN > 0u
OSStatTaskCPUUsageInit(&err); //统计任务
#endif
#ifdef CPU_CFG_INT_DIS_MEAS_EN //如果使能了测量中断关闭时间
CPU_IntDisMeasMaxCurReset();
#endif
#if OS_CFG_SCHED_ROUND_ROBIN_EN //当使用时间片轮转的时候
//使能时间片轮转调度功能,时间片长度为1个系统时钟节拍，既1*5=5ms
OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);
#endif
OS_CRITICAL_ENTER(); //进入临界区
//创建一个事件标志组
OSFlagCreate((OS_FLAG_GRP*)&EventFlags, //指向事件标志组
(CPU_CHAR* )"Event Flags", //名字
(OS_FLAGS )KEYFLAGS_VALUE, //事件标志组初始值
(OS_ERR* )&err); //错误码
OSTaskCreate((OS_TCB* )&Main_TaskTCB, //创建主任务
(CPU_CHAR* )"Main task",
(OS_TASK_PTR )main_task,
(void* )0,
(OS_PRIO )MAIN_TASK_PRIO,
(CPU_STK* )&MAIN_TASK_STK[0],
(CPU_STK_SIZE)MAIN_STK_SIZE/10,
(CPU_STK_SIZE)MAIN_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void* )0,
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR* )&err);
OSTaskCreate((OS_TCB* )&Flagsprocess_TaskTCB, //创建MSGDIS任务
(CPU_CHAR* )"Flagsprocess task",
(OS_TASK_PTR )flagsprocess_task,
(void* )0,
(OS_PRIO )FLAGSPROCESS_TASK_PRIO,
(CPU_STK* )&FLAGSPROCESS_TASK_STK[0],
(CPU_STK_SIZE)FLAGSPROCESS_STK_SIZE/10,
(CPU_STK_SIZE)FLAGSPROCESS_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void* )0,
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR* )&err);
OS_CRITICAL_EXIT(); //退出临界区
OSTaskDel((OS_TCB*)0,&err); //删除start_task任务自身
}
void main_task(void *p_arg) //主任务的任务函数
{
u8 key,num;
OS_FLAGS flags_num;
OS_ERR err;
while(1)
{
key = KEY_Scan(0); //扫描按键
if(key == KEY0_PRES)
{
//向事件标志组EventFlags发送标志
flags_num=OSFlagPost((OS_FLAG_GRP*)&EventFlags,
(OS_FLAGS )KEY0_FLAG,
(OS_OPT )OS_OPT_POST_FLAG_SET,
(OS_ERR* )&err);
LCD_ShowxNum(174,110,flags_num,1,16,0);
printf("事件标志组EventFlags的值:%d\r\n",flags_num);
}
else if(key == KEY1_PRES)
{
//向事件标志组EventFlags发送标志
flags_num=OSFlagPost((OS_FLAG_GRP*)&EventFlags,
(OS_FLAGS )KEY1_FLAG,
(OS_OPT )OS_OPT_POST_FLAG_SET,
(OS_ERR* )&err);
LCD_ShowxNum(174,110,flags_num,1,16,0);
printf("事件标志组EventFlags的值:%d\r\n",flags_num);
}
num++;
if(num==50)
{
num=0;
LED0 = ~LED0;
}
OSTimeDlyHMSM(0,0,0,10,OS_OPT_TIME_PERIODIC,&err); //延时10ms
}
}
void flagsprocess_task(void *p_arg) //事件标志组处理任务
{
u8 num;
OS_ERR err;
while(1)
{
//等待事件标志组
OSFlagPend((OS_FLAG_GRP*)&EventFlags,
(OS_FLAGS )KEY0_FLAG+KEY1_FLAG,
(OS_TICK )0,
(OS_OPT )OS_OPT_PEND_FLAG_SET_ALL+OS_OPT_PEND_FLAG_CONSUME,
(CPU_TS* )0,
(OS_ERR* )&err);
num++;
LED1 = ~LED1;
LCD_Fill(6,131,233,313,lcd_discolor[num%14]);
printf("事件标志组EventFlags的值:%d\r\n",EventFlags.Flags);
LCD_ShowxNum(174,110,EventFlags.Flags,1,16,0);
}
}