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); } }