os_flag.s

ucos如何移植到单片机mega128

; 
;         default:
;              OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 478
	.dbline 479
;              flags_cur = (OS_FLAGS)0;
	clr R20
	.dbline 480
;              *err      = OS_FLAG_ERR_WAIT_TYPE;
	ldi R24,151
	movw R30,R22
	std z+0,R24
	.dbline 481
;              return (flags_cur);
	mov R16,R20
	xjmp L59
L69:
	.dbline 483
;     }
;     OS_Sched();                                            /* Find next HPT ready to run               */
	push R6
	push R7
	xcall _OS_Sched
	pop R7
	pop R6
	.dbline 484
;     OS_ENTER_CRITICAL();
	st -y,r16
	in r16,0x3F
	cli
	push r16
	ld r16,y+
	.dbline 484
	.dbline 485
;     if (OSTCBCur->OSTCBStat & OS_STAT_FLAG) {              /* Have we timed-out?                       */
	lds R30,_OSTCBCur
	lds R31,_OSTCBCur+1
	ldd R2,z+11
	sbrs R2,5
	rjmp L91
	.dbline 485
	.dbline 486
;         OS_FlagUnlink(&node);
	movw R16,R28
	subi R16,250  ; offset = 6
	sbci R17,255
	push R6
	push R7
	xcall _OS_FlagUnlink
	pop R7
	pop R6
	.dbline 487
;         OSTCBCur->OSTCBStat = OS_STAT_RDY;                 /* Yes, make task ready-to-run              */
	clr R2
	lds R30,_OSTCBCur
	lds R31,_OSTCBCur+1
	std z+11,R2
	.dbline 488
;         OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 488
	.dbline 489
;         flags_cur           = (OS_FLAGS)0;
	clr R20
	.dbline 490
;         *err                = OS_TIMEOUT;                  /* Indicate that we timed-out waiting       */
	ldi R24,10
	movw R30,R22
	std z+0,R24
	.dbline 491
	xjmp L92
L91:
	.dbline 491
;     } else {
	.dbline 492
;         if (consume == TRUE) {                             /* See if we need to consume the flags      */
	mov R24,R14
	cpi R24,1
	breq X19
	xjmp L93
X19:
	.dbline 492
	.dbline 493
	clr R13
	tst R12
	brne X14
	tst R13
	breq L99
X14:
	movw R24,R12
	cpi R24,1
	ldi R30,0
	cpc R25,R30
	breq L99
	cpi R24,2
	ldi R30,0
	cpc R25,R30
	breq L98
	cpi R24,3
	ldi R30,0
	cpc R25,R30
	breq L98
	xjmp L95
X15:
	.dbline 493
;             switch (wait_type) {
L98:
	.dbline 496
;                 case OS_FLAG_WAIT_SET_ALL:
;                 case OS_FLAG_WAIT_SET_ANY:                 /* Clear ONLY the flags we got              */
;                      pgrp->OSFlagFlags &= ~OSTCBCur->OSTCBFlagsRdy;
	movw R24,R6
	adiw R24,3
	lds R30,_OSTCBCur
	lds R31,_OSTCBCur+1
	ldd R4,z+8
	com R4
	movw R30,R24
	ldd R5,z+0
	and R5,R4
	std z+0,R5
	.dbline 497
;                      break;
	xjmp L96
L99:
	.dbline 502
; 
; #if OS_FLAG_WAIT_CLR_EN > 0
;                 case OS_FLAG_WAIT_CLR_ALL:
;                 case OS_FLAG_WAIT_CLR_ANY:                 /* Set   ONLY the flags we got              */
;                      pgrp->OSFlagFlags |= OSTCBCur->OSTCBFlagsRdy;
	movw R24,R6
	adiw R24,3
	lds R30,_OSTCBCur
	lds R31,_OSTCBCur+1
	ldd R4,z+8
	movw R30,R24
	ldd R5,z+0
	or R5,R4
	std z+0,R5
	.dbline 503
;                      break;
L95:
L96:
	.dbline 506
; #endif
;             }
;         }
L93:
	.dbline 507
;         flags_cur = pgrp->OSFlagFlags;
	movw R30,R6
	ldd R20,z+3
	.dbline 508
;         OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 508
	.dbline 509
;         *err      = OS_NO_ERR;                             /* Event(s) must have occurred              */
	clr R2
	movw R30,R22
	std z+0,R2
	.dbline 510
;     }
L92:
	.dbline 511
;     return (flags_cur);
	mov R16,R20
	.dbline -2
L59:
	adiw R28,16
	xcall pop_gset5
	adiw R28,2
	.dbline 0 ; func end
	ret
	.dbsym l node 6 S[.2]
	.dbsym r flags_rdy 10 c
	.dbsym r consume 14 c
	.dbsym r flags_cur 20 c
	.dbsym r err 22 pc
	.dbsym l timeout 30 i
	.dbsym r wait_type 12 c
	.dbsym l flags 26 c
	.dbsym r pgrp 6 pS[.1]
	.dbend
	.dbfunc e OSFlagPost _OSFlagPost fc
;      flags_cur -> R20
;          sched -> R14
;      flags_rdy -> R10
;          pnode -> R12,R13
;            err -> R22,R23
;            opt -> y+14
;          flags -> R20
;           pgrp -> y+10
	.even
_OSFlagPost::
	xcall push_arg4
	xcall push_gset5
	mov R20,R18
	ldd R22,y+16
	ldd R23,y+17
	.dbline -1
	.dbline 556
; }
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                         POST EVENT FLAG BIT(S)
; *
; * Description: This function is called to set or clear some bits in an event flag group.  The bits to
; *              set or clear are specified by a 'bit mask'.
; *
; * Arguments  : pgrp          is a pointer to the desired event flag group.
; *
; *              flags         If 'opt' (see below) is OS_FLAG_SET, each bit that is set in 'flags' will
; *                            set the corresponding bit in the event flag group.  e.g. to set bits 0, 4
; *                            and 5 you would set 'flags' to:
; *
; *                                0x31     (note, bit 0 is least significant bit)
; *
; *                            If 'opt' (see below) is OS_FLAG_CLR, each bit that is set in 'flags' will
; *                            CLEAR the corresponding bit in the event flag group.  e.g. to clear bits 0,
; *                            4 and 5 you would specify 'flags' as:
; *
; *                                0x31     (note, bit 0 is least significant bit)
; *
; *              opt           indicates whether the flags will be:
; *                                set     (OS_FLAG_SET) or
; *                                cleared (OS_FLAG_CLR)
; *
; *              err           is a pointer to an error code and can be:
; *                            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
; *                            OS_FLAG_INVALID_OPT    You specified an invalid option
; *
; * Returns    : the new value of the event flags bits that are still set.
; *
; * Called From: Task or ISR
; *
; * WARNING(s) : 1) The execution time of this function depends on the number of tasks waiting on the event
; *                 flag group.
; *              2) The amount of time interrupts are DISABLED depends on the number of tasks waiting on
; *                 the event flag group.
; *********************************************************************************************************
; */
; OS_FLAGS  OSFlagPost (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U opt, INT8U *err)
; {
	.dbline 567
; #if OS_CRITICAL_METHOD == 3                          /* Allocate storage for CPU status register       */
;     OS_CPU_SR     cpu_sr;
; #endif
;     OS_FLAG_NODE *pnode;
;     BOOLEAN       sched;
;     OS_FLAGS      flags_cur;
;     OS_FLAGS      flags_rdy;
; 
; 
; #if OS_ARG_CHK_EN > 0
;     if (pgrp == (OS_FLAG_GRP *)0) {                  /* Validate 'pgrp'                                */
	ldd R0,y+10
	ldd R1,y+11
	tst R0
	brne L101
	tst R1
	brne L101
X20:
	.dbline 567
	.dbline 568
;         *err = OS_FLAG_INVALID_PGRP;
	ldi R24,150
	movw R30,R22
	std z+0,R24
	.dbline 569
;         return ((OS_FLAGS)0);
	clr R16
	xjmp L100
L101:
	.dbline 571
;     }
;     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {    /* Make sure we are pointing to an event flag grp */
	ldd R30,y+10
	ldd R31,y+11
	ldd R24,z+0
	cpi R24,5
	breq L103
	.dbline 571
	.dbline 572
;         *err = OS_ERR_EVENT_TYPE;
	ldi R24,1
	movw R30,R22
	std z+0,R24
	.dbline 573
;         return ((OS_FLAGS)0);
	clr R16
	xjmp L100
L103:
	.dbline 577
;     }
; #endif
; /*$PAGE*/
;     OS_ENTER_CRITICAL();
	st -y,r16
	in r16,0x3F
	cli
	push r16
	ld r16,y+
	.dbline 577
	.dbline 578
	ldd R10,y+14
	clr R11
	tst R10
	brne X21
	tst R11
	breq L108
X21:
	movw R24,R10
	cpi R24,1
	ldi R30,0
	cpc R25,R30
	breq L109
	xjmp L105
X22:
	.dbline 578
;     switch (opt) {
L108:
	.dbline 580
;         case OS_FLAG_CLR:
;              pgrp->OSFlagFlags &= ~flags;            /* Clear the flags specified in the group         */
	ldd R24,y+10
	ldd R25,y+11
	adiw R24,3
	mov R4,R20
	com R4
	movw R30,R24
	ldd R5,z+0
	and R5,R4
	std z+0,R5
	.dbline 581
;              break;
	xjmp L106
L109:
	.dbline 584
; 
;         case OS_FLAG_SET:
;              pgrp->OSFlagFlags |=  flags;            /* Set   the flags specified in the group         */
	ldd R24,y+10
	ldd R25,y+11
	adiw R24,3
	movw R30,R24
	ldd R4,z+0
	or R4,R20
	std z+0,R4
	.dbline 585
;              break;
	xjmp L106
L105:
	.dbline 588
; 
;         default:
;              OS_EXIT_CRITICAL();                     /* INVALID option                                 */
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 588
	.dbline 589
;              *err = OS_FLAG_INVALID_OPT;
	ldi R24,153
	movw R30,R22
	std z+0,R24
	.dbline 590
;              return ((OS_FLAGS)0);
	clr R16
	xjmp L100
L106:
	.dbline 592
;     }
;     sched = FALSE;                                   /* Indicate that we don't need rescheduling       */
	clr R14
	.dbline 593
;     pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;
	ldd R30,y+10
	ldd R31,y+11
	ldd R12,z+1
	ldd R13,z+2
	xjmp L111
L110:
	.dbline 594
;     while (pnode != (OS_FLAG_NODE *)0) {             /* Go through all tasks waiting on event flag(s)  */
	.dbline 595
	movw R30,R12
	ldd R20,z+9
	clr R21
	cpi R20,0
	cpc R20,R21
	brne X26
	xjmp L126
X26:
X23:
	cpi R20,1
	ldi R30,0
	cpc R21,R30
	brne X27
	xjmp L131
X27:
	cpi R20,2
	ldi R30,0
	cpc R21,R30
	breq L116
	cpi R20,3
	ldi R30,0
	cpc R21,R30
	breq L121
	xjmp L113
X24:
	.dbline 595
;         switch (pnode->OSFlagNodeWaitType) {
L116:
	.dbline 597
;             case OS_FLAG_WAIT_SET_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
	and R10,R2
	.dbline 598
;                  if (flags_rdy == pnode->OSFlagNodeFlags) {
	movw R30,R12
	ldd R2,z+8
	cp R10,R2
	breq X28
	xjmp L114
X28:
	.dbline 598
	.dbline 599
;                      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
	breq X29
	xjmp L114
X29:
	.dbline 599
	.dbline 600
;                          sched = TRUE;                               /* When done we will reschedule   */
	clr R14
	inc R14
	.dbline 601
;                      }
	.dbline 602
;                  }
	.dbline 603
;                  break;
	xjmp L114
L121:
	.dbline 606
; 
;             case OS_FLAG_WAIT_SET_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
	and R10,R2
	.dbline 607
;                  if (flags_rdy != (OS_FLAGS)0) {
	brne X30
	xjmp L114
X30:
	.dbline 607
	.dbline 608
;                      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
	breq X31
	xjmp L114
X31:
	.dbline 608
	.dbline 609
;                          sched = TRUE;                               /* When done we will reschedule   */
	clr R14
	inc R14
	.dbline 610
;                      }
	.dbline 611
;                  }
	.dbline 612
;                  break;