static void vNotifiedTask( void *pvParameters )

{

    for( ;; )

    {

        /* Wait to receive a notification sent directly to this task. 


        The first parameter is set to pdFALSE, which makes the call 


        replicate the behavior of a counting semaphore.  Set the 


        parameter to pdTRUE to replicate the behavior of a binary 


        semaphore.  The second parameter is set to portMAX_DELAY, 


        which makes the task block indefinitely to wait for the


        notification.  That is done to simplify the example – real 


        applications should not block indefinitely as that prevents 


        the task recovering from error conditions. */



        if( ulTaskNotifyTake( pdFALSE, portMAX_DELAY ) != 0 )

        {

            /* The task received a notification – do whatever is 


            necessary to process the received event. */ 

            DoSomething();

        }

    }

}

static uint32_t vNotifyingISR( void )

{

BaseType_t xHigherPriorityTaskWoken;



    /* The xHigherPriorityTaskWoken parameter must be initialized 


    to pdFALSE as it will get set to pdTRUE inside the interrupt 


    safe API function if calling the API function unblocks a task 


    that has a higher priority than the task in the running state 


    (the task this ISR interrupted). */ 

    xHigherPriorityTaskWoken = pdFALSE;



    /* Send a notification directly to the task that will perform 


    any processing necessitated by this interrupt. */ 

    vTaskNotifyGiveFromISR( /* The handle of the task to which 


                            the notification is being sent. */

                            xHandlerTask,

                            &xHigherPriorityTaskWoken );



    /* If xHigherPriorityTaskWoken is now pdTRUE then calling 


    portYIELD_FROM_ISR() will result in a context switch, and 


    this interrupt will return directly to the unblocked task.  


    The FAQ "why is there a separate API for use in interrupts"


    describes why it is done this way. */

    portYIELD_FROM_ISR( xHigherPriorityTaskWoken );

}

#define MAX_ADC_CHANNELS



/* Holds the handle of a task to notify when an ADC conversion 


ends on any given ADC channel. */

static TaskHandle_t xBlockedTasks[ MAX_ADC_CHANNELS ] = { 0 };



ErrorCode_t xGetADC( uint8_t ucChannel, 

                     uint32_t *pulConversionResult )

{

ErrorCode_t xErrorCode = SUCCESS;



    /* Check the ADC channel is not already in use. */

    taskENTER_CRITICAL();

    {

        if( xBlockedTasks[ ucChannel ] != NULL )

        {

            /* A task is already waiting for a result from 


            this channel. */

            xErrorCode = CHANNEL_IN_USE;

        }

        else

        {

            /* Store the handle of the calling task so it can


            be notified when the conversion is complete. This 


            is cleared back to NULL by the conversion end 


            interrupt. */

            xBlockedTasks[ ucChannel ] = xTaskGetCurrentTaskHandle();

        }

    }

    taskEXIT_CRITICAL();

               

    if( xErrorCode == SUCCESS )

    {

        /* Ensure the calling task does not already have a 


        notification pending. xTaskNotifyStateClear() clears 


        the state of the notification at array index 0.  Use 


        xTaskNotifyStateClearIndexed() to clear the state of 


        a notification at a specific array index. */

        xTaskNotifyStateClear( NULL );



        /* Start the ADC conversion. */

        StartADCConversion( ucChannel );



        /* Block to wait for the conversion result. */

        xResult = xTaskNotifyWait(

                 /* The new ADC value will overwrite the old 


                 value, so there is no need to clear any bits 


                 before or after waiting for the new 


                 notification value. */

                 0,

                 0,

                 /* The address of the variable in which to 


                 store the result. */

                 pulConversionResult,

                 /* Wait indefinitely.  Again this is only done


                 to keep the example simple. Production code 


                 should never block indefinitely as doing so 


                 prevents the task from recovering from 


                 errors. */

                 portMAX_DELAY );



        /* If not using an infinite block time then check xResult 


        to see why xTaskNotifyWait() returned. Production code 


        should not use an infinite block time as doing so prevents 


        the task recovering from an error.*/

   }



   return xErrorCode;

} 

/* The interrupt service routine (ISR) that executes each time 


an ADC conversion completes. It is assumed the xBlockedTasks[] 


array used in Listing 3 is in scope for use by this ISR.*/ 

void ADC_ConversionEndISR( void )

{

Uint8_t ucChannel;

uint32_t ulConversionResult;

BaseType_t xHigherPriorityTaskWoken = pdFALSE, xResult;



   /* This ISR handles all ADC channels.  Determine which 


   channel needs servicing. */

   ucChannel = ADC_GetChannelNumber(); 



   if( ucChannel < MAX_ADC_CHANNELS )

   {

       /* Read the conversion result to clear the interrupt. */ 

       ulConversionResult = ADC_ReadResult( ucChannel );



       /* Is a task waiting for a result from channel


       ucChannel? */ 

       if( xBlockedTasks[ ucChannel ] != NULL )

       {

           /* Send a notification, and the ADC conversion 


           result, directly to the waiting task. */

           xTaskNotifyFromISR( /* xTaskToNotify parameter. */

                               xBlockedTasks[ ucChannel ],

                               /* ulValue parameter. */

                               ulConversionResult,        

                               /* eAction parameter. */

                               eSetValueWithoutOverwrite, 

                               &xHigherPriorityTaskWoken );



           /* There is no longer a task waiting for a result 


           from channel ucChannel. */

           xBlockedTasks[ ucChannel ] = NULL; 

       }

   }



   /* As normal – see comments in code Listing 2. */ 

   portYIELD_FROM_ISR( xHigherPriorityTaskWoken );

}