📄 os_flag.s
字号:
xjmp L114
L126:
.dbline 616
;
; #if OS_FLAG_WAIT_CLR_EN > 0
; case OS_FLAG_WAIT_CLR_ALL: /* See if all req. flags are set for current node */
; flags_rdy = ~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
movw R30,R12
ldd R2,z+8
ldd R30,y+10
ldd R31,y+11
ldd R10,z+3
com R10
and R10,R2
.dbline 617
; if (flags_rdy == pnode->OSFlagNodeFlags) {
movw R30,R12
ldd R2,z+8
cp R10,R2
brne L114
.dbline 617
.dbline 618
; if (OS_FlagTaskRdy(pnode, flags_rdy) == TRUE) { /* Make task RTR, event(s) Rx'd */
mov R18,R10
movw R16,R12
xcall _OS_FlagTaskRdy
cpi R16,1
brne L114
.dbline 618
.dbline 619
; sched = TRUE; /* When done we will reschedule */
clr R14
inc R14
.dbline 620
; }
.dbline 621
; }
.dbline 622
; break;
xjmp L114
L131:
.dbline 625
;
; case OS_FLAG_WAIT_CLR_ANY: /* See if any flag set */
; flags_rdy = ~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
movw R30,R12
ldd R2,z+8
ldd R30,y+10
ldd R31,y+11
ldd R10,z+3
com R10
and R10,R2
.dbline 626
; if (flags_rdy != (OS_FLAGS)0) {
breq L114
.dbline 626
.dbline 627
; if (OS_FlagTaskRdy(pnode, flags_rdy) == TRUE) { /* Make task RTR, event(s) Rx'd */
mov R18,R10
movw R16,R12
xcall _OS_FlagTaskRdy
cpi R16,1
brne L114
.dbline 627
.dbline 628
; sched = TRUE; /* When done we will reschedule */
clr R14
inc R14
.dbline 629
; }
.dbline 630
; }
.dbline 631
; break;
L113:
L114:
.dbline 634
movw R30,R12
ldd R12,z+0
ldd R13,z+1
.dbline 635
L111:
.dbline 594
tst R12
breq X32
xjmp L110
X32:
tst R13
breq X33
xjmp L110
X33:
X25:
.dbline 636
; #endif
; }
; pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext; /* Point to next task waiting for event flag(s) */
; }
; OS_EXIT_CRITICAL();
st -y,r16
pop r16
out 0x3F,r16
ld r16,y+
.dbline 636
.dbline 637
; if (sched == TRUE) {
mov R24,R14
cpi R24,1
brne L136
.dbline 637
.dbline 638
; OS_Sched();
xcall _OS_Sched
.dbline 639
; }
L136:
.dbline 640
; OS_ENTER_CRITICAL();
st -y,r16
in r16,0x3F
cli
push r16
ld r16,y+
.dbline 640
.dbline 641
; flags_cur = pgrp->OSFlagFlags;
ldd R30,y+10
ldd R31,y+11
ldd R20,z+3
.dbline 642
; OS_EXIT_CRITICAL();
st -y,r16
pop r16
out 0x3F,r16
ld r16,y+
.dbline 642
.dbline 643
; *err = OS_NO_ERR;
clr R2
movw R30,R22
std z+0,R2
.dbline 644
; return (flags_cur);
mov R16,R20
.dbline -2
L100:
xcall pop_gset5
adiw R28,4
.dbline 0 ; func end
ret
.dbsym r flags_cur 20 c
.dbsym r sched 14 c
.dbsym r flags_rdy 10 c
.dbsym r pnode 12 pS[.2]
.dbsym r err 22 pc
.dbsym l opt 14 c
.dbsym r flags 20 c
.dbsym l pgrp 10 pS[.1]
.dbend
.dbfunc e OSFlagQuery _OSFlagQuery fc
; flags -> R20
; err -> R18,R19
; pgrp -> R16,R17
.even
_OSFlagQuery::
xcall push_gset1
.dbline -1
.dbline 668
; }
; /*$PAGE*/
; /*
; *********************************************************************************************************
; * QUERY EVENT FLAG
; *
; * Description: This function is used to check the value of the event flag group.
; *
; * Arguments : pgrp is a pointer to the desired event flag group.
; *
; * err is a pointer to an error code returned to the called:
; * OS_NO_ERR The call was successfull
; * OS_FLAG_INVALID_PGRP You passed a NULL pointer
; * OS_ERR_EVENT_TYPE You are not pointing to an event flag group
; *
; * Returns : The current value of the event flag group.
; *
; * Called From: Task or ISR
; *********************************************************************************************************
; */
;
; #if OS_FLAG_QUERY_EN > 0
; OS_FLAGS OSFlagQuery (OS_FLAG_GRP *pgrp, INT8U *err)
; {
.dbline 676
; #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
; OS_CPU_SR cpu_sr;
; #endif
; OS_FLAGS flags;
;
;
; #if OS_ARG_CHK_EN > 0
; if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
cpi R16,0
cpc R16,R17
brne L139
X34:
.dbline 676
.dbline 677
; *err = OS_FLAG_INVALID_PGRP;
ldi R24,150
movw R30,R18
std z+0,R24
.dbline 678
; return ((OS_FLAGS)0);
clr R16
xjmp L138
L139:
.dbline 680
; }
; if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type */
movw R30,R16
ldd R24,z+0
cpi R24,5
breq L141
.dbline 680
.dbline 681
; *err = OS_ERR_EVENT_TYPE;
ldi R24,1
movw R30,R18
std z+0,R24
.dbline 682
; return ((OS_FLAGS)0);
clr R16
xjmp L138
L141:
.dbline 685
; }
; #endif
; OS_ENTER_CRITICAL();
st -y,r16
in r16,0x3F
cli
push r16
ld r16,y+
.dbline 685
.dbline 686
; flags = pgrp->OSFlagFlags;
movw R30,R16
ldd R20,z+3
.dbline 687
; OS_EXIT_CRITICAL();
st -y,r16
pop r16
out 0x3F,r16
ld r16,y+
.dbline 687
.dbline 688
; *err = OS_NO_ERR;
clr R2
movw R30,R18
std z+0,R2
.dbline 689
; return (flags); /* Return the current value of the event flags */
mov R16,R20
.dbline -2
L138:
xcall pop_gset1
.dbline 0 ; func end
ret
.dbsym r flags 20 c
.dbsym r err 18 pc
.dbsym r pgrp 16 pS[.1]
.dbend
.dbfunc s OS_FlagBlock _OS_FlagBlock fV
; pnode_next -> R20,R21
; timeout -> y+6
; wait_type -> y+4
; flags -> y+2
; pnode -> R18,R19
; pgrp -> R16,R17
.even
_OS_FlagBlock:
xcall push_gset1
.dbline -1
.dbline 732
; }
; #endif
;
; /*$PAGE*/
; /*
; *********************************************************************************************************
; * SUSPEND TASK UNTIL EVENT FLAG(s) RECEIVED OR TIMEOUT OCCURS
; *
; * Description: This function is internal to uC/OS-II and is used to put a task to sleep until the desired
; * event flag bit(s) are set.
; *
; * Arguments : pgrp is a pointer to the desired event flag group.
; *
; * pnode is a pointer to a structure which contains data about the task waiting for
; * event flag bit(s) to be set.
; *
; * flags Is a bit pattern indicating which bit(s) (i.e. flags) you wish to check.
; * The bits you want are specified by setting the corresponding bits in
; * 'flags'. e.g. if your application wants to wait for bits 0 and 1 then
; * 'flags' would contain 0x03.
; *
; * wait_type specifies whether you want ALL bits to be set/cleared or ANY of the bits
; * to be set/cleared.
; * You can specify the following argument:
; *
; * OS_FLAG_WAIT_CLR_ALL You will check ALL bits in 'mask' to be clear (0)
; * OS_FLAG_WAIT_CLR_ANY You will check ANY bit in 'mask' to be clear (0)
; * OS_FLAG_WAIT_SET_ALL You will check ALL bits in 'mask' to be set (1)
; * OS_FLAG_WAIT_SET_ANY You will check ANY bit in 'mask' to be set (1)
; *
; * timeout is the desired amount of time that the task will wait for the event flag
; * bit(s) to be set.
; *
; * Returns : none
; *
; * Called by : OSFlagPend() OS_FLAG.C
; *
; * Note(s) : This function is INTERNAL to uC/OS-II and your application should not call it.
; *********************************************************************************************************
; */
;
; static void OS_FlagBlock (OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout)
; {
.dbline 736
; OS_FLAG_NODE *pnode_next;
;
;
; OSTCBCur->OSTCBStat |= OS_STAT_FLAG;
lds R24,_OSTCBCur
lds R25,_OSTCBCur+1
adiw R24,11
movw R30,R24
ldd R24,z+0
ori R24,32
std z+0,R24
.dbline 737
; OSTCBCur->OSTCBDly = timeout; /* Store timeout in task's TCB */
lds R30,_OSTCBCur
lds R31,_OSTCBCur+1
ldd R0,y+6
ldd R1,y+7
std z+10,R1
std z+9,R0
.dbline 739
; #if OS_TASK_DEL_EN > 0
; OSTCBCur->OSTCBFlagNode = pnode; /* TCB to link to node */
std z+7,R19
std z+6,R18
.dbline 741
; #endif
; pnode->OSFlagNodeFlags = flags; /* Save the flags that we need to wait for */
movw R30,R18
ldd R0,y+2
std z+8,R0
.dbline 742
; pnode->OSFlagNodeWaitType = wait_type; /* Save the type of wait we are doing */
movw R30,R18
ldd R0,y+4
std z+9,R0
.dbline 743
; pnode->OSFlagNodeTCB = (void *)OSTCBCur; /* Link to task's TCB */
lds R2,_OSTCBCur
lds R3,_OSTCBCur+1
movw R30,R18
std z+5,R3
std z+4,R2
.dbline 744
; pnode->OSFlagNodeNext = pgrp->OSFlagWaitList; /* Add node at beginning of event flag wait list */
movw R30,R16
ldd R2,z+1
ldd R3,z+2
movw R30,R18
std z+1,R3
std z+0,R2
.dbline 745
; pnode->OSFlagNodePrev = (void *)0;
clr R2
clr R3
std z+3,R3
std z+2,R2
.dbline 746
; pnode->OSFlagNodeFlagGrp = (void *)pgrp; /* Link to Event Flag Group */
movw R30,R18
std z+7,R17
std z+6,R16
.dbline 747
; pnode_next = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;
movw R30,R16
ldd R20,z+1
ldd R21,z+2
.dbline 748
; if (pnode_next != (void *)0) { /* Is this the first NODE to insert? */
cpi R20,0
cpc R20,R21
breq L144
X35:
.dbline 748
.dbline 749
; pnode_next->OSFlagNodePrev = pnode; /* No, link in doubly linked list */
movw R30,R20
std z+3,R19
std z+2,R18
.dbline 750
; }
L144:
.dbline 751
movw R30,R16
std z+2,R19
std z+1,R18
.dbline 753
ldi R24,<_OSRdyTbl
ldi R25,>_OSRdyTbl
lds R30,_OSTCBCur
lds R31,_OSTCBCur+1
ldd R2,z+14
clr R3
add R2,R24
adc R3,R25
lds R30,_OSTCBCur
lds R31,_OSTCBCur+1
ldd R4,z+15
com R4
movw R30,R2
ldd R5,z+0
and R5,R4
mov R4,R5
std z+0,R4
tst R5
brne L146
.dbline 753
.dbline 754
lds R30,_OSTCBCur
lds R31,_OSTCBCur+1
ldd R2,z+16
com R2
lds R3,_OSRdyGrp
and R3,R2
sts _OSRdyGrp,R3
.dbline 755
L146:
.dbline -2
L143:
xcall pop_gset1
.dbline 0 ; func end
ret
.dbsym r pnode_next 20 pS[.2]
.dbsym l timeout 6 i
.dbsym l wait_type 4 c
.dbsym l flags 2 c
.dbsym r pnode 18 pS[.2]
.dbsym r pgrp 16 pS[.1]
.dbend
.dbfunc e OS_FlagInit _OS_FlagInit fV
; pgrp2 -> R16,R17
; i -> R18
; pgrp1 -> R20,R21
.even
_OS_FlagInit::
xcall push_gset1
.dbline -1
.dbline 775
; pgrp->OSFlagWaitList = (void *)pnode;
; /* Suspend current task until flag(s) received */
; if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {
; OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
; }
; }
;
; /*$PAGE*/
; /*
; *********************************************************************************************************
; * INITIALIZE THE EVENT FLAG MODULE
; *
; * Description: This function is called by uC/OS-II to initialize the event flag module. Your application
; * MUST NOT call this function. In other words, this function is internal to uC/OS-II.
; *
; * Arguments : none
; *
; * Returns : none
; *
; * WARNING : You MUST NOT call this function from your code. This is an INTERNAL function to uC/OS-II.
; *********************************************************************************************************
; */
;
; void OS_FlagInit (void)
; {
.dbline 788
; #if OS_MAX_FLAGS == 1
; OSFlagFreeList = (OS_FLAG_GRP *)&OSFlagTbl[0]; /* Only ONE event flag group! */
; OSFlagFreeList->OSFlagType = OS_EVENT_TYPE_UNUSED;
; OSFlagFreeList->OSFlagWaitList = (void *)0;
; #endif
;
; #if OS_MAX_FLAGS >= 2
; INT8U i;
; OS_FLAG_GRP *pgrp1;
; OS_FLAG_GRP *pgrp2;
;
;
; pgrp1 = &OSFla⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -