Importância em Sistemas Embarcados🔗

Em sistemas embarcados, como os baseados no ESP32, o gerenciamento de recursos é crucial. O FreeRTOS auxilia no controle preciso do tempo de execução, permitindo que aplicações respondam a eventos em tempo real. Isso é especialmente importante em aplicações críticas, onde atrasos não são toleráveis.

Multitarefa🔗

A multitarefa permite que um sistema execute várias tarefas "ao mesmo tempo". Em microcontroladores, isso é alcançado por meio de um escalonador que alterna rapidamente entre as tarefas, dando a impressão de simultaneidade.

Escalonamento de Tarefas🔗

O escalonador é responsável por decidir qual tarefa será executada em determinado momento, baseado em prioridades e estados das tarefas (pronta, em execução, bloqueada).

Priorização🔗

Cada tarefa recebe uma prioridade. Tarefas com prioridades mais altas são selecionadas pelo escalonador antes das de prioridade inferior.

Sincronização🔗

Mecanismos para coordenar a execução de tarefas, garantindo que acessos a recursos compartilhados sejam seguros e que as tarefas possam se comunicar de forma eficiente.

Dual Core do ESP32 e o FreeRTOS🔗

O ESP32 possui dois núcleos de processamento: PRO_CPU e APP_CPU. O FreeRTOS pode gerenciar tarefas em ambos os núcleos, permitindo um paralelismo real.

Integração com o Hardware🔗

O FreeRTOS no ESP32 é otimizado para interagir com os periféricos do microcontrolador, como GPIOs, interfaces de comunicação e outros recursos, facilitando o desenvolvimento de aplicações complexas.

Tarefas (Tasks)🔗

São funções independentes que o FreeRTOS gerencia. Cada tarefa possui seu próprio contexto de execução, incluindo registradores e pilha.

Criando Tarefas

A criação de uma tarefa é feita usando a função xTaskCreate().

void MinhaTarefa(void *pvParameter)
{
    while(1)
    {
        // Código da tarefa
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void app_main()
{
    xTaskCreate(
        &MinhaTarefa,      // Função da tarefa
        "MinhaTarefa",     // Nome da tarefa
        2048,              // Tamanho da pilha
        NULL,              // Parâmetro passado para a tarefa
        5,                 // Prioridade da tarefa
        NULL               // Handle da tarefa
    );
}

Filas (Queues)🔗

Permitem a troca de informações entre tarefas de forma segura, através de um buffer FIFO (First In, First Out).

Exemplo de Uso de Filas

QueueHandle_t xFila;
void TarefaProdutora(void *pvParameter)
{
    int contador = 0;
    while(1)
    {
        contador++;
        xQueueSend(
            xFila,
            (void *)&contador,
            portMAX_DELAY
        );
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}
void TarefaConsumidora(void *pvParameter)
{
    int recebido;
    while(1)
    {
        if(xQueueReceive(
            xFila,
            &(recebido),
            portMAX_DELAY
        ))
        {
            printf("Valor recebido: %d\n", recebido);
        }
    }
}
void app_main()
{
    xFila = xQueueCreate(
        10,              // Tamanho da fila
        sizeof(int)      // Tamanho do item
    );
    xTaskCreate(&TarefaProdutora, "Produtora", 2048, NULL, 5, NULL);
    xTaskCreate(&TarefaConsumidora, "Consumidora", 2048, NULL, 5, NULL);
}

Semáforos🔗

Semáforos são usados para controlar o acesso a recursos compartilhados, evitando condições de corrida.

Exemplo de Uso de Semáforos

SemaphoreHandle_t xSemaforo;
void TarefaA(void *pvParameter)
{
    while(1)
    {
        if(xSemaphoreTake(xSemaforo, portMAX_DELAY))
        {
            // Seção crítica
            printf("Tarefa A está acessando o recurso compartilhado.\n");
            xSemaphoreGive(xSemaforo);
            vTaskDelay(1000 / portTICK_PERIOD_MS);
        }
    }
}
void TarefaB(void *pvParameter)
{
    while(1)
    {
        if(xSemaphoreTake(xSemaforo, portMAX_DELAY))
        {
            // Seção crítica
            printf("Tarefa B está acessando o recurso compartilhado.\n");
            xSemaphoreGive(xSemaforo);
            vTaskDelay(2000 / portTICK_PERIOD_MS);
        }
    }
}
void app_main()
{
    xSemaforo = xSemaphoreCreateMutex();
    xTaskCreate(&TarefaA, "TarefaA", 2048, NULL, 5, NULL);
    xTaskCreate(&TarefaB, "TarefaB", 2048, NULL, 5, NULL);
}

Mutexes🔗

Semelhantes aos semáforos, mas especificamente projetados para garantir a exclusão mútua de recursos.

Configurando o Ambiente de Desenvolvimento🔗

Para programar o ESP32 com FreeRTOS, você pode utilizar o ESP-IDF. Certifique-se de que ele está instalado e configurado em sua máquina.

Exemplo Prático: Criando e Executando Tarefas🔗

Neste exemplo, vamos criar duas tarefas que exibem mensagens no console em intervalos diferentes.

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
void Tarefa1(void *pvParameter)
{
    while(1)
    {
        printf("Executando Tarefa 1\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void Tarefa2(void *pvParameter)
{
    while(1)
    {
        printf("Executando Tarefa 2\n");
        vTaskDelay(2000 / portTICK_PERIOD_MS);
    }
}
void app_main()
{
    xTaskCreate(
        &Tarefa1,
        "Tarefa1",
        2048,
        NULL,
        5,
        NULL
    );
    xTaskCreate(
        &Tarefa2,
        "Tarefa2",
        2048,
        NULL,
        5,
        NULL
    );
}

Entendendo o Código🔗

• vTaskDelay(): Suspende a tarefa por um período de tempo, permitindo que outras tarefas sejam executadas.
• portTICK_PERIOD_MS: Constante que converte milissegundos para ticks do sistema.

Referências🔗

• Documentação da Espressif docs.espressif.com
• Documentação de Apresentação do ESP32 espressif.com/en/products/socs/esp32
• Guia de Programação ESP-IDF docs.espressif.com/projects/esp-idf