μC/OSIII——任务同步（事件标志组）

最新推荐文章于 2022-08-09 16:15:52 发布

weixin_30446197

最新推荐文章于 2022-08-09 16:15:52 发布

阅读量114

点赞数

文章标签：操作系统

原文链接：http://www.cnblogs.com/chenliang826380678/p/chenliang1.html

版权

使用情况

当任务需要与多个事件的发生同步，可以使用事件标志组。有两种情况：

或同步——等待多个事件发生，任何一个事件发生，任务就发生（同步）
与同步——等待多个事件发生，当所有事件都发生，任务就发生（同步）

使用方法

事件标志组服务函数的实现代码在os_flag.c文件中，在编译时，将os_cfg.h文件中的配置常数OS_CFG_FLAG+EN设为1就可启用这些服务函数。

常用的事件标志组的服务函数有：

OSFlagCreate() 创建事件标志组
OSFlagPend() 等待事件标志
OSFlagPost() 向事件标志组发布标志

void OSFlagCreate(OS_FLAG_GRP *p_grp, 指向事件标志组的指针

CPU_CHAR *p_name, 字符串——事件标志组的名字

OS_FLAGS flags, 事件标志组的初始值

OS_ERR err) 该函数返回的错误码

OS_FLAGS OSFlagPend(OS_FLAG_GRP *p_grp, 指向事件标志组的指针

OS_FLAGS flags, 等待事件标志组的哪一位

OS_TICK timeout, 指定等待事件标志组的超时时间（时钟节拍数）

OS_OPT opt,

CPU_TS *p_ts, 指向时间戳

OS_ERR *p_err) 该函数返回的错误码

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_BLOCKING (OS_OPT_PEND_NON_BLOCKING)

在标志组不满足条件时，任务选择挂起(不挂起)

OS_FLAGS OSFlagPost(OS_FLAG_GRP *p_grp, 指向事件标志组的指针

OS_FLAGS flags, 决定对哪些标志位进行置位或清零

OS_OPT opt,

OS_ERR *p_err) 函数返回错误码

opt OS_OPT_POST_FLAG_SET 置位 OS_OPT_POST_FLAG_CLR 清零

使用实例

  1 #define  APP_TASK_START_PRIO                           4u
  2 #define  APP_TASK_1_PRIO                                   5u
  3 #define  APP_TASK_2_PRIO                                   6u
  4 #define  APP_TASK_3_PRIO                                   7u
  5 
  6 
  7 #define  APP_TASK_START_STK_SIZE                     256u
  8 #define  APP_TASK_1_STK_SIZE                             256u
  9 #define  APP_TASK_2_STK_SIZE                             256u
 10 #define  APP_TASK_3_STK_SIZE                             256u
 11 
 12 
 13 #define  TASK1 (OS_FLAGS)0x0003
 14 #define  TASK2 (OS_FLAGS)0x0001
 15 #define  TASK3 (OS_FLAGS)0x0002
 16 
 17 
 18 static  OS_TCB   AppTaskStartTCB;
 19 static  OS_TCB   AppTask1TCB;
 20 static  OS_TCB   AppTask2TCB;
 21 static  OS_TCB   AppTask3TCB;
 22 
 23 
 24 static  OS_FLAG_GRP MyFLAGGRP;
 25 
 26 
 27 static  CPU_STK  AppTaskStartStk[APP_TASK_START_STK_SIZE];
 28 static  CPU_STK  AppTask1Stk[APP_TASK_1_STK_SIZE];
 29 static  CPU_STK  AppTask2Stk[APP_TASK_2_STK_SIZE];
 30 static  CPU_STK  AppTask3Stk[APP_TASK_3_STK_SIZE];
 31 
 32 
 33 static  void  AppTaskStart(void  *p_arg);
 34 void AppTask1(void *p_arg);
 35 void AppTask2(void *p_arg);
 36 void AppTask3(void *p_arg);
 37 
 38 
 39 
 40 
 41 int  main (void)
 42 {
 43     OS_ERR  err;
 44 
 45 
 46 
 47 
 48     OSInit(&err);                                               
 49 
 50 
 51     OSFlagCreate(&MyFLAGGRP,
 52                  "MyFLAGGRP",
 53                  (OS_FLAGS)0,
 54                  &err);
 55 
 56 
 57     OSTaskCreate((OS_TCB     *)&AppTaskStartTCB,                
 58                  (CPU_CHAR   *)"App Task Start",
 59                  (OS_TASK_PTR ) AppTaskStart,
 60                  (void       *) 0,
 61                  (OS_PRIO     ) APP_TASK_START_PRIO,
 62                  (CPU_STK    *)&AppTaskStartStk[0],
 63                  (CPU_STK_SIZE) APP_TASK_START_STK_SIZE / 10u,
 64                  (CPU_STK_SIZE) APP_TASK_START_STK_SIZE,
 65                  (OS_MSG_QTY  ) 0u,
 66                  (OS_TICK     ) 0u,
 67                  (void       *) 0,
 68                  (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
 69                  (OS_ERR     *)&err);
 70 
 71 
 72     OSStart(&err);                                              
 73 }
 74 
 75 
 76 static  void  AppTaskStart (void *p_arg)
 77 {
 78     OS_ERR  err;
 79 
 80 
 81 
 82 
 83    (void)p_arg;
 84 
 85 
 86     CPU_Init();                                                
 87 
 88 
 89     OSTaskCreate((OS_TCB     *)&AppTask1TCB,               
 90                 (CPU_CHAR   *)"AppTask1",
 91                 (OS_TASK_PTR)AppTask1,
 92                 (void       *)0,
 93                 (OS_PRIO)APP_TASK_1_PRIO,
 94                 (CPU_STK    *)&AppTask1Stk[0],
 95                 (CPU_STK_SIZE)APP_TASK_1_STK_SIZE / 10u,
 96                 (CPU_STK_SIZE)APP_TASK_1_STK_SIZE,
 97                 (OS_MSG_QTY)0u,
 98                 (OS_TICK)0u,
 99                 (void       *)0,
100                 (OS_OPT)(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
101                 (OS_ERR     *)&err);
102     OSTaskCreate((OS_TCB     *)&AppTask2TCB,
103                 (CPU_CHAR   *)"AppTask2",
104                 (OS_TASK_PTR)AppTask2,
105                 (void       *)0,
106                 (OS_PRIO)APP_TASK_2_PRIO,
107                 (CPU_STK    *)&AppTask2Stk[0],
108                 (CPU_STK_SIZE)APP_TASK_2_STK_SIZE / 10u,
109                 (CPU_STK_SIZE)APP_TASK_2_STK_SIZE,
110                 (OS_MSG_QTY)0u,
111                 (OS_TICK)0u,
112                 (void       *)0,
113                 (OS_OPT)(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
114                 (OS_ERR     *)&err);
115     OSTaskCreate((OS_TCB     *)&AppTask3TCB,
116                 (CPU_CHAR   *)"AppTask3",
117                 (OS_TASK_PTR)AppTask3,
118                 (void       *)0,
119                 (OS_PRIO)APP_TASK_3_PRIO,
120                 (CPU_STK    *)&AppTask3Stk[0],
121                 (CPU_STK_SIZE)APP_TASK_3_STK_SIZE / 10u,
122                 (CPU_STK_SIZE)APP_TASK_3_STK_SIZE,
123                 (OS_MSG_QTY)0u,
124                 (OS_TICK)0u,
125                 (void       *)0,
126                 (OS_OPT)(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
127                 (OS_ERR     *)&err);
128 }
129 
130 
131 void AppTask1(void *p_arg)
132 {
133     OS_ERR  err;
134     CPU_TS ts;
135 
136 
137     (void)p_arg;
138 
139 
140     while (DEF_ON){
141         OSFlagPend(&MyFLAGGRP,
142                    TASK1,
143                    (OS_TICK)0,
144                    (OS_OPT)OS_OPT_PEND_FLAG_SET_ALL+OS_OPT_PEND_FLAG_CONSUME,
145                    &ts,
146                    &err);
147         APP_TRACE_DBG(("Task1 is running...\n\r"));
148         OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
149     }
150 }
151 
152 
153 void AppTask2(void *p_arg)
154 {
155     OS_ERR  err;
156 
157 
158     (void)p_arg;
159 
160 
161     while (DEF_ON){
162         APP_TRACE_DBG(("Task2 is running...\n\r"));
163         OSFlagPost(&MyFLAGGRP,
164                    TASK2,
165                    OS_OPT_POST_FLAG_SET,
166                    &err);
167         OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
168     }
169 }
170 
171 
172 void AppTask3(void *p_arg)
173 {
174     OS_ERR err;
175     (void)p_arg;
176     while (DEF_ON){
177         APP_TRACE_DBG(("Task3 is running...\n\r"/*,OSTimeGet(&err)*/));
178         OSFlagPost(&MyFLAGGRP,
179                    TASK3,
180                    OS_OPT_POST_FLAG_SET,
181                    &err);
182         OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
183     }
184 }

实验结果

转载于:https://www.cnblogs.com/chenliang826380678/p/chenliang1.html

weixin_30446197

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
μC/OSIII——任务同步（事件标志组）

使用情况当任务需要与多个事件的发生同步，可以使用事件标志组。有两种情况：或同步——等待多个事件发生，任何一个事件发生，任务就发生（同步）与同步——等待多个事件发生，当所有事件都发生，任务就发生（同步）使用方法事件标志组服务函数的实现代码在os_flag.c文件中，在编译时，将os_cfg.h文件中的配置常数OS_CFG_FLAG+EN设为1就可启用这些服...
复制链接

扫一扫