Os microcontroladores são limitados a determinadas tarefas e normalmente não possuem a capacidade de multithreading, o que permitiria mais de um usuário ou tarefa ao mesmo tempo, sem exigir múltiplas cópias de um programa ou computador. Geralmente, os microcontroladores não podem dividir aplicações maiores ou mais complexas em vários threads. Eles lidam com sequências simples de código em tempo real, com exceção de loops de programação, condições específicas e interrupções.
As interrupções são uma forma de solucionar tarefas urgentes em dispositivos incorporados. No entanto, as interrupções permanecem dependentes de circuitos externos (no caso de interrupções de hardware) ou de periféricos integrados (no caso de interrupções de temporizador).
Tenha em mente que as interrupções têm como objetivo fazer com que os microcontroladores respondam a eventos específicos em tempo real e não a prazos rígidos. Como resultado, não há garantia de execução oportuna de tarefas críticas porque as interrupções nos microcontroladores são inerentemente priorizadas. Além disso, apesar das melhores práticas de codificação, uma rotina de serviço de interrupção pode ser muito longa. Ele também suspende o código de execução principal, que pode incluir outras tarefas urgentes.
A solução? Um sistema operacional em tempo real (RTOS) pode ser usado para cumprir prazos operacionais rigorosos. Existem vários RTOS disponíveis para microcontroladores, e RTOS grátis é popular com versões comerciais disponíveis.
Tecnicamente, o FreeRTOS não é um sistema operacional de tempo real completo, mas um agendador de tempo real projetado para microcontroladores. Com o suporte do FreeRTOS, é possível priorizar tarefas incorporadas para que sejam executadas dentro de prazos rígidos.
Neste projeto, faremos upload do FreeRTOS no Arduino UNO para aprender como ele agenda tarefas incorporadas. Neste caso, será para acender LEDs. Este projeto também pode ser executado em ESP8266, ESP32 ou qualquer outra placa microcontroladora compatível com Arduino.
Componentes necessários
1. Arduino UNO x1
2. LEDx4
3. Resistores 330Ω x4
4. Tábua de ensaio
5. Fios de ligação/fios de conexão
Como funciona o FreeRTOS
Os microcontroladores possuem um único núcleo, o que significa que só podem executar uma tarefa simultaneamente. O FreeRTOS permite o agendamento de tarefas, de modo que parece que vários eventos estão sendo executados simultaneamente. Isso é chamado de agendamento em tempo real. Na realidade, apenas uma tarefa está ativa por vez em microcontroladores de núcleo único, e as demais permanecem inativas.
O FreeRTOS divide as tarefas inativas em três estados…
1. Estado pronto: As tarefas no estado pronto estão disponíveis para agendamento por meio do agendador do FreeRTOS. Essas tarefas recebem recursos de memória e processador de acordo com o algoritmo de escalonamento. O algoritmo define o cronograma para as tarefas no estado pronto com base na prioridade atribuída a elas. Essas tarefas não são bloqueadas nem suspensas. Então, eles não estão correndo, mas esperando para correr.
2. Estado bloqueado: As tarefas no estado bloqueado não estão na fila do agendador. Em vez disso, eles são bloqueados pelo agendador e permanecem inativos indefinidamente. O estado bloqueado depende de uma interrupção externa ou de um recurso como mutex, semáforo ou semáforo de contagem. Outra razão para uma tarefa bloqueada e inativa pode ser sua natureza periódica – o que significa que ela é atrasada periodicamente no loop principal.
3. Estado suspenso: Tarefas inativas em estado bloqueado só podem ser executadas quando uma respectiva interrupção é recebida ou um recurso necessário é usado. Mas algumas tarefas inativas são explicitamente atrasadas pelo desenvolvedor e então colocadas em uma fila. Freqüentemente, essas tarefas são agendadas quando condições específicas são atendidas ou após a execução de outra tarefa. Por exemplo, um desenvolvedor pode suspender a impressão do valor da leitura de um sensor em uma unidade de exibição até que seja lido e convertido pelo ADC.
A API FreeRTOS oferece uma função vTaskSuspend que suspende explicitamente uma tarefa e uma função vTaskResume que retoma a tarefa.
Uma tarefa pode transitar por um estado bloqueado, pronto, suspenso e em execução várias vezes durante seu tempo de vida multitarefa, conforme mostrado no fluxograma abaixo.
No Arduino, cada tarefa é definida como um bloco de código envolvido em sua própria função. O FreeRTOS permite a criação de tarefas que chamam uma respectiva função. Cada tarefa recebe uma prioridade. O FreeRTOS define automaticamente o algoritmo de agendamento das tarefas durante o tempo de execução, de acordo com as prioridades atribuídas e a disponibilidade de recursos de processamento.
Instalando o FreeRTOS
O FreeRTOS está disponível na biblioteca do Arduino. Para incorporar o FreeRTOS em um aplicativo Arduino, basta incluir a biblioteca no esboço. Mas primeiro, instale-o no Arduino IDE.
Para fazer isso, navegue até Ferramentas->Gerenciar Bibliotecas e pesquise FreeRTOS. Vá até a biblioteca FreeRTOS escrita por Phillip Steven. Instale a biblioteca.
Agora, você pode incluir facilmente o FreeRTOS em um aplicativo Arduino importando a biblioteca para o sketch usando esta instrução…
#includeArduino_FreeRTOS.h>
Criando e priorizando tarefas
A API FreeRTOS fornece uma função xTaskCreate para criar tarefas. A função tem este protótipo…
BaseType_t xTaskCreate(
TaskFunction_t pvTaskCode,
const char * const nome_do_pc,
configSTACK_DEPTH_TYPE usStackDepth,
void *pvParâmetros,
UBaseType_t uxPriority,
TaskHandle_t *pxCreatedTask
);
São necessários os seguintes argumentos…
- pvTaskCode: o ponteiro para a função definida da tarefa. A tarefa é implementada como um loop infinito. O ponteiro é passado como argumento para a função. A tarefa também pode ser excluída.
- nome do pc: o nome da função de retorno de chamada que executa a tarefa. A função não deve retornar um valor ou sair.
- usStackDepth: o tamanho da pilha no número de palavras alocadas para a tarefa. Em um microcontrolador de 32 bits, cada palavra tem quatro bytes. Portanto, se o tamanho da pilha for definido como 100, 400 bytes serão alocados para a tarefa.
- Parâmetros pv: o valor do parâmetro, que é passado como argumento da função de tarefa.
- uxPrioridade: a prioridade definida para a tarefa, que pode ser um número inteiro positivo ou -1. Se definido como -1, a prioridade será definida como indefinida. Quanto maior o número inteiro (que é passado como argumento), maior será a prioridade da tarefa. Por exemplo, uma tarefa com prioridade 3 tem prioridade mais alta do que uma tarefa com prioridade 2. A prioridade mais baixa é 0.
- pxCreatedTask: o identificador da função para a tarefa. O identificador pode ser usado para excluir a tarefa.
Configurando a sequência de execução da tarefa
O FreeRTOS executa primeiro a tarefa de maior prioridade. As demais tarefas são executadas quando os recursos estão disponíveis ou em turnos periódicos. Normalmente, é necessário definir a sequência inicial de tarefas. Isso se aplica à execução de tarefas iniciais. Se as tarefas devem ser executadas em uma ordem predeterminada, isso pode ser definido usando a função vTaskDelayUntil da API FreeRTOS. Esta função permite definir um atraso antes que a tarefa seja executada pela primeira vez.
Conexões de circuito
Para demonstrar o FreeRTOS como um agendador de tarefas, acenderemos LEDs no Arduino. Para este projeto, usamos quatro LEDs e os conectamos com GPIO8, GPIO9, GPIO10 e GPIO11 do Arduino.
Os LEDs têm interface para que brilhem quando o GPIO envia uma saída de sinal LOW.
Depois de fazer as conexões do circuito, carregue o seguinte esboço no Arduino.
Como funciona
O FreeRTOS é usado para executar quatro tarefas diferentes. Cada tarefa acende uma luz LED e desliga os outros LEDs. Uma mensagem é impressa no monitor serial indicando a execução de determinada tarefa.
- A tarefa que acende o LED conectado ao GPIO8 tem a prioridade mais alta de 3. Ela está programada para ser executada após 100 milissegundos na primeira execução.
- A tarefa que acende o LED conectado ao GPIO9 tem prioridade 2. Está programada para ser executada após 110 milissegundos na primeira execução.
- A tarefa que acende o LED conectado ao GPIO10 tem prioridade 1. Está programada para ser executada após 120 milissegundos na primeira execução.
- A tarefa que acende o LED conectado ao GPIO11 tem a prioridade mais baixa, 0. Está programada para ser executada com um atraso de 50 milissegundos.
Inicialmente, as tarefas devem ser executadas nesta ordem predefinida. Em seguida, a execução das tarefas ocorre de acordo com sua prioridade e disponibilidade de recursos de processamento.
O código
O esboço começa importando a biblioteca Arduino_FreeRTOS.h. Na função setup , a taxa de transmissão para comunicação de mensagens ao monitor serial é de 9600 bps. A execução da função setup é indicada pela impressão de uma mensagem no monitor serial.
Os LEDs são conectados aos pinos do Arduino que são configurados como saídas digitais usando a função pinMode . As tarefas são criadas com prioridades 3, 2, 1 e 0 usando a função xTaskCreate da API FreeRTOS. Todas as tarefas recebem uma pilha de 100 palavras. As tarefas estão vinculadas às funções de retorno de chamada MyTask1 , MyTask2 , MyTask3 e IdleTask .
A função loop fica vazia, pois as tarefas incorporadas serão executadas pelo agendador do FreeRTOS. A primeira tarefa é definida na função MyTask1 . Ele acende o LED que está conectado ao GPIO8, desligando todos os demais LEDs. Após a execução, 'Task1' é impresso no monitor serial. A tarefa é agendada para ser executada após 100 milissegundos usando a função vTaskDelay quando executada pela primeira vez.
A segunda tarefa é definida na função MyTask2 . Ele acende o LED que está conectado ao GPIO9, desligando todos os demais LEDs. Após a execução, 'Task2' é impresso no monitor serial. A tarefa é agendada para ser executada após 110 milissegundos usando a função vTaskDelay quando executada pela primeira vez.
A terceira tarefa é definida na função MyTask3 . Ele acende o LED que está conectado ao GPIO10, desligando todos os demais LEDs. Após a execução, 'Task3' é impresso no monitor serial. A tarefa é agendada para ser executada após 120 milissegundos usando a função vTaskDelay quando executada pela primeira vez.
A última tarefa é definida na função MyIdleTask . Acende o LED que está conectado ao GPIO11 (LED Amarelo), desligando todos os demais LEDs. Após a execução, 'Idle State' é impresso no monitor serial. A tarefa está programada para ser executada periodicamente após 50 milissegundos.
Esta tarefa só é executada quando o microcontrolador não está ocupado realizando outras tarefas. Como está atrasado em 50 milissegundos, ele deve ser executado periodicamente.
Resultados
O seguinte log da execução das tarefas do FreeRTOS é apresentado no monitor serial.
Os LEDs são alternados pelo agendador do FreeRTOS.
(Link para vídeo de demonstração P35-DV)
Conclusão
O log do monitor serial indica que as tarefas foram inicialmente executadas no padrão predefinido definido pela função vTaskDelay . Posteriormente, as tarefas são executadas de acordo com sua prioridade e disponibilidade de recursos de processamento.
Como a tarefa inativa é executada periodicamente a 50 milissegundos, o LED conectado no GPIO11 parece permanecer aceso. O LED conectado ao GPIO8 fica aceso por mais tempo porque a tarefa responsável por ligá-lo tem a prioridade mais alta e dura mais tempo. O LED conectado ao GPIO9 acende de forma intermitente porque a tarefa responsável por ligá-lo o faz sempre que a tarefa 1 não está em execução. O LED conectado ao GPIO10 aparece apagado porque a tarefa responsável por ligá-lo raramente tem chance.
