1/*这是通用外设驱动程序中的传输函数的一个例子。
 2RTOS任务调用传输函数，然后处于阻塞状态(因此不占用CPU时间)，
 3直到收到传输完成的通知。传输由DMA执行，DMA端中断用于通知任务。 */
 4
 5/* 存储传输完成时将收到通知的任务句柄。 */
 6static TaskHandle_t xTaskToNotify = NULL;
 7
 8/* 目标任务要使用的任务通知数组中的索引。 */
 9const UBaseType_t xArrayIndex = 1;
10
11/* 外设驱动的传输功能 */
12void StartTransmission( uint8_t *pcData, size_t xDataLength )
13{
14/*此时xTaskToNotify应该为NULL，因为没有正在进行传输。
15如果有必要，可以使用互斥量来保护对外设的访问。*/
16configASSERT( xTaskToNotify == NULL );
17
18/* 存储调用任务的句柄。 */
19xTaskToNotify = xTaskGetCurrentTaskHandle();
20
21/* 开始传输:在传输完成时产生一个中断。 */
22vStartTransmit( pcData, xDatalength );
23}
24/*-----------------------------------------------------------*/
25
26/* 结束中断传输 */
27void vTransmitEndISR( void )
28{
29BaseType_t xHigherPriorityTaskWoken = pdFALSE;
30
31/* 此时，xTaskToNotify不应该为NULL，因为传输正在进行中。 */
32configASSERT( xTaskToNotify != NULL );
33
34/* Notify the task that the transmission is complete. */
35vTaskNotifyGiveIndexedFromISR( xTaskToNotify,
36xArrayIndex,
37&xHigherPriorityTaskWoken );
38
39/*此时，xTaskToNotify不应该为NULL，因为传输正在进行中。 */
40xTaskToNotify = NULL;
41
42/*如果xHigherPriorityTaskWoken现在设置为pdTRUE，
43那么应该执行切换，以确保中断直接返回到最高优先级的任务。
44用于该目的的宏取决于所使用的端口，可以称为portEND_SWITCHING_ISR()。 */
45portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
46}
47/*-----------------------------------------------------------*/
48
49/* 发起传输的任务，然后进入阻塞状态(因此不消耗任何CPU时间)，以等待传输完成。 */
50void vAFunctionCalledFromATask( uint8_t ucDataToTransmit,
51size_t xDataLength )
52{
53uint32_t ulNotificationValue;
54const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 200 );
55
56/* 通过调用上面显示的函数开始传输。 */
57StartTransmission( ucDataToTransmit, xDataLength );
58
59/* 等待传输完成的通知。注意，第一个参数是pdTRUE，
60它的作用是将任务的通知值清除回0，
61使通知值类似于二进制(而不是计数)信号量。 */
62ulNotificationValue = ulTaskNotifyTakeIndexed( xArrayIndex,
63pdTRUE,
64xMaxBlockTime );
65
66if( ulNotificationValue == 1 )
67{
68/* The transmission ended as expected. */
69}
70else
71{
72/* The call to ulTaskNotifyTake() timed out. */
73}
74}

1/* An interrupt handler that does not process interrupts directly,
 2but instead defers processing to a high priority RTOS task. The
 3ISR uses RTOS task notifications to both unblock the RTOS task
 4and increment the RTOS task's notification value. */
 5void vANInterruptHandler( void )
 6{
 7BaseType_t xHigherPriorityTaskWoken;
 8
 9/* Clear the interrupt. */
10prvClearInterruptSource();
11
12/* xHigherPriorityTaskWoken must be initialised to pdFALSE.
13If calling vTaskNotifyGiveFromISR() unblocks the handling
14task, and the priority of the handling task is higher than
15the priority of the currently running task, then
16xHigherPriorityTaskWoken will be automatically set to pdTRUE. */
17xHigherPriorityTaskWoken = pdFALSE;
18
19/* Unblock the handling task so the task can perform
20any processing necessitated by the interrupt. xHandlingTask
21is the task's handle, which was obtained when the task was
22created. vTaskNotifyGiveFromISR() also increments
23the receiving task's notification value. */
24vTaskNotifyGiveFromISR( xHandlingTask, &xHigherPriorityTaskWoken );
25
26/* Force a context switch if xHigherPriorityTaskWoken is now
27set to pdTRUE. The macro used to do this is dependent on
28the port and may be called portEND_SWITCHING_ISR. */
29portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
30}
31/*-----------------------------------------------------------*/
32
33/* A task that blocks waiting to be notified that the peripheral
34needs servicing. */
35void vHandlingTask( void *pvParameters )
36{
37BaseType_t xEvent;
38const TickType_t xBlockTime = pdMS_TO_TICS( 500 );
39uint32_t ulNotifiedValue;
40
41for( ;; )
42{
43/* Block to wait for a notification. Here the RTOS
44task notification is being used as a counting semaphore.
45The task's notification value is incremented each time
46the ISR calls vTaskNotifyGiveFromISR(), and decremented
47each time the RTOS task calls ulTaskNotifyTake() - so in
48effect holds a count of the number of outstanding interrupts.
49The first parameter is set to pdFALSE, so the notification
50value is only decremented and not cleared to zero, and one
51deferred interrupt event is processed at a time. See
52example 2 below for a more pragmatic approach. */
53ulNotifiedValue = ulTaskNotifyTake( pdFALSE,
54xBlockTime );
55
56if( ulNotifiedValue > 0 )
57{
58/* Perform any processing necessitated by the interrupt. */
59xEvent = xQueryPeripheral();
60
61if( xEvent != NO_MORE_EVENTS )
62{
63vProcessPeripheralEvent( xEvent );
64}
65}
66else
67{
68/* Did not receive a notification within the expected
69time. */
70vCheckForErrorConditions();
71}
72}
73}

1这个例子展示了一个更实用和高效的RTOS任务的实现。在这个实现中，ulTaskNotifyTake()的返回值用于知道有多少未处理的ISR事件必须被处理，允许RTOS任务的通知计数在每次ulTaskNotifyTake()被调用时被清除回零。中断服务例程(ISR)假定如上例1所示。
 2/* The index within the target task's array of task notifications
 3to use. */
 4const UBaseType_t xArrayIndex = 0;
 5
 6/* A task that blocks waiting to be notified that the peripheral
 7needs servicing. */
 8void vHandlingTask( void *pvParameters )
 9{
10BaseType_t xEvent;
11const TickType_t xBlockTime = pdMS_TO_TICS( 500 );
12uint32_t ulNotifiedValue;
13
14for( ;; )
15{
16/* As before, block to wait for a notification form the ISR.
17This time however the first parameter is set to pdTRUE,
18clearing the task's notification value to 0, meaning each
19outstanding outstanding deferred interrupt event must be
20processed before ulTaskNotifyTake() is called again. */
21ulNotifiedValue = ulTaskNotifyTakeIndexed( xArrayIndex,
22pdTRUE,
23xBlockTime );
24
25if( ulNotifiedValue == 0 )
26{
27/* Did not receive a notification within the expected
28time. */
29vCheckForErrorConditions();
30}
31else
32{
33/* ulNotifiedValue holds a count of the number of
34outstanding interrupts. Process each in turn. */
35while( ulNotifiedValue > 0 )
36{
37xEvent = xQueryPeripheral();
38
39if( xEvent != NO_MORE_EVENTS )
40{
41vProcessPeripheralEvent( xEvent );
42ulNotifiedValue--;
43}
44else
45{
46break;
47}
48}
49}
50}
51}

1/* This example demonstrates a single RTOS task being used to process
  2events that originate from two separate interrupt service routines -
  3a transmit interrupt and a receive interrupt. Many peripherals will
  4use the same handler for both, in which case the peripheral's
  5interrupt status register can simply be bitwise ORed with the
  6receiving task's notification value.
  7
  8First bits are defined to represent each interrupt source. */
  9#define TX_BIT 0x01
 10#define RX_BIT 0x02
 11
 12/* The handle of the task that will receive notifications from the
 13interrupts. The handle was obtained when the task
 14was created. */
 15static TaskHandle_t xHandlingTask;
 16
 17/*-----------------------------------------------------------*/
 18
 19/* The implementation of the transmit interrupt service routine. */
 20void vTxISR( void )
 21{
 22BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 23
 24/* Clear the interrupt source. */
 25prvClearInterrupt();
 26
 27/* Notify the task that the transmission is complete by setting the TX_BIT
 28in the task's notification value. */
 29xTaskNotifyFromISR( xHandlingTask,
 30TX_BIT,
 31eSetBits,
 32&xHigherPriorityTaskWoken );
 33
 34/* If xHigherPriorityTaskWoken is now set to pdTRUE then a context switch
 35should be performed to ensure the interrupt returns directly to the highest
 36priority task. The macro used for this purpose is dependent on the port in
 37use and may be called portEND_SWITCHING_ISR(). */
 38portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
 39}
 40/*-----------------------------------------------------------*/
 41
 42/* The implementation of the receive interrupt service routine is identical
 43except for the bit that gets set in the receiving task's notification value. */
 44void vRxISR( void )
 45{
 46BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 47
 48/* Clear the interrupt source. */
 49prvClearInterrupt();
 50
 51/* Notify the task that the reception is complete by setting the RX_BIT
 52in the task's notification value. */
 53xTaskNotifyFromISR( xHandlingTask,
 54RX_BIT,
 55eSetBits,
 56&xHigherPriorityTaskWoken );
 57
 58/* If xHigherPriorityTaskWoken is now set to pdTRUE then a context switch
 59should be performed to ensure the interrupt returns directly to the highest
 60priority task. The macro used for this purpose is dependent on the port in
 61use and may be called portEND_SWITCHING_ISR(). */
 62portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
 63}
 64/*-----------------------------------------------------------*/
 65
 66/* The implementation of the task that is notified by the interrupt service
 67routines. */
 68static void prvHandlingTask( void *pvParameter )
 69{
 70const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 500 );
 71BaseType_t xResult;
 72
 73for( ;; )
 74{
 75/* Wait to be notified of an interrupt. */
 76xResult = xTaskNotifyWait( pdFALSE, /* Don't clear bits on entry. */
 77ULONG_MAX, /* Clear all bits on exit. */
 78&ulNotifiedValue, /* Stores the notified value. */
 79xMaxBlockTime );
 80
 81if( xResult == pdPASS )
 82{
 83/* A notification was received. See which bits were set. */
 84if( ( ulNotifiedValue & TX_BIT ) != 0 )
 85{
 86/* The TX ISR has set a bit. */
 87prvProcessTx();
 88}
 89
 90if( ( ulNotifiedValue & RX_BIT ) != 0 )
 91{
 92/* The RX ISR has set a bit. */
 93prvProcessRx();
 94}
 95}
 96else
 97{
 98/* Did not receive a notification within the expected time. */
 99prvCheckForErrors();
100}
101}
102}