中断驱动的零拷贝传输模式

[FreeRTOS-Plus-IO 传输模式]

/* FreeRTOS-Plus-IO includes. */

#include "FreeRTOS_IO.h"



void vAFunction( void )

{

/* The Peripheral_Descriptor_t type is the FreeRTOS-Plus-IO equivalent of a descriptor. */

Peripheral_Descriptor_t xOpenedPort;

BaseType_t xReturned;

const uint32_t ulMaxBlock100ms = ( 100UL / portTICK_PERIOD_MS );



    /* Open the SPI port identified in the board support package as using the

    path string "/SPI2/".  The second parameter is not currently used and can

    be set to anything, although, for future compatibility, it is recommended 

    that it is set to NULL. */

    xOpenedPort = FreeRTOS_open( "/SPI2/", NULL );



    if( xOpenedPort != NULL )

    {

        /***************** Configure the port *********************************/

    

        /* xOpenedPort now contains a valid descriptor that can be used with

        other FreeRTOS-Plus-IO API functions.  

        

        Peripherals default to using Polled mode for both reads and  writes.

        Change from the default to use the interrupt driven zero copy transfer

        mode for writing.  The third FreeRTOS_ioctl() parameter is not used and

        can take any value - although it is recommended to set the value to NULL

        for future compatibility.  A successful FreeRTOS_ioctl() call will return 

        pdPASS, for simplicity, this example does not show the return value being 

        checked. */

        FreeRTOS_ioctl( xOpenedPort, ioctlUSE_ZERO_COPY_TX, NULL );

                



        /***************** Use the port ***************************************/

        

        /* As the zero copy transfer mode is being used, the write mutex must

        be obtained before FreeRTOS_write() is called. The following call will

        attempt to obtain the mutex.  If the mutex is not immediately available,

        then the calling task will be placed into the Blocked state to wait for

        it, but the task will not wait longer than 100ms.  If the task is 

        successful in obtaining the mutex in that time, FreeRTOS_ioctl() will

        return pdPASS, otherwise FreeRTOS_ioctl() will return pdFAIL. */

        xReturned = FreeRTOS_ioctl( xOpenedPort, ioctlOBTAIN_WRITE_MUTEX, ulMaxBlock100ms );

        

        if( xReturned == pdTRUE )

        {

            /* The mutex was successfully obtained, now a FreeRTOS_write() can

            be performed.  This call will send 100 bytes from ucBuffer.  ucBuffer

            is assumed to be defined outside of this function. */

            xReturned = FreeRTOS_write( xOpenedPort, ucBuffer, 100 );

            

            if( xReturned == 100 )

            {

                /* The write was successful BUT will not yet have completed. The

                peripheral's interrupt service routine will be accessing ucBuffer,

                but this task is free to do anything else it needs to do at this

                point - provided the data in ucBuffer is not changed. */

            }

        }



        /* Some time later the task wants to update the data in ucBuffer, and

        perform another write.  First it must ensure the previous write has

        completed. If it can successfully obtain the write mutex again then

        it knows it is safe to access ucBuffer. Again, a maximum block time of

        100ms is used. */

        xReturned = FreeRTOS_ioctl( xOpenedPort, ioctlOBTAIN_WRITE_MUTEX, ulMaxBlock100ms );

        

        if( xReturned == pdTRUE )

        {

            /* The mutex was obtained, so the task can go ahead and update the

            buffer.  In this example, all it is going to do is clear it to zero. */

            memset( ucBuffer, 0, 100 );

            

            /* The task already holds the mutex, so can perform the write now. */

            xReturned = FreeRTOS_write( xOpenedPort, ucBuffer, 100 );

            

            /* Again - if at this point xReturned == 100, the write was successful,

            but will still be in progress. */

        }



        /* Before exiting the function, the task wants to ensure the write has

        completed, but this time it does not want to perform another write itself,

        so uses the ioctlWAIT_PREVIOUS_WRITE_COMPLETE request code in place of the

        ioctlOBTAIN_WRITE_MUTEX request code in a call to FreeRTOS_ioctl(). */

        FreeRTOS_ioctl( xOpenedPort, ioctlWAIT_PREVIOUS_WRITE_COMPLETE, ulMaxBlock100ms );

    }

}