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.

Neste artigo, vamos explorar os seguintes pontos:

1. O problema da exclusão mútua.
2. Como o algoritmo de Peterson resolve este problema.
3. A relação entre Peterson’s Algorithm e spinlocks.
4. Comparação com outras soluções de exclusão mútua.
5. Exemplos práticos em código.

1. O Problema da Exclusão Mútua

Em sistemas com threads ou processos que compartilham recursos (como variáveis ou arquivos), pode ocorrer o problema de condições de corrida. Isso ocorre quando dois ou mais processos tentam acessar e modificar o mesmo recurso ao mesmo tempo, causando resultados imprevisíveis.

A exclusão mútua garante que apenas um processo possa acessar o recurso crítico por vez.

2. O Algoritmo de Peterson

O algoritmo de Peterson é uma solução de exclusão mútua projetada para dois processos. Ele usa duas variáveis:

• flag[i]: indica que o processo i quer entrar na seção crítica.
• turn: determina de quem é a vez de entrar na seção crítica.

O algoritmo funciona da seguinte forma para dois processos (P0 e P1):

Implementação do Algoritmo

#include <stdio.h>
#include <pthread.h>
#include <stdbool.h>
#include <unistd.h>

#define NUM_ITERATIONS 5

bool flag[2] = {false, false};
int turn = 0;

void *process_0(void *arg) {
    for (int i = 0; i < NUM_ITERATIONS; i++) {
        // Indica interesse em entrar na seção crítica
        flag[0] = true;
        turn = 1;

        // Aguarda até que o outro processo não esteja interessado ou seja sua vez
        while (flag[1] && turn == 1);

        // Seção crítica
        printf("Processo 0 na seção crítica.\n");
        sleep(1);

        // Sai da seção crítica
        flag[0] = false;
    }
    return NULL;
}

void *process_1(void *arg) {
    for (int i = 0; i < NUM_ITERATIONS; i++) {
        // Indica interesse em entrar na seção crítica
        flag[1] = true;
        turn = 0;

        // Aguarda até que o outro processo não esteja interessado ou seja sua vez
        while (flag[0] && turn == 0);

        // Seção crítica
        printf("Processo 1 na seção crítica.\n");
        sleep(1);

        // Sai da seção crítica
        flag[1] = false;
    }
    return NULL;
}

int main() {
    pthread_t t0, t1;

    pthread_create(&t0, NULL, process_0, NULL);
    pthread_create(&t1, NULL, process_1, NULL);

    pthread_join(t0, NULL);
    pthread_join(t1, NULL);

    return 0;
}

3. Relação com Spinlocks

Peterson’s Algorithm pode ser visto como uma forma rudimentar de spinlock, uma técnica onde um processo “gira” em um loop verificando continuamente se pode acessar um recurso.

Vantagens e Desvantagens

• Vantagens:
  • Simples e eficiente para dois processos.
  • Não requer instruções atômicas específicas do hardware.
• Desvantagens:
  • Não é escalável para mais de dois processos.
  • É menos eficiente que soluções modernas que usam instruções como compare-and-swap.

Spinlock Clássico em C

#include <stdatomic.h>
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

atomic_flag lock = ATOMIC_FLAG_INIT;

void lock_spin() {
    while (atomic_flag_test_and_set(&lock)); // Gira até obter o lock
}

void unlock_spin() {
    atomic_flag_clear(&lock); // Libera o lock
}

void *critical_section(void *arg) {
    lock_spin();
    printf("Thread %ld na seção crítica.\n", (long)arg);
    sleep(1);
    unlock_spin();
    return NULL;
}

int main() {
    pthread_t threads[2];

    for (long i = 0; i < 2; i++) {
        pthread_create(&threads[i], NULL, critical_section, (void *)i);
    }

    for (int i = 0; i < 2; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

4. Comparação com Outras Soluções

5. Exemplos de Uso no Mundo Real

Embora Peterson’s Algorithm seja de interesse mais acadêmico, a ideia de exclusão mútua se aplica amplamente:

• Mutexes e Semáforos em sistemas operacionais.
• Controle de acesso em bases de dados.
• Exclusão mútua em drivers de hardware.

Conclusão

Peterson’s Algorithm é uma solução elegante para exclusão mútua, especialmente em cenários simples. Apesar de suas limitações, sua compreensão é essencial para qualquer profissional interessado em sistemas concorrentes.

The post Peterson’s Algorithm: Uma Solução Elegante para Exclusão Mútua first appeared on MCU & FPGA.

No desenvolvimento de sistemas embarcados com FreeRTOS, o uso de variáveis globais do tipo float e double exige atenção especial devido à natureza não atômica dessas operações e ao impacto do chaveamento de contexto. Operações matemáticas como divisão e multiplicação podem ser interrompidas, resultando em valores corrompidos.

Neste artigo, abordaremos:

1. A questão da atomicidade em operações matemáticas.
2. O impacto do chaveamento de contexto.
3. O papel de variáveis volatile.
4. Uso do modificador _Atomic.
5. Proteções adequadas e boas práticas.
6. Exemplos práticos em código.

Atomicidade e Operações Matemáticas

O que é Atomicidade?

Uma operação é atômica se for executada do início ao fim sem interrupções. Em sistemas multitarefa, operações não atômicas podem ser interrompidas por uma interrupção ou por outro contexto de tarefa, resultando em valores inconsistentes.

Por exemplo, ao realizar uma multiplicação em uma variável global:

global_var = global_var * factor;

Se essa operação for interrompida, a variável pode conter um valor intermediário inválido.

O Impacto do Chaveamento de Contexto

O escalonador do FreeRTOS pode trocar entre tarefas a qualquer momento, inclusive no meio de uma operação não atômica. Isso pode levar à corrupção de dados, especialmente ao lidar com variáveis globais compartilhadas entre tarefas e interrupções.

O Papel das Variáveis volatile

O que é volatile?

A palavra-chave volatile instrui o compilador a não otimizar o acesso a uma variável, garantindo que ela seja sempre lida/escrita diretamente na memória.

Limitações de volatile

Embora útil para variáveis acessadas por interrupções ou tarefas diferentes, volatile não garante atomicidade. Ele não protege operações compostas, como global_var = global_var * factor;, contra interrupções.

Uso do Modificador _Atomic

O que é _Atomic?

O modificador _Atomic é parte do padrão C11 e fornece uma maneira de declarar variáveis atômicas. Variáveis marcadas com _Atomic garantem que as operações sobre elas sejam realizadas de maneira atômica, evitando interrupções no meio da operação.

Benefícios de _Atomic

• Elimina a necessidade de desabilitar interrupções para operações simples.
• Pode ser combinado com funções atômicas como atomic_fetch_add e atomic_store para realizar operações seguras.

Exemplo de declaração:

#include <stdatomic.h>

_Atomic float global_var = 0.0f;

Operações Atômicas em Variáveis _Atomic

É possível realizar operações matemáticas seguras usando funções atômicas disponíveis no cabeçalho <stdatomic.h>:

#include <stdatomic.h>

void TaskA(void *pvParameters) {
    float factor = 2.0f;
    float local_copy;

    while (1) {
        local_copy = atomic_load(&global_var);       // Carregar o valor de forma atômica
        local_copy = local_copy * factor;           // Operação local
        atomic_store(&global_var, local_copy);      // Atualizar o valor de forma atômica
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

Compatibilidade

Embora _Atomic seja padrão em C11, nem todos os compiladores para sistemas embarcados o suportam completamente. É importante verificar a documentação do compilador.

Boas Práticas e Soluções

1. Uso de Mutex

Um Mutex pode proteger operações mais complexas envolvendo variáveis globais.

#include "FreeRTOS.h"
#include "semphr.h"

SemaphoreHandle_t xMutex;
volatile float global_var;

void TaskA(void *pvParameters) {
    float factor = 1.5f;

    while (1) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY) == pdTRUE) {
            global_var = global_var * factor;
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

2. Desabilitar Interrupções Temporariamente

Para operações breves:

taskENTER_CRITICAL();
global_var = global_var / factor;
taskEXIT_CRITICAL();

3. Combinação com _Atomic

Ao usar _Atomic, muitas vezes não é necessário desabilitar interrupções ou usar mutexes para operações simples.

Exemplo Completo com _Atomic

Abaixo, um exemplo que combina _Atomic e FreeRTOS para garantir a manipulação segura de uma variável float global:

#include <stdatomic.h>
#include "FreeRTOS.h"
#include "task.h"

_Atomic float global_var = 0.0f;

void TaskA(void *pvParameters) {
    float factor = 2.5f;
    float local_var;

    while (1) {
        local_var = atomic_load(&global_var);       // Carregar valor
        local_var = local_var * factor;            // Operação local
        atomic_store(&global_var, local_var);      // Atualizar valor
        vTaskDelay(pdMS_TO_TICKS(100));            // Aguardar 100ms
    }
}

void TaskB(void *pvParameters) {
    float divisor = 1.2f;
    float local_var;

    while (1) {
        local_var = atomic_load(&global_var);       // Carregar valor
        local_var = local_var / divisor;           // Operação local
        atomic_store(&global_var, local_var);      // Atualizar valor
        vTaskDelay(pdMS_TO_TICKS(200));            // Aguardar 200ms
    }
}

int main(void) {
    xTaskCreate(TaskA, "TaskA", 1000, NULL, 1, NULL);
    xTaskCreate(TaskB, "TaskB", 1000, NULL, 1, NULL);
    vTaskStartScheduler();

    for (;;);
    return 0;
}

Conclusão

Usar _Atomic é uma solução moderna e eficiente para manipular variáveis globais em sistemas multitarefa com FreeRTOS. Ele elimina a necessidade de técnicas manuais mais complexas para garantir atomicidade em operações simples. No entanto, para operações mais complexas, o uso de Mutex ou a combinação com desabilitação de interrupções ainda pode ser necessário.

Sempre verifique o suporte ao padrão C11 no compilador utilizado e teste rigorosamente para garantir a confiabilidade em sistemas críticos.

The post Manipulação de Variáveis Globais do Tipo float e double com Interrupções e Tasks no FreeRTOS first appeared on MCU & FPGA.