linuxucos.c

关于ucos 在avr128 中应用用icc编译

// *****************


INT8U OSTaskCreate( THREAD (*task)(void *pd), void *pdata, OS_STK *ptos, INT8U prio)
{
    int err;

    if( prio > OS_LOWEST_PRIO ) {
        return OS_PRIO_INVALID;
    }

    if( prio >= MAX_TASKS ) {
        return OS_ERR_INTERNAL;
    }

    if( pthread_to_prio[prio] != (pthread_t)0 ) {
        return OS_PRIO_EXIST;
    }

    err = pthread_create( &pthread_to_prio[prio], NULL, task, pdata );
    if( err != 0 ) {
        // shouldn't happen
        PERROR( "pthread_create() failed in OSTaskCreate()" );
        return OS_ERR_INTERNAL;
    }

    return OS_NO_ERR;
}

INT8U OSTaskCreateExt( THREAD (*task)(void *pd),
                      void   *pdata,
                      OS_STK *ptos,
                      INT8U   prio,
                      INT16U  id,
                      OS_STK *pbos,
                      INT32U  stk_size,
                      void   *pext,
                      INT16U  opt)
{
    return OSTaskCreate( task, pdata, ptos, prio );
}


// *****************
//
// Base functions
//
// *****************

void OSInit( void )
{
    int perr;

    epoch_init();

    memset( lnxOSEventTbl, 0, sizeof(lnxOSEventTbl) );

    // initialize the tables' mutexes
    perr = pthread_mutex_init( &oseventtbl_mutex, NULL );
    ASSERT( perr == 0 );

    perr = pthread_mutex_init( &osflagtbl_mutex, NULL );
    ASSERT( perr == 0 );
}

void OSStart( void )
{
    // nothing necessary??
}


// **********************************************************************
//
// test code 
//
// **********************************************************************

#ifdef OSTEST
#include <stdio.h>
#include <assert.h>

OS_EVENT *CommQ;
OS_EVENT *DispSem;
void *CommMsg[10];

// not really used in the pthreads code but necessary 
OS_STK task1_stack[1];
OS_STK task2_stack[1];
OS_STK task3_stack[1];

OS_FLAG_GRP *EngineStatus;
#define ENGINE_OIL_PRES_OK 0x01
#define ENGINE_OIL_TEMP_OK 0x02
#define ENGINE_START       0x04

THREAD task1( void *arg )
{
    char *ptr;
    int id;
    INT8U os_err;

    id = (int)arg;

    while( 1 ) {
        ptr = (char *)OSQPend( CommQ, 10*SECONDS, &os_err );
        if( os_err == OS_TIMEOUT ) {
            continue;
        }
        assert( os_err == 0 );
        
        // claim the semaphore to display
        OSMutexPend( DispSem, 10*SECONDS, &os_err );  
        if( os_err == OS_TIMEOUT ) {
            PRINTF( "task%d OSMutexPend() timeout\n", id );
            free( ptr );
            continue;
        }

        printf( "task %d \"%s\"\n", id, ptr );

        os_err = OSMutexPost( DispSem );
        if( os_err != 0 ) {
            PRINTF( "task%d OSMutexPost() failed with error %d\n", id, os_err );
            break;
        }

        free( ptr );

        OSTimeDly( random()%3 * SECONDS );
    }

    // how to deal with reaching this point (error)?
    while(1){}
}

THREAD task2( void *arg )
{
    INT8U os_err;
    char *ptr;
    int counter;

    counter = 0;
    while( 1 ) {
        ptr = (char *)malloc( 32 );
        sprintf( ptr, "hello %d from task 2", counter++ );
        os_err = OSQPost( CommQ, (void *)ptr );
        assert( os_err == 0 );

        printf( "task 2 sleep\n" );
        OSTimeDly( 1 * SECONDS );
    }
}

void tasks_test( void )
{
    INT8U os_err;

    // create some IPC to play with 
    DispSem = OSMutexCreate( 20, &os_err );
    assert( DispSem != NULL );

    CommQ = OSQCreate( &CommMsg[0], 10 );
    assert( CommQ != NULL );


    os_err = OSTaskCreate( task1, (void *)1, task1_stack, 12 );
    assert( os_err == OS_NO_ERR );

    os_err = OSTaskCreate( task2, (void *)2, task2_stack, 13 );
    assert( os_err == OS_NO_ERR );

    // hang around and watch what happens
    while( 1 ) {
        OSTimeDly( 10 * SECONDS );
    }
}

THREAD flag_task1( void *arg )
{
    INT8U err;
    OS_FLAGS value;

    while( 1 ) {
        // without OS_FLAG_CONSUME, this loop will run pretty quickly

        // wait on some flags
//        value = OSFlagAccept( EngineStatus, ENGINE_OIL_PRES_OK+ENGINE_OIL_TEMP_OK,
//                    OS_FLAG_WAIT_SET_ALL+OS_FLAG_CONSUME, &err );
//        value = OSFlagPend( EngineStatus, ENGINE_OIL_PRES_OK+ENGINE_OIL_TEMP_OK,
//                    OS_FLAG_WAIT_SET_ALL+OS_FLAG_CONSUME, 5*SECONDS, &err );
//        value = OSFlagPend( EngineStatus, ENGINE_OIL_PRES_OK+ENGINE_OIL_TEMP_OK,
//                    OS_FLAG_WAIT_SET_ANY+OS_FLAG_CONSUME, 5*SECONDS, &err );
//        value = OSFlagPend( EngineStatus, ENGINE_OIL_PRES_OK+ENGINE_OIL_TEMP_OK,
//                    OS_FLAG_WAIT_SET_ANY, 5*SECONDS, &err );
        value = OSFlagPend( EngineStatus, ENGINE_OIL_PRES_OK+ENGINE_OIL_TEMP_OK,
                    OS_FLAG_WAIT_SET_ALL+OS_FLAG_CONSUME, 0, &err );

        switch( err ) {
            case OS_NO_ERR :
                // desired flags are available
                printf( "flag_task1 : flags available!\n" );
                break;

            case OS_FLAG_ERR_NOT_RDY :
                // the desired flags are NOT available
                printf( "flag_task1 : flags not available\n" );
                break;

            case OS_TIMEOUT :
                printf( "flag_task1 : timeout\n" );
                break;

            default :
                printf( "flag_task1 : unknown return %d\n", err );
                break;
        }

//        OSTimeDly( 1 * SECONDS );
    }

}

THREAD flag_task2( void *arg )
{
    INT8U err;
    OS_FLAGS value;

    value = OSFlagPost( EngineStatus, ENGINE_START, OS_FLAG_SET, &err );
    ASSERT( err == 0 );

    while( 1 ) {
        // signal the flags
        printf( "flag_task2 : setting flag %d\n", ENGINE_OIL_PRES_OK );
        value = OSFlagPost( EngineStatus, ENGINE_OIL_PRES_OK, OS_FLAG_SET, &err );
        ASSERT( err == 0 );
        
        OSTimeDly( 5 * SECONDS );

        printf( "flag_task2 : setting flag %d\n", ENGINE_OIL_TEMP_OK );
        value = OSFlagPost( EngineStatus, ENGINE_OIL_TEMP_OK, OS_FLAG_SET, &err );
        ASSERT( err == 0 );

        OSTimeDly( 5 * SECONDS );
    }
}

THREAD flag_task3( void *arg )
{
    INT8U err;
    OS_FLAGS value;

    while( 1 ) {
        printf( "flag_task3 : clearing flags\n" );

        value = OSFlagPost( EngineStatus, ENGINE_OIL_PRES_OK+ENGINE_OIL_TEMP_OK, 
                    OS_FLAG_CLR, &err );
        ASSERT( err == 0 );

        OSTimeDly( 1 * SECONDS );
    }
}


void flags_test( void )
{
    INT8U os_err;

    EngineStatus = OSFlagCreate( 0x00, &os_err );
    ASSERT( os_err == 0 );

    os_err = OSTaskCreate( flag_task1, (void *)1, task1_stack, 12 );
    assert( os_err == OS_NO_ERR );

    os_err = OSTaskCreate( flag_task2, (void *)2, task2_stack, 13 );
    assert( os_err == OS_NO_ERR );

//    os_err = OSTaskCreate( flag_task3, (void *)2, task3_stack, 14 );
//    assert( os_err == OS_NO_ERR );

    // hang around and watch what happens
    while( 1 ) {
        OSTimeDly( 10 * SECONDS );
    }
}

int main( void )
{
    INT8U err;
    INT8U claimed;
    char *str = "hello, world";
    char *ptr;

    OSInit();

//    tasks_test();
    /* never returns */

    flags_test();

    printf( "***************\n" );
    printf( "semaphore tests\n" );

    DispSem = OSMutexCreate( 20, &err );
    assert( DispSem != NULL );
    
    // claim the semaphore
    claimed = OSMutexAccept( DispSem, &err );
    if( claimed ) {
        printf( "semaphore claimed\n" );
    }
    else {
        OSMutexDel( DispSem, OS_DEL_ALWAYS, &err );
        printf( "Error: semaphore not claimed!\n" );
        exit(1);
    }

    // release the semaphore
    err = OSMutexPost( DispSem );
    assert( err == OS_NO_ERR );
    printf( "semaphore released\n" );

    OSMutexPend( DispSem, 2, &err );    
    if( err != OS_NO_ERR ) {
        OSMutexDel( DispSem, OS_DEL_ALWAYS, &err );
        printf( "failed to claim semaphore!\n" );
        exit(1);
    }
    printf( "semaphore claimed\n" );

    // try to claim it again (should timeout)

    printf( "pending on claimed semaphore...\n" );
    OSMutexPend( DispSem, 2, &err );    
    if( err != OS_TIMEOUT ) {
        OSMutexDel( DispSem, OS_DEL_ALWAYS, &err );
        printf( "Error: OSMutexPend() failed to timeout\n" );
        exit(1);
    }
    printf( "semaphore not claimed\n" );

    // release it again
    err = OSMutexPost( DispSem );
    assert( err == OS_NO_ERR );
    printf( "semaphore released\n" );

    OSMutexDel( DispSem, OS_DEL_ALWAYS, &err );


    printf( "******************\n" );
    printf( "message queue test\n" );

    CommQ = OSQCreate( &CommMsg[0], 10 );
    assert( CommQ != NULL );

    err = OSQPost( CommQ, (void *)str );
    assert( err == OS_NO_ERR );

    ptr = OSQAccept( CommQ );
    assert( err == OS_NO_ERR );

    printf( "%s\n", ptr );

    // this should timeout
    printf( "pending on message queue...\n" );
    ptr = OSQPend( CommQ, 2, &err );
    if( err == OS_TIMEOUT ) {
        printf( "timeout on message queue\n" );
    }
    else {
        printf( "Error: OSQPend() failed to timeout\n" );
        OSQDel( CommQ, OS_DEL_ALWAYS, &err );
        exit(1);
    }

    ptr = (char *)malloc(100);
    memset( ptr, 0, 100 );
    strcpy( ptr, "first" );
    err = OSQPost( CommQ, (void *)ptr );
    assert( err == OS_NO_ERR );

    ptr = (char *)malloc(100);
    memset( ptr, 0, 100 );
    strcpy( ptr, "second" );
    err = OSQPost( CommQ, (void *)ptr );
    assert( err == OS_NO_ERR );

    ptr = (char *)malloc(100);
    memset( ptr, 0, 100 );
    strcpy( ptr, "third" );
    err = OSQPost( CommQ, (void *)ptr );
    assert( err == OS_NO_ERR );

    ptr = (char *)malloc(100);
    memset( ptr, 0, 100 );
    strcpy( ptr, "fourth" );
    err = OSQPost( CommQ, (void *)ptr );
    assert( err == OS_NO_ERR );

    // now read them
    ptr = OSQPend( CommQ, 0, &err );
    assert( ptr != NULL );
    printf( "%s\n", ptr );
    free( ptr );

    ptr = OSQPend( CommQ, 0, &err );
    assert( ptr != NULL );
    printf( "%s\n", ptr );
    free( ptr );

    ptr = OSQPend( CommQ, 0, &err );
    assert( ptr != NULL );
    printf( "%s\n", ptr );
    free( ptr );
    
    ptr = OSQPend( CommQ, 0, &err );
    assert( ptr != NULL );
    printf( "%s\n", ptr );
    free( ptr );

    ptr = OSQPend( CommQ, 5, &err );
    assert( err == OS_TIMEOUT );
    assert( ptr == NULL );

    OSQDel( CommQ, OS_DEL_ALWAYS, &err );


    return 0;
}
#endif