ucos.c

比较老的ucos最初的版本

        psem->OSSemTbl[4] = 0x00;
        psem->OSSemTbl[5] = 0x00;
        psem->OSSemTbl[6] = 0x00;
        psem->OSSemTbl[7] = 0x00;
        OS_EXIT_CRITICAL();
        return (OS_NO_ERR);
    } else {
        OS_EXIT_CRITICAL();
        return (OS_SEM_ERR);
    }
}
/*
************************************************************
*                     PEND ON SEMAPHORE
************************************************************
*/
UBYTE OSSemPend(OS_SEM *psem, UWORD timeout)
{
    UBYTE x, y, bitx, bity;


    OS_ENTER_CRITICAL();
    if (psem->OSSemCnt-- > 0) {
        OS_EXIT_CRITICAL();
        return (OS_NO_ERR);
    } else {
        OSTCBCur->OSTCBStat |= OS_STAT_SEM;
        OSTCBCur->OSTCBDly   = timeout;
        y                    = OSTCBCur->OSTCBPrio >> 3;
        x                    = OSTCBCur->OSTCBPrio & 0x07;
        bity                 = OSMapTbl[y];
        bitx                 = OSMapTbl[x];
        if ((OSRdyTbl[y] &= ~bitx) == 0)
            OSRdyGrp &= ~bity;
        psem->OSSemTbl[y] |= bitx;
        psem->OSSemGrp    |= bity;
        OS_EXIT_CRITICAL();
        OSSched();
        OS_ENTER_CRITICAL();
        if (OSTCBCur->OSTCBStat & OS_STAT_SEM) {
            if ((psem->OSSemTbl[y] &= ~bitx) == 0) {
                psem->OSSemGrp &= ~bity;
            }
            OSTCBCur->OSTCBStat = OS_STAT_RDY;
            OS_EXIT_CRITICAL();
            return (OS_TIMEOUT);
        } else {
            OS_EXIT_CRITICAL();
            return (OS_NO_ERR);
        }
    }
}
/*
************************************************************
*                    POST TO A SEMAPHORE
************************************************************
*/
UBYTE OSSemPost(OS_SEM *psem)
{
    UBYTE x, y, bitx, bity, p;


    OS_ENTER_CRITICAL();
    if (psem->OSSemCnt < 32767) {
        if (psem->OSSemCnt++ >= 0) {
            OS_EXIT_CRITICAL();
        } else {
            if (psem->OSSemGrp != 0) {                          /* Rev. A, This line was missing   */
                y    = OSUnMapTbl[psem->OSSemGrp];
                x    = OSUnMapTbl[psem->OSSemTbl[y]];
                bity = OSMapTbl[y];
                bitx = OSMapTbl[x];
                if ((psem->OSSemTbl[y] &= ~bitx) == 0) {
                    psem->OSSemGrp &= ~bity;
                }
                p                           = (y << 3) + x;
                OSTCBPrioTbl[p]->OSTCBDly   =  0;
                OSTCBPrioTbl[p]->OSTCBStat &= ~OS_STAT_SEM;
                OSRdyGrp                   |=  bity;
                OSRdyTbl[y]                |=  bitx;
                OS_EXIT_CRITICAL();
                OSSched();
            } else {
                OS_EXIT_CRITICAL();
            }
        }
        return (OS_NO_ERR);
    } else {
        OS_EXIT_CRITICAL();
        return (OS_SEM_OVF);
    }
}
/*
************************************************************
*                   INITIALIZE MAILBOX
************************************************************
*/
UBYTE OSMboxInit(OS_MBOX *pmbox, void *msg)
{
    OS_ENTER_CRITICAL();
    pmbox->OSMboxMsg    = msg;
    pmbox->OSMboxGrp    = 0x00;
    pmbox->OSMboxTbl[0] = 0x00;
    pmbox->OSMboxTbl[1] = 0x00;
    pmbox->OSMboxTbl[2] = 0x00;
    pmbox->OSMboxTbl[3] = 0x00;
    pmbox->OSMboxTbl[4] = 0x00;
    pmbox->OSMboxTbl[5] = 0x00;
    pmbox->OSMboxTbl[6] = 0x00;
    pmbox->OSMboxTbl[7] = 0x00;
    OS_EXIT_CRITICAL();
    return (OS_NO_ERR);
}
/*
************************************************************
*                     PEND ON MAILBOX
************************************************************
*/
void *OSMboxPend(OS_MBOX *pmbox, UWORD timeout, UBYTE *err)
{
    UBYTE  x, y, bitx, bity;
    void  *msg;


    OS_ENTER_CRITICAL();
    if ((msg = pmbox->OSMboxMsg) != (void *)0) {
        pmbox->OSMboxMsg = (void *)0;
        OS_EXIT_CRITICAL();
        *err = OS_NO_ERR;
    } else {
        OSTCBCur->OSTCBStat |= OS_STAT_MBOX;
        OSTCBCur->OSTCBDly   = timeout;
        y                    = OSTCBCur->OSTCBPrio >> 3;
        x                    = OSTCBCur->OSTCBPrio & 0x07;
        bity                 = OSMapTbl[y];
        bitx                 = OSMapTbl[x];
        if ((OSRdyTbl[y] &= ~bitx) == 0) {
            OSRdyGrp &= ~bity;
        }
        pmbox->OSMboxTbl[y] |= bitx;
        pmbox->OSMboxGrp    |= bity;
        OS_EXIT_CRITICAL();
        OSSched();
        OS_ENTER_CRITICAL();
        if (OSTCBCur->OSTCBStat & OS_STAT_MBOX) {
            if ((pmbox->OSMboxTbl[y] &= ~bitx) == 0) {
                pmbox->OSMboxGrp &= ~bity;
            }
            OSTCBCur->OSTCBStat = OS_STAT_RDY;
            msg                 = (void *)0;
            OS_EXIT_CRITICAL();
            *err 		= OS_TIMEOUT;
        } else {
            msg                 = pmbox->OSMboxMsg;
            pmbox->OSMboxMsg    = (void *)0;
            OS_EXIT_CRITICAL();
            *err                = OS_NO_ERR;
        }
    }
    return (msg);
}
/*
************************************************************
*                    POST TO A MAILBOX
************************************************************
*/

UBYTE OSMboxPost(OS_MBOX *pmbox, void *msg)
{
    UBYTE x, y, bitx, bity, p;


    OS_ENTER_CRITICAL();
    if (pmbox->OSMboxMsg != (void *)0) {
        OS_EXIT_CRITICAL();
        return (OS_MBOX_FULL);
    } else {
        pmbox->OSMboxMsg = msg;
        if (pmbox->OSMboxGrp != 0) {                            /* Rev. A, This line was missing   */
            y                = OSUnMapTbl[pmbox->OSMboxGrp];
            x                = OSUnMapTbl[pmbox->OSMboxTbl[y]];
            bity             = OSMapTbl[y];
            bitx             = OSMapTbl[x];
            if ((pmbox->OSMboxTbl[y] &= ~bitx) == 0) {
                pmbox->OSMboxGrp &= ~bity;
            }
            p                           = (y << 3) + x;
            OSTCBPrioTbl[p]->OSTCBStat &= ~OS_STAT_MBOX;
            OSTCBPrioTbl[p]->OSTCBDly   =  0;
            OSRdyGrp                   |= bity;
            OSRdyTbl[y]                |= bitx;
            OS_EXIT_CRITICAL();
            OSSched();
        } else {
            OS_EXIT_CRITICAL();
        }
        return (OS_NO_ERR);
    }
}
/*
************************************************************
*                    INITIALIZE QUEUE
************************************************************
*/
UBYTE OSQInit(OS_Q *pq, void **start, UBYTE size)
{
    OS_ENTER_CRITICAL();
    pq->OSQStart   = start;
    pq->OSQEnd     = &start[size];
    pq->OSQIn      = start;
    pq->OSQOut     = start;
    pq->OSQSize    = size;
    pq->OSQEntries = 0;
    pq->OSQGrp     = 0x00;
    pq->OSQTbl[0]  = 0x00;
    pq->OSQTbl[1]  = 0x00;
    pq->OSQTbl[2]  = 0x00;
    pq->OSQTbl[3]  = 0x00;
    pq->OSQTbl[4]  = 0x00;
    pq->OSQTbl[5]  = 0x00;
    pq->OSQTbl[6]  = 0x00;
    pq->OSQTbl[7]  = 0x00;
    OS_EXIT_CRITICAL();
    return (OS_NO_ERR);
}
/*
************************************************************
*                     PEND ON A QUEUE
************************************************************
*/
void *OSQPend(OS_Q *pq, UWORD timeout, UBYTE *err)
{
    UBYTE  x, y, bitx, bity;
    void  *msg;


    OS_ENTER_CRITICAL();
    if (pq->OSQEntries != 0) {
        msg = *pq->OSQOut++;
        pq->OSQEntries--;
        if (pq->OSQOut == pq->OSQEnd) {
            pq->OSQOut = pq->OSQStart;
        }
        OS_EXIT_CRITICAL();
        *err = OS_NO_ERR;
    } else {
        OSTCBCur->OSTCBStat |= OS_STAT_Q;
        OSTCBCur->OSTCBDly   = timeout;
        y                    = OSTCBCur->OSTCBPrio >> 3;
        x                    = OSTCBCur->OSTCBPrio & 0x07;
        bity                 = OSMapTbl[y];
        bitx                 = OSMapTbl[x];
        if ((OSRdyTbl[y] &= ~bitx) == 0) {
            OSRdyGrp &= ~bity;
        }
        pq->OSQTbl[y] |= bitx;
        pq->OSQGrp    |= bity;
        OS_EXIT_CRITICAL();
        OSSched();
        OS_ENTER_CRITICAL();
        if (OSTCBCur->OSTCBStat & OS_STAT_Q) {
            if ((pq->OSQTbl[y] &= ~bitx) == 0) {
                pq->OSQGrp &= ~bity;
            }
            OSTCBCur->OSTCBStat = OS_STAT_RDY;
            msg                 = (void *)0;
            OS_EXIT_CRITICAL();
            *err 		= OS_TIMEOUT;
        } else {
            msg = *pq->OSQOut++;
            pq->OSQEntries--;
            if (pq->OSQOut == pq->OSQEnd) {
                pq->OSQOut = pq->OSQStart;
            }
            OS_EXIT_CRITICAL();
            *err = OS_NO_ERR;
        }
    }
    return (msg);
}
/*
************************************************************
*                     POST TO A QUEUE
************************************************************
*/

UBYTE OSQPost(OS_Q *pq, void *msg)
{
    UBYTE x, y, bitx, bity, p;


    OS_ENTER_CRITICAL();
    if (pq->OSQEntries >= pq->OSQSize) {
        OS_EXIT_CRITICAL();
        return (OS_Q_FULL);
    } else {
        *pq->OSQIn++ = msg;
        pq->OSQEntries++;
        if (pq->OSQIn == pq->OSQEnd) {
            pq->OSQIn = pq->OSQStart;
        }
        if (pq->OSQGrp != 0) {                                  /* Rev. A, This line was missing   */
            y    = OSUnMapTbl[pq->OSQGrp];
            x    = OSUnMapTbl[pq->OSQTbl[y]];
            bity = OSMapTbl[y];
            bitx = OSMapTbl[x];
            if ((pq->OSQTbl[y] &= ~bitx) == 0) {
                pq->OSQGrp &= ~bity;
            }
            p                           = (y << 3) + x;
            OSTCBPrioTbl[p]->OSTCBStat &= ~OS_STAT_Q;
            OSTCBPrioTbl[p]->OSTCBDly   = 0;
            OSRdyGrp                   |= bity;
            OSRdyTbl[y]                |= bitx;
            OS_EXIT_CRITICAL();
            OSSched();
        } else {
            OS_EXIT_CRITICAL();
        }
        return (OS_NO_ERR);
    }
}