133.htm

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

    OSTime++; <br>
    OS_EXIT_CRITICAL(); <br>
} <br>
/*$PAGE*/ <br>
/* <br>
********************************************************************************************************** <br>
*                                           SET SYSTEM CLOCK <br>
********************************************************************************************************** <br>

*/ <br>
  <br>
void OSTimeSet(ULONG ticks) <br>
{ <br>
    OS_ENTER_CRITICAL(); <br>
    OSTime = ticks; <br>
    OS_EXIT_CRITICAL(); <br>
} <br>
  <br>
  <br>
/* <br>
********************************************************************************************************** <br>
*                                        GET CURRENT SYSTEM TIME <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
ULONG OSTimeGet(void) <br>
{ <br>
    ULONG ticks; <br>
  <br>
  <br>
    OS_ENTER_CRITICAL(); <br>

    ticks = OSTime; <br>
    OS_EXIT_CRITICAL(); <br>
    return (ticks); <br>
} <br>
/*$PAGE*/ <br>
#if OS_SEM_EN <br>
/* <br>
********************************************************************************************************** <br>
*                                         INITIALIZE SEMAPHORE <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
OS_EVENT *OSSemCreate(UWORD cnt) <br>
{ <br>
    OS_EVENT *pevent; <br>
  <br>
  <br>
    OS_ENTER_CRITICAL(); <br>
    pevent = OSEventFreeList;                              /* Get next free evennt control block        */ <br>
    if (OSEventFreeList != (OS_EVENT *)0) {                /* See if pool of freee ECB pool was empty   */ <br>
        OSEventFreeList = (OS_EVENT *)OSEventFreeList->OSEventPtr; <br>
    } <br>
    } <br>
    OS_EXIT_CRITICAL(); <br>
    if (pevent != (OS_EVENT *)0) {                         /* Get an event contrrol block               */ <br>
        pevent->OSEventCnt    = cnt;                       /* Set semaphore valuue                      */ <br>
        pevent->OSEventGrp    = 0x00;                      /* Initialize rest off event control block   */ <br>
        pevent->OSEventTbl[0] = 0x00; <br>
        pevent->OSEventTbl[1] = 0x00; <br>
        pevent->OSEventTbl[2] = 0x00; <br>
        pevent->OSEventTbl[3] = 0x00; <br>
        pevent->OSEventTbl[4] = 0x00; <br>
        pevent->OSEventTbl[5] = 0x00; <br>
        pevent->OSEventTbl[6] = 0x00; <br>
        pevent->OSEventTbl[7] = 0x00; <br>
        return (pevent); <br>
    } else { <br>
        return ((OS_EVENT *)0); <br>
    } <br>
} <br>
  <br>
/*$PAGE*/ <br>
/* <br>
********************************************************************************************************** <br>
*                                           ACCEPT SEMAPHORE <br>

* <br>
* Description: This function checks the semaphore to see if the resource is avaiilable or if an event <br>
*              occurred.  Unlike OSSemPend(), OSSemAccept() does not suspend thee calling task if the <br>
*              resource is not available or the event did not occur. <br>
* Arguments  : 'pevent'   is a pointer to the event control block <br>
* Returns    : >  0       if the resource is available or the event did not occu <br>
*                         the semaphore is decremented so the next time OSSemAcccept() is called, the <br>
*                         resource will no longer be available. <br>
*              == 0       if the resource is not available or the event did not occur <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
UWORD OSSemAccept(OS_EVENT *pevent) <br>
{ <br>
    WORD cnt; <br>
  <br>
  <br>
    OS_ENTER_CRITICAL(); <br>
    cnt = pevent->OSEventCnt; <br>
    if (cnt > 0) {                               /* See if resource is availablee                       */ <br>
        pevent->OSEventCnt--;                    /* Yes, decrement semaphore andd notify caller         */ <br>
    } <br>
    } <br>
    OS_EXIT_CRITICAL(); <br>
    return (cnt);                                /* Return semaphore count <br>
} <br>
  <br>
/*$PAGE*/ <br>
/* <br>
********************************************************************************************************** <br>
*                                           PEND ON SEMAPHORE <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
void OSSemPend(OS_EVENT *pevent, UWORD timeout, UBYTE *err) <br>
{ <br>
    OS_ENTER_CRITICAL(); <br>
    if (pevent->OSEventCnt > 0) {                     /* If sem. is positive, reesource available ...   */ <br>
        pevent->OSEventCnt--;                         /* ... decrement semaphoree only if positive.     */ <br>
        OS_EXIT_CRITICAL(); <br>
        *err = OS_NO_ERR; <br>
    } else {                                          /* Otherwise, must wait unntil event occurs       */ <br>
        OSTCBCur->OSTCBStat    |= OS_STAT_SEM;        /* Resource not available,, pend on semaphore     */ <br>
        OSTCBCur->OSTCBDly      = timeout;            /* Store pend timeout in TTCB                     */ <br>
        OSTCBCur->OSTCBEventPtr = pevent;             /* Store pointer to ECB inn TCB                   */ <br>

        if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {  /* Tassk no longer ready      */ <br>
            OSRdyGrp &= ~OSTCBCur->OSTCBBitY; <br>
        } <br>
        pevent->OSEventTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;      /* Putt task in waiting list  */ <br>
        pevent->OSEventGrp                   |= OSTCBCur->OSTCBBitY; <br>
        OS_EXIT_CRITICAL(); <br>
        OSSched();                                    /* Find next highest priorrity task ready         */ <br>
        OS_ENTER_CRITICAL(); <br>
        if (OSTCBCur->OSTCBStat & OS_STAT_SEM) {      /* Must have timed out if still waiting for event*/ <br>
            if ((pevent->OSEventTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) === 0) { <br>
                pevent->OSEventGrp &= ~OSTCBCur->OSTCBBitY; <br>
            } <br>
            OSTCBCur->OSTCBStat     = OS_STAT_RDY;    /* Set status to ready <br>
            OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;  /* Task is no longer waitiing for the event       */ <br>
            OS_EXIT_CRITICAL(); <br>
            *err = OS_TIMEOUT;                        /* Indicate that didn't geet event within TO      */ <br>
        } else { <br>
            OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0; <br>
            OS_EXIT_CRITICAL(); <br>
            *err = OS_NO_ERR; <br>
        } <br>
    } <br>
    } <br>
} <br>
/*$PAGE*/ <br>
/* <br>
********************************************************************************************************** <br>
*                                         POST TO A SEMAPHORE <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
UBYTE OSSemPost(OS_EVENT *pevent) <br>
{ <br>
    OS_TCB *ptcb; <br>
    UBYTE   x; <br>
    UBYTE   y; <br>
    UBYTE   bitx; <br>
    UBYTE   bity; <br>
    UBYTE   p; <br>
  <br>
  <br>
    OS_ENTER_CRITICAL(); <br>
    if (pevent->OSEventGrp) {                         /* See if any task waitingg for semaphore         */ <br>
        y    = OSUnMapTbl[pevent->OSEventGrp];        /* Find highest priority ttask pending on event   */ <br>
        bity = OSMapTbl[y]; <br>

        x    = OSUnMapTbl[pevent->OSEventTbl[y]]; <br>
        bitx = OSMapTbl[x]; <br>
        p    = (y << 3) + x; <br>
        if ((pevent->OSEventTbl[y] &= ~bitx) == 0) {  /* Remove this task from tthe waiting list        */ <br>
            pevent->OSEventGrp &= ~bity; <br>
        } <br>
        ptcb                 =  OSTCBPrioTbl[p];      /* Point to this task's OSS_TCB                   */ <br>
        ptcb->OSTCBDly       =  0;                    /* Prevent OSTimeTick() frrom readying this task  */ <br>
        ptcb->OSTCBEventPtr  = (OS_EVENT *)0;         /* Unlink event control bllock from this task     */ <br>
        ptcb->OSTCBStat     &= ~OS_STAT_SEM;          /* Clear bit associated wiith event type          */ <br>
        if (ptcb->OSTCBStat == OS_STAT_RDY) {         /* See if task is ready (ccould be suspended)     */ <br>
            OSRdyGrp        |=  bity;                 /* Put task in the ready tto run list             */ <br>
            OSRdyTbl[y]     |=  bitx; <br>
        } <br>
        OS_EXIT_CRITICAL(); <br>
        OSSched();                                    /* Find highest priority ttask ready to run       */ <br>
        return (OS_NO_ERR); <br>
    } else { <br>
        if (pevent->OSEventCnt < 65535) {             /* Make sure semaphore willl not overflow         */ <br>
            pevent->OSEventCnt++;                     /* Increment semaphore couunt to register event   */ <br>
            OS_EXIT_CRITICAL(); <br>
            return (OS_NO_ERR); <br>

        } else {                                      /* Semaphore value has reaached its maximum       */ <br>
            OS_EXIT_CRITICAL(); <br>
            return (OS_SEM_OVF); <br>
        } <br>
    } <br>
} <br>
#endif <br>
/*$PAGE*/ <br>
#if OS_MBOX_EN <br>
/* <br>
********************************************************************************************************** <br>
*                                      INITIALIZE MESSAGE MAILBOX <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
OS_EVENT *OSMboxCreate(void *msg) <br>
{ <br>
    OS_EVENT *pevent; <br>
  <br>
  <br>
    OS_ENTER_CRITICAL(); <br>
    pevent = OSEventFreeList;                    /* Get next free event control block                  */ <br>

    if (OSEventFreeList != (OS_EVENT *)0) {      /* See if pool of free ECB pooll was empty             */ <br>
        OSEventFreeList = (OS_EVENT *)OSEventFreeList->OSEventPtr; <br>
    } <br>
    OS_EXIT_CRITICAL(); <br>
    if (pevent != (OS_EVENT *)0) { <br>
        pevent->OSEventPtr    = msg;             /* Deposit message in event conntrol block             */ <br>
        pevent->OSEventGrp    = 0x00;            /* Initialize rest of event conntrol block             */ <br>
        pevent->OSEventTbl[0] = 0x00; <br>
        pevent->OSEventTbl[1] = 0x00; <br>
        pevent->OSEventTbl[2] = 0x00; <br>
        pevent->OSEventTbl[3] = 0x00; <br>
        pevent->OSEventTbl[4] = 0x00; <br>
        pevent->OSEventTbl[5] = 0x00; <br>
        pevent->OSEventTbl[6] = 0x00; <br>
        pevent->OSEventTbl[7] = 0x00; <br>
    } <br>
    return (pevent);                             /* Return pointer to event conttrol block              */ <br>
} <br>
/*$PAGE*/ <br>
/* <br>
********************************************************************************************************** <br>
*                                     ACCEPT MESSAGE FROM MAILBOX <br>

* <br>
* Description: This function checks the mailbox to see if a message is availablee.  Unlike OSMboxPend(), <br>
*              OSMboxAccept() does not suspend the calling task if a message is not available. <br>
* Arguments  : 'pevent'      is a pointer to the event control block <br>
* Returns    : != (void *)0  is the message in the mailbox if one is available.  The mailbox is cleared <br>
*                            so the next time OSMboxAccept() is called, the maillbox will be empty. <br>
*              == (void *)0  if the mailbox is empty <br>
********************************************************************************************************** <br>
*/ <br>
  <br>
void *OSMboxAccept(OS_EVENT *pevent) <br>
{ <br>
    void  *msg; <br>
  <br>
  <br>
    OS_ENTER_CRITICAL(); <br>