validate.c

如何将基于vxworks的应用程序移植到LINUX操作系统。

    **  WatchDog Timer Start Test
    ************************************************************************/
    puts( "\n.......... Next we start Watchdog 1 to time out after 1/2 second.");
    puts( "           Watchdog 1's timeout function will restart the timer" );
    puts( "           for another half second each time it expires." );
    puts( "           Then we start Watchdog 2 with a single 1 second delay." );

    puts( "Starting Watchdog 1" );
    errno = 0;
    err = wdStart( wdog1_id, 50, t_500_msec, 0 );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    puts( "Starting Watchdog 2" );
    errno = 0;
    err = wdStart( wdog2_id, 25, t_1000_msec, 0 );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    puts( "Task 1 sleeping for 2.5 seconds while timers run." );
    taskDelay( 250 );

    /************************************************************************
    **  WatchDog Timer Cancellation/Restart Test
    ************************************************************************/
    puts( "\n.......... Next we cancel Watchdog 1 and restart Watchdog 2" );
    puts( "           with a repeating 250 msec timeout function." );

    puts( "Cancelling Watchdog 1" );
    errno = 0;
    err = wdCancel( wdog1_id );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    puts( "Restarting Watchdog 2" );
    errno = 0;
    err = wdStart( wdog2_id, 25, t_250_msec, 0 );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    puts( "Task 1 sleeping for 1.5 seconds while timers run." );
    taskDelay( 150 );

    /************************************************************************
    **  WatchDog Timer Deletion Test
    ************************************************************************/
    puts( "\n.......... Finally we delete both Watchdog 1 and Watchdog 2" );

    puts( "Deleting Watchdog 1" );
    errno = 0;
    err = wdDelete( wdog1_id );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    puts( "Deleting Watchdog 2" );
    errno = 0;
    err = wdDelete( wdog2_id );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    puts( "Task 1 sleeping for 1 second to show timers not running." );
    taskDelay( 100 );
}

/*****************************************************************************
**  task10
*****************************************************************************/
int task10( int dummy0, int dummy1, int dummy2, int dummy3, int dummy4,
            int dummy5, int dummy6, int dummy7, int dummy8, int dummy9 )
{
    STATUS err;
    int i;

    for ( i = 0; i < 10; i++ )
    {
        taskDelay( 50 );
        puts( "\nTask 10 Not Suspended." );
    }

    /************************************************************************
    **  First wait on empty enable1 in pre-determined task order to test
    **  semaphore flush task waking order.
    ************************************************************************/
    puts( "\nTask 10 waiting on enable10 to begin acquiring token from enable1" );
    errno = 0;
    err = semTake( enable10, WAIT_FOREVER );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    /*
    **  Consume one token from enable1.
    */
    puts( "\nTask 10 waiting indefinitely to acquire token from enable1" );
    errno = 0;
    if ( (err = semTake( enable1, WAIT_FOREVER )) == OK )
        printf( "\r\nTask 10 acquired token from enable1\r\n" );
    else
        printf( "\nTask 10 semTake on enable1 returned error %x\r\n", errno );

    puts( "Signalling complt10 to Task 1 - Task 10 ready to test SEM_Q_FIFO." );
    errno = 0;
    err = semGive( complt10 );
    if ( err != OK )
    {
        printf( " returned error %x", errno );
    }

    /************************************************************************
    **  Next wait on empty SEM1 in pre-determined task order to test
    **  task wait-queueing order ( FIFO vs. PRIORITY ).
    ************************************************************************/
    puts( "\nTask 10 waiting on enable10 to begin acquiring token from SEM1" );
    errno = 0;
    err = semTake( enable10, WAIT_FOREVER );
    if ( err != OK )
    {
        printf( " returned error %x\r\n", errno );
    }

    puts( "Task 10 signalling complt10 to Task 1 to indicate Task 10 ready." );
    errno = 0;
    err = semGive( complt10 );
    if ( err != OK )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Consume one token from SEM1.
    */
    puts( "\nTask 10 waiting indefinitely to acquire token from SEM1" );
    errno = 0;
    if ( (errno = semTake( sema41_id, WAIT_FOREVER )) == OK )
        printf( "\r\nTask 10 acquired token from SEM1\r\n" );
    else
        printf( "\nTask 10 semTake on SEM1 returned error %x\r\n", errno );

    /************************************************************************
    **  Next wait on SEM2 to demonstrate semTake without wait.
    ************************************************************************/
    puts( "Signalling complt10 to Task 1 - Task 10 ready to test NO_WAIT." );
    errno = 0;
    err = semGive( complt10 );
    if ( err != OK )
    {
        printf( " returned error %x", errno );
    }

    puts( "\nTask 10 waiting on enable10 to begin acquiring token from SEM2" );
    errno = 0;
    err = semTake( enable10, WAIT_FOREVER );
    if ( err != OK )
    {
        printf( " returned error %x\r\n", errno );
    }

    /*
    **  Consume a token from SEM2 without waiting.
    */
    puts( "\nTask 10 attempting to acquire token from SEM2 without waiting." );
    errno = 0;
    if ( (err = semTake( sema42_id, NO_WAIT )) == OK )
        printf( "\r\nTask 10 acquired token from SEM2\r\n" );
    else
        printf( "\nTask 10 semTake on SEM2 returned error %x\r\n", errno );
    puts( "Signalling complt10 to Task 1 - Task 10 ready to test SEM_Q_PRIORITY." );
    errno = 0;
    err = semGive( complt10 );
    if ( err != OK )
    {
        printf( " returned error %x @ %p\r\n", errno, &errno );
    }

    /************************************************************************
    **  Next wait on SEM3 in pre-determined task order to test
    **  task wait-queueing order ( FIFO vs. PRIORITY ).
    ************************************************************************/
    puts( "\nTask 10 waiting on enable10 to begin acquiring token from SEM3" );
    errno = 0;
    err = semTake( enable10, WAIT_FOREVER );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    puts( "Task 10 signalling complt10 to Task 1 to indicate Task 10 ready." );
    errno = 0;
    err = semGive( complt10 );
    if ( err != OK )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Consume one token from SEM3.
    */
    puts( "\nTask 10 waiting up to 1 second to acquire token from SEM3" );
    errno = 0;
    if ( (err = semTake( sema43_id, 100 )) == OK )
        printf( "\r\nTask 10 acquired token from SEM3\r\n" );
    else
        printf( "\nTask 10 semTake on SEM3 returned error %x\r\n", errno );

    puts( "Signalling complt10 to Task 1 - Task 10 ready for semDelete test." );
    errno = 0;
    err = semGive( complt10 );
    if ( err != OK )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Consume one token from SEM1.
    */
    puts( "\nTask 10 waiting indefinitely to acquire token from SEM1" );
    errno = 0;
    if ( (err = semTake( sema41_id, WAIT_FOREVER )) == OK )
        printf( "\r\nTask 10 acquired token from SEM1\r\n" );
    else
        printf( "\nTask 10 semTake on SEM1 returned error %x\r\n", errno );

    puts( "Signalling complt10 to Task 1 - Task 10 finished semDelete test." );
    errno = 0;
    err = semGive( complt10 );
    if ( err != OK )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Tests all done... delete our own task.
    */
    puts( "\n.......... Task 10 deleting itself." );
    errno = 0;
    err = taskDelete( 0 );

    return( 0 );
}

/*****************************************************************************
**  task9
*****************************************************************************/
int task9( int dummy0, int dummy1, int dummy2, int dummy3, int dummy4,
           int dummy5, int dummy6, int dummy7, int dummy8, int dummy9 )
{
    STATUS err;
    msgblk_t msg;
    int i;

    /************************************************************************
    **  First wait on empty MSQ1 in pre-determined task order to test
    **  task wait-queueing order ( FIFO vs. PRIORITY ).
    ************************************************************************/
    puts( "\nTask 9 waiting on enable9 to begin receive on MSQ1" );
    errno = 0;
    err = semTake( enable9, WAIT_FOREVER );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    /*
    **  Consume 3 messages from MSQ1.
    */
    puts( "\nTask 9 waiting indefinitely to receive 3 msgs on MSQ1" );
    for ( i = 0; i < 3; i++ )
    {
        errno = 0;
        err = msgQReceive( queue1_id, msg.blk, 16, WAIT_FOREVER );
        if ( err == OK )
        {
            printf( "\r\nTask 9 rcvd Test Cycle %d Msg No. %d from %s\r\n",
                    msg.msg.t_cycle, msg.msg.msg_no, msg.msg.qname );
        }
        else
        {
            printf( "\nTask 9 msgQReceive on MSQ1 returned error %x\r\n",
                    errno );
            break;
        }
    }
    puts( "Signalling complt9 to Task 1 - Task 9 finished queuing order test." );
    errno = 0;
    err = semGive( complt9 );
    if ( err != OK )
    {
        printf( " returned error %x\r\n", errno );
    }

    /************************************************************************
    **  Next wait on empty MSQ3 to demonstrate q_send to zero-length queue.
    ************************************************************************/
    puts( "\nTask 9 waiting on enable9 to begin receive on MSQ3" );
    errno = 0;
    err = semTake( enable9, WAIT_FOREVER );
    if ( err != OK )
         printf( " returned error %x\r\n", errno );

    puts( "Task 9 signalling complt9 to Task 1 to indicate Task 9 ready." );
    errno = 0;
    err = semGive( complt9 );
    if ( err != OK )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Consume messages until 1 second elapses without an available message.
    */
    puts( "\nTask 9 waiting up to 1 sec to receive msgs on MSQ3" );
    while( 1 )
    {
        errno = 0;
        err = msgQReceive( queue3_id, msg.blk, 16, 100 );
        if ( err == OK )
        {
            printf( "\r\nTask 9 rcvd Test Cycle %d Msg No. %d from %s\r\n",
                    msg.msg.t_cycle, msg.msg.msg_no, msg.msg.qname );
        }
        else
        {
            printf( "\nTask 9 msgQReceive on MSQ3 returned error %x\r\n",
                    errno );
            break;
        }
    }
    puts( "Signalling complt9 to Task 1 - Task 9 finished zero-length test." );
    errno = 0;
    err = semGive( complt9 );
    if ( err != OK )
    {
        printf( " returned error %x\r\n", errno );
    }

    /************************************************************************
    **  Now wait along with other tasks on empty MSQ1 to demonstrate
    **  queue delete behavior.
    ************************************************************************/
    puts( "\nTask 9 waiting on enable9 to begin receive on MSQ1" );
    errno = 0;
    err = semTake( enable9, WAIT_FOREVER );
    if ( err != OK )
    {
        printf( " returned error %x\r\n", errno );
    }

    puts( "Task 9 signalling complt9 to Task 1 to indicate Task 9 ready." );
    errno = 0;
    err = semGive( complt9 );
    if ( err != OK )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Consume messages until 1 second elapses without an available message.
    */
    puts( "\nTask 9 waiting up to 1 sec to receive msgs on MSQ1" );
    while( 1 )
    {
        errno = 0;
        err = msgQReceive( queue1_id, msg.blk, 16, 100 );
        if ( err == OK )
        {
            printf( "\r\nTask 9 rcvd Test Cycle %d Msg No. %d from %s\r\n",
                    msg.msg.t_cycle, msg.msg.msg_no, msg.msg.qname );
        }
        else
        {
            printf( "\nTask 9 msgQReceive on MSQ1 returned error %x\r\n",