133.htm

pcb设计资料初学者难得的入门资料包含工厂制作过程

  <br>
  <br>
/* <br>
********************************************************************************************************** <br>
*                                          ENABLE SCHEDULING <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
void OSSchedUnlock(void) <br>
{ <br>
    if (OSRunning == TRUE) {                           /* Make sure multitaskingg is running            */ <br>
        OS_ENTER_CRITICAL(); <br>

        if (OSLockNesting != 0) {                      /* Do not decrement if allready 0                */ <br>
            OSLockNesting--;                           /* Decrement lock nestingg level                 */ <br>
            if ((OSLockNesting | OSIntNesting) == 0) { /* See if scheduling re-eenabled and not an ISR  */ <br>
                OS_EXIT_CRITICAL(); <br>
                OSSched();                             /* See if a higher prioriity task is ready       */ <br>
            } else { <br>
                OS_EXIT_CRITICAL(); <br>
            } <br>
        } else { <br>
            OS_EXIT_CRITICAL(); <br>
        } <br>
    } <br>
} <br>
/*$PAGE*/ <br>
/* <br>
********************************************************************************************************** <br>
*                                            INITIALIZE TCB <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
UBYTE OSTCBInit(UBYTE prio, void OS_FAR *stk) <br>
{ <br>
{ <br>
    OS_TCB *ptcb; <br>
  <br>
  <br>
    OS_ENTER_CRITICAL(); <br>
    ptcb = OSTCBFreeList;                                  /* Get a free TCB froom the free TCB list    */ <br>
    if (ptcb != (OS_TCB *)0) { <br>
        OSTCBFreeList           = ptcb->OSTCBNext;         /* Update pointer to free TCB list          */ <br>
        OS_EXIT_CRITICAL(); <br>
        ptcb->OSTCBStkPtr       = stk;                     /* Load Stack pointerr in TCB                */ <br>
        ptcb->OSTCBPrio         = (UBYTE)prio;             /* Load task priorityy into TCB              */ <br>
        ptcb->OSTCBStat         = OS_STAT_RDY;             /* Task is ready to rrun                     */ <br>
        ptcb->OSTCBDly          = 0; <br>
        ptcb->OSTCBDelReq       = OS_NO_ERR; <br>
        ptcb->OSTCBY            = prio >> 3; <br>
        ptcb->OSTCBBitY         = OSMapTbl[ptcb->OSTCBY]; <br>
        ptcb->OSTCBX            = prio & 0x07; <br>
        ptcb->OSTCBBitX         = OSMapTbl[ptcb->OSTCBX]; <br>
        ptcb->OSTCBEventPtr     = (OS_EVENT *)0;           /* Task is not pendinng on an event          */ <br>
        ptcb->OSTCBMsg          = (void *)0;               /* No message receiveed                      */ <br>
        OS_ENTER_CRITICAL(); <br>
        OSTCBPrioTbl[prio]      = ptcb; <br>
        ptcb->OSTCBNext         = OSTCBList;               /* Link into TCB chaiin                      */ <br>

        ptcb->OSTCBPrev         = (OS_TCB *)0; <br>
        if (OSTCBList != (OS_TCB *)0) { <br>
            OSTCBList->OSTCBPrev = ptcb; <br>
        } <br>
        OSTCBList               = ptcb; <br>
        OSRdyGrp               |= ptcb->OSTCBBitY;         /* Make task ready too run                   */ <br>
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX; <br>
        OS_EXIT_CRITICAL(); <br>
        return (OS_NO_ERR); <br>
    } else { <br>
        OS_EXIT_CRITICAL(); <br>
        return (OS_NO_MORE_TCB); <br>
    } <br>
} <br>
/*$PAGE*/ <br>
/* <br>
********************************************************************************************************** <br>
*                                               ENTER ISR <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
void OSIntEnter(void) <br>

{ <br>
    OS_ENTER_CRITICAL(); <br>
    OSIntNesting++;                              /* Increment ISR nesting level                        */ <br>
    OS_EXIT_CRITICAL(); <br>
} <br>
  <br>
  <br>
/* <br>
********************************************************************************************************** <br>
*                                               EXIT ISR <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
void OSIntExit(void) <br>
{ <br>
    OS_ENTER_CRITICAL(); <br>
    if ((--OSIntNesting | OSLockNesting) == 0) { /* Reschedule only if all ISRs completed & not locked */ <br>
        OSIntExitY   = OSUnMapTbl[OSRdyGrp]; <br>
        OSTCBHighRdy = OSTCBPrioTbl[(OSIntExitY << 3) + OSUnMapTbl[OSRdyTbl[OSInntExitY]]]; <br>
        if (OSTCBHighRdy != OSTCBCur) {          /* No context switch if currentt task is highest ready */ <br>
            OSCtxSwCtr++; <br>
            OSIntCtxSw();                        /* Perform interrupt level conttext switch             */ <br>

        } <br>
    } <br>
    OS_EXIT_CRITICAL(); <br>
} <br>
/*$PAGE*/ <br>
#if OS_TASK_CHANGE_PRIO_EN <br>
/* <br>
********************************************************************************************************** <br>
*                                       CHANGE PRIORITY OF A TASK <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
UBYTE OSTaskChangePrio(UBYTE oldprio, UBYTE newprio) <br>
{ <br>
    OS_TCB   *ptcb; <br>
    OS_EVENT *pevent; <br>
    UBYTE     x; <br>
    UBYTE     y; <br>
    UBYTE     bitx; <br>
    UBYTE     bity; <br>
  <br>
  <br>
  <br>
  <br>
    if (oldprio >= OS_MAX_TASKS || newprio >= OS_MAX_TASKS) { <br>
        return (OS_PRIO_INVALID); <br>
    } <br>
    OS_ENTER_CRITICAL(); <br>
    if (OSTCBPrioTbl[newprio] != (OS_TCB *)0) {                 /* New priority must not already exist */ <br>
        OS_EXIT_CRITICAL(); <br>
        return (OS_PRIO_EXIST); <br>
    } else { <br>
        OS_EXIT_CRITICAL(); <br>
        y    = newprio >> 3;                                    /* Precompute too reduce INT. latency   */ <br>
        bity = OSMapTbl[y]; <br>
        x    = newprio & 0x07; <br>
        bitx = OSMapTbl[x]; <br>
        OS_ENTER_CRITICAL(); <br>
        if ((ptcb = OSTCBPrioTbl[oldprio]) != (OS_TCB *)0) {    /* Task to changge must exist           */ <br>
            OSTCBPrioTbl[oldprio] = (OS_TCB *)0;                /* Remove TCB frrom old priority        */ <br>
            if (OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) {     /* If task is reeady make it not ready  */ <br>
                if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) { <br>
                    OSRdyGrp &= ~ptcb->OSTCBBitY; <br>
                } <br>
                OSRdyGrp    |= bity;                            /* Make new prioority ready to run      */ <br>

                OSRdyTbl[y] |= bitx; <br>
            } else { <br>
                if ((pevent = ptcb->OSTCBEventPtr) != (OS_EVENT *)0) { /* Removee from event wait list  */ <br>
                    if ((pevent->OSEventTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) === 0) { <br>
                        pevent->OSEventGrp &= ~ptcb->OSTCBBitY; <br>
                    } <br>
                    pevent->OSEventGrp    |= bity; <br>
                    pevent->OSEventTbl[y] |= bitx; <br>
                } <br>
            } <br>
            OSTCBPrioTbl[newprio] = ptcb;                       /* Place pointerr to TCB @ new priority */ <br>
            ptcb->OSTCBPrio       = newprio;                    /* Set new task priority               */ <br>
            ptcb->OSTCBY          = y; <br>
            ptcb->OSTCBX          = x; <br>
            ptcb->OSTCBBitY       = bity; <br>
            ptcb->OSTCBBitX       = bitx; <br>
            OS_EXIT_CRITICAL(); <br>
            OSSched();                                          /* Run highest ppriority task ready     */ <br>
            return (OS_NO_ERR); <br>
        } else { <br>
            OS_EXIT_CRITICAL(); <br>
            return (OS_PRIO_ERR);                               /* Task to changge didn't exist         */ <br>

        } <br>
    } <br>
} <br>
#endif <br>
/*$PAGE*/ <br>
#if OS_TASK_DEL_EN <br>
/* <br>
********************************************************************************************************** <br>
*                                            DELETE A TASK <br>
* <br>
* Notes: <br>
*    1) To reduce interrupt latency, OSTaskDel() 'disables' the task: <br>
*           a) by making it not ready <br>
*           b) by removing it from any wait lists <br>
*           c) by preventing OSTimeTick() from making the task ready to run. <br>
*       The task can then be 'unlinked' from the miscellaneous structures in uC//OS. <br>
*    2) The function OSDummy() is called after OS_EXIT_CRITICAL() because, on moost processors, the next <br>
*       instruction following the enable interrupt instruction is ignored.  You can replace OSDummy() <br>
*       with a macro that basically executes a NO OP (i.e. OS_NOP()).  The NO OPP macro would avoid the <br>
*       execution time of the function call and return. <br>
********************************************************************************************************** <br>
*/ <br>
*/ <br>
/*$PAGE*/ <br>
UBYTE OSTaskDel(UBYTE prio) <br>
{ <br>
    OS_TCB   *ptcb; <br>
    OS_EVENT *pevent; <br>
    UBYTE     priocur; <br>
  <br>
  <br>
    if (prio == OS_LO_PRIO) {                                   /* Not allowed tto delete idle task     */ <br>
        return (OS_TASK_DEL_IDLE); <br>
    } <br>
    if (prio >= OS_MAX_TASKS && prio != OS_PRIO_SELF) {         /* Make sure tassk priority is valid    */ <br>
        return (OS_PRIO_INVALID); <br>
    } <br>
    OS_ENTER_CRITICAL(); <br>
    priocur = OSTCBCur->OSTCBPrio;                              /* Obtain the cuurrent priority         */ <br>
    if (prio == OS_PRIO_SELF) {                                 /* See if requessting to delete self    */ <br>
        prio = priocur;                                         /* Set priority to delete to current   */ <br>
    } <br>
    if ((ptcb = OSTCBPrioTbl[prio]) != (OS_TCB *)0) {           /* Task to delette must exist           */ <br>
        OSTCBPrioTbl[prio] = (OS_TCB *)0;                       /* Clear old priiority entry            */ <br>
        if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) {/* Make task nott ready                 */ <br>

            OSRdyGrp &= ~ptcb->OSTCBBitY; <br>
        } <br>
        if ((pevent = ptcb->OSTCBEventPtr) != (OS_EVENT *)0) {  /* If task is waaiting on event         */ <br>
            if ((pevent->OSEventTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) { //* ... remove task from */ <br>
                pevent->OSEventGrp &= ~ptcb->OSTCBBitY;                        //* ... event ctrl block */ <br>
            } <br>
        } <br>
        ptcb->OSTCBDly = 0;                                     /* Prevent OSTimmeTick() from updating  */ <br>
        OS_EXIT_CRITICAL();                                     /* Enabling INT.. ignores next instruc. */ <br>
        OSDummy();                                              /* ... Dummy enssures that INTs will be */ <br>
        OS_ENTER_CRITICAL();                                    /* ... disabled HERE!                  */ <br>
        if (ptcb->OSTCBPrev == (OS_TCB *)0) {                   /* Remove from TTCB chain               */ <br>
            ptcb->OSTCBNext->OSTCBPrev = (OS_TCB *)0; <br>
            OSTCBList                  = ptcb->OSTCBNext; <br>
        } else { <br>
            ptcb->OSTCBPrev->OSTCBNext = ptcb->OSTCBNext; <br>
            ptcb->OSTCBNext->OSTCBPrev = ptcb->OSTCBPrev; <br>
        } <br>
        ptcb->OSTCBNext = OSTCBFreeList;                        /* Return TCB too free TCB list         */ <br>
        OSTCBFreeList   = ptcb; <br>
        if (prio == priocur) {                                  /* Resched. onlyy if deleting self!     */ <br>
            OS_EXIT_CRITICAL(); <br>

            OSSched();                                          /* Find new highhest priority task      */ <br>
        } else { <br>
            OS_EXIT_CRITICAL(); <br>
        } <br>
        return (OS_NO_ERR); <br>
    } else { <br>
        OS_EXIT_CRITICAL(); <br>
        return (OS_TASK_DEL_ERR); <br>
    } <br>
} <br>
/*$PAGE*/ <br>
/* <br>