Este artigo explora a convenção de nomenclatura do FreeRTOS, explicando a lógica por trás da escolha dos prefixos e sufixos, além de fornecer exemplos práticos e amplamente documentados para ajudar iniciantes no uso desse sistema operacional.

1. Convenção de Nomenclatura no FreeRTOS

O FreeRTOS segue um conjunto de regras bem definido para nomear funções, variáveis e tipos de dados. Essas regras são fundamentais para manter a legibilidade e a consistência do código. As principais características da nomenclatura são:

1. Prefixos das Funções – Indicam a categoria da função.
2. Tipos de Dados e Estruturas – Usam typedefs com convenções específicas.
3. Uso de Sufixos – Algumas funções e variáveis possuem sufixos que indicam propriedades específicas.

Nos tópicos seguintes, vamos explorar essas convenções com mais detalhes e exemplos práticos.

2. Prefixos das Funções no FreeRTOS

As funções do FreeRTOS seguem uma padronização de prefixos para indicar a categoria ou funcionalidade à qual pertencem. Isso facilita a organização do código e a compreensão rápida do que cada função faz. Os prefixos mais comuns são:

2.1. Funções de Gerenciamento de Tarefas

Essas funções lidam com a criação, suspensão, retomada e exclusão de tarefas no FreeRTOS. O prefixo usado é vTask ou xTask, dependendo do tipo de retorno. Elas são definidas no arquivo de cabeçalho tasks.h que deve ser incluído para seu uso.

• xTaskCreate() – Cria uma nova tarefa.
• vTaskDelete() – Exclui uma tarefa existente.
• vTaskDelay() – Suspende a tarefa por um período de tempo.
• xTaskGetSchedulerState() – Obtém o estado atual do escalonador.

Exemplo: Criando uma tarefa no FreeRTOS

#include "FreeRTOS.h"
#include "task.h"

void vTaskFunction(void *pvParameters) {
    while(1) {
        // Código da tarefa
        vTaskDelay(pdMS_TO_TICKS(1000)); // Atraso de 1 segundo
    }
}

void app_main(void) {
    xTaskCreate(vTaskFunction, "MinhaTarefa", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
}

Neste exemplo, xTaskCreate() é usada para criar a tarefa, e vTaskDelay() para introduzir um atraso.

2.2. Funções de Gerenciamento de Filas

As filas são amplamente utilizadas no FreeRTOS para comunicação entre tarefas. As funções relacionadas a filas começam com o prefixo xQueue. As funções relativas ao Queue são definidas no header queue.h que deve ser incluído sempre que forem usadas.

• xQueueCreate() – Cria uma fila.
• xQueueSend() – Envia um item para a fila.
• xQueueReceive() – Recebe um item da fila.
• uxQueueMessagesWaiting() – Retorna o número de itens na fila.

Exemplo: Criando e usando uma fila

QueueHandle_t xQueue;

void vTaskSender(void *pvParameters) {
    int valor = 42;
    while(1) {
        xQueueSend(xQueue, &valor, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(500)); // Envio a cada 500ms
    }
}

void vTaskReceiver(void *pvParameters) {
    int recebido;
    while(1) {
        if (xQueueReceive(xQueue, &recebido, portMAX_DELAY)) {
            printf("Recebido: %d\n", recebido);
        }
    }
}

void app_main(void) {
    xQueue = xQueueCreate(10, sizeof(int)); // Cria fila com 10 posições
    xTaskCreate(vTaskSender, "Sender", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(vTaskReceiver, "Receiver", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
}

Aqui, xQueueCreate() cria a fila, xQueueSend() insere valores e xQueueReceive() os lê.

2.3. Funções de Semáforos e Mutexes

Os semáforos e mutexes são usados para sincronizar tarefas e gerenciar acesso a recursos compartilhados. O prefixo para essas funções é xSemaphore ou xMutex. Estas funçõe são definidas no arquivo de cabeçalho semaphore.h.

• xSemaphoreCreateBinary() – Cria um semáforo binário.
• xSemaphoreGive() – Libera um semáforo.
• xSemaphoreTake() – Captura um semáforo.
• xSemaphoreCreateMutex() – Cria um mutex.

Exemplo: Uso de mutex para evitar condições de corrida

SemaphoreHandle_t xMutex;

void vTask1(void *pvParameters) {
    while(1) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
            printf("Tarefa 1 acessando recurso\n");
            vTaskDelay(pdMS_TO_TICKS(500));
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void vTask2(void *pvParameters) {
    while(1) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
            printf("Tarefa 2 acessando recurso\n");
            vTaskDelay(pdMS_TO_TICKS(500));
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void app_main(void) {
    xMutex = xSemaphoreCreateMutex();
    xTaskCreate(vTask1, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(vTask2, "Task2", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
}

Aqui, xSemaphoreCreateMutex() cria um mutex, enquanto xSemaphoreTake() e xSemaphoreGive() garantem o acesso seguro ao recurso.

2.4. Funções de Timers

Os timers no FreeRTOS permitem a execução periódica de funções. As funções relacionadas a timers começam com xTimer. As funções de Timer são definidas no arquivo de cabeçalho timer.h.

• xTimerCreate() – Cria um novo timer.
• xTimerStart() – Inicia um timer.
• xTimerStop() – Para um timer.
• xTimerReset() – Reinicia um timer.

Exemplo: Criando um timer no FreeRTOS

TimerHandle_t xTimer;

void vTimerCallback(TimerHandle_t xTimer) {
    printf("Timer expirado!\n");
}

void app_main(void) {
    xTimer = xTimerCreate("MeuTimer", pdMS_TO_TICKS(2000), pdTRUE, NULL, vTimerCallback);
    if (xTimer != NULL) {
        xTimerStart(xTimer, 0);
    }
}

O timer dispara vTimerCallback() a cada 2 segundos.

3. Tipos de Dados e Estruturas no FreeRTOS

No FreeRTOS, a padronização dos tipos de dados e estruturas é essencial para garantir a portabilidade entre diferentes arquiteturas de microcontroladores. A nomenclatura segue convenções bem definidas para facilitar a leitura e evitar ambiguidades.

Os principais tipos de dados no FreeRTOS são:

• BaseType_t – Tipo base genérico para representar valores numéricos.
• TickType_t – Usado para armazenar valores de tempo (ticks do sistema).
• UBaseType_t – Variante sem sinal de BaseType_t, usada para contadores e índices.
• TaskHandle_t – Representa uma referência para uma tarefa.
• QueueHandle_t – Representa uma referência para uma fila.
• SemaphoreHandle_t – Representa um semáforo ou mutex.
• TimerHandle_t – Manipulador para um timer do FreeRTOS.

A seguir, exploraremos esses tipos de dados com exemplos práticos.

3.1. BaseType_t e UBaseType_t

O tipo BaseType_t é a base para a maioria dos tipos de retorno no FreeRTOS. Ele é definido de forma genérica para ser compatível com diferentes arquiteturas (8, 16, 32 ou 64 bits).

• BaseType_t pode ser positivo, negativo ou zero.
• UBaseType_t é sempre positivo e é usado para índices e contadores.

Exemplo: Verificando retorno de uma função

BaseType_t xStatus;
UBaseType_t uxCount = 0;

void app_main(void) {
    xStatus = xTaskCreatePinnedToCore(vTaskFunction, "Task", configMINIMAL_STACK_SIZE, NULL, 1, NULL, 0);

    if (xStatus == pdPASS) {
        printf("Tarefa criada com sucesso!\n");
    } else {
        printf("Falha ao criar tarefa.\n");
    }

    uxCount++;
    printf("Número de tentativas: %u\n", (unsigned int)uxCount);
}

Aqui, BaseType_t verifica se a criação da tarefa foi bem-sucedida, enquanto UBaseType_t conta as tentativas de criação.

3.2. TickType_t

O tipo TickType_t é usado para armazenar valores de tempo no FreeRTOS. O sistema mede o tempo em “ticks”, que dependem da frequência configurada (configTICK_RATE_HZ).

Exemplo: Obtendo o tempo atual do sistema

TickType_t xStartTime, xElapsedTime;

void app_main(void) {
    xStartTime = xTaskGetTickCount(); // Obtém o tempo atual em ticks
    vTaskDelay(pdMS_TO_TICKS(500)); // Aguarda 500ms
    xElapsedTime = xTaskGetTickCount() - xStartTime; // Calcula o tempo decorrido

    printf("Tempo decorrido: %lu ticks\n", (unsigned long)xElapsedTime);
}

Aqui, xTaskGetTickCount() é usado para medir o tempo decorrido de uma operação.

3.3. TaskHandle_t

O tipo TaskHandle_t é um ponteiro que referencia uma tarefa, permitindo manipulá-la dinamicamente.

Exemplo: Criando e suspendendo uma tarefa

TaskHandle_t xTaskHandle = NULL;

void vTaskFunction(void *pvParameters) {
    while (1) {
        printf("Tarefa executando...\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void app_main(void) {
    xTaskCreate(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, &xTaskHandle);

    vTaskDelay(pdMS_TO_TICKS(5000)); // Espera 5 segundos antes de suspender a tarefa
    vTaskSuspend(xTaskHandle);
    printf("Tarefa suspensa!\n");
}

Aqui, xTaskHandle é usado para suspender a tarefa após 5 segundos.

3.4. QueueHandle_t

O tipo QueueHandle_t armazena uma referência a uma fila, permitindo sua manipulação por diferentes tarefas.

Exemplo: Criando e verificando uma fila

QueueHandle_t xQueue;

void app_main(void) {
    xQueue = xQueueCreate(5, sizeof(int)); // Cria uma fila com capacidade para 5 inteiros

    if (xQueue != NULL) {
        printf("Fila criada com sucesso!\n");
    } else {
        printf("Falha ao criar a fila.\n");
    }
}

Aqui, QueueHandle_t é usado para armazenar a referência da fila criada.

3.5. SemaphoreHandle_t

O tipo SemaphoreHandle_t é usado para armazenar referência a semáforos e mutexes.

Exemplo: Criando um semáforo binário

SemaphoreHandle_t xSemaphore;

void app_main(void) {
    xSemaphore = xSemaphoreCreateBinary();

    if (xSemaphore != NULL) {
        printf("Semáforo criado!\n");
    } else {
        printf("Falha ao criar semáforo.\n");
    }
}

Aqui, SemaphoreHandle_t armazena o manipulador do semáforo criado.

3.6. TimerHandle_t

O tipo TimerHandle_t é usado para armazenar referências a timers criados no FreeRTOS.

Exemplo: Criando um timer que dispara a cada 2 segundos

TimerHandle_t xTimer;

void vTimerCallback(TimerHandle_t xTimer) {
    printf("Timer expirado!\n");
}

void app_main(void) {
    xTimer = xTimerCreate("MeuTimer", pdMS_TO_TICKS(2000), pdTRUE, NULL, vTimerCallback);

    if (xTimer != NULL) {
        xTimerStart(xTimer, 0);
        printf("Timer iniciado!\n");
    } else {
        printf("Falha ao criar o timer.\n");
    }
}

Aqui, TimerHandle_t armazena a referência do timer criado.

4. Uso de Sufixos em Funções e Variáveis do FreeRTOS

Além dos prefixos e tipos de dados padronizados, o FreeRTOS também utiliza sufixos em funções e variáveis para indicar propriedades específicas. Esses sufixos ajudam a identificar rapidamente características como escopo, tipo de dado ou comportamento esperado da função.

Os principais sufixos usados no FreeRTOS são:

• FromISR – Indica que a função pode ser chamada a partir de uma interrupção.
• _t – Indica que o nome refere-se a um tipo de dado.
• Handle – Representa um manipulador para um objeto do FreeRTOS.
• Ticks – Refere-se a unidades de tempo do sistema (ticks).
• MS – Representa valores em milissegundos.

A seguir, exploramos cada um desses sufixos com exemplos práticos.

4.1. Sufixo FromISR

Funções que podem ser chamadas dentro de um handler de interrupção possuem o sufixo FromISR. Isso é necessário porque chamadas dentro de interrupções não podem executar determinadas operações do sistema operacional, como esperar indefinidamente (portMAX_DELAY).

Exemplo: Enviando um item para uma fila dentro de uma interrupção

QueueHandle_t xQueue;

void IRAM_ATTR vISRHandler(void *arg) {
    int valor = 10;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    xQueueSendFromISR(xQueue, &valor, &xHigherPriorityTaskWoken);

    if (xHigherPriorityTaskWoken == pdTRUE) {
        portYIELD_FROM_ISR();
    }
}

void app_main(void) {
    xQueue = xQueueCreate(5, sizeof(int));

    gpio_install_isr_service(0);
    gpio_isr_handler_add(GPIO_NUM_4, vISRHandler, NULL);
}

Aqui, xQueueSendFromISR() é usado para evitar bloqueios dentro da interrupção.

4.2. Sufixo _t

O sufixo _t indica que o nome representa um tipo de dado definido pelo FreeRTOS.

Exemplo: Utilizando tipos de dados do FreeRTOS

BaseType_t xStatus;
TickType_t xTime;
QueueHandle_t xQueue;

Aqui, BaseType_t, TickType_t e QueueHandle_t seguem essa convenção.

4.3. Sufixo Handle

O sufixo Handle é usado para representar manipuladores de objetos do FreeRTOS, como tarefas, filas, semáforos e timers.

Exemplo: Criando e manipulando uma tarefa

TaskHandle_t xTaskHandle = NULL;

void vTaskFunction(void *pvParameters) {
    while (1) {
        printf("Executando tarefa...\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void app_main(void) {
    xTaskCreate(vTaskFunction, "MinhaTarefa", configMINIMAL_STACK_SIZE, NULL, 1, &xTaskHandle);
    vTaskDelay(pdMS_TO_TICKS(5000));
    vTaskDelete(xTaskHandle);
}

Aqui, TaskHandle_t armazena o manipulador da tarefa para que possamos manipulá-la posteriormente.

4.4. Sufixo Ticks

O sufixo Ticks indica que o valor da variável ou função está expresso em ticks de sistema.

Exemplo: Calculando tempo em ticks

TickType_t xStartTime, xElapsedTime;

void app_main(void) {
    xStartTime = xTaskGetTickCount(); // Obtém tempo atual
    vTaskDelay(pdMS_TO_TICKS(2000)); // Aguarda 2 segundos
    xElapsedTime = xTaskGetTickCount() - xStartTime;

    printf("Tempo decorrido: %lu ticks\n", (unsigned long)xElapsedTime);
}

Aqui, xStartTime e xElapsedTime armazenam valores em ticks do sistema.

4.5. Sufixo MS

O sufixo MS é usado para representar valores em milissegundos.

Exemplo: Definindo tempos em milissegundos

#define TEMPO_DELAY_MS 500

void app_main(void) {
    vTaskDelay(pdMS_TO_TICKS(TEMPO_DELAY_MS)); // Converte para ticks
    printf("Aguardou %d ms\n", TEMPO_DELAY_MS);
}

Aqui, TEMPO_DELAY_MS representa um tempo em milissegundos.

Resumo da Seção

Os sufixos no FreeRTOS ajudam a identificar o propósito de variáveis e funções rapidamente:

5. Prefixos de Retorno de Funções e Variáveis no FreeRTOS

Além dos prefixos usados para categorizar funções (xTask, vTask, xQueue etc.), o FreeRTOS também utiliza prefixos em variáveis e valores de retorno para indicar tipos de dados específicos. Esses prefixos ajudam a identificar rapidamente a natureza da variável ou o tipo de dado que uma função retorna.

Os principais prefixos utilizados no FreeRTOS incluem:

A seguir, exploramos cada um desses prefixos com exemplos práticos.

5.1. Prefixo u (Unsigned)

O prefixo u indica que a variável é um número inteiro sem sinal, ou seja, não pode armazenar valores negativos.

Exemplo: Contador sem sinal

uint8_t uCounter = 0;

void app_main(void) {
    for (uCounter = 0; uCounter < 10; uCounter++) {
        printf("Contador: %u\n", uCounter);
    }
}

Aqui, uCounter é uma variável do tipo uint8_t, que é um inteiro sem sinal de 8 bits.

5.2. Prefixo x (Retorno de Função)

O prefixo x é usado em funções que retornam um valor de status, geralmente do tipo BaseType_t.

Exemplo: Verificando status da criação de uma tarefa

BaseType_t xStatus;

void app_main(void) {
    xStatus = xTaskCreate(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);

    if (xStatus == pdPASS) {
        printf("Tarefa criada com sucesso!\n");
    } else {
        printf("Falha ao criar a tarefa.\n");
    }
}

O xTaskCreate() retorna um BaseType_t, e o valor de retorno xStatus indica se a operação foi bem-sucedida.

5.3. Prefixo v (Void)

O prefixo v é usado para funções que não retornam valores, ou seja, cujo tipo de retorno é void.

Exemplo: Função sem retorno

void vTaskFunction(void *pvParameters) {
    while (1) {
        printf("Executando tarefa...\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

A função vTaskFunction() não retorna valores, então segue a convenção v.

5.4. Prefixo ux (Unsigned BaseType_t)

O prefixo ux é usado para variáveis do tipo UBaseType_t, que é um inteiro sem sinal usado para contadores e índices.

Exemplo: Usando UBaseType_t para armazenar um índice

UBaseType_t uxIndex;

void app_main(void) {
    for (uxIndex = 0; uxIndex < 5; uxIndex++) {
        printf("Índice: %u\n", (unsigned int)uxIndex);
    }
}

O UBaseType_t é frequentemente usado para contadores e índices em loops.

5.5. Prefixo e (Enumeração)

O prefixo e indica que a variável é uma enumeração (enum), usada para definir valores simbólicos.

Exemplo: Obtendo o estado de uma tarefa

eTaskState eState;

void app_main(void) {
    eState = eTaskGetState(NULL);
    printf("Estado da tarefa: %d\n", eState);
}

O eTaskGetState() retorna um valor do tipo eTaskState, que segue a convenção e.

5.6. Prefixo p (Pointer)

O prefixo p é usado para variáveis que armazenam ponteiros.

Exemplo: Ponteiro para uma string

char *pMessage = "Olá, FreeRTOS!";

void app_main(void) {
    printf("%s\n", pMessage);
}

O pMessage armazena um ponteiro para uma string.

5.7. Prefixo s (String)

O prefixo s indica que a variável é uma string.

Exemplo: Definição de uma string

const char *sWelcomeMessage = "Bem-vindo ao FreeRTOS!";

void app_main(void) {
    printf("%s\n", sWelcomeMessage);
}

Aqui, sWelcomeMessage representa uma string constante.

5.8. Prefixo pc e pu (Ponteiros para constantes)

Os prefixos pc e pu são usados para indicar ponteiros para constantes, diferenciando entre char e unsigned.

Exemplo: Ponteiro para constante

const char *pcMessage = "Mensagem constante";
const uint8_t *puData;

O pcMessage aponta para uma string constante, enquanto puData pode apontar para um buffer de dados constantes.

5.9. Prefixo c (Char)

O prefixo c indica que a variável é do tipo char.

Exemplo: Armazenando um caractere

char cCharacter = 'A';

void app_main(void) {
    printf("Caractere: %c\n", cCharacter);
}

Aqui, cCharacter armazena um único caractere.

5.10. Prefixo pd (Port Define)

O prefixo pd é usado para constantes internas do FreeRTOS, geralmente definindo estados ou resultados de funções.

Exemplo: Uso de pdPASS e pdFALSE

if (xTaskCreate(vTaskFunction, "Task", configMINIMAL_STACK_SIZE, NULL, 1, NULL) == pdPASS) {
    printf("Tarefa criada com sucesso!\n");
}

if (xSemaphoreTake(xSemaphore, 0) == pdFALSE) {
    printf("Semáforo não disponível.\n");
}

O pdPASS indica sucesso e pdFALSE indica falha na tentativa de captura do semáforo.

6. Boas Práticas na Nomenclatura do FreeRTOS

O uso correto da nomenclatura do FreeRTOS não é apenas uma questão de padronização, mas também uma prática essencial para aumentar a legibilidade, manutenibilidade e clareza do código. Aqui estão algumas boas práticas recomendadas ao trabalhar com o FreeRTOS.

6.1. Use os Prefixos e Sufixos Corretamente

O FreeRTOS adota uma convenção de nomenclatura bem estruturada para ajudar os desenvolvedores a entender rapidamente o propósito de funções e variáveis. Para manter essa clareza:

Use os prefixos apropriados para funções:

• Funções que retornam um status devem começar com x (ex.: xTaskCreate()).
• Funções que não retornam valores devem começar com v (ex.: vTaskDelay()).
• Funções que podem ser chamadas dentro de interrupções devem terminar com FromISR (ex.: xQueueSendFromISR()).

Use os tipos de dados apropriados:

• Utilize BaseType_t e UBaseType_t para variáveis de controle.
• Use TickType_t para valores relacionados ao tempo.
• Manipuladores devem ser sempre declarados com seus respectivos tipos (TaskHandle_t, QueueHandle_t, etc.).

Respeite a nomenclatura dos sufixos:

• Para variáveis que representam tempo, use Ticks ou MS.
• Para ponteiros, use p, pc, ou pu, conforme necessário.
• Para caracteres e strings, use c e s.

6.2. Evite Modificar os Nomes das Funções do FreeRTOS

As funções do FreeRTOS seguem uma convenção bem definida e não devem ser renomeadas. Isso pode causar confusão e dificultar a manutenção do código.

Evite fazer isso:

#define CriarTarefa xTaskCreate  // NÃO RECOMENDADO
CriarTarefa(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);

Forma correta:

xTaskCreate(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);

Alterar nomes de funções pode tornar o código difícil de entender para outros desenvolvedores.

6.3. Nomeie Tarefas, Filas e Recursos de Forma Clara

Sempre nomeie tarefas e recursos do FreeRTOS com nomes descritivos que indiquem sua função.

Evite nomes genéricos:

TaskHandle_t xTarefa1;
QueueHandle_t xFila;

Use nomes descritivos:

TaskHandle_t xTaskSensor;
QueueHandle_t xQueueMensagens;

Nomes descritivos tornam o código mais intuitivo e fácil de depurar.

6.4. Utilize pdMS_TO_TICKS() para Conversão de Tempo

O FreeRTOS mede o tempo em ticks, então é essencial converter corretamente valores de tempo em milissegundos para ticks.

Evite valores fixos em ticks:

vTaskDelay(100); // NÃO RECOMENDADO, pois depende da configuração do sistema

Use pdMS_TO_TICKS():

vTaskDelay(pdMS_TO_TICKS(100)); // Correto e portátil

Isso garante que o código funcione corretamente em diferentes configurações de configTICK_RATE_HZ.

6.5. Declare Variáveis no Escopo Adequado

Variáveis globais podem ser úteis, mas devem ser usadas com cuidado para evitar conflitos e garantir encapsulamento.

Use escopo local sempre que possível:

void vTaskFunction(void *pvParameters) {
    uint32_t ulContador = 0; // Variável local, melhor encapsulamento
    while (1) {
        ulContador++;
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

Evite variáveis globais desnecessárias:

uint32_t ulContadorGlobal; // Pode causar conflitos e dificultar depuração

void vTaskFunction(void *pvParameters) {
    while (1) {
        ulContadorGlobal++;
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

Sempre prefira variáveis locais, a menos que seja essencial compartilhá-las entre tarefas.

6.6. Documente Seu Código

O FreeRTOS facilita o desenvolvimento de sistemas embarcados, mas um código mal documentado pode se tornar difícil de entender e manter.

Exemplo de código bem documentado:

/**
 * @brief  Função da tarefa que lê sensores periodicamente.
 * @param  pvParameters: Parâmetros da tarefa (não usados aqui).
 */
void vTaskSensor(void *pvParameters) {
    while (1) {
        printf("Lendo sensor...\n");
        vTaskDelay(pdMS_TO_TICKS(1000)); // Espera 1 segundo
    }
}

Uma boa documentação ajuda a equipe de desenvolvimento e facilita futuras manutenções.

6.7. Teste e Valide o Código Com Regularidade

Ao trabalhar com o FreeRTOS, é essencial testar o código regularmente para garantir que ele funcione corretamente e não tenha problemas de concorrência.

Dicas para testes eficazes:

• Use configASSERT() para verificar condições críticas.
• Monitore o uso de memória e pilha (uxTaskGetStackHighWaterMark()).
• Teste cenários de alta concorrência e preempção para evitar deadlocks e starvation.

Conclusão

O FreeRTOS fornece um sistema operacional leve e eficiente para sistemas embarcados, mas seu uso correto exige boas práticas na nomenclatura e estrutura do código. Resumindo:

Use os prefixos e sufixos corretamente para garantir legibilidade.
Não modifique nomes das funções do FreeRTOS para manter compatibilidade.
Dê nomes descritivos a tarefas, filas e semáforos para facilitar manutenção.
Sempre converta milissegundos para ticks com pdMS_TO_TICKS().
Evite variáveis globais desnecessárias para reduzir riscos de conflitos.
Documente e teste seu código regularmente para manter qualidade.

Seguindo essas boas práticas, você garantirá que seus projetos baseados no FreeRTOS sejam mais organizados, confiáveis e fáceis de manter.

The post Introdução à Nomenclatura do FreeRTOS first appeared on MCU & FPGA.