os_task.s

将本站的UCOSFORAVR128V276版本升级到了280版

	.dbsym l p_arg 22 pV
	.dbsym r task 12 pfV
	.dbend
	.dbfunc e OSTaskDel _OSTaskDel fc
	.dbstruct 0 8 os_event
	.dbfield 0 OSEventType c
	.dbfield 1 OSEventPtr pV
	.dbfield 3 OSEventCnt i
	.dbfield 5 OSEventGrp c
	.dbfield 6 OSEventTbl A[2:2]c
	.dbend
	.dbstruct 0 18 os_tcb
	.dbfield 0 OSTCBStkPtr pc
	.dbfield 2 OSTCBNext pS[os_tcb]
	.dbfield 4 OSTCBPrev pS[os_tcb]
	.dbfield 6 OSTCBEventPtr pS[os_event]
	.dbfield 8 OSTCBDly i
	.dbfield 10 OSTCBStat c
	.dbfield 11 OSTCBPendTO c
	.dbfield 12 OSTCBPrio c
	.dbfield 13 OSTCBX c
	.dbfield 14 OSTCBY c
	.dbfield 15 OSTCBBitX c
	.dbfield 16 OSTCBBitY c
	.dbfield 17 OSTCBDelReq c
	.dbend
;         pevent -> R12,R13
;              y -> R14
;         cpu_sr -> R20
;           ptcb -> R22,R23
;           prio -> R10
	.even
_OSTaskDel::
	xcall push_gset5
	mov R10,R16
	.dbline -1
	.dbline 380
; }
; #endif
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                     CREATE A TASK (Extended Version)
; *
; * Description: This function is used to have uC/OS-II manage the execution of a task.  Tasks can either
; *              be created prior to the start of multitasking or by a running task.  A task cannot be
; *              created by an ISR.  This function is similar to OSTaskCreate() except that it allows
; *              additional information about a task to be specified.
; *
; * Arguments  : task      is a pointer to the task's code
; *
; *              p_arg     is a pointer to an optional data area which can be used to pass parameters to
; *                        the task when the task first executes.  Where the task is concerned it thinks
; *                        it was invoked and passed the argument 'p_arg' as follows:
; *
; *                            void Task (void *p_arg)
; *                            {
; *                                for (;;) {
; *                                    Task code;
; *                                }
; *                            }
; *
; *              ptos      is a pointer to the task's top of stack.  If the configuration constant
; *                        OS_STK_GROWTH is set to 1, the stack is assumed to grow downward (i.e. from high
; *                        memory to low memory).  'ptos' will thus point to the highest (valid) memory
; *                        location of the stack.  If OS_STK_GROWTH is set to 0, 'ptos' will point to the
; *                        lowest memory location of the stack and the stack will grow with increasing
; *                        memory locations.  'ptos' MUST point to a valid 'free' data item.
; *
; *              prio      is the task's priority.  A unique priority MUST be assigned to each task and the
; *                        lower the number, the higher the priority.
; *
; *              id        is the task's ID (0..65535)
; *
; *              pbos      is a pointer to the task's bottom of stack.  If the configuration constant
; *                        OS_STK_GROWTH is set to 1, the stack is assumed to grow downward (i.e. from high
; *                        memory to low memory).  'pbos' will thus point to the LOWEST (valid) memory
; *                        location of the stack.  If OS_STK_GROWTH is set to 0, 'pbos' will point to the
; *                        HIGHEST memory location of the stack and the stack will grow with increasing
; *                        memory locations.  'pbos' MUST point to a valid 'free' data item.
; *
; *              stk_size  is the size of the stack in number of elements.  If OS_STK is set to INT8U,
; *                        'stk_size' corresponds to the number of bytes available.  If OS_STK is set to
; *                        INT16U, 'stk_size' contains the number of 16-bit entries available.  Finally, if
; *                        OS_STK is set to INT32U, 'stk_size' contains the number of 32-bit entries
; *                        available on the stack.
; *
; *              pext      is a pointer to a user supplied memory location which is used as a TCB extension.
; *                        For example, this user memory can hold the contents of floating-point registers
; *                        during a context switch, the time each task takes to execute, the number of times
; *                        the task has been switched-in, etc.
; *
; *              opt       contains additional information (or options) about the behavior of the task.  The
; *                        LOWER 8-bits are reserved by uC/OS-II while the upper 8 bits can be application
; *                        specific.  See OS_TASK_OPT_??? in uCOS-II.H.  Current choices are:
; *
; *                        OS_TASK_OPT_STK_CHK      Stack checking to be allowed for the task
; *                        OS_TASK_OPT_STK_CLR      Clear the stack when the task is created
; *                        OS_TASK_OPT_SAVE_FP      If the CPU has floating-point registers, save them
; *                                                 during a context switch.
; *
; * Returns    : OS_NO_ERR               if the function was successful.
; *              OS_PRIO_EXIT            if the task priority already exist
; *                                      (each task MUST have a unique priority).
; *              OS_PRIO_INVALID         if the priority you specify is higher that the maximum allowed
; *                                      (i.e. > OS_LOWEST_PRIO)
; *              OS_ERR_TASK_CREATE_ISR  if you tried to create a task from an ISR.
; *********************************************************************************************************
; */
; /*$PAGE*/
; #if OS_TASK_CREATE_EXT_EN > 0
; INT8U  OSTaskCreateExt (void   (*task)(void *p_arg),
;                         void    *p_arg,
;                         OS_STK  *ptos,
;                         INT8U    prio,
;                         INT16U   id,
;                         OS_STK  *pbos,
;                         INT32U   stk_size,
;                         void    *pext,
;                         INT16U   opt)
; {
;     OS_STK    *psp;
;     INT8U      err;
; #if OS_CRITICAL_METHOD == 3                  /* Allocate storage for CPU status register               */
;     OS_CPU_SR  cpu_sr = 0;
; #endif
; 
; 
; 
; #if OS_ARG_CHK_EN > 0
;     if (prio > OS_LOWEST_PRIO) {             /* Make sure priority is within allowable range           */
;         return (OS_PRIO_INVALID);
;     }
; #endif
;     OS_ENTER_CRITICAL();
;     if (OSIntNesting > 0) {                  /* Make sure we don't create the task from within an ISR  */
;         OS_EXIT_CRITICAL();
;         return (OS_ERR_TASK_CREATE_ISR);
;     }
;     if (OSTCBPrioTbl[prio] == (OS_TCB *)0) { /* Make sure task doesn't already exist at this priority  */
;         OSTCBPrioTbl[prio] = (OS_TCB *)1;    /* Reserve the priority to prevent others from doing ...  */
;                                              /* ... the same thing until task is created.              */
;         OS_EXIT_CRITICAL();
; 
;         OS_TaskStkClr(pbos, stk_size, opt);                    /* Clear the task stack (if needed)     */
; 
;         psp = OSTaskStkInit(task, p_arg, ptos, opt);           /* Initialize the task's stack          */
;         err = OS_TCBInit(prio, psp, pbos, id, stk_size, pext, opt);
;         if (err == OS_NO_ERR) {
;             if (OSRunning == TRUE) {                           /* Find HPT if multitasking has started */
;                 OS_Sched();
;             }
;         } else {
;             OS_ENTER_CRITICAL();
;             OSTCBPrioTbl[prio] = (OS_TCB *)0;                  /* Make this priority avail. to others  */
;             OS_EXIT_CRITICAL();
;         }
;         return (err);
;     }
;     OS_EXIT_CRITICAL();
;     return (OS_PRIO_EXIST);
; }
; #endif
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                            DELETE A TASK
; *
; * Description: This function allows you to delete a task.  The calling task can delete itself by
; *              its own priority number.  The deleted task is returned to the dormant state and can be
; *              re-activated by creating the deleted task again.
; *
; * Arguments  : prio    is the priority of the task to delete.  Note that you can explicitely delete
; *                      the current task without knowing its priority level by setting 'prio' to
; *                      OS_PRIO_SELF.
; *
; * Returns    : OS_NO_ERR           if the call is successful
; *              OS_TASK_DEL_IDLE    if you attempted to delete uC/OS-II's idle task
; *              OS_PRIO_INVALID     if the priority you specify is higher that the maximum allowed
; *                                  (i.e. >= OS_LOWEST_PRIO) or, you have not specified OS_PRIO_SELF.
; *              OS_TASK_DEL_ERR     if the task you want to delete does not exist.
; *              OS_TASK_NOT_EXIST   if the task is assigned to a Mutex PIP.
; *              OS_TASK_DEL_ISR     if you tried to delete a task from an ISR
; *
; * Notes      : 1) To reduce interrupt latency, OSTaskDel() 'disables' the task:
; *                    a) by making it not ready
; *                    b) by removing it from any wait lists
; *                    c) by preventing OSTimeTick() from making the task ready to run.
; *                 The task can then be 'unlinked' from the miscellaneous structures in uC/OS-II.
; *              2) The function OS_Dummy() is called after OS_EXIT_CRITICAL() because, on most processors,
; *                 the next instruction following the enable interrupt instruction is ignored.
; *              3) An ISR cannot delete a task.
; *              4) The lock nesting counter is incremented because, for a brief instant, if the current
; *                 task is being deleted, the current task would not be able to be rescheduled because it
; *                 is removed from the ready list.  Incrementing the nesting counter prevents another task
; *                 from being schedule.  This means that an ISR would return to the current task which is
; *                 being deleted.  The rest of the deletion would thus be able to be completed.
; *********************************************************************************************************
; */
; /*$PAGE*/
; #if OS_TASK_DEL_EN > 0
; INT8U  OSTaskDel (INT8U prio)
; {
	.dbline 390
; #if OS_EVENT_EN
;     OS_EVENT     *pevent;
; #endif
; #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
;     OS_FLAG_NODE *pnode;
; #endif
;     OS_TCB       *ptcb;
; 	INT8U         y;
; #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
;     OS_CPU_SR     cpu_sr = 0;
	clr R20
	.dbline 395
; #endif
; 
; 
; 
;     if (OSIntNesting > 0) {                                     /* See if trying to delete from ISR    */
	clr R2
	lds R3,_OSIntNesting
	cp R2,R3
	brsh L11
	.dbline 395
	.dbline 396
;         return (OS_TASK_DEL_ISR);
	ldi R16,63
	xjmp L10
L11:
	.dbline 408
;     }
; #if OS_ARG_CHK_EN > 0
;     if (prio == OS_IDLE_PRIO) {                                 /* Not allowed to delete idle task     */
;         return (OS_TASK_DEL_IDLE);
;     }
;     if (prio >= OS_LOWEST_PRIO) {                               /* Task priority valid ?               */
;         if (prio != OS_PRIO_SELF) {
;             return (OS_PRIO_INVALID);
;         }
;     }
; #endif
;     OS_ENTER_CRITICAL();
	xcall _OS_CPU_SR_Save
	mov R20,R16
	.dbline 409
;     if (prio == OS_PRIO_SELF) {                                 /* See if requesting to delete self    */
	mov R24,R10
	cpi R24,255
	brne L13
	.dbline 409
	.dbline 410
;         prio = OSTCBCur->OSTCBPrio;                             /* Set priority to delete to current   */
	lds R30,_OSTCBCur
	lds R31,_OSTCBCur+1
	ldd R10,z+12
	.dbline 411
;     }
L13:
	.dbline 412
;     ptcb = OSTCBPrioTbl[prio];
	ldi R24,2
	mul R24,R10
	movw R30,R0
	ldi R24,<_OSTCBPrioTbl
	ldi R25,>_OSTCBPrioTbl
	add R30,R24
	adc R31,R25
	ldd R22,z+0
	ldd R23,z+1
	.dbline 413
;     if (ptcb == (OS_TCB *)0) {                                  /* Task to delete must exist           */
	cpi R22,0
	cpc R22,R23
	brne L15
X3:
	.dbline 413
	.dbline 414
;         OS_EXIT_CRITICAL();
	mov R16,R20
	xcall _OS_CPU_SR_Restore
	.dbline 415
;         return (OS_TASK_DEL_ERR);
	ldi R16,60
	xjmp L10
L15:
	.dbline 417
;     }
;     if (ptcb == (OS_TCB *)1) {                                  /* Must not be assigned to Mutex       */
	cpi R22,1
	ldi R30,0
	cpc R23,R30
	brne L17
	.dbline 417
	.dbline 418
;         OS_EXIT_CRITICAL();
	mov R16,R20
	xcall _OS_CPU_SR_Restore
	.dbline 419
;         return (OS_TASK_NOT_EXIST);
	ldi R16,11
	xjmp L10
L17:
	.dbline 421
;     }
; 	y            =  ptcb->OSTCBY;
	movw R30,R22
	ldd R14,z+14
	.dbline 422
; 	OSRdyTbl[y] &= ~ptcb->OSTCBBitX;
	ldi R24,<_OSRdyTbl
	ldi R25,>_OSRdyTbl
	mov R2,R14
	clr R3
	add R2,R24
	adc R3,R25
	movw R30,R22
	ldd R4,z+15
	com R4
	movw R30,R2
	ldd R5,z+0
	and R5,R4
	std z+0,R5
	.dbline 423
;     if (OSRdyTbl[y] == 0) {                                     /* Make task not ready                 */
	mov R30,R14
	clr R31
	add R30,R24
	adc R31,R25
	ldd R2,z+0
	tst R2
	brne L19
	.dbline 423
	.dbline 424
;         OSRdyGrp &= ~ptcb->OSTCBBitY;
	movw R30,R22
	ldd R2,z+16
	com R2
	lds R3,_OSRdyGrp
	and R3,R2
	sts _OSRdyGrp,R3
	.dbline 425
;     }
L19:
	.dbline 427
; #if OS_EVENT_EN
;     pevent = ptcb->OSTCBEventPtr;
	movw R30,R22
	ldd R12,z+6
	ldd R13,z+7
	.dbline 428
;     if (pevent != (OS_EVENT *)0) {                              /* If task is waiting on event         */
	tst R12
	brne X4
	tst R13
	brne X6
	xjmp L21
X6:
X4:
	.dbline 428
	.dbline 429
; 	    pevent->OSEventTbl[y] &= ~ptcb->OSTCBBitX;
	movw R24,R12
	adiw R24,6
	mov R2,R14
	clr R3
	add R2,R24
	adc R3,R25
	movw R30,R22
	ldd R4,z+15
	com R4
	movw R30,R2
	ldd R5,z+0
	and R5,R4
	std z+0,R5
	.dbline 430
;         if (pevent->OSEventTbl[y] == 0) {                       /* ... remove task from ...            */
	movw R24,R12
	adiw R24,6