FreeRTOS na Prática: Threads, Semáforos, Filas, Mutexes, Timers e Boas Práticas em Sistemas Embarcados

Event Groups (Event Flags): Sincronização Baseada em Múltiplos Eventos

Os Event Groups, também conhecidos como Event Flags, são um mecanismo do FreeRTOS destinado à sincronização de tasks com base em múltiplas condições simultâneas. Diferentemente das Task Notifications, que são ideais para comunicação ponto-a-ponto, os Event Groups permitem que várias tasks aguardem por um conjunto de eventos representados por bits, oferecendo um modelo mais expressivo para estados complexos do sistema.

Conceitualmente, um Event Group é uma variável de 32 bits, onde cada bit representa um evento ou condição lógica. Tasks podem bloquear aguardando um ou mais bits específicos, podendo escolher entre:

• aguardar qualquer evento (OR lógico),
• aguardar todos os eventos (AND lógico),
• limpar automaticamente os bits após o desbloqueio.

Esse modelo é extremamente útil para sistemas em que múltiplos subsistemas precisam sinalizar sua prontidão ou estado antes que uma ação possa ocorrer.

Modelo Conceitual

Imagine um sistema que só pode iniciar uma operação quando:

• a comunicação está pronta,
• os sensores estão inicializados,
• e a fonte de alimentação está estável.

Cada uma dessas condições pode ser representada por um bit distinto em um Event Group.

Criação de um Event Group

#include "FreeRTOS.h"
#include "event_groups.h"

EventGroupHandle_t xSystemEventGroup;

#define EVT_COMM_READY     (1 << 0)
#define EVT_SENSOR_READY   (1 << 1)
#define EVT_POWER_READY    (1 << 2)

void vSystemInit(void)
{
    xSystemEventGroup = xEventGroupCreate();
}

#include "FreeRTOS.h"
#include "event_groups.h"

EventGroupHandle_t xSystemEventGroup;

#define EVT_COMM_READY     (1 << 0)
#define EVT_SENSOR_READY   (1 << 1)
#define EVT_POWER_READY    (1 << 2)

void vSystemInit(void)
{
    xSystemEventGroup = xEventGroupCreate();
}

Task aguardando múltiplos eventos

void vControlTask(void *pvParameters)
{
    (void) pvParameters;

    xEventGroupWaitBits(
        xSystemEventGroup,
        EVT_COMM_READY | EVT_SENSOR_READY | EVT_POWER_READY,
        pdTRUE,          // Limpa bits ao sair
        pdTRUE,          // Aguarda TODOS os bits
        portMAX_DELAY
    );

    start_system();
}

void vControlTask(void *pvParameters)
{
    (void) pvParameters;

    xEventGroupWaitBits(
        xSystemEventGroup,
        EVT_COMM_READY | EVT_SENSOR_READY | EVT_POWER_READY,
        pdTRUE,          // Limpa bits ao sair
        pdTRUE,          // Aguarda TODOS os bits
        portMAX_DELAY
    );

    start_system();
}

Sinalizando eventos

xEventGroupSetBits(xSystemEventGroup, EVT_SENSOR_READY);

xEventGroupSetBits(xSystemEventGroup, EVT_SENSOR_READY);

Também é possível sinalizar eventos a partir de uma ISR usando xEventGroupSetBitsFromISR().

Quando usar Event Groups

Use Event Groups quando:

• Várias condições precisam ser satisfeitas antes de prosseguir.
• Mais de uma task deve reagir ao mesmo evento.
• Estados globais do sistema precisam ser representados claramente.

Evite Event Groups quando:

• A comunicação é estritamente ponto-a-ponto.
• É necessário transportar dados, não apenas eventos.
• A ordem dos eventos é crítica (neste caso, filas são melhores).

Vantagens Técnicas

• Modelo intuitivo baseado em estados.
• Facilita sincronização de inicialização.
• Reduz lógica condicional espalhada pelo código.
• Permite coordenação entre múltiplas tasks.

Armadilhas comuns

• Usar Event Groups como substituto de filas de dados.
• Exceder o limite de 24 bits (dependendo da configuração).
• Criar dependências cíclicas difíceis de depurar.

Event Groups são particularmente poderosos quando combinados com máquinas de estado, tornando o código mais legível e previsível.

Na próxima seção, entraremos nos Mutexes, explorando exclusão mútua, herança de prioridade e as diferenças fundamentais entre mutexes e semáforos.