A versão 8.0.0 do FreeRTOS, liberada no último dia 19, possui uma funcionalidade interessante chamada Event Groups.

A idéia é agrupar bits (Event Bits) em grupos (Event Groups), que podem ser usados como mecanismo de sincronização (notificação) entre tarefas.

Um Event Group pode ser criado com a função xEventGroupCreate():

1
2
3
4
5
6
7
8

int main()
{
    [...]
 
    EventGroupHandle_t xEventGroup = xEventGroupCreate();
 
    [...]
}

Uma tarefa pode bloquear esperando por uma mudança em um dos bits com a função xEventGroupWaitBits():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#define BIT_2 (1 << 2)
 
void task1(void *pvParameters)
{
    xEventGroup = (EventGroupHandle_t) pvParameters;
    EventBits_t uxBits;
 
    for (;;) {
 
        /* wait for the bit to be set */ 
        uxBits = xEventGroupWaitBits(xEventGroup, BIT_2, pdTRUE, 
                                     pdFALSE, portMAX_DELAY);
 
        /* bit set, do something! */
    }
}

Outra tarefa pode setar um bit com a função xEventGroupSetBits():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#define BIT_2 (1 << 2)
 
void task2(void *pvParameters)
{
    xEventGroup = (EventGroupHandle_t) pvParameters;
    EventBits_t uxBits;
 
    for (;;) {
 
        /* wait for a network package */
        rx_package();
 
        /* handle network package */
        handle_package();
 
        /* notify package received */
        uxBits = xEventGroupSetBits(xEventGroup, BIT_2);
    }
}

Existem ainda as funções que terminam com FromISR, para serem usadas em rotinas de tratamento de interrupção. A lista completa de funções desta API está disponível no site do FreeRTOS.

Usando semáforos e Queue Sets, podemos ter uma funcionalidade parecida com a oferecida por esta API. Mas além de ser mais leve, esta API tem uma diferença conceitual bem importante.

Imagine que você queira criar um mecanismo de broadcasting de mensagens, onde diversas tarefas possam receber o mesmo evento. Por exemplo, quando o botão POWER for pressionado, diversas tarefas devem receber o evento para salvar seu estado antes da máquina ser desligada.

Isso não é possível com as APIs de semáforos e queues, já que, mesmo com várias tarefas esperando no mesmo semáforo ou queue, apenas uma tarefa será acordada quando o evento acontecer.

Mas com a API de Event Groups isso é possível. Quando várias tarefas estão esperando no mesmo bit do Event Group, todas serão acordadas quando o evento acontecer.

Mais uma ferramenta bem interessante para quem desenvolve com o FreeRTOS.

Um abraço,

Sergio Prado