ucos.s

uCOS源码

 1000550:	e1a0e000 	mov	lr, r0
    if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {      /* Task no longer ready      */
 1000554:	e59f0070 	ldr	r0, [pc, #70]	; 10005cc <OSEventTaskWait+0x88>
 1000558:	e24cb004 	sub	r11, r12, #4	; 0x4
 100055c:	e594c000 	ldr	r12, [r4]
 1000560:	e58ce00c 	str	lr, [r12, #12]
 1000564:	e5dc1017 	ldrb	r1, [r12, #23]
 1000568:	e5dc2018 	ldrb	r2, [r12, #24]
 100056c:	e7d03001 	ldrb	r3, [r0, r1]
 1000570:	e1c33002 	bic	r3, r3, r2
 1000574:	e3530000 	cmp	r3, #0	; 0x0
 1000578:	e7c13000 	strb	r3, [r1, r0]
 100057c:	1a000004 	bne	1000594 <OSEventTaskWait+0x50>
        OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
 1000580:	e59f1048 	ldr	r1, [pc, #48]	; 10005d0 <OSEventTaskWait+0x8c>
 1000584:	e5dc2019 	ldrb	r2, [r12, #25]
 1000588:	e5d13000 	ldrb	r3, [r1]
 100058c:	e1c33002 	bic	r3, r3, r2
 1000590:	e5c13000 	strb	r3, [r1]
    }
    pevent->OSEventTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;          /* Put task in waiting list  */
 1000594:	e5941000 	ldr	r1, [r4]
 1000598:	e5d1c017 	ldrb	r12, [r1, #23]
 100059c:	e5d12018 	ldrb	r2, [r1, #24]
 10005a0:	e28e0004 	add	r0, lr, #4	; 0x4
 10005a4:	e7d0300c 	ldrb	r3, [r0, r12]
 10005a8:	e1833002 	orr	r3, r3, r2
 10005ac:	e7c0300c 	strb	r3, [r0, r12]
    pevent->OSEventGrp                   |= OSTCBCur->OSTCBBitY;
 10005b0:	e5941000 	ldr	r1, [r4]
 10005b4:	e5de300d 	ldrb	r3, [lr, #13]
 10005b8:	e5d12019 	ldrb	r2, [r1, #25]
 10005bc:	e1833002 	orr	r3, r3, r2
 10005c0:	e5ce300d 	strb	r3, [lr, #13]
 10005c4:	e91ba810 	ldmdb	r11, {r4, r11, sp, pc}
 10005c8:	010070b8 	streqh	r7, [r0, -r8]
 10005cc:	010070ac 	tsteq	r0, r12, lsr #1
 10005d0:	010070a8 	tsteq	r0, r8, lsr #1

010005d4 <OSEventTO>:
 10005d4:	e1a0c00d 	mov	r12, sp
 10005d8:	e92dd800 	stmdb	sp!, {r11, r12, lr, pc}
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                              MAKE TASK READY TO RUN BASED ON EVENT TIMEOUT
*
* Description: This function is called by other uC/OS-II services to make a task ready to run because a
*              timeout occurred.
*
* Arguments  : pevent   is a pointer to the event control block which is readying a task.
*
* Returns    : none
*
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if  (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
void  OSEventTO (OS_EVENT *pevent)
{
    if ((pevent->OSEventTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {
 10005dc:	e59fe050 	ldr	lr, [pc, #50]	; 1000634 <OSEventTO+0x60>
 10005e0:	e59e3000 	ldr	r3, [lr]
 10005e4:	e24cb004 	sub	r11, r12, #4	; 0x4
 10005e8:	e5d3c017 	ldrb	r12, [r3, #23]
 10005ec:	e5d31018 	ldrb	r1, [r3, #24]
 10005f0:	e2802004 	add	r2, r0, #4	; 0x4
 10005f4:	e7d2300c 	ldrb	r3, [r2, r12]
 10005f8:	e1c33001 	bic	r3, r3, r1
 10005fc:	e3530000 	cmp	r3, #0	; 0x0
 1000600:	e7c2300c 	strb	r3, [r2, r12]
 1000604:	1a000004 	bne	100061c <OSEventTO+0x48>
        pevent->OSEventGrp &= ~OSTCBCur->OSTCBBitY;
 1000608:	e59e3000 	ldr	r3, [lr]
 100060c:	e5d0200d 	ldrb	r2, [r0, #13]
 1000610:	e5d31019 	ldrb	r1, [r3, #25]
 1000614:	e1c22001 	bic	r2, r2, r1
 1000618:	e5c0200d 	strb	r2, [r0, #13]
    }
    OSTCBCur->OSTCBStat     = OS_STAT_RDY;       /* Set status to ready                                */
 100061c:	e59e3000 	ldr	r3, [lr]
 1000620:	e3a01000 	mov	r1, #0	; 0x0
 1000624:	e5c31014 	strb	r1, [r3, #20]
    OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;     /* No longer waiting for event                        */
 1000628:	e59e2000 	ldr	r2, [lr]
 100062c:	e582100c 	str	r1, [r2, #12]
 1000630:	e91ba800 	ldmdb	r11, {r11, sp, pc}
 1000634:	010070b8 	streqh	r7, [r0, -r8]

01000638 <OSEventWaitListInit>:
 1000638:	e1a0c00d 	mov	r12, sp
 100063c:	e92dd800 	stmdb	sp!, {r11, r12, lr, pc}
 1000640:	e24cb004 	sub	r11, r12, #4	; 0x4
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                 INITIALIZE EVENT CONTROL BLOCK'S WAIT LIST
*
* Description: This function is called by other uC/OS-II services to initialize the event wait list.
*
* Arguments  : pevent    is a pointer to the event control block allocated to the event.
*
* Returns    : none
*
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if  (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
void  OSEventWaitListInit (OS_EVENT *pevent)
{
    INT8U i;
    
    
    pevent->OSEventGrp = 0x00;                   /* No task waiting on event                           */
 1000644:	e3a03000 	mov	r3, #0	; 0x0
    for (i = 0; i < OS_EVENT_TBL_SIZE; i++) {
 1000648:	e1a02003 	mov	r2, r3
 100064c:	e2801004 	add	r1, r0, #4	; 0x4
 1000650:	e1a0c002 	mov	r12, r2
 1000654:	e5c0300d 	strb	r3, [r0, #13]
 1000658:	e2823001 	add	r3, r2, #1	; 0x1
        pevent->OSEventTbl[i] = 0x00;
 100065c:	e7c1c002 	strb	r12, [r1, r2]
 1000660:	e20320ff 	and	r2, r3, #255	; 0xff
 1000664:	e3520001 	cmp	r2, #1	; 0x1
 1000668:	9afffffa 	bls	1000658 <OSEventWaitListInit+0x20>
    }
}
 100066c:	e91ba800 	ldmdb	r11, {r11, sp, pc}

01000670 <OSInit>:
 1000670:	e1a0c00d 	mov	r12, sp
 1000674:	e92dd810 	stmdb	sp!, {r4, r11, r12, lr, pc}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                             INITIALIZATION
*
* Description: This function is used to initialize the internals of uC/OS-II and MUST be called prior to
*              creating any uC/OS-II object and, prior to calling OSStart().
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

void OSInit (void)
{
    INT16U i;


    OSTime        = 0L;                                    /* Clear the 32-bit system clock            */
    OSIntNesting  = 0;                                     /* Clear the interrupt nesting counter      */
    OSLockNesting = 0;                                     /* Clear the scheduling lock counter        */
#if OS_TASK_CREATE_EN  || OS_TASK_CREATE_EXT_EN || OS_TASK_DEL_EN
    OSTaskCtr     = 0;                                     /* Clear the number of tasks                */
#endif
    OSRunning     = FALSE;                                 /* Indicate that multitasking not started   */
    OSIdleCtr     = 0L;                                    /* Clear the 32-bit idle counter            */
#if OS_TASK_STAT_EN && OS_TASK_CREATE_EXT_EN
    OSIdleCtrRun  = 0L;
    OSIdleCtrMax  = 0L;
    OSStatRdy     = FALSE;                                 /* Statistic task is not ready              */
#endif
    OSCtxSwCtr    = 0;                                     /* Clear the context switch counter         */
    OSRdyGrp      = 0;                                     /* Clear the ready list                     */
    for (i = 0; i < OS_RDY_TBL_SIZE; i++) {
 1000678:	e59fe118 	ldr	lr, [pc, #118]	; 1000798 <OSInit+0x128>
 100067c:	e59f4118 	ldr	r4, [pc, #118]	; 100079c <OSInit+0x12c>
 1000680:	e24cb004 	sub	r11, r12, #4	; 0x4
 1000684:	e59fc114 	ldr	r12, [pc, #114]	; 10007a0 <OSInit+0x130>
 1000688:	e59f2114 	ldr	r2, [pc, #114]	; 10007a4 <OSInit+0x134>
 100068c:	e59f3114 	ldr	r3, [pc, #114]	; 10007a8 <OSInit+0x138>
 1000690:	e3a01000 	mov	r1, #0	; 0x0
 1000694:	e5821000 	str	r1, [r2]
 1000698:	e5c31000 	strb	r1, [r3]
 100069c:	e59f2108 	ldr	r2, [pc, #108]	; 10007ac <OSInit+0x13c>
 10006a0:	e59f3108 	ldr	r3, [pc, #108]	; 10007b0 <OSInit+0x140>
 10006a4:	e5c21000 	strb	r1, [r2]
 10006a8:	e5c31000 	strb	r1, [r3]
 10006ac:	e59f2100 	ldr	r2, [pc, #100]	; 10007b4 <OSInit+0x144>
 10006b0:	e59f3100 	ldr	r3, [pc, #100]	; 10007b8 <OSInit+0x148>
 10006b4:	e5c21000 	strb	r1, [r2]
 10006b8:	e5831000 	str	r1, [r3]
 10006bc:	e59f20f8 	ldr	r2, [pc, #f8]	; 10007bc <OSInit+0x14c>
 10006c0:	e59f30f8 	ldr	r3, [pc, #f8]	; 10007c0 <OSInit+0x150>
 10006c4:	e5821000 	str	r1, [r2]
 10006c8:	e1a02001 	mov	r2, r1
 10006cc:	e1a00002 	mov	r0, r2
 10006d0:	e5c31000 	strb	r1, [r3]
        OSRdyTbl[i] = 0;
 10006d4:	e7cc0002 	strb	r0, [r12, r2]
 10006d8:	e2822001 	add	r2, r2, #1	; 0x1
 10006dc:	e3520001 	cmp	r2, #1	; 0x1
 10006e0:	9afffffb 	bls	10006d4 <OSInit+0x64>
    }
                
    OSPrioCur     = 0;
 10006e4:	e59f30d8 	ldr	r3, [pc, #d8]	; 10007c4 <OSInit+0x154>
    OSPrioHighRdy = 0;                                           
 10006e8:	e59f20d8 	ldr	r2, [pc, #d8]	; 10007c8 <OSInit+0x158>
 10006ec:	e3a01000 	mov	r1, #0	; 0x0
 10006f0:	e5c31000 	strb	r1, [r3]
 10006f4:	e5c21000 	strb	r1, [r2]
    OSTCBHighRdy  = (OS_TCB *)0;                                 /* TCB Initialization                 */
 10006f8:	e59f30cc 	ldr	r3, [pc, #cc]	; 10007cc <OSInit+0x15c>
    OSTCBCur      = (OS_TCB *)0;
 10006fc:	e59f20cc 	ldr	r2, [pc, #cc]	; 10007d0 <OSInit+0x160>
 1000700:	e5831000 	str	r1, [r3]
 1000704:	e5821000 	str	r1, [r2]
    OSTCBList     = (OS_TCB *)0;
 1000708:	e59f30c4 	ldr	r3, [pc, #c4]	; 10007d4 <OSInit+0x164>
    for (i = 0; i < (OS_LOWEST_PRIO + 1); i++) {                 /* Clear the priority table           */
 100070c:	e1a02001 	mov	r2, r1
 1000710:	e5831000 	str	r1, [r3]
 1000714:	e59f30bc 	ldr	r3, [pc, #bc]	; 10007d8 <OSInit+0x168>
        OSTCBPrioTbl[i] = (OS_TCB *)0;
 1000718:	e7831102 	str	r1, [r3, r2, lsl #2]
 100071c:	e2822001 	add	r2, r2, #1	; 0x1
 1000720:	e352000c 	cmp	r2, #12	; 0xc
 1000724:	9afffffb 	bls	1000718 <OSInit+0xa8>
    }
    for (i = 0; i < (OS_MAX_TASKS + OS_N_SYS_TASKS - 1); i++) {  /* Init. list of free TCBs            */
 1000728:	e59f3068 	ldr	r3, [pc, #68]	; 1000798 <OSInit+0x128>
 100072c:	e3a02000 	mov	r2, #0	; 0x0
 1000730:	e2831004 	add	r1, r3, #4	; 0x4
 1000734:	e283301c 	add	r3, r3, #28	; 0x1c
        OSTCBTbl[i].OSTCBNext = &OSTCBTbl[i + 1];
 1000738:	e481301c 	str	r3, [r1], #28
 100073c:	e283301c 	add	r3, r3, #28	; 0x1c
 1000740:	e2822001 	add	r2, r2, #1	; 0x1
 1000744:	e352000a 	cmp	r2, #10	; 0xa
 1000748:	9afffffa 	bls	1000738 <OSInit+0xc8>
    }
    OSTCBTbl[OS_MAX_TASKS + OS_N_SYS_TASKS - 1].OSTCBNext = (OS_TCB *)0;    /* Last OS_TCB             */
 100074c:	e3a02000 	mov	r2, #0	; 0x0
 1000750:	e58e2138 	str	r2, [lr, #312]
    OSTCBFreeList                                         = &OSTCBTbl[0];
 1000754:	e59f3080 	ldr	r3, [pc, #80]	; 10007dc <OSInit+0x16c>

#if OS_MAX_EVENTS >= 2
    for (i = 0; i < (OS_MAX_EVENTS - 1); i++) {            /* Init. list of free EVENT control blocks  */
 1000758:	e59f003c 	ldr	r0, [pc, #3c]	; 100079c <OSInit+0x12c>
 100075c:	e583e000 	str	lr, [r3]
 1000760:	e2803010 	add	r3, r0, #16	; 0x10
        OSEventTbl[i].OSEventPtr = (OS_EVENT *)&OSEventTbl[i + 1];
 1000764:	e7803202 	str	r3, [r0, r2, lsl #4]
 1000768:	e2833010 	add	r3, r3, #16	; 0x10
 100076c:	e2922001 	adds	r2, r2, #1	; 0x1
 1000770:	0afffffb 	beq	1000764 <OSInit+0xf4>
    }
    OSEventTbl[OS_MAX_EVENTS - 1].OSEventPtr = (OS_EVENT *)0;
 1000774:	e3a01000 	mov	r1, #0	; 0x0
 1000778:	e5841010 	str	r1, [r4, #16]
    OSEventFreeList                          = &OSEventTbl[0];    
#endif

#if OS_Q_EN && (OS_MAX_QS >= 2)
    OSQInit();                                             /* Initialize the message queue structures  */
#endif

#if OS_MEM_EN && OS_MAX_MEM_PART >= 2
    OSMemInit();                                           /* Initialize the memory manager            */
#endif    

#if OS_STK_GROWTH == 1
    #if OS_TASK_CREATE_EXT_EN
    OSTaskCreateExt(OSTaskIdle, 
                    (void *)0,                                 /* No arguments passed to OSTaskIdle()  */
                    &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Top-Of-Stack                     */
                    OS_IDLE_PRIO,                              /* Lowest priority level                */
                    OS_TASK_IDLE_ID,
                    &OSTaskIdleStk[0],                         /* Set Bottom-Of-Stack                  */
                    OS_TASK_IDLE_STK_SIZE, 
                    (void *)0,                                 /* No TCB extension                     */
                    OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
    #else
    OSTaskCreate(OSTaskIdle, (void *)0, &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], OS_IDLE_PRIO);
 100077c:	e59f005c 	ldr	r0, [pc, #5c]	; 10007e0 <OSInit+0x170>
 1000780:	e59f305c 	ldr	r3, [pc, #5c]	; 10007e4 <OSInit+0x174>
 1000784:	e59f205c 	ldr	r2, [pc, #5c]	; 10007e8 <OSInit+0x178>
 1000788:	e5834000 	str	r4, [r3]
 100078c:	e3a0300c 	mov	r3, #12	; 0xc
 1000790:	eb0001fe 	bl	1000f90 <OSTaskCreate>
    #endif
#else
    #if OS_TASK_CREATE_EXT_EN
    OSTaskCreateExt(OSTaskIdle, 
                    (void *)0,                                 /* No arguments passed to OSTaskIdle()  */
                    &OSTaskIdleStk[0],                         /* Set Top-Of-Stack                     */
                    OS_IDLE_PRIO,                              /* Lowest priority level                */
                    OS_TASK_IDLE_ID,
                    &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Bottom-Of-Stack                  */
                    OS_TASK_IDLE_STK_SIZE, 
                    (void *)0,                                 /* No TCB extension                     */
                    OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
    #else
    OSTaskCreate(OSTaskIdle, (void *)0, &OSTaskIdleStk[0], OS_IDLE_PRIO);
    #endif
#endif

#if OS_TASK_STAT_EN 
    #if OS_TASK_CREATE_EXT_EN
        #if OS_STK_GROWTH == 1
        OSTaskCreateExt(OSTaskStat, 
                        (void *)0,                                /* No args passed to OSTaskStat()    */
                        &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],/* Set Top-Of-Stack                  */
                        OS_STAT_PRIO,                             /* One higher than the idle task     */
                        OS_TASK_STAT_ID,
                        &OSTaskStatStk[0],                        /* Set Bottom-Of-Stack               */
                        OS_TASK_STAT_STK_SIZE, 
                        (void *)0,                                /* No TCB extension                  */
                        OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
        #else
        OSTaskCreateExt(OSTaskStat,