📄 ucosii.lst
字号:
(0357) * desired bit combination. If you specify 0, however, your task will wait
(0358) * forever at the specified event flag group or, until a message arrives.
(0359) *
(0360) * err is a pointer to an error code and can be:
(0361) * OS_NO_ERR The desired bits have been set within the specified
(0362) * 'timeout'.
(0363) * OS_ERR_PEND_ISR If you tried to PEND from an ISR
(0364) * OS_FLAG_INVALID_PGRP If 'pgrp' is a NULL pointer.
(0365) * OS_ERR_EVENT_TYPE You are not pointing to an event flag group
(0366) * OS_TIMEOUT The bit(s) have not been set in the specified
(0367) * 'timeout'.
(0368) * OS_FLAG_ERR_WAIT_TYPE You didn't specify a proper 'wait_type' argument.
(0369) *
(0370) * Returns : The new state of the flags in the event flag group when the task is resumed or,
(0371) * 0 if a timeout or an error occurred.
(0372) *
(0373) * Called from: Task ONLY
(0374) *********************************************************************************************************
(0375) */
(0376)
(0377) OS_FLAGS OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err)
(0378) {
(0379) #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
(0380) OS_CPU_SR cpu_sr;
(0381) #endif
(0382) OS_FLAG_NODE node;
(0383) OS_FLAGS flags_cur;
(0384) OS_FLAGS flags_rdy;
(0385) BOOLEAN consume;
(0386)
(0387)
(0388) if (OSIntNesting > 0) { /* See if called from ISR ... */
02C7 2422 CLR R2
02C8 9030032C LDS R3,OSIntNesting
02CA 1423 CP R2,R3
02CB F428 BCC 0x02D1
(0389) *err = OS_ERR_PEND_ISR; /* ... can't PEND from an ISR */
02CC E082 LDI R24,2
02CD 01FB MOVW R30,R22
02CE 8380 STD Z+0,R24
(0390) return ((OS_FLAGS)0);
02CF 2700 CLR R16
02D0 C161 RJMP 0x0432
(0391) }
(0392) #if OS_ARG_CHK_EN > 0
(0393) if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
02D1 2066 TST R6
02D2 F439 BNE 0x02DA
02D3 2077 TST R7
02D4 F429 BNE 0x02DA
(0394) *err = OS_FLAG_INVALID_PGRP;
02D5 E986 LDI R24,0x96
02D6 01FB MOVW R30,R22
02D7 8380 STD Z+0,R24
(0395) return ((OS_FLAGS)0);
02D8 2700 CLR R16
02D9 C158 RJMP 0x0432
(0396) }
(0397) if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type */
02DA 01F3 MOVW R30,R6
02DB 8180 LDD R24,Z+0
02DC 3085 CPI R24,5
02DD F029 BEQ 0x02E3
(0398) *err = OS_ERR_EVENT_TYPE;
02DE E081 LDI R24,1
02DF 01FB MOVW R30,R22
02E0 8380 STD Z+0,R24
(0399) return ((OS_FLAGS)0);
02E1 2700 CLR R16
02E2 C14F RJMP 0x0432
(0400) }
(0401) #endif
(0402) if (wait_type & OS_FLAG_CONSUME) { /* See if we need to consume the flags */
02E3 FEC7 SBRS R12,7
02E4 C006 RJMP 0x02EB
(0403) wait_type &= ~OS_FLAG_CONSUME;
02E5 2D8C MOV R24,R12
02E6 778F ANDI R24,0x7F
02E7 2EC8 MOV R12,R24
(0404) consume = TRUE;
02E8 24EE CLR R14
02E9 94E3 INC R14
(0405) } else {
02EA C001 RJMP 0x02EC
(0406) consume = FALSE;
02EB 24EE CLR R14
(0407) }
(0408) /*$PAGE*/
(0409) OS_ENTER_CRITICAL();
02EC 930A ST R16,-Y
02ED B70F IN R16,0x3F
02EE 94F8 BCLR 7
02EF 930F PUSH R16
02F0 9109 LD R16,Y+
(0410) switch (wait_type) {
02F1 2D4C MOV R20,R12
02F2 2755 CLR R21
02F3 3040 CPI R20,0
02F4 0745 CPC R20,R21
02F5 F409 BNE 0x02F7
02F6 C070 RJMP 0x0367
02F7 3041 CPI R20,1
02F8 E0E0 LDI R30,0
02F9 075E CPC R21,R30
02FA F409 BNE 0x02FC
02FB C09B RJMP 0x0397
02FC 3042 CPI R20,2
02FD E0E0 LDI R30,0
02FE 075E CPC R21,R30
02FF F031 BEQ 0x0306
0300 3043 CPI R20,3
0301 E0E0 LDI R30,0
0302 075E CPC R21,R30
0303 F409 BNE 0x0305
0304 C032 RJMP 0x0337
0305 C0C0 RJMP 0x03C6
(0411) case OS_FLAG_WAIT_SET_ALL: /* See if all required flags are set */
(0412) flags_rdy = pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
0306 01F3 MOVW R30,R6
0307 80A3 LDD R10,Z+3
0308 8C0A LDD R0,Y+26
0309 20A0 AND R10,R0
(0413) if (flags_rdy == flags) { /* Must match ALL the bits that we want */
030A 14A0 CP R10,R0
030B F4B1 BNE 0x0322
(0414) if (consume == TRUE) { /* See if we need to consume the flags */
030C 2D8E MOV R24,R14
030D 3081 CPI R24,1
030E F441 BNE 0x0317
(0415) pgrp->OSFlagFlags &= ~flags_rdy; /* Clear ONLY the flags that we wanted */
030F 01C3 MOVW R24,R6
0310 9603 ADIW R24,3
0311 2C4A MOV R4,R10
0312 9440 COM R4
0313 01FC MOVW R30,R24
0314 8050 LDD R5,Z+0
0315 2054 AND R5,R4
0316 8250 STD Z+0,R5
(0416) }
(0417) flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
0317 01F3 MOVW R30,R6
0318 8143 LDD R20,Z+3
(0418) OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
0319 930A ST R16,-Y
031A 910F POP R16
031B BF0F OUT 0x3F,R16
031C 9109 LD R16,Y+
(0419) *err = OS_NO_ERR;
031D 2422 CLR R2
031E 01FB MOVW R30,R22
031F 8220 STD Z+0,R2
(0420) return (flags_cur);
0320 2F04 MOV R16,R20
0321 C110 RJMP 0x0432
(0421) } else { /* Block task until events occur or timeout */
(0422) OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
0322 8C0E LDD R0,Y+30
0323 8C1F LDD R1,Y+31
0324 821D STD Y+5,R1
0325 820C STD Y+4,R0
0326 82CA STD Y+2,R12
0327 8C0A LDD R0,Y+26
0328 8208 STD Y+0,R0
0329 019E MOVW R18,R28
032A 5F2A SUBI R18,0xFA
032B 4F3F SBCI R19,0xFF
032C 0183 MOVW R16,R6
032D 930F PUSH R16
032E 931F PUSH R17
032F D1FC RCALL _OS_FlagBlock
0330 907F POP R7
0331 906F POP R6
(0423) OS_EXIT_CRITICAL();
0332 930A ST R16,-Y
0333 910F POP R16
0334 BF0F OUT 0x3F,R16
0335 9109 LD R16,Y+
(0424) }
(0425) break;
0336 C099 RJMP 0x03D0
(0426)
(0427) case OS_FLAG_WAIT_SET_ANY:
(0428) flags_rdy = pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
0337 01F3 MOVW R30,R6
0338 80A3 LDD R10,Z+3
0339 8C0A LDD R0,Y+26
033A 20A0 AND R10,R0
(0429) if (flags_rdy != (OS_FLAGS)0) { /* See if any flag set */
033B F0B1 BEQ 0x0352
(0430) if (consume == TRUE) { /* See if we need to consume the flags */
033C 2D8E MOV R24,R14
033D 3081 CPI R24,1
033E F441 BNE 0x0347
(0431) pgrp->OSFlagFlags &= ~flags_rdy; /* Clear ONLY the flags that we got */
033F 01C3 MOVW R24,R6
0340 9603 ADIW R24,3
0341 2C4A MOV R4,R10
0342 9440 COM R4
0343 01FC MOVW R30,R24
0344 8050 LDD R5,Z+0
0345 2054 AND R5,R4
0346 8250 STD Z+0,R5
(0432) }
(0433) flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
0347 01F3 MOVW R30,R6
0348 8143 LDD R20,Z+3
(0434) OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
0349 930A ST R16,-Y
034A 910F POP R16
034B BF0F OUT 0x3F,R16
034C 9109 LD R16,Y+
(0435) *err = OS_NO_ERR;
034D 2422 CLR R2
034E 01FB MOVW R30,R22
034F 8220 STD Z+0,R2
(0436) return (flags_cur);
0350 2F04 MOV R16,R20
0351 C0E0 RJMP 0x0432
(0437) } else { /* Block task until events occur or timeout */
(0438) OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
0352 8C0E LDD R0,Y+30
0353 8C1F LDD R1,Y+31
0354 821D STD Y+5,R1
0355 820C STD Y+4,R0
0356 82CA STD Y+2,R12
0357 8C0A LDD R0,Y+26
0358 8208 STD Y+0,R0
0359 019E MOVW R18,R28
035A 5F2A SUBI R18,0xFA
035B 4F3F SBCI R19,0xFF
035C 0183 MOVW R16,R6
035D 930F PUSH R16
035E 931F PUSH R17
035F D1CC RCALL _OS_FlagBlock
0360 907F POP R7
0361 906F POP R6
(0439) OS_EXIT_CRITICAL();
0362 930A ST R16,-Y
0363 910F POP R16
0364 BF0F OUT 0x3F,R16
0365 9109 LD R16,Y+
(0440) }
(0441) break;
0366 C069 RJMP 0x03D0
(0442)
(0443) #if OS_FLAG_WAIT_CLR_EN > 0
(0444) case OS_FLAG_WAIT_CLR_ALL: /* See if all required flags are cleared */
(0445) flags_rdy = ~pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
0367 01F3 MOVW R30,R6
0368 80A3 LDD R10,Z+3
0369 94A0 COM R10
036A 8C0A LDD R0,Y+26
036B 20A0 AND R10,R0
(0446) if (flags_rdy == flags) { /* Must match ALL the bits that we want */
036C 14A0 CP R10,R0
036D F4A1 BNE 0x0382
(0447) if (consume == TRUE) { /* See if we need to consume the flags */
036E 2D8E MOV R24,R14
036F 3081 CPI R24,1
0370 F431 BNE 0x0377
(0448) pgrp->OSFlagFlags |= flags_rdy; /* Set ONLY the flags that we wanted */
0371 01C3 MOVW R24,R6
0372 9603 ADIW R24,3
0373 01FC MOVW R30,R24
0374 8040 LDD R4,Z+0
0375 284A OR R4,R10
0376 8240 STD Z+0,R4
(0449) }
(0450) flags_cur = pgrp->OSFlagFlags; /* Will return the state of the group */
0377 01F3 MOVW R30,R6
0378 8143 LDD R20,Z+3
(0451) OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
0379 930A ST R16,-Y
037A 910F POP R16
037B BF0F OUT 0x3F,R16
037C 9109 LD R16,Y+
(0452) *err = OS_NO_ERR;
037D 2422 CLR R2
037E 01FB MOVW R30,R22
037F 8220 STD Z+0,R2
(0453) return (flags_cur);
0380 2F04 MOV R16,R20
0381 C0B0 RJMP 0x0432
(0454) } else { /* Block task until events occur or timeout */
(0455) OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
0382 8C0E LDD R0,Y+30
0383 8C1F LDD R1,Y+31
0384 821D STD Y+5,R1
0385 820C STD Y+4,R0
0386 82CA STD Y+2,R12
0387 8C0A LDD R0,Y+26
0388 8208 STD Y+0,R0
0389 019E MOVW R18,R28
038A 5F2A SUBI R18,0xFA
038B 4F3F SBCI R19,0xFF
038C 0183 MOVW R16,R6
038D 930F PUSH R16
038E 931F PUSH R17
038F D19C RCALL _OS_FlagBlock
0390 907F POP R7
0391 906F POP R6
(0456) OS_EXIT_CRITICAL();
0392 930A ST R16,-Y
0393 910F POP R16
0394 BF0F OUT 0x3F,R16
0395 9109 LD R16,Y+
(0457) }
(0458) break;
0396 C039 RJMP 0x03D0
(0459)
(0460) case OS_FLAG_WAIT_CLR_ANY:
(0461) flags_rdy = ~pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
0397 01F3 MOVW R30,R6
0398 80A3 LDD R10,Z+3
0399 94A0 COM R10
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -