if( xResult != pdPASS )

        {

            // The message was not posted!

        }



        // Increment the number to be posted onto the queue.

        xNumberToPost++;



        // Delay for 100 ticks.

        crDELAY( xHandle, 100 );

    }



    // Co-routines must end with a call to crEND().

    crEND();

 }</pre>

 * \defgroup crQUEUE_SEND crQUEUE_SEND

 * \ingroup Tasks

 */

#define crQUEUE_SEND( xHandle, pxQueue, pvItemToQueue, xTicksToWait, pxResult )			\

{																						\

	*pxResult = xQueueCRSend( pxQueue, pvItemToQueue, xTicksToWait );					\

	if( *pxResult == errQUEUE_BLOCKED )													\

	{																					\

		crSET_STATE0( xHandle );														\

		*pxResult = xQueueCRSend( pxQueue, pvItemToQueue, 0 );							\

	}																					\

	if( *pxResult == errQUEUE_YIELD )													\

	{																					\

		crSET_STATE1( xHandle );														\

		*pxResult = pdPASS;																\

	}																					\

}



/**

 * croutine. h

 * <pre>

  crQUEUE_RECEIVE(

                     xCoRoutineHandle xHandle,

                     xQueueHandle pxQueue,

                     void *pvBuffer,

                     portTickType xTicksToWait,

                     portBASE_TYPE *pxResult

                 )</pre>

 *

 * The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine

 * equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.

 *

 * crQUEUE_SEND and crQUEUE_RECEIVE can only be used from a co-routine whereas

 * xQueueSend() and xQueueReceive() can only be used from tasks.

 *

 * crQUEUE_RECEIVE can only be called from the co-routine function itself - not

 * from within a function called by the co-routine function.  This is because

 * co-routines do not maintain their own stack.

 *

 * See the co-routine section of the WEB documentation for information on

 * passing data between tasks and co-routines and between ISR's and

 * co-routines.

 *

 * @param xHandle The handle of the calling co-routine.  This is the xHandle

 * parameter of the co-routine function.

 *

 * @param pxQueue The handle of the queue from which the data will be received.

 * The handle is obtained as the return value when the queue is created using

 * the xQueueCreate() API function.

 *

 * @param pvBuffer The buffer into which the received item is to be copied.

 * The number of bytes of each queued item is specified when the queue is

 * created.  This number of bytes is copied into pvBuffer.

 *

 * @param xTickToDelay The number of ticks that the co-routine should block

 * to wait for data to become available from the queue, should data not be

 * available immediately. The actual amount of time this equates to is defined

 * by configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant

 * portTICK_RATE_MS can be used to convert ticks to milliseconds (see the

 * crQUEUE_SEND example).

 *

 * @param pxResult The variable pointed to by pxResult will be set to pdPASS if

 * data was successfully retrieved from the queue, otherwise it will be set to

 * an error code as defined within ProjDefs.h.

 *

 * Example usage:

 <pre>

 // A co-routine receives the number of an LED to flash from a queue.  It

 // blocks on the queue until the number is received.

 static void prvCoRoutineFlashWorkTask( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )

 {

 // Variables in co-routines must be declared static if they must maintain value across a blocking call.

 static portBASE_TYPE xResult;

 static unsigned portBASE_TYPE uxLEDToFlash;



    // All co-routines must start with a call to crSTART().

    crSTART( xHandle );



    for( ;; )

    {

        // Wait for data to become available on the queue.

        crQUEUE_RECEIVE( xHandle, xCoRoutineQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );



        if( xResult == pdPASS )

        {

            // We received the LED to flash - flash it!

            vParTestToggleLED( uxLEDToFlash );

        }

    }



    crEND();

 }</pre>

 * \defgroup crQUEUE_RECEIVE crQUEUE_RECEIVE

 * \ingroup Tasks

 */

#define crQUEUE_RECEIVE( xHandle, pxQueue, pvBuffer, xTicksToWait, pxResult )			\

{																						\

	*pxResult = xQueueCRReceive( pxQueue, pvBuffer, xTicksToWait );						\

	if( *pxResult == errQUEUE_BLOCKED ) 												\

	{																					\

		crSET_STATE0( xHandle );														\

		*pxResult = xQueueCRReceive( pxQueue, pvBuffer, 0 );							\

	}																					\

	if( *pxResult == errQUEUE_YIELD )													\

	{																					\

		crSET_STATE1( xHandle );														\

		*pxResult = pdPASS;																\

	}																					\

}



/**

 * croutine. h

 * <pre>

  crQUEUE_SEND_FROM_ISR(

                            xQueueHandle pxQueue,

                            void *pvItemToQueue,

                            portBASE_TYPE xCoRoutinePreviouslyWoken

                       )</pre>

 *

 * The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the

 * co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()

 * functions used by tasks.

 *

 * crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to

 * pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and

 * xQueueReceiveFromISR() can only be used to pass data between a task and and

 * ISR.

 *

 * crQUEUE_SEND_FROM_ISR can only be called from an ISR to send data to a queue

 * that is being used from within a co-routine.

 *

 * See the co-routine section of the WEB documentation for information on

 * passing data between tasks and co-routines and between ISR's and

 * co-routines.

 *

 * @param xQueue The handle to the queue on which the item is to be posted.

 *

 * @param pvItemToQueue A pointer to the item that is to be placed on the

 * queue.  The size of the items the queue will hold was defined when the

 * queue was created, so this many bytes will be copied from pvItemToQueue

 * into the queue storage area.

 *

 * @param xCoRoutinePreviouslyWoken This is included so an ISR can post onto

 * the same queue multiple times from a single interrupt.  The first call

 * should always pass in pdFALSE.  Subsequent calls should pass in

 * the value returned from the previous call.

 *

 * @return pdTRUE if a co-routine was woken by posting onto the queue.  This is

 * used by the ISR to determine if a context switch may be required following

 * the ISR.

 *

 * Example usage:

 <pre>

 // A co-routine that blocks on a queue waiting for characters to be received.

 static void vReceivingCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )

 {

 portCHAR cRxedChar;

 portBASE_TYPE xResult;



     // All co-routines must start with a call to crSTART().

     crSTART( xHandle );



     for( ;; )

     {

         // Wait for data to become available on the queue.  This assumes the

         // queue xCommsRxQueue has already been created!

         crQUEUE_RECEIVE( xHandle, xCommsRxQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );



         // Was a character received?

         if( xResult == pdPASS )

         {

             // Process the character here.

         }

     }



     // All co-routines must end with a call to crEND().

     crEND();

 }



 // An ISR that uses a queue to send characters received on a serial port to

 // a co-routine.

 void vUART_ISR( void )

 {

 portCHAR cRxedChar;

 portBASE_TYPE xCRWokenByPost = pdFALSE;



     // We loop around reading characters until there are none left in the UART.

     while( UART_RX_REG_NOT_EMPTY() )

     {

         // Obtain the character from the UART.

         cRxedChar = UART_RX_REG;



         // Post the character onto a queue.  xCRWokenByPost will be pdFALSE

         // the first time around the loop.  If the post causes a co-routine

         // to be woken (unblocked) then xCRWokenByPost will be set to pdTRUE.

         // In this manner we can ensure that if more than one co-routine is

         // blocked on the queue only one is woken by this ISR no matter how

         // many characters are posted to the queue.

         xCRWokenByPost = crQUEUE_SEND_FROM_ISR( xCommsRxQueue, &cRxedChar, xCRWokenByPost );

     }

 }</pre>

 * \defgroup crQUEUE_SEND_FROM_ISR crQUEUE_SEND_FROM_ISR

 * \ingroup Tasks

 */

#define crQUEUE_SEND_FROM_ISR( pxQueue, pvItemToQueue, xCoRoutinePreviouslyWoken ) xQueueCRSendFromISR( pxQueue, pvItemToQueue, xCoRoutinePreviouslyWoken )





/**

 * croutine. h

 * <pre>

  crQUEUE_SEND_FROM_ISR(

                            xQueueHandle pxQueue,

                            void *pvBuffer,

                            portBASE_TYPE * pxCoRoutineWoken

                       )</pre>

 *

 * The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the

 * co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()

 * functions used by tasks.

 *

 * crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to

 * pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and

 * xQueueReceiveFromISR() can only be used to pass data between a task and and

 * ISR.

 *

 * crQUEUE_RECEIVE_FROM_ISR can only be called from an ISR to receive data

 * from a queue that is being used from within a co-routine (a co-routine

 * posted to the queue).

 *

 * See the co-routine section of the WEB documentation for information on

 * passing data between tasks and co-routines and between ISR's and

 * co-routines.

 *

 * @param xQueue The handle to the queue on which the item is to be posted.

 *

 * @param pvBuffer A pointer to a buffer into which the received item will be

 * placed.  The size of the items the queue will hold was defined when the

 * queue was created, so this many bytes will be copied from the queue into

 * pvBuffer.

 *

 * @param pxCoRoutineWoken A co-routine may be blocked waiting for space to become

 * available on the queue.  If crQUEUE_RECEIVE_FROM_ISR causes such a

 * co-routine to unblock *pxCoRoutineWoken will get set to pdTRUE, otherwise

 * *pxCoRoutineWoken will remain unchanged.

 *

 * @return pdTRUE an item was successfully received from the queue, otherwise

 * pdFALSE.

 *

 * Example usage:

 <pre>

 // A co-routine that posts a character to a queue then blocks for a fixed

 // period.  The character is incremented each time.

 static void vSendingCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )

 {

 // cChar holds its value while this co-routine is blocked and must therefore

 // be declared static.

 static portCHAR cCharToTx = 'a';

 portBASE_TYPE xResult;



     // All co-routines must start with a call to crSTART().

     crSTART( xHandle );



     for( ;; )

     {

         // Send the next character to the queue.

         crQUEUE_SEND( xHandle, xCoRoutineQueue, &cCharToTx, NO_DELAY, &xResult );



         if( xResult == pdPASS )

         {

             // The character was successfully posted to the queue.

         }

		 else

		 {

			// Could not post the character to the queue.

		 }



         // Enable the UART Tx interrupt to cause an interrupt in this

		 // hypothetical UART.  The interrupt will obtain the character

		 // from the queue and send it.

		 ENABLE_RX_INTERRUPT();



		 // Increment to the next character then block for a fixed period.

		 // cCharToTx will maintain its value across the delay as it is

		 // declared static.

		 cCharToTx++;

		 if( cCharToTx > 'x' )

		 {

			cCharToTx = 'a';

		 }

		 crDELAY( 100 );

     }



     // All co-routines must end with a call to crEND().

     crEND();

 }



 // An ISR that uses a queue to receive characters to send on a UART.

 void vUART_ISR( void )

 {

 portCHAR cCharToTx;

 portBASE_TYPE xCRWokenByPost = pdFALSE;



     while( UART_TX_REG_EMPTY() )

     {

         // Are there any characters in the queue waiting to be sent?

		 // xCRWokenByPost will automatically be set to pdTRUE if a co-routine

		 // is woken by the post - ensuring that only a single co-routine is

		 // woken no matter how many times we go around this loop.

         if( crQUEUE_RECEIVE_FROM_ISR( pxQueue, &cCharToTx, &xCRWokenByPost ) )

		 {

			 SEND_CHARACTER( cCharToTx );

		 }

     }

 }</pre>

 * \defgroup crQUEUE_RECEIVE_FROM_ISR crQUEUE_RECEIVE_FROM_ISR

 * \ingroup Tasks

 */

#define crQUEUE_RECEIVE_FROM_ISR( pxQueue, pvBuffer, pxCoRoutineWoken ) xQueueCRReceiveFromISR( pxQueue, pvBuffer, pxCoRoutineWoken )



/*

 * This function is intended for internal use by the co-routine macros only.

 * The macro nature of the co-routine implementation requires that the

 * prototype appears here.  The function should not be used by application

 * writers.

 *

 * Removes the current co-routine from its ready list and places it in the

 * appropriate delayed list.

 */

void vCoRoutineAddToDelayedList( portTickType xTicksToDelay, xList *pxEventList );



/*

 * This function is intended for internal use by the queue implementation only.

 * The function should not be used by application writers.

 *

 * Removes the highest priority co-routine from the event list and places it in

 * the pending ready list.

 */

signed portBASE_TYPE xCoRoutineRemoveFromEventList( const xList *pxEventList );





#endif /* CO_ROUTINE_H */