Neste artigo, exploraremos como o FreeRTOS interage com o ESP32 no contexto multicore, com foco nas funções avançadas como vPortCPUInitializeMutex, portENTER_CRITICAL e portEXIT_CRITICAL. Também faremos uma comparação com a diretiva atomic do C e apresentaremos outros métodos de gerenciamento de recursos e sincronização, como semáforos e mutexes, para ilustrar as melhores práticas e implicações de uso.

Nosso objetivo é explicar cada recurso de forma clara e detalhada, com exemplos práticos que demonstram como implementar esses mecanismos no ESP32. Ao final, você terá uma visão completa das opções disponíveis e entenderá como escolher a abordagem ideal para o seu projeto.

Entendendo as Funções de Controle Crítico no FreeRTOS

Ao trabalhar com sistemas multicore, como o ESP32, é fundamental garantir que determinados trechos de código sejam executados de forma atômica, ou seja, sem interrupções e sem acesso simultâneo por outro núcleo ou tarefa. O FreeRTOS fornece diversas ferramentas para isso, e nesta seção abordaremos três delas: vPortCPUInitializeMutex, portENTER_CRITICAL e portEXIT_CRITICAL.

vPortCPUInitializeMutex

A função vPortCPUInitializeMutex é utilizada para inicializar mutexes que podem ser acessados de forma segura entre múltiplos núcleos. Essa função é essencial para garantir que um recurso seja utilizado por apenas uma tarefa de cada vez, independentemente do núcleo em execução.

Exemplo de uso:

#include "freertos/FreeRTOS.h"<br>#include "freertos/task.h"
#include "freertos/semphr.h"

portMUX_TYPE myMutex = portMUX_INITIALIZER_UNLOCKED;

void task1(void *pvParameters) {
    while (true) {
            portENTER_CRITICAL(&myMutex);     // Entra na seção crítica
            printf("Tarefa 1 está executando em núcleo %d\n", xPortGetCoreID());
            portEXIT_CRITICAL(&myMutex);      // Sai da seção crítica
            vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

void app_main() {
    vPortCPUInitializeMutex(&myMutex); // Inicializa o mutex para controle multicore
    
    xTaskCreatePinnedToCore(task1, "Task1", 2048, NULL, 1, NULL, 0);
}

portENTER_CRITICAL e portEXIT_CRITICAL

As funções portENTER_CRITICAL e portEXIT_CRITICAL são usadas para proteger seções críticas de código, desativando interrupções e garantindo que nenhum outro código ou núcleo interfira enquanto a seção crítica é executada.

Exemplo de uso:

portMUX_TYPE criticalMux = portMUX_INITIALIZER_UNLOCKED;

void task2(void *pvParameters) {
    while (true) {
        portENTER_CRITICAL(&criticalMux);
        // Código que deve ser executado sem interferências
        printf("Tarefa 2 executando em núcleo %d\n", xPortGetCoreID());
        portEXIT_CRITICAL(&criticalMux);
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

void app_main() {
    xTaskCreatePinnedToCore(task2, "Task2", 2048, NULL, 1, NULL, 1);
}

Implicações do Uso no Contexto Multicore

• Desempenho: Desativar interrupções pode causar atrasos, especialmente em sistemas com alta carga.
• Concorrência: Garantir acesso exclusivo evita condições de corrida (race conditions), mas deve ser usado com cuidado para não causar deadlocks.
• Multicore: No ESP32, essas funções garantem consistência ao sincronizar tarefas entre os dois núcleos, mas o uso excessivo pode prejudicar o desempenho.

Nesta seção, exploramos como essas funções permitem gerenciar acesso a recursos em um sistema multicore. Na próxima seção, faremos uma comparação entre essas abordagens e a diretiva atomic do C.

Comparação com a Diretiva atomic do C

A diretiva atomic, introduzida no padrão C11, é uma alternativa moderna para lidar com operações atômicas. Ela oferece uma abordagem mais direta para certas tarefas em sistemas embarcados e multicore, como o ESP32. Nesta seção, compararemos as funções de controle crítico do FreeRTOS com a diretiva atomic, discutindo suas vantagens, limitações e melhores práticas.

O Que é a Diretiva atomic?

A diretiva atomic permite realizar operações em variáveis de forma atômica, sem a necessidade de bloqueios explícitos ou desativação de interrupções. Isso é especialmente útil para incrementar, decrementar ou alterar valores compartilhados entre tarefas ou núcleos.

Exemplo de uso com atomic:

#include <stdatomic.h>

atomic_int sharedCounter = 0;

void task1(void *pvParameters) {
    while (true) {
        atomic_fetch_add(&sharedCounter, 1); // Incrementa de forma atômica
        printf("Tarefa 1 incrementou o contador: %d\n", sharedCounter);
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

void task2(void *pvParameters) {
    while (true) {
        atomic_fetch_sub(&sharedCounter, 1); // Decrementa de forma atômica
        printf("Tarefa 2 decrementou o contador: %d\n", sharedCounter);
        vTaskDelay(150 / portTICK_PERIOD_MS);
    }
}

void app_main() {
    xTaskCreate(task1, "Task1", 2048, NULL, 1, NULL);
    xTaskCreate(task2, "Task2", 2048, NULL, 1, NULL);
}

Comparação com Controle Crítico no FreeRTOS

Quando Usar Cada Abordagem?

1. Diretiva atomic:
   • Operações simples em variáveis, como incrementos e decrementos.
   • Cenários em que o desempenho é crítico e o suporte a C11 está garantido.
2. Funções do FreeRTOS:
   • Controle de acesso a recursos complexos, como periféricos ou blocos de código.
   • Garantia de exclusividade entre tarefas e núcleos.

Exemplo Combinando Abordagens

É possível usar ambas as abordagens em um mesmo projeto, dependendo do tipo de recurso sendo protegido.

atomic_int sharedCounter = 0;
portMUX_TYPE criticalMux = portMUX_INITIALIZER_UNLOCKED;

void task3(void *pvParameters) {
    while (true) {
        portENTER_CRITICAL(&criticalMux);
        atomic_fetch_add(&sharedCounter, 1);
        printf("Task3 executando com valor atômico: %d\n", sharedCounter);
        portEXIT_CRITICAL(&criticalMux);
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

Outros Métodos de Sincronização no FreeRTOS

Além das funções de controle crítico e da diretiva atomic, o FreeRTOS oferece uma ampla gama de ferramentas para gerenciar a sincronização em sistemas embarcados multicore, como semáforos, mutexes e grupos de eventos. Nesta seção, abordaremos esses métodos, explicando seu funcionamento, vantagens e situações ideais de uso.

1. Semáforos

Os semáforos são usados para sinalizar eventos ou gerenciar o acesso a recursos compartilhados. Eles podem ser binários (simples) ou de contagem (que permite múltiplos sinais).

Exemplo: Semáforo Binário

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"

SemaphoreHandle_t binarySemaphore;

void producerTask(void *pvParameters) {
    while (true) {
        printf("Produzindo um evento\n");
        xSemaphoreGive(binarySemaphore); // Sinaliza que o recurso está disponível
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void consumerTask(void *pvParameters) {
    while (true) {
        if (xSemaphoreTake(binarySemaphore, portMAX_DELAY)) { // Aguarda o sinal
            printf("Consumindo o evento\n");
        }
    }
}

void app_main() {
    binarySemaphore = xSemaphoreCreateBinary();
    xTaskCreate(producerTask, "Producer", 2048, NULL, 1, NULL);
    xTaskCreate(consumerTask, "Consumer", 2048, NULL, 1, NULL);
}

2. Mutexes

Os mutexes (Mutual Exclusion) são utilizados para garantir acesso exclusivo a um recurso. Diferente de semáforos, eles podem detectar e evitar inversões de prioridade.

Exemplo: Uso de Mutex

SemaphoreHandle_t resourceMutex;

void writerTask(void *pvParameters) {
    while (true) {
        if (xSemaphoreTake(resourceMutex, portMAX_DELAY)) {
            printf("Tarefa escrevendo no recurso\n");
            vTaskDelay(500 / portTICK_PERIOD_MS);
            xSemaphoreGive(resourceMutex);
        }
    }
}

void readerTask(void *pvParameters) {
    while (true) {
        if (xSemaphoreTake(resourceMutex, portMAX_DELAY)) {
            printf("Tarefa lendo o recurso\n");
            vTaskDelay(300 / portTICK_PERIOD_MS);
            xSemaphoreGive(resourceMutex);
        }
    }
}

void app_main() {
    resourceMutex = xSemaphoreCreateMutex();
    xTaskCreate(writerTask, "Writer", 2048, NULL, 1, NULL);
    xTaskCreate(readerTask, "Reader", 2048, NULL, 1, NULL);
}

3. Grupos de Eventos

Os grupos de eventos permitem sincronizar tarefas usando bits de evento. Cada tarefa pode aguardar por um ou mais bits específicos, facilitando a coordenação.

Exemplo: Grupo de Eventos

#include "freertos/event_groups.h"

EventGroupHandle_t eventGroup;

#define EVENT_BIT_0 (1 << 0)
#define EVENT_BIT_1 (1 << 1)

void taskA(void *pvParameters) {
    while (true) {
        printf("Tarefa A sinalizando evento 0\n");
        xEventGroupSetBits(eventGroup, EVENT_BIT_0);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void taskB(void *pvParameters) {
    while (true) {
        EventBits_t bits = xEventGroupWaitBits(eventGroup, EVENT_BIT_0 | EVENT_BIT_1, pdTRUE, pdFALSE, portMAX_DELAY);
        if (bits & EVENT_BIT_0) {
            printf("Evento 0 detectado pela tarefa B\n");
        }
        if (bits & EVENT_BIT_1) {
            printf("Evento 1 detectado pela tarefa B\n");
        }
    }
}

void app_main() {
    eventGroup = xEventGroupCreate();
    xTaskCreate(taskA, "TaskA", 2048, NULL, 1, NULL);
    xTaskCreate(taskB, "TaskB", 2048, NULL, 1, NULL);
}

Comparação dos Métodos

Com essas ferramentas, o FreeRTOS permite uma gestão robusta de sincronização em sistemas multicore.

Conclusão e Melhores Práticas

Neste artigo, exploramos como o FreeRTOS pode ser usado para gerenciar tarefas e recursos em sistemas multicore como o ESP32. Abordamos funções avançadas como vPortCPUInitializeMutex, portENTER_CRITICAL e portEXIT_CRITICAL, além de compará-las com a diretiva atomic do C e outros métodos de sincronização, como semáforos, mutexes e grupos de eventos.

Principais Pontos Abordados

• Controle Crítico: As funções do FreeRTOS são poderosas para proteger recursos compartilhados, mas exigem um planejamento cuidadoso para evitar problemas como deadlocks e impacto no desempenho.
• Diretiva atomic: Uma alternativa simples e eficiente para operações em variáveis, adequada para cenários onde o suporte a C11 está disponível.
• Métodos de Sincronização: Semáforos, mutexes e grupos de eventos oferecem flexibilidade para gerenciar tarefas e recursos, permitindo projetar sistemas robustos e escaláveis.

Melhores Práticas no Uso do FreeRTOS no ESP32

1. Escolha a Ferramenta Certa para Cada Situação:
   • Use atomic para operações simples em variáveis.
   • Use mutexes para controlar acesso exclusivo a recursos complexos.
   • Use semáforos e grupos de eventos para sincronização entre tarefas.
2. Evite Bloqueios Excessivos:
   • Limite o tempo dentro de seções críticas para minimizar atrasos.
   • Prefira abordagens não bloqueantes sempre que possível.
3. Planeje para o Contexto Multicore:
   • Verifique se o código é seguro para execução em múltiplos núcleos.
   • Use as ferramentas do FreeRTOS para garantir consistência e evitar condições de corrida.
4. Teste Extensivamente:
   • Simule cenários com alta carga para identificar possíveis falhas de sincronização.
   • Verifique o desempenho em diferentes condições para evitar gargalos.
5. Documente o Código:
   • Inclua comentários claros sobre o propósito de cada ferramenta usada.
   • Explique o motivo de escolhas específicas, como o uso de semáforos ou mutexes.

Com as ferramentas apresentadas, você estará preparado para projetar sistemas confiáveis e eficientes no ESP32, aproveitando ao máximo as funcionalidades multicore do FreeRTOS.

Esperamos que este artigo tenha sido útil e que você possa aplicá-lo em seus projetos. Caso tenha dúvidas ou sugestões, deixe seu comentário no site!

The post Introdução ao FreeRTOS no ESP32: Controle Multicore e Recursos Avançados first appeared on MCU & FPGA.