PageRenderTime 57ms CodeModel.GetById 27ms RepoModel.GetById 0ms app.codeStats 0ms

/src/compiler/ucos-vs2008/UCOS_SIM/src/ucosii/os_flag.c

http://ftk.googlecode.com/
C | 1146 lines | 684 code | 78 blank | 384 comment | 168 complexity | a63cb391c7b63d8ecbd98fd475c6e1e4 MD5 | raw file
Possible License(s): LGPL-3.0 
    

  1. /*

    2. 

  2. *********************************************************************************************************

    3. 

  3. *                                                uC/OS-II

    4. 

  4. *                                          The Real-Time Kernel

    5. 

  5. *                                         EVENT FLAG  MANAGEMENT

    6. 

  6. *

    7. 

  7. *                          (c) Copyright 2001-2005, Jean J. Labrosse, Weston, FL

    8. 

  8. *                                           All Rights Reserved

    9. 

  9. *

    10. 

  10. * File    : OS_FLAG.C

    11. 

  11. * By      : Jean J. Labrosse

    12. 

  12. * Version : V2.80

    13. 

  13. *********************************************************************************************************

    14. 

  14. */

    15. 

  15. 

    16. 

  16. #ifndef  OS_MASTER_FILE

    17. 

  17. #include <ucos_ii.h>

    18. 

  18. #endif

    19. 

  19. 

    20. 

  20. #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)

    21. 

  21. /*

    22. 

  22. *********************************************************************************************************

    23. 

  23. *                                            LOCAL PROTOTYPES

    24. 

  24. *********************************************************************************************************

    25. 

  25. */

    26. 

  26. 

    27. 

  27. static  void     OS_FlagBlock(OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout);

    28. 

  28. static  BOOLEAN  OS_FlagTaskRdy(OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy);

    29. 

  29. 

    30. 

  30. /*$PAGE*/

    31. 

  31. /*

    32. 

  32. *********************************************************************************************************

    33. 

  33. *                              CHECK THE STATUS OF FLAGS IN AN EVENT FLAG GROUP

    34. 

  34. *

    35. 

  35. * Description: This function is called to check the status of a combination of bits to be set or cleared

    36. 

  36. *              in an event flag group.  Your application can check for ANY bit to be set/cleared or ALL

    37. 

  37. *              bits to be set/cleared.

    38. 

  38. *

    39. 

  39. *              This call does not block if the desired flags are not present.

    40. 

  40. *

    41. 

  41. * Arguments  : pgrp          is a pointer to the desired event flag group.

    42. 

  42. *

    43. 

  43. *              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to check.

    44. 

  44. *                            The bits you want are specified by setting the corresponding bits in

    45. 

  45. *                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then

    46. 

  46. *                            'flags' would contain 0x03.

    47. 

  47. *

    48. 

  48. *              wait_type     specifies whether you want ALL bits to be set/cleared or ANY of the bits

    49. 

  49. *                            to be set/cleared.

    50. 

  50. *                            You can specify the following argument:

    51. 

  51. *

    52. 

  52. *                            OS_FLAG_WAIT_CLR_ALL   You will check ALL bits in 'flags' to be clear (0)

    53. 

  53. *                            OS_FLAG_WAIT_CLR_ANY   You will check ANY bit  in 'flags' to be clear (0)

    54. 

  54. *                            OS_FLAG_WAIT_SET_ALL   You will check ALL bits in 'flags' to be set   (1)

    55. 

  55. *                            OS_FLAG_WAIT_SET_ANY   You will check ANY bit  in 'flags' to be set   (1)

    56. 

  56. *

    57. 

  57. *                            NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by

    58. 

  58. *                                  the call.  Example, to wait for any flag in a group AND then clear

    59. 

  59. *                                  the flags that are present, set 'wait_type' to:

    60. 

  60. *

    61. 

  61. *                                  OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME

    62. 

  62. *

    63. 

  63. *              err           is a pointer to an error code and can be:

    64. 

  64. *                            OS_NO_ERR              No error

    65. 

  65. *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group

    66. 

  66. *                            OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument.

    67. 

  67. *                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer instead of the event flag

    68. 

  68. *                                                   group handle.

    69. 

  69. *                            OS_FLAG_ERR_NOT_RDY    The desired flags you are waiting for are not

    70. 

  70. *                                                   available.

    71. 

  71. *

    72. 

  72. * Returns    : The flags in the event flag group that made the task ready or, 0 if a timeout or an error

    73. 

  73. *              occurred.

    74. 

  74. *

    75. 

  75. * Called from: Task or ISR

    76. 

  76. *

    77. 

  77. * Note(s)    : 1) IMPORTANT, the behavior of this function has changed from PREVIOUS versions.  The

    78. 

  78. *                 function NOW returns the flags that were ready INSTEAD of the current state of the

    79. 

  79. *                 event flags.

    80. 

  80. *********************************************************************************************************

    81. 

  81. */

    82. 

  82. 

    83. 

  83. #if OS_FLAG_ACCEPT_EN > 0

    84. 

  84. OS_FLAGS  OSFlagAccept (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT8U *err)

    85. 

  85. {

    86. 

  86.     OS_FLAGS      flags_rdy;

    87. 

  87.     INT8U         result;

    88. 

  88.     BOOLEAN       consume;

    89. 

  89. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */

    90. 

  90.     OS_CPU_SR     cpu_sr = 0;

    91. 

  91. #endif

    92. 

  92. 

    93. 

  93. 

    94. 

  94. 

    95. 

  95. #if OS_ARG_CHK_EN > 0

    96. 

  96.     if (err == (INT8U *)0) {                               /* Validate 'err'                           */

    97. 

  97.         return ((OS_FLAGS)0);

    98. 

  98.     }

    99. 

  99.     if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */

    100. 

  100.         *err = OS_FLAG_INVALID_PGRP;

    101. 

  101.         return ((OS_FLAGS)0);

    102. 

  102.     }

    103. 

  103. #endif

    104. 

  104.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event block type                */

    105. 

  105.         *err = OS_ERR_EVENT_TYPE;

    106. 

  106.         return ((OS_FLAGS)0);

    107. 

  107.     }

    108. 

  108.     result = wait_type & OS_FLAG_CONSUME;

    109. 

  109.     if (result != (INT8U)0) {                              /* See if we need to consume the flags      */

    110. 

  110.         wait_type &= ~OS_FLAG_CONSUME;

    111. 

  111.         consume    = TRUE;

    112. 

  112.     } else {

    113. 

  113.         consume    = FALSE;

    114. 

  114.     }

    115. 

  115. /*$PAGE*/

    116. 

  116.     *err = OS_NO_ERR;                                      /* Assume NO error until proven otherwise.  */

    117. 

  117.     OS_ENTER_CRITICAL();

    118. 

  118.     switch (wait_type) {

    119. 

  119.         case OS_FLAG_WAIT_SET_ALL:                         /* See if all required flags are set        */

    120. 

  120.              flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */

    121. 

  121.              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */

    122. 

  122.                  if (consume == TRUE) {                    /* See if we need to consume the flags      */

    123. 

  123.                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we wanted      */

    124. 

  124.                  }

    125. 

  125.              } else {

    126. 

  126.                  *err  = OS_FLAG_ERR_NOT_RDY;

    127. 

  127.              }

    128. 

  128.              OS_EXIT_CRITICAL();

    129. 

  129.              break;

    130. 

  130. 

    131. 

  131.         case OS_FLAG_WAIT_SET_ANY:

    132. 

  132.              flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */

    133. 

  133.              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag set                      */

    134. 

  134.                  if (consume == TRUE) {                    /* See if we need to consume the flags      */

    135. 

  135.                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we got         */

    136. 

  136.                  }

    137. 

  137.              } else {

    138. 

  138.                  *err  = OS_FLAG_ERR_NOT_RDY;

    139. 

  139.              }

    140. 

  140.              OS_EXIT_CRITICAL();

    141. 

  141.              break;

    142. 

  142. 

    143. 

  143. #if OS_FLAG_WAIT_CLR_EN > 0

    144. 

  144.         case OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */

    145. 

  145.              flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags; /* Extract only the bits we want        */

    146. 

  146.              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */

    147. 

  147.                  if (consume == TRUE) {                    /* See if we need to consume the flags      */

    148. 

  148.                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we wanted        */

    149. 

  149.                  }

    150. 

  150.              } else {

    151. 

  151.                  *err  = OS_FLAG_ERR_NOT_RDY;

    152. 

  152.              }

    153. 

  153.              OS_EXIT_CRITICAL();

    154. 

  154.              break;

    155. 

  155. 

    156. 

  156.         case OS_FLAG_WAIT_CLR_ANY:

    157. 

  157.              flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags; /* Extract only the bits we want        */

    158. 

  158.              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */

    159. 

  159.                  if (consume == TRUE) {                    /* See if we need to consume the flags      */

    160. 

  160.                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we got           */

    161. 

  161.                  }

    162. 

  162.              } else {

    163. 

  163.                  *err  = OS_FLAG_ERR_NOT_RDY;

    164. 

  164.              }

    165. 

  165.              OS_EXIT_CRITICAL();

    166. 

  166.              break;

    167. 

  167. #endif

    168. 

  168. 

    169. 

  169.         default:

    170. 

  170.              OS_EXIT_CRITICAL();

    171. 

  171.              flags_rdy = (OS_FLAGS)0;

    172. 

  172.              *err      = OS_FLAG_ERR_WAIT_TYPE;

    173. 

  173.              break;

    174. 

  174.     }

    175. 

  175.     return (flags_rdy);

    176. 

  176. }

    177. 

  177. #endif

    178. 

  178. 

    179. 

  179. /*$PAGE*/

    180. 

  180. /*

    181. 

  181. *********************************************************************************************************

    182. 

  182. *                                           CREATE AN EVENT FLAG

    183. 

  183. *

    184. 

  184. * Description: This function is called to create an event flag group.

    185. 

  185. *

    186. 

  186. * Arguments  : flags         Contains the initial value to store in the event flag group.

    187. 

  187. *

    188. 

  188. *              err           is a pointer to an error code which will be returned to your application:

    189. 

  189. *                               OS_NO_ERR                if the call was successful.

    190. 

  190. *                               OS_ERR_CREATE_ISR        if you attempted to create an Event Flag from an

    191. 

  191. *                                                        ISR.

    192. 

  192. *                               OS_FLAG_GRP_DEPLETED     if there are no more event flag groups

    193. 

  193. *

    194. 

  194. * Returns    : A pointer to an event flag group or a NULL pointer if no more groups are available.

    195. 

  195. *

    196. 

  196. * Called from: Task ONLY

    197. 

  197. *********************************************************************************************************

    198. 

  198. */

    199. 

  199. 

    200. 

  200. OS_FLAG_GRP  *OSFlagCreate (OS_FLAGS flags, INT8U *err)

    201. 

  201. {

    202. 

  202.     OS_FLAG_GRP *pgrp;

    203. 

  203. #if OS_CRITICAL_METHOD == 3                         /* Allocate storage for CPU status register        */

    204. 

  204.     OS_CPU_SR    cpu_sr = 0;

    205. 

  205. #endif

    206. 

  206. 

    207. 

  207. 

    208. 

  208. 

    209. 

  209. #if OS_ARG_CHK_EN > 0

    210. 

  210.     if (err == (INT8U *)0) {                        /* Validate 'err'                                  */

    211. 

  211.         return ((OS_FLAG_GRP *)0);

    212. 

  212.     }

    213. 

  213. #endif

    214. 

  214.     if (OSIntNesting > 0) {                         /* See if called from ISR ...                      */

    215. 

  215.         *err = OS_ERR_CREATE_ISR;                   /* ... can't CREATE from an ISR                    */

    216. 

  216.         return ((OS_FLAG_GRP *)0);

    217. 

  217.     }

    218. 

  218.     OS_ENTER_CRITICAL();

    219. 

  219.     pgrp = OSFlagFreeList;                          /* Get next free event flag                        */

    220. 

  220.     if (pgrp != (OS_FLAG_GRP *)0) {                 /* See if we have event flag groups available      */

    221. 

  221.                                                     /* Adjust free list                                */

    222. 

  222.         OSFlagFreeList       = (OS_FLAG_GRP *)OSFlagFreeList->OSFlagWaitList;

    223. 

  223.         pgrp->OSFlagType     = OS_EVENT_TYPE_FLAG;  /* Set to event flag group type                    */

    224. 

  224.         pgrp->OSFlagFlags    = flags;               /* Set to desired initial value                    */

    225. 

  225.         pgrp->OSFlagWaitList = (void *)0;           /* Clear list of tasks waiting on flags            */

    226. 

  226. #if OS_FLAG_NAME_SIZE > 1

    227. 

  227.         pgrp->OSFlagName[0]  = '?';

    228. 

  228.         pgrp->OSFlagName[1]  = OS_ASCII_NUL;

    229. 

  229. #endif

    230. 

  230.         OS_EXIT_CRITICAL();

    231. 

  231.         *err                 = OS_NO_ERR;

    232. 

  232.     } else {

    233. 

  233.         OS_EXIT_CRITICAL();

    234. 

  234.         *err                 = OS_FLAG_GRP_DEPLETED;

    235. 

  235.     }

    236. 

  236.     return (pgrp);                                  /* Return pointer to event flag group              */

    237. 

  237. }

    238. 

  238. 

    239. 

  239. /*$PAGE*/

    240. 

  240. /*

    241. 

  241. *********************************************************************************************************

    242. 

  242. *                                     DELETE AN EVENT FLAG GROUP

    243. 

  243. *

    244. 

  244. * Description: This function deletes an event flag group and readies all tasks pending on the event flag

    245. 

  245. *              group.

    246. 

  246. *

    247. 

  247. * Arguments  : pgrp          is a pointer to the desired event flag group.

    248. 

  248. *

    249. 

  249. *              opt           determines delete options as follows:

    250. 

  250. *                            opt == OS_DEL_NO_PEND   Deletes the event flag group ONLY if no task pending

    251. 

  251. *                            opt == OS_DEL_ALWAYS    Deletes the event flag group even if tasks are

    252. 

  252. *                                                    waiting.  In this case, all the tasks pending will be

    253. 

  253. *                                                    readied.

    254. 

  254. *

    255. 

  255. *              err           is a pointer to an error code that can contain one of the following values:

    256. 

  256. *                            OS_NO_ERR               The call was successful and the event flag group was

    257. 

  257. *                                                    deleted

    258. 

  258. *                            OS_ERR_DEL_ISR          If you attempted to delete the event flag group from

    259. 

  259. *                                                    an ISR

    260. 

  260. *                            OS_FLAG_INVALID_PGRP    If 'pgrp' is a NULL pointer.

    261. 

  261. *                            OS_ERR_EVENT_TYPE       If you didn't pass a pointer to an event flag group

    262. 

  262. *                            OS_ERR_INVALID_OPT      An invalid option was specified

    263. 

  263. *                            OS_ERR_TASK_WAITING     One or more tasks were waiting on the event flag

    264. 

  264. *                                                    group.

    265. 

  265. *

    266. 

  266. * Returns    : pgrp          upon error

    267. 

  267. *              (OS_EVENT *)0 if the event flag group was successfully deleted.

    268. 

  268. *

    269. 

  269. * Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of

    270. 

  270. *                 the event flag group MUST check the return code of OSFlagAccept() and OSFlagPend().

    271. 

  271. *              2) This call can potentially disable interrupts for a long time.  The interrupt disable

    272. 

  272. *                 time is directly proportional to the number of tasks waiting on the event flag group.

    273. 

  273. *********************************************************************************************************

    274. 

  274. */

    275. 

  275. 

    276. 

  276. #if OS_FLAG_DEL_EN > 0

    277. 

  277. OS_FLAG_GRP  *OSFlagDel (OS_FLAG_GRP *pgrp, INT8U opt, INT8U *err)

    278. 

  278. {

    279. 

  279.     BOOLEAN       tasks_waiting;

    280. 

  280.     OS_FLAG_NODE *pnode;

    281. 

  281.     OS_FLAG_GRP  *pgrp_return;

    282. 

  282. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */

    283. 

  283.     OS_CPU_SR     cpu_sr = 0;

    284. 

  284. #endif

    285. 

  285. 

    286. 

  286. 

    287. 

  287. 

    288. 

  288. #if OS_ARG_CHK_EN > 0

    289. 

  289.     if (err == (INT8U *)0) {                               /* Validate 'err'                           */

    290. 

  290.         return (pgrp);

    291. 

  291.     }

    292. 

  292.     if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */

    293. 

  293.         *err = OS_FLAG_INVALID_PGRP;

    294. 

  294.         return (pgrp);

    295. 

  295.     }

    296. 

  296. #endif

    297. 

  297.     if (OSIntNesting > 0) {                                /* See if called from ISR ...               */

    298. 

  298.         *err = OS_ERR_DEL_ISR;                             /* ... can't DELETE from an ISR             */

    299. 

  299.         return (pgrp);

    300. 

  300.     }

    301. 

  301.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event group type                */

    302. 

  302.         *err = OS_ERR_EVENT_TYPE;

    303. 

  303.         return (pgrp);

    304. 

  304.     }

    305. 

  305.     OS_ENTER_CRITICAL();

    306. 

  306.     if (pgrp->OSFlagWaitList != (void *)0) {               /* See if any tasks waiting on event flags  */

    307. 

  307.         tasks_waiting = TRUE;                              /* Yes                                      */

    308. 

  308.     } else {

    309. 

  309.         tasks_waiting = FALSE;                             /* No                                       */

    310. 

  310.     }

    311. 

  311.     switch (opt) {

    312. 

  312.         case OS_DEL_NO_PEND:                               /* Delete group if no task waiting          */

    313. 

  313.              if (tasks_waiting == FALSE) {

    314. 

  314. #if OS_FLAG_NAME_SIZE > 1

    315. 

  315.                  pgrp->OSFlagName[0]  = '?';               /* Unknown name                             */

    316. 

  316.                  pgrp->OSFlagName[1]  = OS_ASCII_NUL;

    317. 

  317. #endif

    318. 

  318.                  pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED;

    319. 

  319.                  pgrp->OSFlagWaitList = (void *)OSFlagFreeList; /* Return group to free list           */

    320. 

  320.                  pgrp->OSFlagFlags    = (OS_FLAGS)0;

    321. 

  321.                  OSFlagFreeList       = pgrp;

    322. 

  322.                  OS_EXIT_CRITICAL();

    323. 

  323.                  *err                 = OS_NO_ERR;

    324. 

  324.                  pgrp_return          = (OS_FLAG_GRP *)0;  /* Event Flag Group has been deleted        */

    325. 

  325.              } else {

    326. 

  326.                  OS_EXIT_CRITICAL();

    327. 

  327.                  *err                 = OS_ERR_TASK_WAITING;

    328. 

  328.                  pgrp_return          = pgrp;

    329. 

  329.              }

    330. 

  330.              break;

    331. 

  331. 

    332. 

  332.         case OS_DEL_ALWAYS:                                /* Always delete the event flag group       */

    333. 

  333.              pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;

    334. 

  334.              while (pnode != (OS_FLAG_NODE *)0) {          /* Ready ALL tasks waiting for flags        */

    335. 

  335.                  (void)OS_FlagTaskRdy(pnode, (OS_FLAGS)0);

    336. 

  336.                  pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;

    337. 

  337.              }

    338. 

  338. #if OS_FLAG_NAME_SIZE > 1

    339. 

  339.              pgrp->OSFlagName[0]  = '?';                   /* Unknown name                             */

    340. 

  340.              pgrp->OSFlagName[1]  = OS_ASCII_NUL;

    341. 

  341. #endif

    342. 

  342.              pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED;

    343. 

  343.              pgrp->OSFlagWaitList = (void *)OSFlagFreeList;/* Return group to free list                */

    344. 

  344.              pgrp->OSFlagFlags    = (OS_FLAGS)0;

    345. 

  345.              OSFlagFreeList       = pgrp;

    346. 

  346.              OS_EXIT_CRITICAL();

    347. 

  347.              if (tasks_waiting == TRUE) {                  /* Reschedule only if task(s) were waiting  */

    348. 

  348.                  OS_Sched();                               /* Find highest priority task ready to run  */

    349. 

  349.              }

    350. 

  350.              *err = OS_NO_ERR;

    351. 

  351.              pgrp_return          = (OS_FLAG_GRP *)0;      /* Event Flag Group has been deleted        */

    352. 

  352.              break;

    353. 

  353. 

    354. 

  354.         default:

    355. 

  355.              OS_EXIT_CRITICAL();

    356. 

  356.              *err                 = OS_ERR_INVALID_OPT;

    357. 

  357.              pgrp_return          = pgrp;

    358. 

  358.              break;

    359. 

  359.     }

    360. 

  360.     return (pgrp_return);

    361. 

  361. }

    362. 

  362. #endif

    363. 

  363. /*$PAGE*/

    364. 

  364. /*

    365. 

  365. *********************************************************************************************************

    366. 

  366. *                                 GET THE NAME OF AN EVENT FLAG GROUP

    367. 

  367. *

    368. 

  368. * Description: This function is used to obtain the name assigned to an event flag group

    369. 

  369. *

    370. 

  370. * Arguments  : pgrp      is a pointer to the event flag group.

    371. 

  371. *

    372. 

  372. *              pname     is a pointer to an ASCII string that will receive the name of the event flag

    373. 

  373. *                        group.  The string must be able to hold at least OS_FLAG_NAME_SIZE characters.

    374. 

  374. *

    375. 

  375. *              err       is a pointer to an error code that can contain one of the following values:

    376. 

  376. *

    377. 

  377. *                        OS_NO_ERR                  if the requested task is resumed

    378. 

  378. *                        OS_ERR_EVENT_TYPE          if 'pevent' is not pointing to an event flag group

    379. 

  379. *                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname'

    380. 

  380. *                        OS_FLAG_INVALID_PGRP       if you passed a NULL pointer for 'pgrp'

    381. 

  381. *

    382. 

  382. * Returns    : The length of the string or 0 if the 'pgrp' is a NULL pointer.

    383. 

  383. *********************************************************************************************************

    384. 

  384. */

    385. 

  385. 

    386. 

  386. #if OS_FLAG_NAME_SIZE > 1

    387. 

  387. INT8U  OSFlagNameGet (OS_FLAG_GRP *pgrp, INT8U *pname, INT8U *err)

    388. 

  388. {

    389. 

  389.     INT8U      len;

    390. 

  390. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */

    391. 

  391.     OS_CPU_SR  cpu_sr = 0;

    392. 

  392. #endif

    393. 

  393. 

    394. 

  394. 

    395. 

  395. 

    396. 

  396.     OS_ENTER_CRITICAL();

    397. 

  397. #if OS_ARG_CHK_EN > 0

    398. 

  398.     if (err == (INT8U *)0) {                     /* Validate 'err'                                     */

    399. 

  399.         OS_EXIT_CRITICAL();

    400. 

  400.         return (0);

    401. 

  401.     }

    402. 

  402.     if (pgrp == (OS_FLAG_GRP *)0) {              /* Is 'pgrp' a NULL pointer?                          */

    403. 

  403.         OS_EXIT_CRITICAL();                      /* Yes                                                */

    404. 

  404.         *err = OS_FLAG_INVALID_PGRP;

    405. 

  405.         return (0);

    406. 

  406.     }

    407. 

  407.     if (pname == (INT8U *)0) {                    /* Is 'pname' a NULL pointer?                         */

    408. 

  408.         OS_EXIT_CRITICAL();                      /* Yes                                                */

    409. 

  409.         *err = OS_ERR_PNAME_NULL;

    410. 

  410.         return (0);

    411. 

  411.     }

    412. 

  412. #endif

    413. 

  413.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {

    414. 

  414.         OS_EXIT_CRITICAL();

    415. 

  415.         *err = OS_ERR_EVENT_TYPE;

    416. 

  416.         return (0);

    417. 

  417.     }

    418. 

  418.     len  = OS_StrCopy(pname, pgrp->OSFlagName);  /* Copy name from OS_FLAG_GRP                         */

    419. 

  419.     OS_EXIT_CRITICAL();

    420. 

  420.     *err = OS_NO_ERR;

    421. 

  421.     return (len);

    422. 

  422. }

    423. 

  423. #endif

    424. 

  424. 

    425. 

  425. /*$PAGE*/

    426. 

  426. /*

    427. 

  427. *********************************************************************************************************

    428. 

  428. *                                 ASSIGN A NAME TO AN EVENT FLAG GROUP

    429. 

  429. *

    430. 

  430. * Description: This function assigns a name to an event flag group.

    431. 

  431. *

    432. 

  432. * Arguments  : pgrp      is a pointer to the event flag group.

    433. 

  433. *

    434. 

  434. *              pname     is a pointer to an ASCII string that will be used as the name of the event flag

    435. 

  435. *                        group.  The string must be able to hold at least OS_FLAG_NAME_SIZE characters.

    436. 

  436. *

    437. 

  437. *              err       is a pointer to an error code that can contain one of the following values:

    438. 

  438. *

    439. 

  439. *                        OS_NO_ERR                  if the requested task is resumed

    440. 

  440. *                        OS_ERR_EVENT_TYPE          if 'pevent' is not pointing to an event flag group

    441. 

  441. *                        OS_ERR_PNAME_NULL          You passed a NULL pointer for 'pname'

    442. 

  442. *                        OS_FLAG_INVALID_PGRP       if you passed a NULL pointer for 'pgrp'

    443. 

  443. *

    444. 

  444. * Returns    : None

    445. 

  445. *********************************************************************************************************

    446. 

  446. */

    447. 

  447. 

    448. 

  448. #if OS_FLAG_NAME_SIZE > 1

    449. 

  449. void  OSFlagNameSet (OS_FLAG_GRP *pgrp, INT8U *pname, INT8U *err)

    450. 

  450. {

    451. 

  451.     INT8U      len;

    452. 

  452. #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */

    453. 

  453.     OS_CPU_SR  cpu_sr = 0;

    454. 

  454. #endif

    455. 

  455. 

    456. 

  456. 

    457. 

  457. 

    458. 

  458.     OS_ENTER_CRITICAL();

    459. 

  459. #if OS_ARG_CHK_EN > 0

    460. 

  460.     if (err == (INT8U *)0) {                     /* Validate 'err'                                     */

    461. 

  461.         OS_EXIT_CRITICAL();

    462. 

  462.         return;

    463. 

  463.     }

    464. 

  464.     if (pgrp == (OS_FLAG_GRP *)0) {              /* Is 'pgrp' a NULL pointer?                          */

    465. 

  465.         OS_EXIT_CRITICAL();                      /* Yes                                                */

    466. 

  466.         *err = OS_FLAG_INVALID_PGRP;

    467. 

  467.         return;

    468. 

  468.     }

    469. 

  469.     if (pname == (INT8U *)0) {                    /* Is 'pname' a NULL pointer?                         */

    470. 

  470.         OS_EXIT_CRITICAL();                      /* Yes                                                */

    471. 

  471.         *err = OS_ERR_PNAME_NULL;

    472. 

  472.         return;

    473. 

  473.     }

    474. 

  474. #endif

    475. 

  475.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {

    476. 

  476.         OS_EXIT_CRITICAL();

    477. 

  477.         *err = OS_ERR_EVENT_TYPE;

    478. 

  478.         return;

    479. 

  479.     }

    480. 

  480.     len = OS_StrLen(pname);                      /* Can we fit the string in the storage area?         */

    481. 

  481.     if (len > (OS_FLAG_NAME_SIZE - 1)) {         /* No                                                 */

    482. 

  482.         OS_EXIT_CRITICAL();

    483. 

  483.         *err = OS_ERR_FLAG_NAME_TOO_LONG;

    484. 

  484.         return;

    485. 

  485.     }

    486. 

  486.     (void)OS_StrCopy(pgrp->OSFlagName, pname);   /* Yes, copy name from OS_FLAG_GRP                    */

    487. 

  487.     OS_EXIT_CRITICAL();

    488. 

  488.     *err = OS_NO_ERR;

    489. 

  489.     return;

    490. 

  490. }

    491. 

  491. #endif

    492. 

  492. 

    493. 

  493. /*$PAGE*/

    494. 

  494. /*

    495. 

  495. *********************************************************************************************************

    496. 

  496. *                                        WAIT ON AN EVENT FLAG GROUP

    497. 

  497. *

    498. 

  498. * Description: This function is called to wait for a combination of bits to be set in an event flag

    499. 

  499. *              group.  Your application can wait for ANY bit to be set or ALL bits to be set.

    500. 

  500. *

    501. 

  501. * Arguments  : pgrp          is a pointer to the desired event flag group.

    502. 

  502. *

    503. 

  503. *              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to wait for.

    504. 

  504. *                            The bits you want are specified by setting the corresponding bits in

    505. 

  505. *                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then

    506. 

  506. *                            'flags' would contain 0x03.

    507. 

  507. *

    508. 

  508. *              wait_type     specifies whether you want ALL bits to be set or ANY of the bits to be set.

    509. 

  509. *                            You can specify the following argument:

    510. 

  510. *

    511. 

  511. *                            OS_FLAG_WAIT_CLR_ALL   You will wait for ALL bits in 'mask' to be clear (0)

    512. 

  512. *                            OS_FLAG_WAIT_SET_ALL   You will wait for ALL bits in 'mask' to be set   (1)

    513. 

  513. *                            OS_FLAG_WAIT_CLR_ANY   You will wait for ANY bit  in 'mask' to be clear (0)

    514. 

  514. *                            OS_FLAG_WAIT_SET_ANY   You will wait for ANY bit  in 'mask' to be set   (1)

    515. 

  515. *

    516. 

  516. *                            NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by

    517. 

  517. *                                  the call.  Example, to wait for any flag in a group AND then clear

    518. 

  518. *                                  the flags that are present, set 'wait_type' to:

    519. 

  519. *

    520. 

  520. *                                  OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME

    521. 

  521. *

    522. 

  522. *              timeout       is an optional timeout (in clock ticks) that your task will wait for the

    523. 

  523. *                            desired bit combination.  If you specify 0, however, your task will wait

    524. 

  524. *                            forever at the specified event flag group or, until a message arrives.

    525. 

  525. *

    526. 

  526. *              err           is a pointer to an error code and can be:

    527. 

  527. *                            OS_NO_ERR              The desired bits have been set within the specified

    528. 

  528. *                                                   'timeout'.

    529. 

  529. *                            OS_ERR_PEND_ISR        If you tried to PEND from an ISR

    530. 

  530. *                            OS_FLAG_INVALID_PGRP   If 'pgrp' is a NULL pointer.

    531. 

  531. *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group

    532. 

  532. *                            OS_TIMEOUT             The bit(s) have not been set in the specified

    533. 

  533. *                                                   'timeout'.

    534. 

  534. *                            OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument.

    535. 

  535. *

    536. 

  536. * Returns    : The flags in the event flag group that made the task ready or, 0 if a timeout or an error

    537. 

  537. *              occurred.

    538. 

  538. *

    539. 

  539. * Called from: Task ONLY

    540. 

  540. *

    541. 

  541. * Note(s)    : 1) IMPORTANT, the behavior of this function has changed from PREVIOUS versions.  The

    542. 

  542. *                 function NOW returns the flags that were ready INSTEAD of the current state of the

    543. 

  543. *                 event flags.

    544. 

  544. *********************************************************************************************************

    545. 

  545. */

    546. 

  546. 

    547. 

  547. OS_FLAGS  OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err)

    548. 

  548. {

    549. 

  549.     OS_FLAG_NODE  node;

    550. 

  550.     OS_FLAGS      flags_rdy;

    551. 

  551.     INT8U         result;

    552. 

  552.     BOOLEAN       consume;

    553. 

  553. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */

    554. 

  554.     OS_CPU_SR     cpu_sr = 0;

    555. 

  555. #endif

    556. 

  556. 

    557. 

  557. 

    558. 

  558. 

    559. 

  559. #if OS_ARG_CHK_EN > 0

    560. 

  560.     if (err == (INT8U *)0) {                               /* Validate 'err'                           */

    561. 

  561.         return ((OS_FLAGS)0);

    562. 

  562.     }

    563. 

  563.     if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */

    564. 

  564.         *err = OS_FLAG_INVALID_PGRP;

    565. 

  565.         return ((OS_FLAGS)0);

    566. 

  566.     }

    567. 

  567. #endif

    568. 

  568.     if (OSIntNesting > 0) {                                /* See if called from ISR ...               */

    569. 

  569.         *err = OS_ERR_PEND_ISR;                            /* ... can't PEND from an ISR               */

    570. 

  570.         return ((OS_FLAGS)0);

    571. 

  571.     }

    572. 

  572.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event block type                */

    573. 

  573.         *err = OS_ERR_EVENT_TYPE;

    574. 

  574.         return ((OS_FLAGS)0);

    575. 

  575.     }

    576. 

  576.     result = wait_type & OS_FLAG_CONSUME;

    577. 

  577.     if (result != (INT8U)0) {                             /* See if we need to consume the flags      */

    578. 

  578.         wait_type &= ~OS_FLAG_CONSUME;

    579. 

  579.         consume    = TRUE;

    580. 

  580.     } else {

    581. 

  581.         consume    = FALSE;

    582. 

  582.     }

    583. 

  583. /*$PAGE*/

    584. 

  584.     OS_ENTER_CRITICAL();

    585. 

  585.     switch (wait_type) {

    586. 

  586.         case OS_FLAG_WAIT_SET_ALL:                         /* See if all required flags are set        */

    587. 

  587.              flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */

    588. 

  588.              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */

    589. 

  589.                  if (consume == TRUE) {                    /* See if we need to consume the flags      */

    590. 

  590.                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we wanted      */

    591. 

  591.                  }

    592. 

  592.                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */

    593. 

  593.                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */

    594. 

  594.                  *err                    = OS_NO_ERR;

    595. 

  595.                  return (flags_rdy);

    596. 

  596.              } else {                                      /* Block task until events occur or timeout */

    597. 

  597.                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);

    598. 

  598.                  OS_EXIT_CRITICAL();

    599. 

  599.              }

    600. 

  600.              break;

    601. 

  601. 

    602. 

  602.         case OS_FLAG_WAIT_SET_ANY:

    603. 

  603.              flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */

    604. 

  604.              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag set                      */

    605. 

  605.                  if (consume == TRUE) {                    /* See if we need to consume the flags      */

    606. 

  606.                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we got         */

    607. 

  607.                  }

    608. 

  608.                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */

    609. 

  609.                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */

    610. 

  610.                  *err                    = OS_NO_ERR;

    611. 

  611.                  return (flags_rdy);

    612. 

  612.              } else {                                      /* Block task until events occur or timeout */

    613. 

  613.                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);

    614. 

  614.                  OS_EXIT_CRITICAL();

    615. 

  615.              }

    616. 

  616.              break;

    617. 

  617. 

    618. 

  618. #if OS_FLAG_WAIT_CLR_EN > 0

    619. 

  619.         case OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */

    620. 

  620.              flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags; /* Extract only the bits we want        */

    621. 

  621.              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */

    622. 

  622.                  if (consume == TRUE) {                    /* See if we need to consume the flags      */

    623. 

  623.                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we wanted        */

    624. 

  624.                  }

    625. 

  625.                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */

    626. 

  626.                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */

    627. 

  627.                  *err                    = OS_NO_ERR;

    628. 

  628.                  return (flags_rdy);

    629. 

  629.              } else {                                      /* Block task until events occur or timeout */

    630. 

  630.                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);

    631. 

  631.                  OS_EXIT_CRITICAL();

    632. 

  632.              }

    633. 

  633.              break;

    634. 

  634. 

    635. 

  635.         case OS_FLAG_WAIT_CLR_ANY:

    636. 

  636.              flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags; /* Extract only the bits we want        */

    637. 

  637.              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */

    638. 

  638.                  if (consume == TRUE) {                    /* See if we need to consume the flags      */

    639. 

  639.                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we got           */

    640. 

  640.                  }

    641. 

  641.                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */

    642. 

  642.                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */

    643. 

  643.                  *err                    = OS_NO_ERR;

    644. 

  644.                  return (flags_rdy);

    645. 

  645.              } else {                                      /* Block task until events occur or timeout */

    646. 

  646.                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);

    647. 

  647.                  OS_EXIT_CRITICAL();

    648. 

  648.              }

    649. 

  649.              break;

    650. 

  650. #endif

    651. 

  651. 

    652. 

  652.         default:

    653. 

  653.              OS_EXIT_CRITICAL();

    654. 

  654.              flags_rdy = (OS_FLAGS)0;

    655. 

  655.              *err      = OS_FLAG_ERR_WAIT_TYPE;

    656. 

  656.              return (flags_rdy);

    657. 

  657.     }

    658. 

  658.     OS_Sched();                                            /* Find next HPT ready to run               */

    659. 

  659.     OS_ENTER_CRITICAL();

    660. 

  660.     if (OSTCBCur->OSTCBPendTO == TRUE) {                   /* Have we timed-out?                       */

    661. 

  661.         OSTCBCur->OSTCBPendTO = FALSE;

    662. 

  662.         OS_FlagUnlink(&node);

    663. 

  663.         OSTCBCur->OSTCBStat   = OS_STAT_RDY;               /* Yes, make task ready-to-run              */

    664. 

  664.         OS_EXIT_CRITICAL();

    665. 

  665.         flags_rdy             = (OS_FLAGS)0;

    666. 

  666.         *err                  = OS_TIMEOUT;                /* Indicate that we timed-out waiting       */

    667. 

  667.         return (flags_rdy);

    668. 

  668.     }

    669. 

  669.     flags_rdy = OSTCBCur->OSTCBFlagsRdy;

    670. 

  670.     if (consume == TRUE) {                                 /* See if we need to consume the flags      */

    671. 

  671.         switch (wait_type) {

    672. 

  672.             case OS_FLAG_WAIT_SET_ALL:

    673. 

  673.             case OS_FLAG_WAIT_SET_ANY:                     /* Clear ONLY the flags we got              */

    674. 

  674.                  pgrp->OSFlagFlags &= ~flags_rdy;

    675. 

  675.                  break;

    676. 

  676. 

    677. 

  677. #if OS_FLAG_WAIT_CLR_EN > 0

    678. 

  678.             case OS_FLAG_WAIT_CLR_ALL:

    679. 

  679.             case OS_FLAG_WAIT_CLR_ANY:                     /* Set   ONLY the flags we got              */

    680. 

  680.                  pgrp->OSFlagFlags |=  flags_rdy;

    681. 

  681.                  break;

    682. 

  682. #endif

    683. 

  683.             default:

    684. 

  684.                  OS_EXIT_CRITICAL();

    685. 

  685.                  *err = OS_FLAG_ERR_WAIT_TYPE;

    686. 

  686.                  return ((OS_FLAGS)0);

    687. 

  687.         }

    688. 

  688.     }

    689. 

  689.     OS_EXIT_CRITICAL();

    690. 

  690.     *err = OS_NO_ERR;                                      /* Event(s) must have occurred              */

    691. 

  691.     return (flags_rdy);

    692. 

  692. }

    693. 

  693. /*$PAGE*/

    694. 

  694. /*

    695. 

  695. *********************************************************************************************************

    696. 

  696. *                               GET FLAGS WHO CAUSED TASK TO BECOME READY

    697. 

  697. *

    698. 

  698. * Description: This function is called to obtain the flags that caused the task to become ready to run.

    699. 

  699. *              In other words, this function allows you to tell "Who done it!".

    700. 

  700. *

    701. 

  701. * Arguments  : None

    702. 

  702. *

    703. 

  703. * Returns    : The flags that caused the task to be ready.

    704. 

  704. *

    705. 

  705. * Called from: Task ONLY

    706. 

  706. *********************************************************************************************************

    707. 

  707. */

    708. 

  708. 

    709. 

  709. OS_FLAGS  OSFlagPendGetFlagsRdy (void)

    710. 

  710. {

    711. 

  711.     OS_FLAGS      flags;

    712. 

  712. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */

    713. 

  713.     OS_CPU_SR     cpu_sr = 0;

    714. 

  714. #endif

    715. 

  715. 

    716. 

  716. 

    717. 

  717. 

    718. 

  718.     OS_ENTER_CRITICAL();

    719. 

  719.     flags = OSTCBCur->OSTCBFlagsRdy;

    720. 

  720.     OS_EXIT_CRITICAL();

    721. 

  721.     return (flags);

    722. 

  722. }

    723. 

  723. 

    724. 

  724. /*$PAGE*/

    725. 

  725. /*

    726. 

  726. *********************************************************************************************************

    727. 

  727. *                                         POST EVENT FLAG BIT(S)

    728. 

  728. *

    729. 

  729. * Description: This function is called to set or clear some bits in an event flag group.  The bits to

    730. 

  730. *              set or clear are specified by a 'bit mask'.

    731. 

  731. *

    732. 

  732. * Arguments  : pgrp          is a pointer to the desired event flag group.

    733. 

  733. *

    734. 

  734. *              flags         If 'opt' (see below) is OS_FLAG_SET, each bit that is set in 'flags' will

    735. 

  735. *                            set the corresponding bit in the event flag group.  e.g. to set bits 0, 4

    736. 

  736. *                            and 5 you would set 'flags' to:

    737. 

  737. *

    738. 

  738. *                                0x31     (note, bit 0 is least significant bit)

    739. 

  739. *

    740. 

  740. *                            If 'opt' (see below) is OS_FLAG_CLR, each bit that is set in 'flags' will

    741. 

  741. *                            CLEAR the corresponding bit in the event flag group.  e.g. to clear bits 0,

    742. 

  742. *                            4 and 5 you would specify 'flags' as:

    743. 

  743. *

    744. 

  744. *                                0x31     (note, bit 0 is least significant bit)

    745. 

  745. *

    746. 

  746. *              opt           indicates whether the flags will be:

    747. 

  747. *                                set     (OS_FLAG_SET) or

    748. 

  748. *                                cleared (OS_FLAG_CLR)

    749. 

  749. *

    750. 

  750. *              err           is a pointer to an error code and can be:

    751. 

  751. *                            OS_NO_ERR              The call was successfull

    752. 

  752. *                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer

    753. 

  753. *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group

    754. 

  754. *                            OS_FLAG_INVALID_OPT    You specified an invalid option

    755. 

  755. *

    756. 

  756. * Returns    : the new value of the event flags bits that are still set.

    757. 

  757. *

    758. 

  758. * Called From: Task or ISR

    759. 

  759. *

    760. 

  760. * WARNING(s) : 1) The execution time of this function depends on the number of tasks waiting on the event

    761. 

  761. *                 flag group.

    762. 

  762. *              2) The amount of time interrupts are DISABLED depends on the number of tasks waiting on

    763. 

  763. *                 the event flag group.

    764. 

  764. *********************************************************************************************************

    765. 

  765. */

    766. 

  766. OS_FLAGS  OSFlagPost (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U opt, INT8U *err)

    767. 

  767. {

    768. 

  768.     OS_FLAG_NODE *pnode;

    769. 

  769.     BOOLEAN       sched;

    770. 

  770.     OS_FLAGS      flags_cur;

    771. 

  771.     OS_FLAGS      flags_rdy;

    772. 

  772.     BOOLEAN       rdy;

    773. 

  773. #if OS_CRITICAL_METHOD == 3                          /* Allocate storage for CPU status register       */

    774. 

  774.     OS_CPU_SR     cpu_sr = 0;

    775. 

  775. #endif

    776. 

  776. 

    777. 

  777. 

    778. 

  778. 

    779. 

  779. #if OS_ARG_CHK_EN > 0

    780. 

  780.     if (err == (INT8U *)0) {                         /* Validate 'err'                                 */

    781. 

  781.         return ((OS_FLAGS)0);

    782. 

  782.     }

    783. 

  783.     if (pgrp == (OS_FLAG_GRP *)0) {                  /* Validate 'pgrp'                                */

    784. 

  784.         *err = OS_FLAG_INVALID_PGRP;

    785. 

  785.         return ((OS_FLAGS)0);

    786. 

  786.     }

    787. 

  787. #endif

    788. 

  788.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {    /* Make sure we are pointing to an event flag grp */

    789. 

  789.         *err = OS_ERR_EVENT_TYPE;

    790. 

  790.         return ((OS_FLAGS)0);

    791. 

  791.     }

    792. 

  792. /*$PAGE*/

    793. 

  793.     OS_ENTER_CRITICAL();

    794. 

  794.     switch (opt) {

    795. 

  795.         case OS_FLAG_CLR:

    796. 

  796.              pgrp->OSFlagFlags &= ~flags;            /* Clear the flags specified in the group         */

    797. 

  797.              break;

    798. 

  798. 

    799. 

  799.         case OS_FLAG_SET:

    800. 

  800.              pgrp->OSFlagFlags |=  flags;            /* Set   the flags specified in the group         */

    801. 

  801.              break;

    802. 

  802. 

    803. 

  803.         default:

    804. 

  804.              OS_EXIT_CRITICAL();                     /* INVALID option                                 */

    805. 

  805.              *err = OS_FLAG_INVALID_OPT;

    806. 

  806.              return ((OS_FLAGS)0);

    807. 

  807.     }

    808. 

  808.     sched = FALSE;                                   /* Indicate that we don't need rescheduling       */

    809. 

  809.     pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;

    810. 

  810.     while (pnode != (OS_FLAG_NODE *)0) {             /* Go through all tasks waiting on event flag(s)  */

    811. 

  811.         switch (pnode->OSFlagNodeWaitType) {

    812. 

  812.             case OS_FLAG_WAIT_SET_ALL:               /* See if all req. flags are set for current node */

    813. 

  813.                  flags_rdy = pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;

    814. 

  814.                  if (flags_rdy == pnode->OSFlagNodeFlags) {

    815. 

  815.                      rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */

    816. 

  816.                      if (rdy == TRUE) {

    817. 

  817.                          sched = TRUE;                        /* When done we will reschedule          */

    818. 

  818.                      }

    819. 

  819.                  }

    820. 

  820.                  break;

    821. 

  821. 

    822. 

  822.             case OS_FLAG_WAIT_SET_ANY:               /* See if any flag set                            */

    823. 

  823.                  flags_rdy = pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;

    824. 

  824.                  if (flags_rdy != (OS_FLAGS)0) {

    825. 

  825.                      rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */

    826. 

  826.                      if (rdy == TRUE) {

    827. 

  827.                          sched = TRUE;                        /* When done we will reschedule          */

    828. 

  828.                      }

    829. 

  829.                  }

    830. 

  830.                  break;

    831. 

  831. 

    832. 

  832. #if OS_FLAG_WAIT_CLR_EN > 0

    833. 

  833.             case OS_FLAG_WAIT_CLR_ALL:               /* See if all req. flags are set for current node */

    834. 

  834.                  flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;

    835. 

  835.                  if (flags_rdy == pnode->OSFlagNodeFlags) {

    836. 

  836.                      rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */

    837. 

  837.                      if (rdy == TRUE) {

    838. 

  838.                          sched = TRUE;                        /* When done we will reschedule          */

    839. 

  839.                      }

    840. 

  840.                  }

    841. 

  841.                  break;

    842. 

  842. 

    843. 

  843.             case OS_FLAG_WAIT_CLR_ANY:               /* See if any flag set                            */

    844. 

  844.                  flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;

    845. 

  845.                  if (flags_rdy != (OS_FLAGS)0) {

    846. 

  846.                      rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */

    847. 

  847.                      if (rdy == TRUE) {

    848. 

  848.                          sched = TRUE;                        /* When done we will reschedule          */

    849. 

  849.                      }

    850. 

  850.                  }

    851. 

  851.                  break;

    852. 

  852. #endif

    853. 

  853.             default:

    854. 

  854.                  OS_EXIT_CRITICAL();

    855. 

  855.                  *err = OS_FLAG_ERR_WAIT_TYPE;

    856. 

  856.                  return ((OS_FLAGS)0);

    857. 

  857.         }

    858. 

  858.         pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext; /* Point to next task waiting for event flag(s) */

    859. 

  859.     }

    860. 

  860.     OS_EXIT_CRITICAL();

    861. 

  861.     if (sched == TRUE) {

    862. 

  862.         OS_Sched();

    863. 

  863.     }

    864. 

  864.     OS_ENTER_CRITICAL();

    865. 

  865.     flags_cur = pgrp->OSFlagFlags;

    866. 

  866.     OS_EXIT_CRITICAL();

    867. 

  867.     *err      = OS_NO_ERR;

    868. 

  868.     return (flags_cur);

    869. 

  869. }

    870. 

  870. /*$PAGE*/

    871. 

  871. /*

    872. 

  872. *********************************************************************************************************

    873. 

  873. *                                           QUERY EVENT FLAG

    874. 

  874. *

    875. 

  875. * Description: This function is used to check the value of the event flag group.

    876. 

  876. *

    877. 

  877. * Arguments  : pgrp         is a pointer to the desired event flag group.

    878. 

  878. *

    879. 

  879. *              err           is a pointer to an error code returned to the called:

    880. 

  880. *                            OS_NO_ERR              The call was successfull

    881. 

  881. *                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer

    882. 

  882. *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group

    883. 

  883. *

    884. 

  884. * Returns    : The current value of the event flag group.

    885. 

  885. *

    886. 

  886. * Called From: Task or ISR

    887. 

  887. *********************************************************************************************************

    888. 

  888. */

    889. 

  889. 

    890. 

  890. #if OS_FLAG_QUERY_EN > 0

    891. 

  891. OS_FLAGS  OSFlagQuery (OS_FLAG_GRP *pgrp, INT8U *err)

    892. 

  892. {

    893. 

  893.     OS_FLAGS   flags;

    894. 

  894. #if OS_CRITICAL_METHOD == 3                       /* Allocate storage for CPU status register          */

    895. 

  895.     OS_CPU_SR  cpu_sr = 0;

    896. 

  896. #endif

    897. 

  897. 

    898. 

  898. 

    899. 

  899. 

    900. 

  900. #if OS_ARG_CHK_EN > 0

    901. 

  901.     if (err == (INT8U *)0) {                      /* Validate 'err'                                    */

    902. 

  902.         return ((OS_FLAGS)0);

    903. 

  903.     }

    904. 

  904.     if (pgrp == (OS_FLAG_GRP *)0) {               /* Validate 'pgrp'                                   */

    905. 

  905.         *err = OS_FLAG_INVALID_PGRP;

    906. 

  906.         return ((OS_FLAGS)0);

    907. 

  907.     }

    908. 

  908. #endif

    909. 

  909.     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type                         */

    910. 

  910.         *err = OS_ERR_EVENT_TYPE;

    911. 

  911.         return ((OS_FLAGS)0);

    912. 

  912.     }

    913. 

  913.     OS_ENTER_CRITICAL();

    914. 

  914.     flags = pgrp->OSFlagFlags;

    915. 

  915.     OS_EXIT_CRITICAL();

    916. 

  916.     *err = OS_NO_ERR;

    917. 

  917.     return (flags);                               /* Return the current value of the event flags       */

    918. 

  918. }

    919. 

  919. #endif

    920. 

  920. 

    921. 

  921. /*$PAGE*/

    922. 

  922. /*

    923. 

  923. *********************************************************************************************************

    924. 

  924. *                         SUSPEND TASK UNTIL EVENT FLAG(s) RECEIVED OR TIMEOUT OCCURS

    925. 

  925. *

    926. 

  926. * Description: This function is internal to uC/OS-II and is used to put a task to sleep until the desired

    927. 

  927. *              event flag bit(s) are set.

    928. 

  928. *

    929. 

  929. * Arguments  : pgrp          is a pointer to the desired event flag group.

    930. 

  930. *

    931. 

  931. *              pnode         is a pointer to a structure which contains data about the task waiting for

    932. 

  932. *                            event flag bit(s) to be set.

    933. 

  933. *

    934. 

  934. *              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to check.

    935. 

  935. *                            The bits you want are specified by setting the corresponding bits in

    936. 

  936. *                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then

    937. 

  937. *                            'flags' would contain 0x03.

    938. 

  938. *

    939. 

  939. *              wait_type     specifies whether you want ALL bits to be set/cleared or ANY of the bits

    940. 

  940. *                            to be set/cleared.

    941. 

  941. *                            You can specify the following argument:

    942. 

  942. *

    943. 

  943. *                            OS_FLAG_WAIT_CLR_ALL   You will check ALL bits in 'mask' to be clear (0)

    944. 

  944. *                            OS_FLAG_WAIT_CLR_ANY   You will check ANY bit  in 'mask' to be clear (0)

    945. 

  945. *                            OS_FLAG_WAIT_SET_ALL   You will check ALL bits in 'mask' to be set   (1)

    946. 

  946. *                            OS_FLAG_WAIT_SET_ANY   You will check ANY bit  in 'mask' to be set   (1)

    947. 

  947. *

    948. 

  948. *              timeout       is the desired amount of time that the task will wait for the event flag

    949. 

  949. *                            bit(s) to be set.

    950. 

  950. *

    951. 

  951. * Returns    : none

    952. 

  952. *

    953. 

  953. * Called by  : OSFlagPend()  OS_FLAG.C

    954. 

  954. *

    955. 

  955. * Note(s)    : This function is INTERNAL to uC/OS-II and your application should not call it.

    956. 

  956. *********************************************************************************************************

    957. 

  957. */

    958. 

  958. 

    959. 

  959. static  void  OS_FlagBlock (OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout)

    960. 

  960. {

    961. 

  961.     OS_FLAG_NODE  *pnode_next;

    962. 

  962.     INT8U          y;

    963. 

  963. 

    964. 

  964. 

    965. 

  965.     OSTCBCur->OSTCBStat      |= OS_STAT_FLAG;

    966. 

  966.     OSTCBCur->OSTCBPendTO     = FALSE;

    967. 

  967.     OSTCBCur->OSTCBDly        = timeout;              /* Store timeout in task's TCB                   */

    968. 

  968.     OSTCBCur->OSTCBEventPtr   = (OS_EVENT *)0;

    969. 

  969. #if OS_TASK_DEL_EN > 0

    970. 

  970.     OSTCBCur->OSTCBFlagNode   = pnode;                /* TCB to link to node                           */

    971. 

  971. #endif

    972. 

  972.     pnode->OSFlagNodeFlags    = flags;                /* Save the flags that we need to wait for       */

    973. 

  973.     pnode->OSFlagNodeWaitType = wait_type;            /* Save the type of wait we are doing            */

    974. 

  974.     pnode->OSFlagNodeTCB      = (void *)OSTCBCur;     /* Link to task's TCB                            */

    975. 

  975.     pnode->OSFlagNodeNext     = pgrp->OSFlagWaitList; /* Add node at beginning of event flag wait list */

    976. 

  976.     pnode->OSFlagNodePrev     = (void *)0;

    977. 

  977.     pnode->OSFlagNodeFlagGrp  = (void *)pgrp;         /* Link to Event Flag Group                      */

    978. 

  978.     pnode_next                = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;

    979. 

  979.     if (pnode_next != (void *)0) {                    /* Is this the first NODE to insert?             */

    980. 

  980.         pnode_next->OSFlagNodePrev = pnode;           /* No, link in doubly linked list                */

    981. 

  981.     }

    982. 

  982.     pgrp->OSFlagWaitList = (void *)pnode;

    983. 

  983. 

    984. 

  984.     y            =  OSTCBCur->OSTCBY;                 /* Suspend current task until flag(s) received   */

    985. 

  985.     OSRdyTbl[y] &= ~OSTCBCur->OSTCBBitX;

    986. 

  986.     if (OSRdyTbl[y] == 0x00) {

    987. 

  987.         OSRdyGrp &= ~OSTCBCur->OSTCBBitY;

    988. 

  988.     }

    989. 

  989. }

    990. 

  990. 

    991. 

  991. /*$PAGE*/

    992. 

  992. /*

    993. 

  993. *********************************************************************************************************

    994. 

  994. *                                    INITIALIZE THE EVENT FLAG MODULE

    995. 

  995. *

    996. 

  996. * Description: This function is called by uC/OS-II to initialize the event flag module.  Your application

    997. 

  997. *              MUST NOT call this function.  In other words, this function is internal to uC/OS-II.

    998. 

  998. *

    999. 

  999. * Arguments  : none

    1000. 

  1000. *

    1001. 

  1001. * Returns    : none

    1002. 

  1002. *

    1003. 

  1003. * WARNING    : You MUST NOT call this function from your code.  This is an INTERNAL function to uC/OS-II.

    1004. 

  1004. *********************************************************************************************************

    1005. 

  1005. */

    1006. 

  1006. 

    1007. 

  1007. void  OS_FlagInit (void)

    1008. 

  1008. {

    1009. 

  1009. #if OS_MAX_FLAGS == 1

    1010. 

  1010.     OSFlagFreeList                 = (OS_FLAG_GRP *)&OSFlagTbl[0];  /* Only ONE event flag group!      */

    1011. 

  1011.     OSFlagFreeList->OSFlagType     = OS_EVENT_TYPE_UNUSED;

    1012. 

  1012.     OSFlagFreeList->OSFlagWaitList = (void *)0;

    1013. 

  1013.     OSFlagFreeList->OSFlagFlags    = (OS_FLAGS)0;

    1014. 

  1014. #if OS_FLAG_NAME_SIZE > 1

    1015. 

  1015.     OSFlagFreeList->OSFlagName[0]  = '?';

    1016. 

  1016.     OSFlagFreeList->OSFlagName[1]  = OS_ASCII_NUL;

    1017. 

  1017. #endif

    1018. 

  1018. #endif

    1019. 

  1019. 

    1020. 

  1020. #if OS_MAX_FLAGS >= 2

    1021. 

  1021.     INT16U       i;

    1022. 

  1022.     OS_FLAG_GRP *pgrp1;

    1023. 

  1023.     OS_FLAG_GRP *pgrp2;

    1024. 

  1024. 

    1025. 

  1025. 

    1026. 

  1026.     OS_MemClr((INT8U *)&OSFlagTbl[0], sizeof(OSFlagTbl));           /* Clear the flag group table      */

    1027. 

  1027.     pgrp1 = &OSFlagTbl[0];

    1028. 

  1028.     pgrp2 = &OSFlagTbl[1];

    1029. 

  1029.     for (i = 0; i < (OS_MAX_FLAGS - 1); i++) {                      /* Init. list of free EVENT FLAGS  */

    1030. 

  1030.         pgrp1->OSFlagType     = OS_EVENT_TYPE_UNUSED;

    1031. 

  1031.         pgrp1->OSFlagWaitList = (void *)pgrp2;

    1032. 

  1032. #if OS_FLAG_NAME_SIZE > 1

    1033. 

  1033.         pgrp1->OSFlagName[0]  = '?';                                /* Unknown name                    */

    1034. 

  1034.         pgrp1->OSFlagName[1]  = OS_ASCII_NUL;

    1035. 

  1035. #endif

    1036. 

  1036.         pgrp1++;

    1037. 

  1037.         pgrp2++;

    1038. 

  1038.     }

    1039. 

  1039.     pgrp1->OSFlagType     = OS_EVENT_TYPE_UNUSED;

    1040. 

  1040.     pgrp1->OSFlagWaitList = (void *)0;

    1041. 

  1041. #if OS_FLAG_NAME_SIZE > 1

    1042. 

  1042.     pgrp1->OSFlagName[0]  = '?';                                    /* Unknown name                    */

    1043. 

  1043.     pgrp1->OSFlagName[1]  = OS_ASCII_NUL;

    1044. 

  1044. #endif

    1045. 

  1045.     OSFlagFreeList        = &OSFlagTbl[0];

    1046. 

  1046. #endif

    1047. 

  1047. }

    1048. 

  1048. 

    1049. 

  1049. /*$PAGE*/

    1050. 

  1050. /*

    1051. 

  1051. *********************************************************************************************************

    1052. 

  1052. *                              MAKE TASK READY-TO-RUN, EVENT(s) OCCURRED

    1053. 

  1053. *

    1054. 

  1054. * Description: This function is internal to uC/OS-II and is used to make a task ready-to-run because the

    1055. 

  1055. *              desired event flag bits have been set.

    1056. 

  1056. *

    1057. 

  1057. * Arguments  : pnode         is a pointer to a structure which contains data about the task waiting for

    1058. 

  1058. *                            event flag bit(s) to be set.

    1059. 

  1059. *

    1060. 

  1060. *              flags_rdy     contains the bit pattern of the event flags that cause the task to become

    1061. 

  1061. *                            ready-to-run.

    1062. 

  1062. *

    1063. 

  1063. * Returns    : TRUE          If the task has been placed in the ready list and thus needs scheduling

    1064. 

  1064. *              FALSE         The task is still not ready to run and thus scheduling is not necessary

    1065. 

  1065. *

    1066. 

  1066. * Called by  : OSFlagsPost() OS_FLAG.C

    1067. 

  1067. *

    1068. 

  1068. * Note(s)    : 1) This function assumes that interrupts are disabled.

    1069. 

  1069. *              2) This function is INTERNAL to uC/OS-II and your application should not call it.

    1070. 

  1070. *********************************************************************************************************

    1071. 

  1071. */

    1072. 

  1072. 

    1073. 

  1073. static  BOOLEAN  OS_FlagTaskRdy (OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy)

    1074. 

  1074. {

    1075. 

  1075.     OS_TCB   *ptcb;

    1076. 

  1076.     BOOLEAN   sched;

    1077. 

  1077. 

    1078. 

  1078. 

    1079. 

  1079.     ptcb                = (OS_TCB *)pnode->OSFlagNodeTCB;  /* Point to TCB of waiting task             */

    1080. 

  1080.     ptcb->OSTCBDly      = 0;

    1081. 

  1081.     ptcb->OSTCBFlagsRdy = flags_rdy;

    1082. 

  1082.     ptcb->OSTCBStat    &= ~OS_STAT_FLAG;

    1083. 

  1083.     ptcb->OSTCBPendTO   = FALSE;

    1084. 

  1084.     if (ptcb->OSTCBStat == OS_STAT_RDY) {                  /* Task now ready?                          */

    1085. 

  1085.         OSRdyGrp               |= ptcb->OSTCBBitY;         /* Put task into ready list                 */

    1086. 

  1086.         OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;

    1087. 

  1087.         sched                   = TRUE;

    1088. 

  1088.     } else {

    1089. 

  1089.         sched                   = FALSE;

    1090. 

  1090.     }

    1091. 

  1091.     OS_FlagUnlink(pnode);

    1092. 

  1092.     return (sched);

    1093. 

  1093. }

    1094. 

  1094. 

    1095. 

  1095. /*$PAGE*/

    1096. 

  1096. /*

    1097. 

  1097. *********************************************************************************************************

    1098. 

  1098. *                                  UNLINK EVENT FLAG NODE FROM WAITING LIST

    1099. 

  1099. *

    1100. 

  1100. * Description: This function is internal to uC/OS-II and is used to unlink an event flag node from a

    1101. 

  1101. *              list of tasks waiting for the event flag.

    1102. 

  1102. *

    1103. 

  1103. * Arguments  : pnode         is a pointer to a structure which contains data about the task waiting for

    1104. 

  1104. *                            event flag bit(s) to be set.

    1105. 

  1105. *

    1106. 

  1106. * Returns    : none

    1107. 

  1107. *

    1108. 

  1108. * Called by  : OS_FlagTaskRdy() OS_FLAG.C

    1109. 

  1109. *              OSFlagPend()     OS_FLAG.C

    1110. 

  1110. *              OSTaskDel()      OS_TASK.C

    1111. 

  1111. *

    1112. 

  1112. * Note(s)    : 1) This function assumes that interrupts are disabled.

    1113. 

  1113. *              2) This function is INTERNAL to uC/OS-II and your application should not call it.

    1114. 

  1114. *********************************************************************************************************

    1115. 

  1115. */

    1116. 

  1116. 

    1117. 

  1117. void  OS_FlagUnlink (OS_FLAG_NODE *pnode)

    1118. 

  1118. {

    1119. 

  1119. #if OS_TASK_DEL_EN > 0

    1120. 

  1120.     OS_TCB       *ptcb;

    1121. 

  1121. #endif

    1122. 

  1122.     OS_FLAG_GRP  *pgrp;

    1123. 

  1123.     OS_FLAG_NODE *pnode_prev;

    1124. 

  1124.     OS_FLAG_NODE *pnode_next;

    1125. 

  1125. 

    1126. 

  1126. 

    1127. 

  1127.     pnode_prev = (OS_FLAG_NODE *)pnode->OSFlagNodePrev;

    1128. 

  1128.     pnode_next = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;

    1129. 

  1129.     if (pnode_prev == (OS_FLAG_NODE *)0) {                      /* Is it first node in wait list?      */

    1130. 

  1130.         pgrp                 = (OS_FLAG_GRP *)pnode->OSFlagNodeFlagGrp;

    1131. 

  1131.         pgrp->OSFlagWaitList = (void *)pnode_next;              /*      Update list for new 1st node   */

    1132. 

  1132.         if (pnode_next != (OS_FLAG_NODE *)0) {

    1133. 

  1133.             pnode_next->OSFlagNodePrev = (OS_FLAG_NODE *)0;     /*      Link new 1st node PREV to NULL */

    1134. 

  1134.         }

    1135. 

  1135.     } else {                                                    /* No,  A node somewhere in the list   */

    1136. 

  1136.         pnode_prev->OSFlagNodeNext = pnode_next;                /*      Link around the node to unlink */

    1137. 

  1137.         if (pnode_next != (OS_FLAG_NODE *)0) {                  /*      Was this the LAST node?        */

    1138. 

  1138.             pnode_next->OSFlagNodePrev = pnode_prev;            /*      No, Link around current node   */

    1139. 

  1139.         }

    1140. 

  1140.     }

    1141. 

  1141. #if OS_TASK_DEL_EN > 0

    1142. 

  1142.     ptcb                = (OS_TCB *)pnode->OSFlagNodeTCB;

    1143. 

  1143.     ptcb->OSTCBFlagNode = (OS_FLAG_NODE *)0;

    1144. 

  1144. #endif

    1145. 

  1145. }

    1146. 

  1146. #endif

    1147. 

  1147.