开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
os_flag.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：54k
源码类别：

uCOS

开发平台：

C/C++

os_flag.c：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/OS-II
  4. *                                          The Real-Time Kernel
  5. *                                         EVENT FLAG  MANAGEMENT
  6. *
  7. *                          (c) Copyright 2001-2006, Jean J. Labrosse, Weston, FL
  8. *                                           All Rights Reserved
  9. *
  10. * File    : OS_FLAG.C
  11. * By      : Jean J. Labrosse
  12. * Version : V2.83
  13. *********************************************************************************************************
  14. */
  16. #ifndef  OS_MASTER_FILE
  17. #include <ucos_ii.h>
  18. #endif
  20. #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
  21. /*
  22. *********************************************************************************************************
  23. *                                            LOCAL PROTOTYPES
  24. *********************************************************************************************************
  25. */
  27. static  void     OS_FlagBlock(OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout);
  28. static  BOOLEAN  OS_FlagTaskRdy(OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy);
  30. /*$PAGE*/
  31. /*
  32. *********************************************************************************************************
  33. *                              CHECK THE STATUS OF FLAGS IN AN EVENT FLAG GROUP
  34. *
  35. * Description: This function is called to check the status of a combination of bits to be set or cleared
  36. *              in an event flag group.  Your application can check for ANY bit to be set/cleared or ALL
  37. *              bits to be set/cleared.
  38. *
  39. *              This call does not block if the desired flags are not present.
  40. *
  41. * Arguments  : pgrp          is a pointer to the desired event flag group.
  42. *
  43. *              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to check.
  44. *                            The bits you want are specified by setting the corresponding bits in
  45. *                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then
  46. *                            'flags' would contain 0x03.
  47. *
  48. *              wait_type     specifies whether you want ALL bits to be set/cleared or ANY of the bits
  49. *                            to be set/cleared.
  50. *                            You can specify the following argument:
  51. *
  52. *                            OS_FLAG_WAIT_CLR_ALL   You will check ALL bits in 'flags' to be clear (0)
  53. *                            OS_FLAG_WAIT_CLR_ANY   You will check ANY bit  in 'flags' to be clear (0)
  54. *                            OS_FLAG_WAIT_SET_ALL   You will check ALL bits in 'flags' to be set   (1)
  55. *                            OS_FLAG_WAIT_SET_ANY   You will check ANY bit  in 'flags' to be set   (1)
  56. *
  57. *                            NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by
  58. *                                  the call.  Example, to wait for any flag in a group AND then clear
  59. *                                  the flags that are present, set 'wait_type' to:
  60. *
  61. *                                  OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME
  62. *
  63. *              err           is a pointer to an error code and can be:
  64. *                            OS_NO_ERR              No error
  65. *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group
  66. *                            OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument.
  67. *                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer instead of the event flag
  68. *                                                   group handle.
  69. *                            OS_FLAG_ERR_NOT_RDY    The desired flags you are waiting for are not
  70. *                                                   available.
  71. *
  72. * Returns    : The flags in the event flag group that made the task ready or, 0 if a timeout or an error
  73. *              occurred.
  74. *
  75. * Called from: Task or ISR
  76. *
  77. * Note(s)    : 1) IMPORTANT, the behavior of this function has changed from PREVIOUS versions.  The
  78. *                 function NOW returns the flags that were ready INSTEAD of the current state of the
  79. *                 event flags.
  80. *********************************************************************************************************
  81. */
  83. #if OS_FLAG_ACCEPT_EN > 0
  84. OS_FLAGS  OSFlagAccept (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT8U *err)
  85. {
  86.     OS_FLAGS      flags_rdy;
  87.     INT8U         result;
  88.     BOOLEAN       consume;
  89. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  90.     OS_CPU_SR     cpu_sr = 0;
  91. #endif
  95. #if OS_ARG_CHK_EN > 0
  96.     if (err == (INT8U *)0) {                               /* Validate 'err'                           */
  97.         return ((OS_FLAGS)0);
  98.     }
  99.     if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */
  100.         *err = OS_FLAG_INVALID_PGRP;
  101.         return ((OS_FLAGS)0);
  102.     }
  103. #endif
  104.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event block type                */
  105.         *err = OS_ERR_EVENT_TYPE;
  106.         return ((OS_FLAGS)0);
  107.     }
  108.     result = (INT8U)(wait_type & OS_FLAG_CONSUME);
  109.     if (result != (INT8U)0) {                              /* See if we need to consume the flags      */
  110.         wait_type &= ~OS_FLAG_CONSUME;
  111.         consume    = OS_TRUE;
  112.     } else {
  113.         consume    = OS_FALSE;
  114.     }
  115. /*$PAGE*/
  116.     *err = OS_NO_ERR;                                      /* Assume NO error until proven otherwise.  */
  117.     OS_ENTER_CRITICAL();
  118.     switch (wait_type) {
  119.         case OS_FLAG_WAIT_SET_ALL:                         /* See if all required flags are set        */
  120.              flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags);     /* Extract only the bits we want   */
  121.              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
  122.                  if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
  123.                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we wanted      */
  124.                  }
  125.              } else {
  126.                  *err  = OS_FLAG_ERR_NOT_RDY;
  127.              }
  128.              OS_EXIT_CRITICAL();
  129.              break;
  131.         case OS_FLAG_WAIT_SET_ANY:
  132.              flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags);     /* Extract only the bits we want   */
  133.              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag set                      */
  134.                  if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
  135.                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we got         */
  136.                  }
  137.              } else {
  138.                  *err  = OS_FLAG_ERR_NOT_RDY;
  139.              }
  140.              OS_EXIT_CRITICAL();
  141.              break;
  143. #if OS_FLAG_WAIT_CLR_EN > 0
  144.         case OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */
  145.              flags_rdy = (OS_FLAGS)(~pgrp->OSFlagFlags & flags);  /* Extract only the bits we want     */
  146.              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
  147.                  if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
  148.                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we wanted        */
  149.                  }
  150.              } else {
  151.                  *err  = OS_FLAG_ERR_NOT_RDY;
  152.              }
  153.              OS_EXIT_CRITICAL();
  154.              break;
  156.         case OS_FLAG_WAIT_CLR_ANY:
  157.              flags_rdy = (OS_FLAGS)(~pgrp->OSFlagFlags & flags); /* Extract only the bits we want      */
  158.              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */
  159.                  if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
  160.                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we got           */
  161.                  }
  162.              } else {
  163.                  *err  = OS_FLAG_ERR_NOT_RDY;
  164.              }
  165.              OS_EXIT_CRITICAL();
  166.              break;
  167. #endif
  169.         default:
  170.              OS_EXIT_CRITICAL();
  171.              flags_rdy = (OS_FLAGS)0;
  172.              *err      = OS_FLAG_ERR_WAIT_TYPE;
  173.              break;
  174.     }
  175.     return (flags_rdy);
  176. }
  177. #endif
  179. /*$PAGE*/
  180. /*
  181. *********************************************************************************************************
  182. *                                           CREATE AN EVENT FLAG
  183. *
  184. * Description: This function is called to create an event flag group.
  185. *
  186. * Arguments  : flags         Contains the initial value to store in the event flag group.
  187. *
  188. *              err           is a pointer to an error code which will be returned to your application:
  189. *                               OS_NO_ERR                if the call was successful.
  190. *                               OS_ERR_CREATE_ISR        if you attempted to create an Event Flag from an
  191. *                                                        ISR.
  192. *                               OS_FLAG_GRP_DEPLETED     if there are no more event flag groups
  193. *
  194. * Returns    : A pointer to an event flag group or a NULL pointer if no more groups are available.
  195. *
  196. * Called from: Task ONLY
  197. *********************************************************************************************************
  198. */
  200. OS_FLAG_GRP  *OSFlagCreate (OS_FLAGS flags, INT8U *err)
  201. {
  202.     OS_FLAG_GRP *pgrp;
  203. #if OS_CRITICAL_METHOD == 3                         /* Allocate storage for CPU status register        */
  204.     OS_CPU_SR    cpu_sr = 0;
  205. #endif
  209. #if OS_ARG_CHK_EN > 0
  210.     if (err == (INT8U *)0) {                        /* Validate 'err'                                  */
  211.         return ((OS_FLAG_GRP *)0);
  212.     }
  213. #endif
  214.     if (OSIntNesting > 0) {                         /* See if called from ISR ...                      */
  215.         *err = OS_ERR_CREATE_ISR;                   /* ... can't CREATE from an ISR                    */
  216.         return ((OS_FLAG_GRP *)0);
  217.     }
  218.     OS_ENTER_CRITICAL();
  219.     pgrp = OSFlagFreeList;                          /* Get next free event flag                        */
  220.     if (pgrp != (OS_FLAG_GRP *)0) {                 /* See if we have event flag groups available      */
  221.                                                     /* Adjust free list                                */
  222.         OSFlagFreeList       = (OS_FLAG_GRP *)OSFlagFreeList->OSFlagWaitList;
  223.         pgrp->OSFlagType     = OS_EVENT_TYPE_FLAG;  /* Set to event flag group type                    */
  224.         pgrp->OSFlagFlags    = flags;               /* Set to desired initial value                    */
  225.         pgrp->OSFlagWaitList = (void *)0;           /* Clear list of tasks waiting on flags            */
  226. #if OS_FLAG_NAME_SIZE > 1
  227.         pgrp->OSFlagName[0]  = '?';
  228.         pgrp->OSFlagName[1]  = OS_ASCII_NUL;
  229. #endif
  230.         OS_EXIT_CRITICAL();
  231.         *err                 = OS_NO_ERR;
  232.     } else {
  233.         OS_EXIT_CRITICAL();
  234.         *err                 = OS_FLAG_GRP_DEPLETED;
  235.     }
  236.     return (pgrp);                                  /* Return pointer to event flag group              */
  237. }
  239. /*$PAGE*/
  240. /*
  241. *********************************************************************************************************
  242. *                                     DELETE AN EVENT FLAG GROUP
  243. *
  244. * Description: This function deletes an event flag group and readies all tasks pending on the event flag
  245. *              group.
  246. *
  247. * Arguments  : pgrp          is a pointer to the desired event flag group.
  248. *
  249. *              opt           determines delete options as follows:
  250. *                            opt == OS_DEL_NO_PEND   Deletes the event flag group ONLY if no task pending
  251. *                            opt == OS_DEL_ALWAYS    Deletes the event flag group even if tasks are
  252. *                                                    waiting.  In this case, all the tasks pending will be
  253. *                                                    readied.
  254. *
  255. *              err           is a pointer to an error code that can contain one of the following values:
  256. *                            OS_NO_ERR               The call was successful and the event flag group was
  257. *                                                    deleted
  258. *                            OS_ERR_DEL_ISR          If you attempted to delete the event flag group from
  259. *                                                    an ISR
  260. *                            OS_FLAG_INVALID_PGRP    If 'pgrp' is a NULL pointer.
  261. *                            OS_ERR_EVENT_TYPE       If you didn't pass a pointer to an event flag group
  262. *                            OS_ERR_INVALID_OPT      An invalid option was specified
  263. *                            OS_ERR_TASK_WAITING     One or more tasks were waiting on the event flag
  264. *                                                    group.
  265. *
  266. * Returns    : pgrp          upon error
  267. *              (OS_EVENT *)0 if the event flag group was successfully deleted.
  268. *
  269. * Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of
  270. *                 the event flag group MUST check the return code of OSFlagAccept() and OSFlagPend().
  271. *              2) This call can potentially disable interrupts for a long time.  The interrupt disable
  272. *                 time is directly proportional to the number of tasks waiting on the event flag group.
  273. *********************************************************************************************************
  274. */
  276. #if OS_FLAG_DEL_EN > 0
  277. OS_FLAG_GRP  *OSFlagDel (OS_FLAG_GRP *pgrp, INT8U opt, INT8U *err)
  278. {
  279.     BOOLEAN       tasks_waiting;
  280.     OS_FLAG_NODE *pnode;
  281.     OS_FLAG_GRP  *pgrp_return;
  282. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  283.     OS_CPU_SR     cpu_sr = 0;
  284. #endif
  288. #if OS_ARG_CHK_EN > 0
  289.     if (err == (INT8U *)0) {                               /* Validate 'err'                           */
  290.         return (pgrp);
  291.     }
  292.     if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */
  293.         *err = OS_FLAG_INVALID_PGRP;
  294.         return (pgrp);
  295.     }
  296. #endif
  297.     if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
  298.         *err = OS_ERR_DEL_ISR;                             /* ... can't DELETE from an ISR             */
  299.         return (pgrp);
  300.     }
  301.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event group type                */
  302.         *err = OS_ERR_EVENT_TYPE;
  303.         return (pgrp);
  304.     }
  305.     OS_ENTER_CRITICAL();
  306.     if (pgrp->OSFlagWaitList != (void *)0) {               /* See if any tasks waiting on event flags  */
  307.         tasks_waiting = OS_TRUE;                           /* Yes                                      */
  308.     } else {
  309.         tasks_waiting = OS_FALSE;                          /* No                                       */
  310.     }
  311.     switch (opt) {
  312.         case OS_DEL_NO_PEND:                               /* Delete group if no task waiting          */
  313.              if (tasks_waiting == OS_FALSE) {
  314. #if OS_FLAG_NAME_SIZE > 1
  315.                  pgrp->OSFlagName[0]  = '?';               /* Unknown name                             */
  316.                  pgrp->OSFlagName[1]  = OS_ASCII_NUL;
  317. #endif
  318.                  pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED;
  319.                  pgrp->OSFlagWaitList = (void *)OSFlagFreeList; /* Return group to free list           */
  320.                  pgrp->OSFlagFlags    = (OS_FLAGS)0;
  321.                  OSFlagFreeList       = pgrp;
  322.                  OS_EXIT_CRITICAL();
  323.                  *err                 = OS_NO_ERR;
  324.                  pgrp_return          = (OS_FLAG_GRP *)0;  /* Event Flag Group has been deleted        */
  325.              } else {
  326.                  OS_EXIT_CRITICAL();
  327.                  *err                 = OS_ERR_TASK_WAITING;
  328.                  pgrp_return          = pgrp;
  329.              }
  330.              break;
  332.         case OS_DEL_ALWAYS:                                /* Always delete the event flag group       */
  333.              pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;
  334.              while (pnode != (OS_FLAG_NODE *)0) {          /* Ready ALL tasks waiting for flags        */
  335.                  (void)OS_FlagTaskRdy(pnode, (OS_FLAGS)0);
  336.                  pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;
  337.              }
  338. #if OS_FLAG_NAME_SIZE > 1
  339.              pgrp->OSFlagName[0]  = '?';                   /* Unknown name                             */
  340.              pgrp->OSFlagName[1]  = OS_ASCII_NUL;
  341. #endif
  342.              pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED;
  343.              pgrp->OSFlagWaitList = (void *)OSFlagFreeList;/* Return group to free list                */
  344.              pgrp->OSFlagFlags    = (OS_FLAGS)0;
  345.              OSFlagFreeList       = pgrp;
  346.              OS_EXIT_CRITICAL();
  347.              if (tasks_waiting == OS_TRUE) {               /* Reschedule only if task(s) were waiting  */
  348.                  OS_Sched();                               /* Find highest priority task ready to run  */
  349.              }
  350.              *err = OS_NO_ERR;
  351.              pgrp_return          = (OS_FLAG_GRP *)0;      /* Event Flag Group has been deleted        */
  352.              break;
  354.         default:
  355.              OS_EXIT_CRITICAL();
  356.              *err                 = OS_ERR_INVALID_OPT;
  357.              pgrp_return          = pgrp;
  358.              break;
  359.     }
  360.     return (pgrp_return);
  361. }
  362. #endif
  363. /*$PAGE*/
  364. /*
  365. *********************************************************************************************************
  366. *                                 GET THE NAME OF AN EVENT FLAG GROUP
  367. *
  368. * Description: This function is used to obtain the name assigned to an event flag group
  369. *
  370. * Arguments  : pgrp      is a pointer to the event flag group.
  371. *
  372. *              pname     is a pointer to an ASCII string that will receive the name of the event flag
  373. *                        group.  The string must be able to hold at least OS_FLAG_NAME_SIZE characters.
  374. *
  375. *              err       is a pointer to an error code that can contain one of the following values:
  376. *
  377. *                        OS_NO_ERR                  if the requested task is resumed
  378. *                        OS_ERR_EVENT_TYPE          if 'pevent' is not pointing to an event flag group
  379. *                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname'
  380. *                        OS_FLAG_INVALID_PGRP       if you passed a NULL pointer for 'pgrp'
  381. *
  382. * Returns    : The length of the string or 0 if the 'pgrp' is a NULL pointer.
  383. *********************************************************************************************************
  384. */
  386. #if OS_FLAG_NAME_SIZE > 1
  387. INT8U  OSFlagNameGet (OS_FLAG_GRP *pgrp, INT8U *pname, INT8U *err)
  388. {
  389.     INT8U      len;
  390. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  391.     OS_CPU_SR  cpu_sr = 0;
  392. #endif
  396.     OS_ENTER_CRITICAL();
  397. #if OS_ARG_CHK_EN > 0
  398.     if (err == (INT8U *)0) {                     /* Validate 'err'                                     */
  399.         OS_EXIT_CRITICAL();
  400.         return (0);
  401.     }
  402.     if (pgrp == (OS_FLAG_GRP *)0) {              /* Is 'pgrp' a NULL pointer?                          */
  403.         OS_EXIT_CRITICAL();                      /* Yes                                                */
  404.         *err = OS_FLAG_INVALID_PGRP;
  405.         return (0);
  406.     }
  407.     if (pname == (INT8U *)0) {                    /* Is 'pname' a NULL pointer?                         */
  408.         OS_EXIT_CRITICAL();                      /* Yes                                                */
  409.         *err = OS_ERR_PNAME_NULL;
  410.         return (0);
  411.     }
  412. #endif
  413.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {
  414.         OS_EXIT_CRITICAL();
  415.         *err = OS_ERR_EVENT_TYPE;
  416.         return (0);
  417.     }
  418.     len  = OS_StrCopy(pname, pgrp->OSFlagName);  /* Copy name from OS_FLAG_GRP                         */
  419.     OS_EXIT_CRITICAL();
  420.     *err = OS_NO_ERR;
  421.     return (len);
  422. }
  423. #endif
  425. /*$PAGE*/
  426. /*
  427. *********************************************************************************************************
  428. *                                 ASSIGN A NAME TO AN EVENT FLAG GROUP
  429. *
  430. * Description: This function assigns a name to an event flag group.
  431. *
  432. * Arguments  : pgrp      is a pointer to the event flag group.
  433. *
  434. *              pname     is a pointer to an ASCII string that will be used as the name of the event flag
  435. *                        group.  The string must be able to hold at least OS_FLAG_NAME_SIZE characters.
  436. *
  437. *              err       is a pointer to an error code that can contain one of the following values:
  438. *
  439. *                        OS_NO_ERR                  if the requested task is resumed
  440. *                        OS_ERR_EVENT_TYPE          if 'pevent' is not pointing to an event flag group
  441. *                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname'
  442. *                        OS_FLAG_INVALID_PGRP       if you passed a NULL pointer for 'pgrp'
  443. *
  444. * Returns    : None
  445. *********************************************************************************************************
  446. */
  448. #if OS_FLAG_NAME_SIZE > 1
  449. void  OSFlagNameSet (OS_FLAG_GRP *pgrp, INT8U *pname, INT8U *err)
  450. {
  451.     INT8U      len;
  452. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  453.     OS_CPU_SR  cpu_sr = 0;
  454. #endif
  458.     OS_ENTER_CRITICAL();
  459. #if OS_ARG_CHK_EN > 0
  460.     if (err == (INT8U *)0) {                     /* Validate 'err'                                     */
  461.         OS_EXIT_CRITICAL();
  462.         return;
  463.     }
  464.     if (pgrp == (OS_FLAG_GRP *)0) {              /* Is 'pgrp' a NULL pointer?                          */
  465.         OS_EXIT_CRITICAL();                      /* Yes                                                */
  466.         *err = OS_FLAG_INVALID_PGRP;
  467.         return;
  468.     }
  469.     if (pname == (INT8U *)0) {                    /* Is 'pname' a NULL pointer?                         */
  470.         OS_EXIT_CRITICAL();                      /* Yes                                                */
  471.         *err = OS_ERR_PNAME_NULL;
  472.         return;
  473.     }
  474. #endif
  475.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {
  476.         OS_EXIT_CRITICAL();
  477.         *err = OS_ERR_EVENT_TYPE;
  478.         return;
  479.     }
  480.     len = OS_StrLen(pname);                      /* Can we fit the string in the storage area?         */
  481.     if (len > (OS_FLAG_NAME_SIZE - 1)) {         /* No                                                 */
  482.         OS_EXIT_CRITICAL();
  483.         *err = OS_ERR_FLAG_NAME_TOO_LONG;
  484.         return;
  485.     }
  486.     (void)OS_StrCopy(pgrp->OSFlagName, pname);   /* Yes, copy name from OS_FLAG_GRP                    */
  487.     OS_EXIT_CRITICAL();
  488.     *err = OS_NO_ERR;
  489.     return;
  490. }
  491. #endif
  493. /*$PAGE*/
  494. /*
  495. *********************************************************************************************************
  496. *                                        WAIT ON AN EVENT FLAG GROUP
  497. *
  498. * Description: This function is called to wait for a combination of bits to be set in an event flag
  499. *              group.  Your application can wait for ANY bit to be set or ALL bits to be set.
  500. *
  501. * Arguments  : pgrp          is a pointer to the desired event flag group.
  502. *
  503. *              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to wait for.
  504. *                            The bits you want are specified by setting the corresponding bits in
  505. *                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then
  506. *                            'flags' would contain 0x03.
  507. *
  508. *              wait_type     specifies whether you want ALL bits to be set or ANY of the bits to be set.
  509. *                            You can specify the following argument:
  510. *
  511. *                            OS_FLAG_WAIT_CLR_ALL   You will wait for ALL bits in 'mask' to be clear (0)
  512. *                            OS_FLAG_WAIT_SET_ALL   You will wait for ALL bits in 'mask' to be set   (1)
  513. *                            OS_FLAG_WAIT_CLR_ANY   You will wait for ANY bit  in 'mask' to be clear (0)
  514. *                            OS_FLAG_WAIT_SET_ANY   You will wait for ANY bit  in 'mask' to be set   (1)
  515. *
  516. *                            NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by
  517. *                                  the call.  Example, to wait for any flag in a group AND then clear
  518. *                                  the flags that are present, set 'wait_type' to:
  519. *
  520. *                                  OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME
  521. *
  522. *              timeout       is an optional timeout (in clock ticks) that your task will wait for the
  523. *                            desired bit combination.  If you specify 0, however, your task will wait
  524. *                            forever at the specified event flag group or, until a message arrives.
  525. *
  526. *              err           is a pointer to an error code and can be:
  527. *                            OS_NO_ERR              The desired bits have been set within the specified
  528. *                                                   'timeout'.
  529. *                            OS_ERR_PEND_ISR        If you tried to PEND from an ISR
  530. *                            OS_FLAG_INVALID_PGRP   If 'pgrp' is a NULL pointer.
  531. *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group
  532. *                            OS_TIMEOUT             The bit(s) have not been set in the specified
  533. *                                                   'timeout'.
  534. *                            OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument.
  535. *
  536. * Returns    : The flags in the event flag group that made the task ready or, 0 if a timeout or an error
  537. *              occurred.
  538. *
  539. * Called from: Task ONLY
  540. *
  541. * Note(s)    : 1) IMPORTANT, the behavior of this function has changed from PREVIOUS versions.  The
  542. *                 function NOW returns the flags that were ready INSTEAD of the current state of the
  543. *                 event flags.
  544. *********************************************************************************************************
  545. */
  547. OS_FLAGS  OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err)
  548. {
  549.     OS_FLAG_NODE  node;
  550.     OS_FLAGS      flags_rdy;
  551.     INT8U         result;
  552.     BOOLEAN       consume;
  553. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  554.     OS_CPU_SR     cpu_sr = 0;
  555. #endif
  559. #if OS_ARG_CHK_EN > 0
  560.     if (err == (INT8U *)0) {                               /* Validate 'err'                           */
  561.         return ((OS_FLAGS)0);
  562.     }
  563.     if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */
  564.         *err = OS_FLAG_INVALID_PGRP;
  565.         return ((OS_FLAGS)0);
  566.     }
  567. #endif
  568.     if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
  569.         *err = OS_ERR_PEND_ISR;                            /* ... can't PEND from an ISR               */
  570.         return ((OS_FLAGS)0);
  571.     }
  572.     if (OSLockNesting > 0) {                               /* See if called with scheduler locked ...  */
  573.         *err = OS_ERR_PEND_LOCKED;                         /* ... can't PEND when locked               */
  574.         return ((OS_FLAGS)0);
  575.     }
  576.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event block type                */
  577.         *err = OS_ERR_EVENT_TYPE;
  578.         return ((OS_FLAGS)0);
  579.     }
  580.     result = (INT8U)(wait_type & OS_FLAG_CONSUME);
  581.     if (result != (INT8U)0) {                             /* See if we need to consume the flags      */
  582.         wait_type &= ~OS_FLAG_CONSUME;
  583.         consume    = OS_TRUE;
  584.     } else {
  585.         consume    = OS_FALSE;
  586.     }
  587. /*$PAGE*/
  588.     OS_ENTER_CRITICAL();
  589.     switch (wait_type) {
  590.         case OS_FLAG_WAIT_SET_ALL:                         /* See if all required flags are set        */
  591.              flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags);   /* Extract only the bits we want     */
  592.              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
  593.                  if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
  594.                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we wanted      */
  595.                  }
  596.                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */
  597.                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
  598.                  *err                    = OS_NO_ERR;
  599.                  return (flags_rdy);
  600.              } else {                                      /* Block task until events occur or timeout */
  601.                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
  602.                  OS_EXIT_CRITICAL();
  603.              }
  604.              break;
  606.         case OS_FLAG_WAIT_SET_ANY:
  607.              flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags);    /* Extract only the bits we want    */
  608.              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag set                      */
  609.                  if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
  610.                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we got         */
  611.                  }
  612.                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */
  613.                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
  614.                  *err                    = OS_NO_ERR;
  615.                  return (flags_rdy);
  616.              } else {                                      /* Block task until events occur or timeout */
  617.                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
  618.                  OS_EXIT_CRITICAL();
  619.              }
  620.              break;
  622. #if OS_FLAG_WAIT_CLR_EN > 0
  623.         case OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */
  624.              flags_rdy = (OS_FLAGS)(~pgrp->OSFlagFlags & flags);  /* Extract only the bits we want     */
  625.              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
  626.                  if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
  627.                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we wanted        */
  628.                  }
  629.                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */
  630.                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
  631.                  *err                    = OS_NO_ERR;
  632.                  return (flags_rdy);
  633.              } else {                                      /* Block task until events occur or timeout */
  634.                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
  635.                  OS_EXIT_CRITICAL();
  636.              }
  637.              break;
  639.         case OS_FLAG_WAIT_CLR_ANY:
  640.              flags_rdy = (OS_FLAGS)(~pgrp->OSFlagFlags & flags); /* Extract only the bits we want      */
  641.              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */
  642.                  if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
  643.                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we got           */
  644.                  }
  645.                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */
  646.                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
  647.                  *err                    = OS_NO_ERR;
  648.                  return (flags_rdy);
  649.              } else {                                      /* Block task until events occur or timeout */
  650.                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
  651.                  OS_EXIT_CRITICAL();
  652.              }
  653.              break;
  654. #endif
  656.         default:
  657.              OS_EXIT_CRITICAL();
  658.              flags_rdy = (OS_FLAGS)0;
  659.              *err      = OS_FLAG_ERR_WAIT_TYPE;
  660.              return (flags_rdy);
  661.     }
  662.     OS_Sched();                                            /* Find next HPT ready to run               */
  663.     OS_ENTER_CRITICAL();
  664.     if (OSTCBCur->OSTCBPendTO == OS_TRUE) {                /* Have we timed-out?                       */
  665.         OSTCBCur->OSTCBPendTO = OS_FALSE;
  666.         OS_FlagUnlink(&node);
  667.         OSTCBCur->OSTCBStat   = OS_STAT_RDY;               /* Yes, make task ready-to-run              */
  668.         OS_EXIT_CRITICAL();
  669.         flags_rdy             = (OS_FLAGS)0;
  670.         *err                  = OS_TIMEOUT;                /* Indicate that we timed-out waiting       */
  671.         return (flags_rdy);
  672.     }
  673.     flags_rdy = OSTCBCur->OSTCBFlagsRdy;
  674.     if (consume == OS_TRUE) {                              /* See if we need to consume the flags      */
  675.         switch (wait_type) {
  676.             case OS_FLAG_WAIT_SET_ALL:
  677.             case OS_FLAG_WAIT_SET_ANY:                     /* Clear ONLY the flags we got              */
  678.                  pgrp->OSFlagFlags &= ~flags_rdy;
  679.                  break;
  681. #if OS_FLAG_WAIT_CLR_EN > 0
  682.             case OS_FLAG_WAIT_CLR_ALL:
  683.             case OS_FLAG_WAIT_CLR_ANY:                     /* Set   ONLY the flags we got              */
  684.                  pgrp->OSFlagFlags |=  flags_rdy;
  685.                  break;
  686. #endif
  687.             default:
  688.                  OS_EXIT_CRITICAL();
  689.                  *err = OS_FLAG_ERR_WAIT_TYPE;
  690.                  return ((OS_FLAGS)0);
  691.         }
  692.     }
  693.     OS_EXIT_CRITICAL();
  694.     *err = OS_NO_ERR;                                      /* Event(s) must have occurred              */
  695.     return (flags_rdy);
  696. }
  697. /*$PAGE*/
  698. /*
  699. *********************************************************************************************************
  700. *                               GET FLAGS WHO CAUSED TASK TO BECOME READY
  701. *
  702. * Description: This function is called to obtain the flags that caused the task to become ready to run.
  703. *              In other words, this function allows you to tell "Who done it!".
  704. *
  705. * Arguments  : None
  706. *
  707. * Returns    : The flags that caused the task to be ready.
  708. *
  709. * Called from: Task ONLY
  710. *********************************************************************************************************
  711. */
  713. OS_FLAGS  OSFlagPendGetFlagsRdy (void)
  714. {
  715.     OS_FLAGS      flags;
  716. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  717.     OS_CPU_SR     cpu_sr = 0;
  718. #endif
  722.     OS_ENTER_CRITICAL();
  723.     flags = OSTCBCur->OSTCBFlagsRdy;
  724.     OS_EXIT_CRITICAL();
  725.     return (flags);
  726. }
  728. /*$PAGE*/
  729. /*
  730. *********************************************************************************************************
  731. *                                         POST EVENT FLAG BIT(S)
  732. *
  733. * Description: This function is called to set or clear some bits in an event flag group.  The bits to
  734. *              set or clear are specified by a 'bit mask'.
  735. *
  736. * Arguments  : pgrp          is a pointer to the desired event flag group.
  737. *
  738. *              flags         If 'opt' (see below) is OS_FLAG_SET, each bit that is set in 'flags' will
  739. *                            set the corresponding bit in the event flag group.  e.g. to set bits 0, 4
  740. *                            and 5 you would set 'flags' to:
  741. *
  742. *                                0x31     (note, bit 0 is least significant bit)
  743. *
  744. *                            If 'opt' (see below) is OS_FLAG_CLR, each bit that is set in 'flags' will
  745. *                            CLEAR the corresponding bit in the event flag group.  e.g. to clear bits 0,
  746. *                            4 and 5 you would specify 'flags' as:
  747. *
  748. *                                0x31     (note, bit 0 is least significant bit)
  749. *
  750. *              opt           indicates whether the flags will be:
  751. *                                set     (OS_FLAG_SET) or
  752. *                                cleared (OS_FLAG_CLR)
  753. *
  754. *              err           is a pointer to an error code and can be:
  755. *                            OS_NO_ERR              The call was successfull
  756. *                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer
  757. *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group
  758. *                            OS_FLAG_INVALID_OPT    You specified an invalid option
  759. *
  760. * Returns    : the new value of the event flags bits that are still set.
  761. *
  762. * Called From: Task or ISR
  763. *
  764. * WARNING(s) : 1) The execution time of this function depends on the number of tasks waiting on the event
  765. *                 flag group.
  766. *              2) The amount of time interrupts are DISABLED depends on the number of tasks waiting on
  767. *                 the event flag group.
  768. *********************************************************************************************************
  769. */
  770. OS_FLAGS  OSFlagPost (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U opt, INT8U *err)
  771. {
  772.     OS_FLAG_NODE *pnode;
  773.     BOOLEAN       sched;
  774.     OS_FLAGS      flags_cur;
  775.     OS_FLAGS      flags_rdy;
  776.     BOOLEAN       rdy;
  777. #if OS_CRITICAL_METHOD == 3                          /* Allocate storage for CPU status register       */
  778.     OS_CPU_SR     cpu_sr = 0;
  779. #endif
  783. #if OS_ARG_CHK_EN > 0
  784.     if (err == (INT8U *)0) {                         /* Validate 'err'                                 */
  785.         return ((OS_FLAGS)0);
  786.     }
  787.     if (pgrp == (OS_FLAG_GRP *)0) {                  /* Validate 'pgrp'                                */
  788.         *err = OS_FLAG_INVALID_PGRP;
  789.         return ((OS_FLAGS)0);
  790.     }
  791. #endif
  792.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {    /* Make sure we are pointing to an event flag grp */
  793.         *err = OS_ERR_EVENT_TYPE;
  794.         return ((OS_FLAGS)0);
  795.     }
  796. /*$PAGE*/
  797.     OS_ENTER_CRITICAL();
  798.     switch (opt) {
  799.         case OS_FLAG_CLR:
  800.              pgrp->OSFlagFlags &= ~flags;            /* Clear the flags specified in the group         */
  801.              break;
  803.         case OS_FLAG_SET:
  804.              pgrp->OSFlagFlags |=  flags;            /* Set   the flags specified in the group         */
  805.              break;
  807.         default:
  808.              OS_EXIT_CRITICAL();                     /* INVALID option                                 */
  809.              *err = OS_FLAG_INVALID_OPT;
  810.              return ((OS_FLAGS)0);
  811.     }
  812.     sched = OS_FALSE;                                /* Indicate that we don't need rescheduling       */
  813.     pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;
  814.     while (pnode != (OS_FLAG_NODE *)0) {             /* Go through all tasks waiting on event flag(s)  */
  815.         switch (pnode->OSFlagNodeWaitType) {
  816.             case OS_FLAG_WAIT_SET_ALL:               /* See if all req. flags are set for current node */
  817.                  flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);
  818.                  if (flags_rdy == pnode->OSFlagNodeFlags) {
  819.                      rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */
  820.                      if (rdy == OS_TRUE) {
  821.                          sched = OS_TRUE;                     /* When done we will reschedule          */
  822.                      }
  823.                  }
  824.                  break;
  826.             case OS_FLAG_WAIT_SET_ANY:               /* See if any flag set                            */
  827.                  flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);
  828.                  if (flags_rdy != (OS_FLAGS)0) {
  829.                      rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */
  830.                      if (rdy == OS_TRUE) {
  831.                          sched = OS_TRUE;                     /* When done we will reschedule          */
  832.                      }
  833.                  }
  834.                  break;
  836. #if OS_FLAG_WAIT_CLR_EN > 0
  837.             case OS_FLAG_WAIT_CLR_ALL:               /* See if all req. flags are set for current node */
  838.                  flags_rdy = (OS_FLAGS)(~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);
  839.                  if (flags_rdy == pnode->OSFlagNodeFlags) {
  840.                      rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */
  841.                      if (rdy == OS_TRUE) {
  842.                          sched = OS_TRUE;                     /* When done we will reschedule          */
  843.                      }
  844.                  }
  845.                  break;
  847.             case OS_FLAG_WAIT_CLR_ANY:               /* See if any flag set                            */
  848.                  flags_rdy = (OS_FLAGS)(~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);
  849.                  if (flags_rdy != (OS_FLAGS)0) {
  850.                      rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */
  851.                      if (rdy == OS_TRUE) {
  852.                          sched = OS_TRUE;                     /* When done we will reschedule          */
  853.                      }
  854.                  }
  855.                  break;
  856. #endif
  857.             default:
  858.                  OS_EXIT_CRITICAL();
  859.                  *err = OS_FLAG_ERR_WAIT_TYPE;
  860.                  return ((OS_FLAGS)0);
  861.         }
  862.         pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext; /* Point to next task waiting for event flag(s) */
  863.     }
  864.     OS_EXIT_CRITICAL();
  865.     if (sched == OS_TRUE) {
  866.         OS_Sched();
  867.     }
  868.     OS_ENTER_CRITICAL();
  869.     flags_cur = pgrp->OSFlagFlags;
  870.     OS_EXIT_CRITICAL();
  871.     *err      = OS_NO_ERR;
  872.     return (flags_cur);
  873. }
  874. /*$PAGE*/
  875. /*
  876. *********************************************************************************************************
  877. *                                           QUERY EVENT FLAG
  878. *
  879. * Description: This function is used to check the value of the event flag group.
  880. *
  881. * Arguments  : pgrp         is a pointer to the desired event flag group.
  882. *
  883. *              err           is a pointer to an error code returned to the called:
  884. *                            OS_NO_ERR              The call was successfull
  885. *                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer
  886. *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group
  887. *
  888. * Returns    : The current value of the event flag group.
  889. *
  890. * Called From: Task or ISR
  891. *********************************************************************************************************
  892. */
  894. #if OS_FLAG_QUERY_EN > 0
  895. OS_FLAGS  OSFlagQuery (OS_FLAG_GRP *pgrp, INT8U *err)
  896. {
  897.     OS_FLAGS   flags;
  898. #if OS_CRITICAL_METHOD == 3                       /* Allocate storage for CPU status register          */
  899.     OS_CPU_SR  cpu_sr = 0;
  900. #endif
  904. #if OS_ARG_CHK_EN > 0
  905.     if (err == (INT8U *)0) {                      /* Validate 'err'                                    */
  906.         return ((OS_FLAGS)0);
  907.     }
  908.     if (pgrp == (OS_FLAG_GRP *)0) {               /* Validate 'pgrp'                                   */
  909.         *err = OS_FLAG_INVALID_PGRP;
  910.         return ((OS_FLAGS)0);
  911.     }
  912. #endif
  913.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type                         */
  914.         *err = OS_ERR_EVENT_TYPE;
  915.         return ((OS_FLAGS)0);
  916.     }
  917.     OS_ENTER_CRITICAL();
  918.     flags = pgrp->OSFlagFlags;
  919.     OS_EXIT_CRITICAL();
  920.     *err = OS_NO_ERR;
  921.     return (flags);                               /* Return the current value of the event flags       */
  922. }
  923. #endif
  925. /*$PAGE*/
  926. /*
  927. *********************************************************************************************************
  928. *                         SUSPEND TASK UNTIL EVENT FLAG(s) RECEIVED OR TIMEOUT OCCURS
  929. *
  930. * Description: This function is internal to uC/OS-II and is used to put a task to sleep until the desired
  931. *              event flag bit(s) are set.
  932. *
  933. * Arguments  : pgrp          is a pointer to the desired event flag group.
  934. *
  935. *              pnode         is a pointer to a structure which contains data about the task waiting for
  936. *                            event flag bit(s) to be set.
  937. *
  938. *              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to check.
  939. *                            The bits you want are specified by setting the corresponding bits in
  940. *                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then
  941. *                            'flags' would contain 0x03.
  942. *
  943. *              wait_type     specifies whether you want ALL bits to be set/cleared or ANY of the bits
  944. *                            to be set/cleared.
  945. *                            You can specify the following argument:
  946. *
  947. *                            OS_FLAG_WAIT_CLR_ALL   You will check ALL bits in 'mask' to be clear (0)
  948. *                            OS_FLAG_WAIT_CLR_ANY   You will check ANY bit  in 'mask' to be clear (0)
  949. *                            OS_FLAG_WAIT_SET_ALL   You will check ALL bits in 'mask' to be set   (1)
  950. *                            OS_FLAG_WAIT_SET_ANY   You will check ANY bit  in 'mask' to be set   (1)
  951. *
  952. *              timeout       is the desired amount of time that the task will wait for the event flag
  953. *                            bit(s) to be set.
  954. *
  955. * Returns    : none
  956. *
  957. * Called by  : OSFlagPend()  OS_FLAG.C
  958. *
  959. * Note(s)    : This function is INTERNAL to uC/OS-II and your application should not call it.
  960. *********************************************************************************************************
  961. */
  963. static  void  OS_FlagBlock (OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout)
  964. {
  965.     OS_FLAG_NODE  *pnode_next;
  966.     INT8U          y;
  969.     OSTCBCur->OSTCBStat      |= OS_STAT_FLAG;
  970.     OSTCBCur->OSTCBPendTO     = OS_FALSE;
  971.     OSTCBCur->OSTCBDly        = timeout;              /* Store timeout in task's TCB                   */
  972.     OSTCBCur->OSTCBEventPtr   = (OS_EVENT *)0;
  973. #if OS_TASK_DEL_EN > 0
  974.     OSTCBCur->OSTCBFlagNode   = pnode;                /* TCB to link to node                           */
  975. #endif
  976.     pnode->OSFlagNodeFlags    = flags;                /* Save the flags that we need to wait for       */
  977.     pnode->OSFlagNodeWaitType = wait_type;            /* Save the type of wait we are doing            */
  978.     pnode->OSFlagNodeTCB      = (void *)OSTCBCur;     /* Link to task's TCB                            */
  979.     pnode->OSFlagNodeNext     = pgrp->OSFlagWaitList; /* Add node at beginning of event flag wait list */
  980.     pnode->OSFlagNodePrev     = (void *)0;
  981.     pnode->OSFlagNodeFlagGrp  = (void *)pgrp;         /* Link to Event Flag Group                      */
  982.     pnode_next                = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;
  983.     if (pnode_next != (void *)0) {                    /* Is this the first NODE to insert?             */
  984.         pnode_next->OSFlagNodePrev = pnode;           /* No, link in doubly linked list                */
  985.     }
  986.     pgrp->OSFlagWaitList = (void *)pnode;
  988.     y            =  OSTCBCur->OSTCBY;                 /* Suspend current task until flag(s) received   */
  989.     OSRdyTbl[y] &= ~OSTCBCur->OSTCBBitX;
  990.     if (OSRdyTbl[y] == 0x00) {
  991.         OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
  992.     }
  993. }
  995. /*$PAGE*/
  996. /*
  997. *********************************************************************************************************
  998. *                                    INITIALIZE THE EVENT FLAG MODULE
  999. *
  1000. * Description: This function is called by uC/OS-II to initialize the event flag module.  Your application
  1001. *              MUST NOT call this function.  In other words, this function is internal to uC/OS-II.
  1002. *
  1003. * Arguments  : none
  1004. *
  1005. * Returns    : none
  1006. *
  1007. * WARNING    : You MUST NOT call this function from your code.  This is an INTERNAL function to uC/OS-II.
  1008. *********************************************************************************************************
  1009. */
  1011. void  OS_FlagInit (void)
  1012. {
  1013. #if OS_MAX_FLAGS == 1
  1014.     OSFlagFreeList                 = (OS_FLAG_GRP *)&OSFlagTbl[0];  /* Only ONE event flag group!      */
  1015.     OSFlagFreeList->OSFlagType     = OS_EVENT_TYPE_UNUSED;
  1016.     OSFlagFreeList->OSFlagWaitList = (void *)0;
  1017.     OSFlagFreeList->OSFlagFlags    = (OS_FLAGS)0;
  1018. #if OS_FLAG_NAME_SIZE > 1
  1019.     OSFlagFreeList->OSFlagName[0]  = '?';
  1020.     OSFlagFreeList->OSFlagName[1]  = OS_ASCII_NUL;
  1021. #endif
  1022. #endif
  1024. #if OS_MAX_FLAGS >= 2
  1025.     INT16U       i;
  1026.     OS_FLAG_GRP *pgrp1;
  1027.     OS_FLAG_GRP *pgrp2;
  1030.     OS_MemClr((INT8U *)&OSFlagTbl[0], sizeof(OSFlagTbl));           /* Clear the flag group table      */
  1031.     pgrp1 = &OSFlagTbl[0];
  1032.     pgrp2 = &OSFlagTbl[1];
  1033.     for (i = 0; i < (OS_MAX_FLAGS - 1); i++) {                      /* Init. list of free EVENT FLAGS  */
  1034.         pgrp1->OSFlagType     = OS_EVENT_TYPE_UNUSED;
  1035.         pgrp1->OSFlagWaitList = (void *)pgrp2;
  1036. #if OS_FLAG_NAME_SIZE > 1
  1037.         pgrp1->OSFlagName[0]  = '?';                                /* Unknown name                    */
  1038.         pgrp1->OSFlagName[1]  = OS_ASCII_NUL;
  1039. #endif
  1040.         pgrp1++;
  1041.         pgrp2++;
  1042.     }
  1043.     pgrp1->OSFlagType     = OS_EVENT_TYPE_UNUSED;
  1044.     pgrp1->OSFlagWaitList = (void *)0;
  1045. #if OS_FLAG_NAME_SIZE > 1
  1046.     pgrp1->OSFlagName[0]  = '?';                                    /* Unknown name                    */
  1047.     pgrp1->OSFlagName[1]  = OS_ASCII_NUL;
  1048. #endif
  1049.     OSFlagFreeList        = &OSFlagTbl[0];
  1050. #endif
  1051. }
  1053. /*$PAGE*/
  1054. /*
  1055. *********************************************************************************************************
  1056. *                              MAKE TASK READY-TO-RUN, EVENT(s) OCCURRED
  1057. *
  1058. * Description: This function is internal to uC/OS-II and is used to make a task ready-to-run because the
  1059. *              desired event flag bits have been set.
  1060. *
  1061. * Arguments  : pnode         is a pointer to a structure which contains data about the task waiting for
  1062. *                            event flag bit(s) to be set.
  1063. *
  1064. *              flags_rdy     contains the bit pattern of the event flags that cause the task to become
  1065. *                            ready-to-run.
  1066. *
  1067. * Returns    : OS_TRUE       If the task has been placed in the ready list and thus needs scheduling
  1068. *              OS_FALSE      The task is still not ready to run and thus scheduling is not necessary
  1069. *
  1070. * Called by  : OSFlagsPost() OS_FLAG.C
  1071. *
  1072. * Note(s)    : 1) This function assumes that interrupts are disabled.
  1073. *              2) This function is INTERNAL to uC/OS-II and your application should not call it.
  1074. *********************************************************************************************************
  1075. */
  1077. static  BOOLEAN  OS_FlagTaskRdy (OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy)
  1078. {
  1079.     OS_TCB   *ptcb;
  1080.     BOOLEAN   sched;
  1083.     ptcb                = (OS_TCB *)pnode->OSFlagNodeTCB;  /* Point to TCB of waiting task             */
  1084.     ptcb->OSTCBDly      = 0;
  1085.     ptcb->OSTCBFlagsRdy = flags_rdy;
  1086.     ptcb->OSTCBStat    &= ~OS_STAT_FLAG;
  1087.     ptcb->OSTCBPendTO   = OS_FALSE;
  1088.     if (ptcb->OSTCBStat == OS_STAT_RDY) {                  /* Task now ready?                          */
  1089.         OSRdyGrp               |= ptcb->OSTCBBitY;         /* Put task into ready list                 */
  1090.         OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
  1091.         sched                   = OS_TRUE;
  1092.     } else {
  1093.         sched                   = OS_FALSE;
  1094.     }
  1095.     OS_FlagUnlink(pnode);
  1096.     return (sched);
  1097. }
  1099. /*$PAGE*/
  1100. /*
  1101. *********************************************************************************************************
  1102. *                                  UNLINK EVENT FLAG NODE FROM WAITING LIST
  1103. *
  1104. * Description: This function is internal to uC/OS-II and is used to unlink an event flag node from a
  1105. *              list of tasks waiting for the event flag.
  1106. *
  1107. * Arguments  : pnode         is a pointer to a structure which contains data about the task waiting for
  1108. *                            event flag bit(s) to be set.
  1109. *
  1110. * Returns    : none
  1111. *
  1112. * Called by  : OS_FlagTaskRdy() OS_FLAG.C
  1113. *              OSFlagPend()     OS_FLAG.C
  1114. *              OSTaskDel()      OS_TASK.C
  1115. *
  1116. * Note(s)    : 1) This function assumes that interrupts are disabled.
  1117. *              2) This function is INTERNAL to uC/OS-II and your application should not call it.
  1118. *********************************************************************************************************
  1119. */
  1121. void  OS_FlagUnlink (OS_FLAG_NODE *pnode)
  1122. {
  1123. #if OS_TASK_DEL_EN > 0
  1124.     OS_TCB       *ptcb;
  1125. #endif
  1126.     OS_FLAG_GRP  *pgrp;
  1127.     OS_FLAG_NODE *pnode_prev;
  1128.     OS_FLAG_NODE *pnode_next;
  1131.     pnode_prev = (OS_FLAG_NODE *)pnode->OSFlagNodePrev;
  1132.     pnode_next = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;
  1133.     if (pnode_prev == (OS_FLAG_NODE *)0) {                      /* Is it first node in wait list?      */
  1134.         pgrp                 = (OS_FLAG_GRP *)pnode->OSFlagNodeFlagGrp;
  1135.         pgrp->OSFlagWaitList = (void *)pnode_next;              /*      Update list for new 1st node   */
  1136.         if (pnode_next != (OS_FLAG_NODE *)0) {
  1137.             pnode_next->OSFlagNodePrev = (OS_FLAG_NODE *)0;     /*      Link new 1st node PREV to NULL */
  1138.         }
  1139.     } else {                                                    /* No,  A node somewhere in the list   */
  1140.         pnode_prev->OSFlagNodeNext = pnode_next;                /*      Link around the node to unlink */
  1141.         if (pnode_next != (OS_FLAG_NODE *)0) {                  /*      Was this the LAST node?        */
  1142.             pnode_next->OSFlagNodePrev = pnode_prev;            /*      No, Link around current node   */
  1143.         }
  1144.     }
  1145. #if OS_TASK_DEL_EN > 0
  1146.     ptcb                = (OS_TCB *)pnode->OSFlagNodeTCB;
  1147.     ptcb->OSTCBFlagNode = (OS_FLAG_NODE *)0;
  1148. #endif
  1149. }
  1150. #endif