PIO-IRQ-RTOS

Criando tarefas

Criar uma tarefa é similar ao de inicializar um programa em um sistema operacional, mas no caso devemos indicar para o RTOS quais "funções" irão se comportar como pequenos programas (tarefas). Para isso devemos chamar a função xTaskCreate que possui a seguinte estrutura:

A função utilizada para criar uma task no freertos é:

/**
 * task. h
 *
 BaseType_t xTaskCreate(
                              TaskFunction_t pvTaskCode,
                              const char * const pcName,
                              uint16_t usStackDepth,
                              void *pvParameters,
                              UBaseType_t uxPriority,
                              TaskHandle_t *pvCreatedTask
                          );
 *
 * Create a new task and add it to the list of tasks that are ready to run.
 *
 * xTaskCreate() can only be used to create a task that has unrestricted
 * access to the entire microcontroller memory map.  Systems that include MPU
 * support can alternatively create an MPU constrained task using
 * xTaskCreateRestricted().
 *
*/

A criação das tasks but e LED são feitas da seguinte maneira (na função main):

 /* Create task to make led blink */
  if (xTaskCreate(task_led, "Led", TASK_LED_STACK_SIZE, NULL,
                  TASK_LED_STACK_PRIORITY, NULL) != pdPASS) {
    printf("Failed to create test led task\r\n");
  }

  /* Create task to monitor processor activity */
  if (xTaskCreate(task_but, "BUT", TASK_BUT_STACK_SIZE, NULL,
                  TASK_BUT_STACK_PRIORITY, NULL) != pdPASS) {
    printf("Failed to create UartTx task\r\n");
  }

O primeiro parâmetro da xTaskCreate é o ponteiro da função que será lidada como uma task. A segunda é o nome dessa tarefa, a terceira é o tamanho da stack que cada task vai possuir, o quarto seria um ponteiro para uma estrutura de dados que poderia ser passada para a task em sua criação, o quinto a sua prioridade e o último é um ponteiro e retorna uma variável que pode ser usada para gerencias a task (deletar, pausar).

O tamanho da stack da tarefa e sua prioridade estão definidos no próprio main.c:

#define TASK_LED_STACK_SIZE (1024 / sizeof(portSTACK_TYPE))
#define TASK_LED_STACK_PRIORITY (tskIDLE_PRIORITY)
#define TASK_BUT_STACK_SIZE (2048 / sizeof(portSTACK_TYPE))
#define TASK_BUT_STACK_PRIORITY (tskIDLE_PRIORITY)

A cada tarefa pode ser atribuída uma prioridade que vai de 0 até configMAX_PRIORITIES - 1, onde configMAX_PRIORITIES está definido no arquivo de configuração FreeRTOSConfig.h, 0 é menor prioridade.

Power Save mode?

Uma forma muito simples de conseguirmos diminuir o consumo energético de um sistema embarcado com RTOS é o de ativar os modos de baixo consumo energético (powersave/ sleep mode) quando o SO estiver na tarefa idle. A tarefa idle é aquela executada quando nenhuma outra tarefa está em execução. Sempre que essa tarefa idle for chamada a o RTOS irá executar a função a seguir já definida no main.c:

/**
 * \brief This function is called by FreeRTOS idle task
 */
extern void vApplicationIdleHook(void) { 

}

Note que devemos entrar em um modo de sleep que o timer utilizado pelo tick consiga ainda acordar a CPU executar, caso contrário o RTOS não irá operar corretamente já que o escalonador não será chamado. O timer usado pelo escalonador é o System Timer, SysTick.

Comunicacao RTOS

Uma das principais vantagens de usar um sistema operacional é o de usar ferramentas de comunicação entre tarefas ou entre ISR e tarefas, em um código baremetal fazemos esse comunicação via variáveis globais (buffers, flags, ...), essa implementação carece de funcionalidades que o RTOS irá suprir, tais como:

• Semáforo (semaphore) É como uma flag binária, permitindo ou não a execução de uma task, funciona para sincronização de tarefas ou para exclusão mútua (multual exclusion), sem nenhum tipo de prioridade.

• Mutex: Similar aos semáforos porém com prioridade de execução (mutex alteram a prioridade da tarefa)

• MailBox ou Queues: Usado para enviar dados entre tarefas ou entre ISR e Tasks

[5] : https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html

Semaphore

No nosso exemplo o semáforo serve para avisar a task_but que um botão foi apertado:

• Consulta: xSemaphoreGiveFromISR

Agora vamos modificar a função task_led para inicializar um semáforo, e configura o botão da placa OLED para funcionar com interrupção chamanado a função: but1_callback sempre que houver uma borda de descida no pino que lê o botão.

A tarefa agora fica no while(1) aguardando o semáforo xSemaphore que será liberado pelo callback. Sempre que houver a leitura do semáforo, o mesmo torna-se vermelho.

SemaphoreHandle_t xSemaphoreBut;

/* Attempt to create a semaphore. */
xSemaphoreBut = xSemaphoreCreateBinary();

xSemaphoreTake(xSemaphoreBut, Tick);

xSemaphoreGiveFromISR(...);

Queues

Mailbox/ queue é uma das maneiras de enviarmos dados entre tarefa em um sistema operacional, com ele podemos comunicar interrupção com tarefa e tarefa com tarefa, enviando valores (diferente do semáforo que só funciona de forma binária).

No nosso exemplo usamos a queue para comunicar a ttask_but com a task_led passando por ela o valor do delay a ser processado.

Uma fila pode ser de diversos tamanhos e largura, a ser definida na criacão! Isso permite o envio de mais de um dado por ela, como por exemplo um struct, ou um array.

Material externos

Deixo aqui materiais externos a matéria para você que está curioso ou com dúvidas. Não precisa assistir agora antes de comećar o lab.