📄 os_flag.s43
字号:
NAME os_flag(16)
RSEG CODE(1)
PUBLIC OSFlagAccept
PUBLIC OSFlagCreate
PUBLIC OSFlagDel
EXTERN OSFlagFreeList
PUBLIC OSFlagPend
PUBLIC OSFlagPost
PUBLIC OSFlagQuery
EXTERN OSFlagTbl
EXTERN OSIntNesting
EXTERN OSRdyGrp
EXTERN OSRdyTbl
EXTERN OSTCBCur
PUBLIC OS_FlagInit
PUBLIC OS_FlagUnlink
EXTERN OS_Sched
EXTERN ?CL430_1_26_L08
RSEG CODE
OSFlagAccept:
; 1. /*
; 2. *********************************************************************************************************
; 3. * uC/OS-II
; 4. * The Real-Time Kernel
; 5. * EVENT FLAG MANAGEMENT
; 6. *
; 7. * (c) Copyright 2001-2002, Jean J. Labrosse, Weston, FL
; 8. * All Rights Reserved
; 9. *
; 10. * File : OS_FLAG.C
; 11. * By : Jean J. Labrosse
; 12. *********************************************************************************************************
; 13. */
; 14.
; 15. #ifndef OS_MASTER_FILE
; 16. #include "INCLUDES.H"
; 17. #endif
; 18.
; 19. #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
; 20. /*
; 21. *********************************************************************************************************
; 22. * LOCAL PROTOTYPES
; 23. *********************************************************************************************************
; 24. */
; 25.
; 26. static void OS_FlagBlock(OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout);
; 27. static BOOLEAN OS_FlagTaskRdy(OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy);
; 28.
; 29. /*$PAGE*/
; 30. /*
; 31. *********************************************************************************************************
; 32. * CHECK THE STATUS OF FLAGS IN AN EVENT FLAG GROUP
; 33. *
; 34. * Description: This function is called to check the status of a combination of bits to be set or cleared
; 35. * in an event flag group. Your application can check for ANY bit to be set/cleared or ALL
; 36. * bits to be set/cleared.
; 37. *
; 38. * This call does not block if the desired flags are not present.
; 39. *
; 40. * Arguments : pgrp is a pointer to the desired event flag group.
; 41. *
; 42. * flags Is a bit pattern indicating which bit(s) (i.e. flags) you wish to check.
; 43. * The bits you want are specified by setting the corresponding bits in
; 44. * 'flags'. e.g. if your application wants to wait for bits 0 and 1 then
; 45. * 'flags' would contain 0x03.
; 46. *
; 47. * wait_type specifies whether you want ALL bits to be set/cleared or ANY of the bits
; 48. * to be set/cleared.
; 49. * You can specify the following argument:
; 50. *
; 51. * OS_FLAG_WAIT_CLR_ALL You will check ALL bits in 'flags' to be clear (0)
; 52. * OS_FLAG_WAIT_CLR_ANY You will check ANY bit in 'flags' to be clear (0)
; 53. * OS_FLAG_WAIT_SET_ALL You will check ALL bits in 'flags' to be set (1)
; 54. * OS_FLAG_WAIT_SET_ANY You will check ANY bit in 'flags' to be set (1)
; 55. *
; 56. * NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by
; 57. * the call. Example, to wait for any flag in a group AND then clear
; 58. * the flags that are present, set 'wait_type' to:
; 59. *
; 60. * OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME
; 61. *
; 62. * err is a pointer to an error code and can be:
; 63. * OS_NO_ERR No error
; 64. * OS_ERR_EVENT_TYPE You are not pointing to an event flag group
; 65. * OS_FLAG_ERR_WAIT_TYPE You didn't specify a proper 'wait_type' argument.
; 66. * OS_FLAG_INVALID_PGRP You passed a NULL pointer instead of the event flag
; 67. * group handle.
; 68. * OS_FLAG_ERR_NOT_RDY The desired flags you are waiting for are not
; 69. * available.
; 70. *
; 71. * Returns : The state of the flags in the event flag group.
; 72. *
; 73. * Called from: Task or ISR
; 74. *********************************************************************************************************
; 75. */
; 76.
; 77. #if OS_FLAG_ACCEPT_EN > 0
; 78. OS_FLAGS OSFlagAccept (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT8U *err)
; 79. {
PUSH R10
MOV.B 4(SP),R13
MOV 6(SP),R10
; 80. #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
; 81. OS_CPU_SR cpu_sr;
; 82. #endif
; 83. OS_FLAGS flags_cur;
; 84. OS_FLAGS flags_rdy;
; 85. BOOLEAN consume;
; 86.
; 87.
; 88. #if OS_ARG_CHK_EN > 0
; 89. if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
CMP #0,R12
JNE (?0059)
; 90. *err = OS_FLAG_INVALID_PGRP;
MOV.B #150,0(R10)
; 91. return ((OS_FLAGS)0);
; 92. }
JMP (?0091)
?0059:
; 93. if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type */
MOV.B #5,R15
CMP.B @R12,R15
JEQ (?0061)
; 94. *err = OS_ERR_EVENT_TYPE;
MOV.B #1,0(R10)
; 95. return ((OS_FLAGS)0);
MOV #0,R12
; 96. }
JMP (?0091)
?0061:
; 97. #endif
; 98. if (wait_type & OS_FLAG_CONSUME) { /* See if we need to consume the flags */
BIT.B #128,R13
JEQ (?0063)
; 99. wait_type &= ~OS_FLAG_CONSUME;
AND.B #127,R13
; 100. consume = TRUE;
MOV.B #1,R15
; 101. } else {
JMP (?0064)
?0063:
; 102. consume = FALSE;
MOV.B #0,R15
?0064:
; 103. }
; 104. /*$PAGE*/
; 105. *err = OS_NO_ERR; /* Assume NO error until proven otherwise. */
MOV.B #0,0(R10)
; 106. OS_ENTER_CRITICAL();
DINT
; 107. switch (wait_type) {
CMP #4,R13
JC (?0090)
ADD R13,R13
BR ?0217(R13)
?0217:
DW ?0078
DW ?0084
DW ?0066
DW ?0072
?0066:
; 108. case OS_FLAG_WAIT_SET_ALL: /* See if all required flags are set */
; 109. flags_rdy = pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
MOV 4(R12),R13
AND R14,R13
; 110. if (flags_rdy == flags) { /* Must match ALL the bits that we want */
CMP R13,R14
JNE (?0068)
; 111. if (consume == TRUE) { /* See if we need to consume the flags */
CMP.B #1,R15
JNE (?0071)
; 112. pgrp->OSFlagFlags &= ~flags_rdy; /* Clear ONLY the flags that we wanted */
XOR #-1,R13
AND R13,4(R12)
; 113. }
; 114. } else {
JMP (?0071)
?0068:
; 115. *err = OS_FLAG_ERR_NOT_RDY;
MOV.B #152,0(R10)
?0071:
; 116. }
; 117. flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
MOV 4(R12),R13
; 118. OS_EXIT_CRITICAL();
EINT
; 119. break;
JMP (?0065)
?0072:
; 120.
; 121. case OS_FLAG_WAIT_SET_ANY:
; 122. flags_rdy = pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
MOV 4(R12),R13
AND R14,R13
; 123. if (flags_rdy != (OS_FLAGS)0) { /* See if any flag set */
JEQ (?0074)
; 124. if (consume == TRUE) { /* See if we need to consume the flags */
CMP.B #1,R15
JNE (?0077)
; 125. pgrp->OSFlagFlags &= ~flags_rdy; /* Clear ONLY the flags that we got */
XOR #-1,R13
AND R13,4(R12)
; 126. }
; 127. } else {
JMP (?0077)
?0074:
; 128. *err = OS_FLAG_ERR_NOT_RDY;
MOV.B #152,0(R10)
?0077:
; 129. }
; 130. flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
MOV 4(R12),R13
; 131. OS_EXIT_CRITICAL();
EINT
; 132. break;
JMP (?0065)
?0078:
; 133.
; 134. #if OS_FLAG_WAIT_CLR_EN > 0
; 135. case OS_FLAG_WAIT_CLR_ALL: /* See if all required flags are cleared */
; 136. flags_rdy = ~pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
MOV 4(R12),R13
XOR #-1,R13
AND R14,R13
; 137. if (flags_rdy == flags) { /* Must match ALL the bits that we want */
CMP R13,R14
JNE (?0080)
; 138. if (consume == TRUE) { /* See if we need to consume the flags */
CMP.B #1,R15
JNE (?0083)
; 139. pgrp->OSFlagFlags |= flags_rdy; /* Set ONLY the flags that we wanted */
BIS R13,4(R12)
; 140. }
; 141. } else {
JMP (?0083)
?0080:
; 142. *err = OS_FLAG_ERR_NOT_RDY;
MOV.B #152,0(R10)
?0083:
; 143. }
; 144. flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
MOV 4(R12),R13
; 145. OS_EXIT_CRITICAL();
EINT
; 146. break;
JMP (?0065)
?0084:
; 147.
; 148. case OS_FLAG_WAIT_CLR_ANY:
; 149. flags_rdy = ~pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
MOV 4(R12),R13
XOR #-1,R13
AND R14,R13
; 150. if (flags_rdy != (OS_FLAGS)0) { /* See if any flag cleared */
JEQ (?0086)
; 151. if (consume == TRUE) { /* See if we need to consume the flags */
CMP.B #1,R15
JNE (?0089)
; 152. pgrp->OSFlagFlags |= flags_rdy; /* Set ONLY the flags that we got */
BIS R13,4(R12)
; 153. }
; 154. } else {
JMP (?0089)
?0086:
; 155. *err = OS_FLAG_ERR_NOT_RDY;
MOV.B #152,0(R10)
?0089:
; 156. }
; 157. flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
MOV 4(R12),R13
; 158. OS_EXIT_CRITICAL();
EINT
; 159. break;
JMP (?0065)
?0090:
; 160. #endif
; 161.
; 162. default:
; 163. OS_EXIT_CRITICAL();
EINT
; 164. flags_cur = (OS_FLAGS)0;
MOV #0,R13
; 165. *err = OS_FLAG_ERR_WAIT_TYPE;
MOV.B #151,0(R10)
; 166. break;
?0065:
; 167. }
; 168. return (flags_cur);
MOV R13,R12
; 169. }
?0091:
POP R10
RET
OSFlagCreate:
; 170. #endif
; 171.
; 172. /*$PAGE*/
; 173. /*
; 174. *********************************************************************************************************
; 175. * CREATE AN EVENT FLAG
; 176. *
; 177. * Description: This function is called to create an event flag group.
; 178. *
; 179. * Arguments : flags Contains the initial value to store in the event flag group.
; 180. *
; 181. * err is a pointer to an error code which will be returned to your application:
; 182. * OS_NO_ERR if the call was successful.
; 183. * OS_ERR_CREATE_ISR if you attempted to create an Event Flag from an
; 184. * ISR.
; 185. * OS_FLAG_GRP_DEPLETED if there are no more event flag groups
; 186. *
; 187. * Returns : A pointer to an event flag group or a NULL pointer if no more groups are available.
; 188. *
; 189. * Called from: Task ONLY
; 190. *********************************************************************************************************
; 191. */
; 192.
; 193. OS_FLAG_GRP *OSFlagCreate (OS_FLAGS flags, INT8U *err)
; 194. {
; 195. #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
; 196. OS_CPU_SR cpu_sr;
; 197. #endif
; 198. OS_FLAG_GRP *pgrp;
; 199.
; 200.
; 201. if (OSIntNesting > 0) { /* See if called from ISR ... */
CMP.B #0,&OSIntNesting
JEQ (?0093)
; 202. *err = OS_ERR_CREATE_ISR; /* ... can't CREATE from an ISR */
MOV.B #141,0(R14)
; 203. return ((OS_FLAG_GRP *)0);
MOV #0,R12
; 204. }
RET
?0093:
; 205. OS_ENTER_CRITICAL();
DINT
; 206. pgrp = OSFlagFreeList; /* Get next free event flag */
MOV &OSFlagFreeList,R13
; 207. if (pgrp != (OS_FLAG_GRP *)0) { /* See if we have event flag groups available */
CMP #0,R13
JEQ (?0095)
; 208. /* Adjust free list */
; 209. OSFlagFreeList = (OS_FLAG_GRP *)OSFlagFreeList->OSFlagWaitList;
MOV &OSFlagFreeList,R15
MOV 2(R15),&OSFlagFreeList
; 210. pgrp->OSFlagType = OS_EVENT_TYPE_FLAG; /* Set to event flag group type */
MOV.B #5,0(R13)
; 211. pgrp->OSFlagFlags = flags; /* Set to desired initial value */
MOV R12,4(R13)
; 212. pgrp->OSFlagWaitList = (void *)0; /* Clear list of tasks waiting on flags */
MOV #0,2(R13)
; 213. OS_EXIT_CRITICAL();
EINT
; 214. *err = OS_NO_ERR;
MOV.B #0,0(R14)
; 215. } else {
JMP (?0096)
?0095:
; 216. OS_EXIT_CRITICAL();
EINT
; 217. *err = OS_FLAG_GRP_DEPLETED;
MOV.B #154,0(R14)
?0096:
; 218. }
; 219. return (pgrp); /* Return pointer to event flag group */
MOV R13,R12
; 220. }
RET
OSFlagDel:
; 221.
; 222. /*$PAGE*/
; 223. /*
; 224. *********************************************************************************************************
; 225. * DELETE AN EVENT FLAG GROUP
; 226. *
; 227. * Description: This function deletes an event flag group and readies all tasks pending on the event flag
; 228. * group.
; 229. *
; 230. * Arguments : pgrp is a pointer to the desired event flag group.
; 231. *
; 232. * opt determines delete options as follows:
; 233. * opt == OS_DEL_NO_PEND Deletes the event flag group ONLY if no task pending
; 234. * opt == OS_DEL_ALWAYS Deletes the event flag group even if tasks are
; 235. * waiting. In this case, all the tasks pending will be
; 236. * readied.
; 237. *
; 238. * err is a pointer to an error code that can contain one of the following values:
; 239. * OS_NO_ERR The call was successful and the event flag group was
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -