os_flag.c
上传用户:ht5068443
上传日期:2016-07-26
资源大小:802k
文件大小:54k
源码类别:

MacOS编程

开发平台:

C/C++

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