X24:
	.dbline 532
	.dbline 533
;         OSEventInit(pevent);
	mov R16,R20
	mov R17,R21
	rcall _OSEventInit
	.dbline 534
; 		pevent->OSEventType = OS_EVENT_TYPE_SEM;
	ldi R24,1
	mov R30,R20
	mov R31,R21
	std z+8,R24
	.dbline 535
;         pevent->OSEventCnt  = cnt;                         /* Set semaphore value                      */
	std z+6,R22
	std z+7,R23
	.dbline 536
;     }
L117:
	.dbline 537
;     return (pevent);
	mov R16,R20
	mov R17,R21
	.dbline -2
L116:
	rcall pop_gset2
	.dbline 0 ; func end
	ret
	.dbsym r cnt 22 i
	.dbsym r pevent 20 pX
	.dbend
	.dbfunc e OSEventRemoveCurrentTCB _OSEventRemoveCurrentTCB fV
;         pevent -> R20,R21
	.even
_OSEventRemoveCurrentTCB::
	rcall push_gset1
	mov R20,R16
	mov R21,R17
	.dbline -1
	.dbline 541
; }
; //called by OSSemPend to remove current tcb from event's waitting task list
; void OSEventRemoveCurrentTCB(OS_EVENT *pevent)
; {
	.dbline 543
; #if OS_STRICT
; 	if((0==pevent)||(OSPrioCur>OS_LOWEST_PRIO)||(OSTCBCur==0))
	cpi R20,0
	cpc R20,R21
	breq L123
X25:
	ldi R24,2
	lds R2,_OSPrioCur
	cp R24,R2
	brlo L123
	lds R2,_OSTCBCur
	lds R3,_OSTCBCur+1
	tst R2
	brne L120
	tst R3
	brne L120
X26:
L123:
	.dbline 544
; 		OSError(0);
	clr R16
	rcall _OSError
L120:
	.dbline 545
; 	if(pevent->OSTaskTbl[OSPrioCur]==0)
	lds R30,_OSPrioCur
	clr R31
	lsl R30
	rol R31
	add R30,R20
	adc R31,R21
	ldd R2,z+0
	ldd R3,z+1
	tst R2
	brne L124
	tst R3
	brne L124
X27:
	.dbline 546
; 		OSError(0);
	clr R16
	rcall _OSError
L124:
	.dbline 548
; #endif
; 	pevent->OSTaskTbl[OSPrioCur]=0;
	lds R30,_OSPrioCur
	clr R31
	lsl R30
	rol R31
	add R30,R20
	adc R31,R21
	clr R2
	clr R3
	std z+0,R2
	std z+1,R3
	.dbline -2
	.dbline 549
; }
L119:
	rcall pop_gset1
	.dbline 0 ; func end
	ret
	.dbsym r pevent 20 pX
	.dbend
	.dbfunc e OSSemPend _OSSemPend fV
;            err -> R20,R21
;        timeout -> R10,R11
;         pevent -> R22,R23
	.even
_OSSemPend::
	rcall push_gset3
	mov R10,R18
	mov R11,R19
	mov R22,R16
	mov R23,R17
	ldd R20,y+6
	ldd R21,y+7
	.dbline -1
	.dbline 581
; 
; /*
; *********************************************************************************************************
; *                                           PEND ON SEMAPHORE
; *
; * Description: This function waits for a semaphore.
; *
; * Arguments  : pevent        is a pointer to the event control block associated with the desired 
; *                            semaphore.
; *
; *              timeout       is an optional timeout period (in clock ticks).  If non-zero, your task will
; *                            wait for the resource up to the amount of time specified by this argument.  
; *                            If you specify 0, however, your task will wait forever at the specified 
; *                            semaphore or, until the resource becomes available (or the event occurs).
; *
; *              err           is a pointer to where an error message will be deposited.  Possible error
; *                            messages are:
; *
; *                            OS_NO_ERR          The call was successful and your task owns the resource 
; *                                               or, the event you are waiting for occurred.
; *                            OS_TIMEOUT         The semaphore was not received within the specified 
; *                                               timeout.
; *                            OS_ERR_EVENT_TYPE  If you didn't pass a pointer to a semaphore.
; *                            OS_ERR_PEND_ISR    If you called this function from an ISR and the result
; *                                               would lead to a suspension.
; *
; * Returns    : none
; *********************************************************************************************************
; */
; 
; void OSSemPend (OS_EVENT *pevent, INT16U timeout, INT8U *err)
; {
	.dbline 582
;     OS_ENTER_CRITICAL();
	st -y,r16
	 in r16,0x3f
	 cli
	 push r16
	ld r16,y+
	.dbline 582
	.dbline 583
;     if (pevent->OSEventType != OS_EVENT_TYPE_SEM) {   /* Validate event block type                     */
	mov R30,R22
	mov R31,R23
	ldd R24,z+8
	cpi R24,1
	breq L127
	.dbline 583
	.dbline 584
;         OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 584
	.dbline 585
;         *err = OSERR_EVENT_TYPE;
	ldi R24,4
	mov R30,R20
	mov R31,R21
	std z+0,R24
	.dbline 586
;     }
L127:
	.dbline 587
;     if (pevent->OSEventCnt > 0) {                     /* If sem. is positive, resource available ...   */
	mov R30,R22
	mov R31,R23
	ldd R2,z+6
	ldd R3,z+7
	tst R2
	brne X28
	tst R3
	breq L129
X28:
	.dbline 587
	.dbline 588
;         pevent->OSEventCnt--;                         /* ... decrement semaphore only if positive.     */
	mov R24,R22
	mov R25,R23
	adiw R24,6
	mov R30,R24
	mov R31,R25
	ldd R24,z+0
	ldd R25,z+1
	sbiw R24,1
	std z+0,R24
	std z+1,R25
	.dbline 589
;         OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 589
	.dbline 590
;         *err = OS_NO_ERR;
	clr R2
	mov R30,R20
	mov R31,R21
	std z+0,R2
	.dbline 591
	rjmp L130
L129:
	.dbline 591
;     } else if (OSIntNesting > 0) {                    /* See if called from ISR ...                    */
	clr R2
	lds R3,_OSIntNesting
	cp R2,R3
	brsh L131
	.dbline 591
	.dbline 592
;         OS_EXIT_CRITICAL();                           /* ... can't PEND from an ISR                    */
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 592
	.dbline 593
;         *err = OSERR_PEND_ISR;
	ldi R24,5
	mov R30,R20
	mov R31,R21
	std z+0,R24
	.dbline 594
	rjmp L132
L131:
	.dbline 594
;     } else {                                          /* Otherwise, must wait until event occurs       */
	.dbline 595
;         OSTCBCur->OSTCBStat    |= OS_STAT_SEM;        /* Resource not available, pend on semaphore     */
	lds R24,_OSTCBCur
	lds R25,_OSTCBCur+1
	adiw R24,4
	mov R30,R24
	mov R31,R25
	ldd R24,z+0
	ori R24,2
	std z+0,R24
	.dbline 596
;         OSTCBCur->OSTCBDly      = timeout;            /* Store pend timeout in TCB                     */
	lds R30,_OSTCBCur
	lds R31,_OSTCBCur+1
	std z+2,R10
	std z+3,R11
	.dbline 597
;         OSEventTaskWait(pevent);                      /* Suspend task until event or timeout occurs    */
	mov R16,R22
	mov R17,R23
	rcall _OSEventTaskWait
	.dbline 598
;         OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 598
	.dbline 599
;         OSSched();                                    /* Find next highest priority task ready         */
	rcall _OSSched
	.dbline 600
;         OS_ENTER_CRITICAL();
	st -y,r16
	 in r16,0x3f
	 cli
	 push r16
	ld r16,y+
	.dbline 600
	.dbline 601
;         OSEventRemoveCurrentTCB(pevent);
	mov R16,R22
	mov R17,R23
	rcall _OSEventRemoveCurrentTCB
	.dbline 602
;         if (OSTCBCur->OSTCBStat & OS_STAT_SEM) {      /* Must have timed out if still waiting for event*/
	lds R30,_OSTCBCur
	lds R31,_OSTCBCur+1
	ldd R2,z+4
	sbrs R2,1
	rjmp L133
	.dbline 602
	.dbline 603
;             OSEventTO(pevent);
	mov R16,R22
	mov R17,R23
	rcall _OSEventTO
	.dbline 604
;             OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 604
	.dbline 605
;             *err = OSERR_TIMEOUT;                        /* Indicate that didn't get event within TO      */
	ldi R24,6
	mov R30,R20
	mov R31,R21
	std z+0,R24
	.dbline 606
	rjmp L134
L133:
	.dbline 606
;         } else {
	.dbline 607
;             OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 607
	.dbline 608
;             *err = OS_NO_ERR;
	clr R2
	mov R30,R20
	mov R31,R21
	std z+0,R2
	.dbline 609
;         }
L134:
	.dbline 610
;     }
L132:
L130:
	.dbline -2
	.dbline 611
; }
L126:
	rcall pop_gset3
	.dbline 0 ; func end
	ret
	.dbsym r err 20 pc
	.dbsym r timeout 10 i
	.dbsym r pevent 22 pX
	.dbend
	.dbfunc e OSSemPost _OSSemPost fc
;           prio -> R22
;         pevent -> R20,R21
	.even
_OSSemPost::
	rcall push_gset2
	mov R20,R16
	mov R21,R17
	.dbline -1
	.dbline 631
; 
; /*
; *********************************************************************************************************
; *                                         POST TO A SEMAPHORE
; *
; * Description: This function signals a semaphore
; *
; * Arguments  : pevent        is a pointer to the event control block associated with the desired 
; *                            semaphore.
; *
; * Returns    : OS_NO_ERR          The call was successful and the semaphore was signaled.
; *              OS_SEM_OVF         If the semaphore count exceeded its limit.  In other words, you have 
; *                                 signalled the semaphore more often than you waited on it with either
; *                                 OSSemAccept() or OSSemPend().
; *              OS_ERR_EVENT_TYPE  If you didn't pass a pointer to a semaphore
; *********************************************************************************************************
; */
; 
; INT8U OSSemPost (OS_EVENT *pevent)
; {
	.dbline 633
; 	INT8U prio;
;     OS_ENTER_CRITICAL();
	st -y,r16
	 in r16,0x3f
	 cli
	 push r16
	ld r16,y+
	.dbline 633
	.dbline 634
;     if (pevent->OSEventType != OS_EVENT_TYPE_SEM) {        /* Validate event block type                */
	mov R30,R20
	mov R31,R21
	ldd R24,z+8
	cpi R24,1
	breq L136
	.dbline 634
	.dbline 635
;         OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 635
	.dbline 636
;         return (OSERR_EVENT_TYPE);
	ldi R16,4
	rjmp L135
L136:
	.dbline 638
;     }
;     prio=OSEventGetHighPrioRdy(pevent);
	mov R16,R20
	mov R17,R21
	rcall _OSEventGetHighPrioRdy
	mov R22,R16
	.dbline 639
;     if (prio<=OS_LOWEST_PRIO) {                              /* See if any task waiting for semaphore    */
	ldi R24,2
	cp R24,R16
	brlo L138
	.dbline 639
	.dbline 640
;         OSEventTaskRdy(pevent,OS_STAT_SEM);    /* Ready highest prio task waiting on event */
	ldi R18,2
	mov R16,R20
	mov R17,R21
	rcall _OSEventTaskRdy
	.dbline 641
;         OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 641
	.dbline 642
;         OSSched();                                    /* Find highest priority task ready to run       */
	rcall _OSSched
	.dbline 643
;         return (OS_NO_ERR);
	clr R16
	rjmp L135
L138:
	.dbline 644
;     } else {
	.dbline 645
;         if (pevent->OSEventCnt < 65535) {             /* Make sure semaphore will not overflow         */
	mov R30,R20
	mov R31,R21
	ldd R24,z+6
	ldd R25,z+7
	cpi R24,255
	ldi R30,255
	cpc R25,R30
	brsh L140
	.dbline 645
	.dbline 646
;             pevent->OSEventCnt++;                     /* Increment semaphore count to register event   */
	mov R24,R20
	mov R25,R21
	adiw R24,6
	mov R30,R24
	mov R31,R25
	ldd R24,z+0
	ldd R25,z+1
	adiw R24,1
	std z+0,R24
	std z+1,R25
	.dbline 647
;             OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 647
	.dbline 648
;             return (OS_NO_ERR);
	clr R16
	rjmp L135
L140:
	.dbline 649
;         } else {                                      /* Semaphore value has reached its maximum       */
	.dbline 650
;             OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 650
	.dbline 651
;             return (OSERR_SEM_OVF);
	ldi R16,7
	.dbline -2
L135:
	rcall pop_gset2
	.dbline 0 ; func end
	ret
	.dbsym r prio 22 c
	.dbsym r pevent 20 pX
	.dbend
	.area bss(ram, con, rel)
	.dbfile G:\編程2002-10-15-HOME\做過的項目\2002-10-22\home-c\software\ucos-ii-at90S-icc-avr\os-task-sem\os-task-switch.c
_uart_sem::
	.blkb 9
	.dbfile G:\編程2002-10-15-HOME\做過的項目\2002-10-22\home-c\software\ucos-ii-at90S-icc-avr\os-task-sem/includes.h
	.dbsym e uart_sem _uart_sem X
_stk_task3::
	.blkb 128
	.dbsym e stk_task3 _stk_task3 A[128:128]c
_stk_task2::
	.blkb 128
	.dbsym e stk_task2 _stk_task2 A[128:128]c
_stk_task1::
	.blkb 128
	.dbsym e stk_task1 _stk_task1 A[128:128]c
_tcb_task3::
	.blkb 6
	.dbsym e tcb_task3 _tcb_task3 X
_tcb_task2::
	.blkb 6
	.dbsym e tcb_task2 _tcb_task2 X
_tcb_task1::
	.blkb 6
	.dbsym e tcb_task1 _tcb_task1 X
_OSTCBHighRdy::
	.blkb 2
	.dbfile G:\編程2002-10-15-HOME\做過的項目\2002-10-22\home-c\software\ucos-ii-at90S-icc-avr\os-task-sem/os-task-switch.h
	.dbsym e OSTCBHighRdy _OSTCBHighRdy pX
_OSTCBCur::
	.blkb 2
	.dbsym e OSTCBCur _OSTCBCur pX
_OSPrioHighRdy::
	.blkb 1
	.dbsym e OSPrioHighRdy _OSPrioHighRdy c
_OSPrioCur::
	.blkb 1
	.dbsym e OSPrioCur _OSPrioCur c
_OSLockNesting::
	.blkb 1
	.dbsym e OSLockNesting _OSLockNesting c
_OSIntNesting::
	.blkb 1
	.dbsym e OSIntNesting _OSIntNesting c
_OSpTCBList::
	.blkb 6
	.dbsym e OSpTCBList _OSpTCBList A[6:3]pX
_OSRunning::
	.blkb 1
	.dbsym e OSRunning _OSRunning c