📄 os_flag.lst
字号:
223 /*
224 *********************************************************************************************************
225 * DELETE AN EVENT FLAG GROUP
226 *
227 * Description: This function deletes an event flag group and readies all tasks pending on the event flag
228 * group.
229 *
230 * Arguments : pgrp is a pointer to the desired event flag group.
231 *
232 * opt determines delete options as follows:
233 * opt == OS_DEL_NO_PEND Deletes the event flag group ONLY if no task pending
234 * opt == OS_DEL_ALWAYS Deletes the event flag group even if tasks are
235 * waiting. In this case, all the tasks pending will be
-
236 * readied.
237 *
238 * err is a pointer to an error code that can contain one of the following values:
C51 COMPILER V8.08 OS_FLAG 08/19/2008 10:59:08 PAGE 5
239 * OS_NO_ERR The call was successful and the event flag group was
240 * deleted
241 * OS_ERR_DEL_ISR If you attempted to delete the event flag group from
242 * an ISR
243 * OS_FLAG_INVALID_PGRP If 'pgrp' is a NULL pointer.
244 * OS_ERR_EVENT_TYPE You are not pointing to an event flag group
245 * OS_ERR_EVENT_TYPE If you didn't pass a pointer to an event flag group
246 * OS_ERR_INVALID_OPT An invalid option was specified
247 * OS_ERR_TASK_WAITING One or more tasks were waiting on the event flag
248 * group.
249 *
250 * Returns : pevent upon error
251 * (OS_EVENT *)0 if the semaphore was successfully deleted.
252 *
253 * Note(s) : 1) This function must be used with care. Tasks that would normally expect the presence of
254 * the event flag group MUST check the return code of OSFlagAccept() and OSFlagPend().
255 * 2) This call can potentially disable interrupts for a long time. The interrupt disable
256 * time is directly proportional to the number of tasks waiting on the event flag group.
257 *********************************************************************************************************
258 */
259
260 #if OS_FLAG_DEL_EN > 0
OS_FLAG_GRP *OSFlagDel (OS_FLAG_GRP *pgrp, INT8U opt, INT8U *err) reentrant
{
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr;
#endif
BOOLEAN tasks_waiting;
OS_FLAG_NODE *pnode;
if (OSIntNesting > 0) { /* See if called from ISR ... */
*err = OS_ERR_DEL_ISR; /* ... can't DELETE from an ISR */
return (pgrp);
}
#if OS_ARG_CHK_EN > 0
if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
*err = OS_FLAG_INVALID_PGRP;
return (pgrp);
}
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event group type */
*err = OS_ERR_EVENT_TYPE;
return (pgrp);
}
#endif
OS_ENTER_CRITICAL();
if (pgrp->OSFlagWaitList != (void *)0) { /* See if any tasks waiting on event flags */
tasks_waiting = TRUE; /* Yes */
} else {
tasks_waiting = FALSE; /* No */
}
switch (opt) {
case OS_DEL_NO_PEND: /* Delete group if no task waiting */
if (tasks_waiting == FALSE) {
pgrp->OSFlagType = OS_EVENT_TYPE_UNUSED;
pgrp->OSFlagWaitList = (void *)OSFlagFreeList; /* Return group to free list */
OSFlagFreeList = pgrp;
OS_EXIT_CRITICAL();
*err = OS_NO_ERR;
return ((OS_FLAG_GRP *)0); /* Event Flag Group has been deleted */
} else {
OS_EXIT_CRITICAL();
C51 COMPILER V8.08 OS_FLAG 08/19/2008 10:59:08 PAGE 6
*err = OS_ERR_TASK_WAITING;
return (pgrp);
}
case OS_DEL_ALWAYS: /* Always delete the event flag group */
pnode = pgrp->OSFlagWaitList;
while (pnode != (OS_FLAG_NODE *)0) { /* Ready ALL tasks waiting for flags */
OS_FlagTaskRdy(pnode, (OS_FLAGS)0);
pnode = pnode->OSFlagNodeNext;
}
pgrp->OSFlagType = OS_EVENT_TYPE_UNUSED;
pgrp->OSFlagWaitList = (void *)OSFlagFreeList;/* Return group to free list */
OSFlagFreeList = pgrp;
OS_EXIT_CRITICAL();
if (tasks_waiting == TRUE) { /* Reschedule only if task(s) were waiting */
OS_Sched(); /* Find highest priority task ready to run */
}
*err = OS_NO_ERR;
return ((OS_FLAG_GRP *)0); /* Event Flag Group has been deleted */
default:
OS_EXIT_CRITICAL();
*err = OS_ERR_INVALID_OPT;
return (pgrp);
}
}
#endif
328 /*$PAGE*/
329 /*
330 *********************************************************************************************************
331 * WAIT ON AN EVENT FLAG GROUP
332 *
333 * Description: This function is called to wait for a combination of bits to be set in an event flag
334 * group. Your application can wait for ANY bit to be set or ALL bits to be set.
335 *
336 * Arguments : pgrp is a pointer to the desired event flag group.
337 *
338 * flags Is a bit pattern indicating which bit(s) (i.e. flags) you wish to wait for.
339 * The bits you want are specified by setting the corresponding bits in
340 * 'flags'. e.g. if your application wants to wait for bits 0 and 1 then
341 * 'flags' would contain 0x03.
342 *
343 * wait_type specifies whether you want ALL bits to be set or ANY of the bits to be set.
344 * You can specify the following argument:
345 *
346 * OS_FLAG_WAIT_CLR_ALL You will wait for ALL bits in 'mask' to be clear (0)
347 * OS_FLAG_WAIT_SET_ALL You will wait for ALL bits in 'mask' to be set (1)
348 * OS_FLAG_WAIT_CLR_ANY You will wait for ANY bit in 'mask' to be clear (0)
349 * OS_FLAG_WAIT_SET_ANY You will wait for ANY bit in 'mask' to be set (1)
350 *
351 * NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by
352 * the call. Example, to wait for any flag in a group AND then clear
353 * the flags that are present, set 'wait_type' to:
354 *
355 * OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME
356 *
357 * timeout is an optional timeout (in clock ticks) that your task will wait for the
358 * desired bit combination. If you specify 0, however, your task will wait
359 * forever at the specified event flag group or, until a message arrives.
360 *
361 * err is a pointer to an error code and can be:
362 * OS_NO_ERR The desired bits have been set within the specified
C51 COMPILER V8.08 OS_FLAG 08/19/2008 10:59:08 PAGE 7
363 * 'timeout'.
364 * OS_ERR_PEND_ISR If you tried to PEND from an ISR
365 * OS_FLAG_INVALID_PGRP If 'pgrp' is a NULL pointer.
366 * OS_ERR_EVENT_TYPE You are not pointing to an event flag group
367 * OS_TIMEOUT The bit(s) have not been set in the specified
368 * 'timeout'.
369 * OS_FLAG_ERR_WAIT_TYPE You didn't specify a proper 'wait_type' argument.
370 *
371 * Returns : The new state of the flags in the event flag group when the task is resumed or,
372 * 0 if a timeout or an error occurred.
373 *
374 * Called from: Task ONLY
375 *********************************************************************************************************
376 */
377
378 OS_FLAGS OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err) reen
-trant
379 {
380 1 #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr;
#endif
383 1 OS_FLAG_NODE node;
384 1 OS_FLAGS flags_cur;
385 1 OS_FLAGS flags_rdy;
386 1 BOOLEAN consume;
387 1
388 1
389 1 if (OSIntNesting > 0) { /* See if called from ISR ... */
390 2 *err = OS_ERR_PEND_ISR; /* ... can't PEND from an ISR */
391 2 return ((OS_FLAGS)0);
392 2 }
393 1 #if OS_ARG_CHK_EN > 0
394 1 if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
395 2 *err = OS_FLAG_INVALID_PGRP;
396 2 return ((OS_FLAGS)0);
397 2 }
398 1 if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type */
399 2 *err = OS_ERR_EVENT_TYPE;
400 2 return ((OS_FLAGS)0);
401 2 }
402 1 #endif
403 1 if (wait_type & OS_FLAG_CONSUME) { /* See if we need to consume the flags */
404 2 wait_type &= ~OS_FLAG_CONSUME;
405 2 consume = TRUE;
406 2 } else {
407 2 consume = FALSE;
408 2 }
409 1 /*$PAGE*/
410 1 OS_ENTER_CRITICAL();
411 1 switch (wait_type) {
412 2 case OS_FLAG_WAIT_SET_ALL: /* See if all required flags are set */
413 2 flags_rdy = pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
414 2 if (flags_rdy == flags) { /* Must match ALL the bits that we want */
415 3 if (consume == TRUE) { /* See if we need to consume the flags */
416 4 pgrp->OSFlagFlags &= ~flags_rdy; /* Clear ONLY the flags that we wanted */
417 4 }
418 3 flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
419 3 OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
420 3 *err = OS_NO_ERR;
421 3 return (flags_cur);
422 3 } else { /* Block task until events occur or timeout */
423 3 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
C51 COMPILER V8.08 OS_FLAG 08/19/2008 10:59:08 PAGE 8
424 3 OS_EXIT_CRITICAL();
425 3 }
426 2 break;
427 2
428 2 case OS_FLAG_WAIT_SET_ANY:
429 2 flags_rdy = pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
430 2 if (flags_rdy != (OS_FLAGS)0) { /* See if any flag set */
431 3 if (consume == TRUE) { /* See if we need to consume the flags */
432 4 pgrp->OSFlagFlags &= ~flags_rdy; /* Clear ONLY the flags that we got */
433 4 }
434 3 flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
435 3 OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
436 3 *err = OS_NO_ERR;
437 3 return (flags_cur);
438 3 } else { /* Block task until events occur or timeout */
439 3 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
440 3 OS_EXIT_CRITICAL();
441 3 }
442 2 break;
443 2
444 2 #if OS_FLAG_WAIT_CLR_EN > 0
case OS_FLAG_WAIT_CLR_ALL: /* See if all required flags are cleared */
flags_rdy = ~pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
if (flags_rdy == flags) { /* Must match ALL the bits that we want */
if (consume == TRUE) { /* See if we need to consume the flags */
pgrp->OSFlagFlags |= flags_rdy; /* Set ONLY the flags that we wanted */
}
flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -