/* В этом примере передающая функция используется драйвером

периферийного устройства. Задача RTOS вызывает передающую функцию,

затем ждет в состоянии Blocked (не потребляя время CPU), пока

не получит оповещение о завершении передачи. Передача происходит

под управлением DMA, и прерывание завершения DMA используется

для оповещения задачи. */

/* Сохранение дескриптора задачи, которая будет оповещаться,

   когда передача завершится. */

static TaskHandle_t xTaskToNotify = NULL;

/* Используемый индекс в массиве оповещений целевой задачи. */

const UBaseType_t xArrayIndex = 1;

/* Функция передачи драйвера периферийного устройства. */

void StartTransmission (uint8_t *pcData, size_t xDataLength)
{
   /* В этом месте xTaskToNotify должен быть NULL, поскольку

      передача не происходит. При необходимости может

      использоваться мьютекс для защиты доступа к периферийному

      устройству. */
   configASSERT( xTaskToNotify == NULL );

   /* Сохранение дескриптора текущей задачи. */
   xTaskToNotify = xTaskGetCurrentTaskHandle();

   /* Запуск передачи. По её завершению будет сгенерировано

      прерывание. */
   vStartTransmit( pcData, xDatalength );
}

/* Прерывание завершения передачи. */

void vTransmitEndISR (void)
{
   BaseType_t xHigherPriorityTaskWoken = pdFALSE;

   /* В этом месте xTaskToNotify не должно быть NULL,

      поскольку была запущена передача. */
   configASSERT( xTaskToNotify != NULL );

   /* Оповещение задачи о том, что передача завершена. */
   vTaskNotifyGiveIndexedFromISR(xTaskToNotify,
                                 xArrayIndex,
                                 &xHigherPriorityTaskWoken);

   /* Нет передачи, так что нет задач для оповещения. */
   xTaskToNotify = NULL;

   /* Если xHigherPriorityTaskWoken не установлено в pdTRUE,

      то должно произойти переключение контекста для гарантии,

      что возврат управления произойдет в задачу с самым

      высоким приоритетом. Для этой цели используется макрос,

      реализация которого зависит от порта FreeRTOS, и он

      может называться portEND_SWITCHING_ISR(). */
   portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

/* Задача, которая инициирует передачу, и затем входит в состояние

   Blocked (не потребляя время CPU) для ожидания завершения передачи. */

void vAFunctionCalledFromATask (uint8_t ucDataToTransmit,
                                size_t xDataLength)
{
   uint32_t ulNotificationValue;
   const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 200 );

   /* Старт передачи вызовом функции, показанной выше. */
   StartTransmission( ucDataToTransmit, xDataLength );

   /* Ожидание оповещения о завершении передачи. Обратите внимание,

      что первый параметр pdTRUE, что дает эффект очистки значения

      оповещения обратно в 0, тем самым значение оповещения работает

      как двоичный семафор (вместо счетчика).  */
   ulNotificationValue = ulTaskNotifyTakeIndexed(xArrayIndex,
                                                 pdTRUE,
                                                 xMaxBlockTime );

   if (ulNotificationValue == 1)
   {
      /* Передача завершилась, как ожидалось. */
   }
   else
   {
      /* Таймаут вызова ulTaskNotifyTake(). */
   }
}

/* Обработчик прерывания, который не обрабатывает прерывания напрямую,

   вместо этого откладывая обработку на задачу с высоким приоритетом.

   Этот ISR использует RTOS task notifications, чтобы разблокировать

   эту задачу RTOS, и инкрементировать task notification value. */

void vANInterruptHandler (void)
{
   BaseType_t xHigherPriorityTaskWoken;
   /* Очистка прерывания. */
   prvClearInterruptSource();

   /* xHigherPriorityTaskWoken должно быть инициализировано в pdFALSE.

      Если вызов vTaskNotifyGiveFromISR() разблокирует задачу обработки,

      и приоритет у этой задач выше, чем приоритет текущей выполняющейся

      задачи, то xHigherPriorityTaskWoken автоматически установится

      в значение pdTRUE. */
   xHigherPriorityTaskWoken = pdFALSE;

   /* Разблокировка задач обработки, чтобы она могла выполнить любые

      необходимые действия, запрошенные прерыванием. Здесь xHandlingTask

      это дескриптор задачи, который был получен при её создании.

      Также vTaskNotifyGiveFromISR() инкрементирует значение оповещения

      задачи. */

   vTaskNotifyGiveFromISR( xHandlingTask, &xHigherPriorityTaskWoken );
   /* Принудительное переключение контекста, если сейчас значение

      xHigherPriorityTaskWoken установлено в pdTRUE. Используемый

      здесь макрос зависит от порта, и он может также называться

      portEND_SWITCHING_ISR. */
   portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

/* Задача, которая блокируется на ожидании необходимости обслужить

   периферийное устройство. */

void vHandlingTask (void *pvParameters)
{
   BaseType_t xEvent;
   const TickType_t xBlockTime = pdMS_TO_TICS( 500 );
   uint32_t ulNotifiedValue;

   for( ;; )
   {
      /* Блокировка на ожидании оповещения. Здесь task notification

         используется в качестве семафора со счетчиком. Значение|

         оповещения задачи инкрементируется всякий раз, когда ISR

         вызывает vTaskNotifyGiveFromISR(), и декрементируется,

         когда задача вызовет ulTaskNotifyTake() - таким образом

         счетчик хранит количество отложенных обработок прерываний.

         Первый параметр установлен в pdFALSE, чтобы значение

         оповещения только декрементировалось (не очищалось в 0),

         и одновременно обрабатывается одно событие отложенной

         обработки прерывания. См. пример 2, где дана более

         практичная реализация. */
      ulNotifiedValue = ulTaskNotifyTake (pdFALSE,
                                          xBlockTime);
      if (ulNotifiedValue > 0)
      {
         /* Выполняется любая обработка, заказанная прерыванием. */
         xEvent = xQueryPeripheral();

         if (xEvent != NO_MORE_EVENTS)
         {
            vProcessPeripheralEvent (xEvent);
         }
      }
      else
      {
         /* За ожидаемое время не было получено оповещение. */
         vCheckForErrorConditions();
      }
   }
}

/* Используемый индекс в массиве оповещений целевой задачи. */

const UBaseType_t xArrayIndex = 0;

/* Задача, которая блокируется в ожидании поступления оповещения о необходимости

   выполнить действия по обслуживанию периферийного устройства. */

void vHandlingTask (void *pvParameters)
{
   BaseType_t xEvent;
   const TickType_t xBlockTime = pdMS_TO_TICS( 500 );
   uint32_t ulNotifiedValue;

   for( ;; )
   {
      /* Как и раньше, здесь происходит блокировка на ожидании оповещения

         от ISR. Однако в этот раз первый параметр установлен в pdTRUE,

         что очищает в 0 значение оповещения. Это значит, что все

         отложенные оповещения должны быть обработаны до того, как

         снова будет вызвана ulTaskNotifyTake(). */
      ulNotifiedValue = ulTaskNotifyTakeIndexed (xArrayIndex,
                                                 pdTRUE,
                                                 xBlockTime);
      if (ulNotifiedValue == 0)
      {
         /* Не было получено оповещение в течение ожидаемого времени. */
         vCheckForErrorConditions();
      }
      else
      {
         /* ulNotifiedValue хранит количество ожидающих обработки

            прерываний. Обработка их всех каждой прокруткой цикла. */
         while (ulNotifiedValue > 0)
         {
            xEvent = xQueryPeripheral();

            if (xEvent != NO_MORE_EVENTS)
            {
               vProcessPeripheralEvent( xEvent );
               ulNotifiedValue--;
            }
            else
            {
               break;
            }
         }
      }
   }
}

/* Этот пример показывает одну задачу RTOS, используемую для обработки

   событий, поступающих от двух разных ISR - прерывание передачи и

   прерывание приема. Множество периферийных устройств используют

   один и тот же обработчик для обоих этих событий, в этом случае

   регистр состояния периферийного устройства может быть просто наложен

   операцией ИЛИ на значение оповещения задачи.

   Первые биты определены для представления каждого из источников

   прерывания: */

#define TX_BIT    0x01

#define RX_BIT    0x02

/* Дескриптор задачи, которая будет получать оповещения из прерываний.

   Значение этого дескриптора было получено при создании этой задачи. */

static TaskHandle_t xHandlingTask;

/* Реализация ISR прерывания передачи. */

void vTxISR (void)
{
   BaseType_t xHigherPriorityTaskWoken = pdFALSE;

   /* Очистка источника прерывания. */
   prvClearInterrupt();

   /* Оповещение задачи о том, что передача завершена, путем установки

      бита TX_BIT в значении оповещения. */
   xTaskNotifyFromISR (xHandlingTask,
                       TX_BIT,
                       eSetBits,
                       &xHigherPriorityTaskWoken);

   /* Если xHigherPriorityTaskWoken сейчас установлен в pdTRUE, то должно

      быть выполнено переключение контекста для гарантии, что возврат

      из прерывания передаст управление в задачу с самым высоким приоритетом.

      Используемый для этого макрос зависит от порта FreeRTOS, и он может

      называться portEND_SWITCHING_ISR(). */
   portYIELD_FROM_ISR (xHigherPriorityTaskWoken);
}

/* Реализация ISR прерывания приема идентична, отличие только в том,

   что установится бит RX_BIT в значении оповещения задачи. */

void vRxISR( void )
{
   BaseType_t xHigherPriorityTaskWoken = pdFALSE;

   /* Очистка источника прерывания. */
   prvClearInterrupt();

   /* Оповещение задачи о том, что прием завершен, путем установки

      бита RX_BIT в значении оповещения. */
   xTaskNotifyFromISR( xHandlingTask,
                       RX_BIT,
                       eSetBits,
                       &xHigherPriorityTaskWoken );

   /* Если xHigherPriorityTaskWoken сейчас установлен в pdTRUE, то должно

      быть выполнено переключение контекста для гарантии, что возврат

      из прерывания передаст управление в задачу с самым высоким приоритетом.

      Используемый для этого макрос зависит от порта FreeRTOS, и он может

      называться portEND_SWITCHING_ISR(). */
   portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

/* Реализация задачи, которая получает оповещения от обработчиков прерывания. */

static void prvHandlingTask( void *pvParameter )
{
   const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 500 );
   BaseType_t xResult;

   for( ;; )
   {
      /* Ожидание оповещения от прерывания. */
      xResult = xTaskNotifyWait (pdFALSE,    /* Не очищать биты на входе. */
                           ULONG_MAX,        /* Очистка всех бит на выходе. */
                           &ulNotifiedValue, /* Сохраняет значение оповещения. */
                           xMaxBlockTime );

      if( xResult == pdPASS )
      {
         /* Было принято оповещение. Анализ установленных бит. */
         if ((ulNotifiedValue & TX_BIT) != 0)
         {
            /* ISR установил бит передачи. */
            prvProcessTx();
         }

         if ((ulNotifiedValue & RX_BIT) != 0)
         {
            /* ISR установил бит приема. */
            prvProcessRx();
         }
      }
      else
      {
         /* За ожидаемое время не было получено оповещение. */
         prvCheckForErrors();
      }
   }
}