Rtos: sistema multi-tarefas para sistemas embarcados
Quando se torna interessante o uso de freeRtos ?
O sistema operacinal de tempo real, se torna uma solução quando sofremos com a necessidade de se ter multi-tarefas em embarcados, devido necessidade de se ter diversos sensores e atuadores trabalhando em tarefas especificas. Assim, o controle se torna algo difícil de se realizar simultâneamente ,deixando a programação e sincronização complexa. Dessa forma, fazendo o uso do sistema operacional de tempo real vantajosa.
O que é um sistema operacional ?
Funciona como um conjunto de softwares que criam um ambiente multi-tarefas e também é uma abstração entre software e hardware, com gerenciamento de recursos internos. Os principais itens de um sistema operacional são :
Kernel : Núcleo do sistema operacional, sendo uma camada de adstração entre os software e hardware para o gerenciamento de memória e gerenciamento de processos
Scheduler: É software do sistema que decide quais tarefas serão executadas. Por prioridade ou em caso de prioridade iguais o software tenta dividir o tempo entre as tarefas.
Tarefas: São pequenos programas. Cada tarefa pode desempenhar algo totalmente diferente das outras ou iguais com partilha de recursos. São nos programas que iremos dividir nosso código em partes, deixando que o scheduler as execute com todas as devidas importâncias.
Qual a finalidade dos RTOS?
Tendo em vista que nos RTOS o tempo de resposta é mais importante do que a capacidade de executar diversas tarefas simultaneamente. Mesmo que não seja imediato o “’ real-time”, deve ser previsível dependendo da forma que seu sistema funciona. As tarefas tem tempos extipulados para serem executas, logo chamadas de “Time Critical”. Logo, sendo indispensável para os embarcados, que necessitam fazer tarefas simultâneas sem que uma atrase a outra.
Esboçando alguns recursos
Função das “taks”(tarefas):
As taks do freeRTOS, são equivalente aos programas de um computador, aonde dentro da função main() tem um loop infinito que pede opções ao usuário, respondendo a cada opção com a execução de um trecho de código específico, e depois voltando a uma nova interação do loop. Logo, e possível chegar que , embora tenha varias opções do que fazer, apenas uma delas e feitas por vez, em um sequência de instruções. A função da task tem o aspecto de uma função main(), com um loop infinito em seu núcleo, evidenciando que ela executa sem precisar se importar em cooperar com as outras funções e tarefas que possam existir. Será o próprio sistema operacional que tratará de parar momentaneamente a execução do código da task para dar chance a outra task.
Semáforo( semaphore):
Como já expecifica o próprio nome, os semáforos coordenam a execução entre as task. Sem que haja necessariamente mais dados associados. Necessitando apenas o contexto associado pelo programador ao semáforo.
Tipo de semáforo:
De exclusão mútua, chamado de mutex, ele age com o contexto de que so uma das tasks pode agir esta ocorrendo. E que todas as demais que pretendem atuar naquele contexto estão excluídas, como em um cruzamento de ruas com semáforo.
temos os semáforos de contadores, que permite que diversas tasks e pontos do código possam alocar o semáforo, decrementando um valor até que chegue a zero, quando não será mais possível alocá-lo.
Temporização:
Alem do código executar as tasks, pode-se utilizar funções que são executadas de tempo em tempos, sem um loop interno apartir do módulo timer. Este módulo coloca as funções definidas em um fila e as executa em intervalos regulares ou em uma única vez, apó uma temporização.
Logo, para controlar o timeout é necessário apenas ativar um chamada de determinada função a cada x segundos, por exemplo.
Usando um exemplo que vem na biblioteca do freeRTOS no Arduino.
Nome do exemplo: Blink_AnalogRead
Como encontrar: abrir o IDE Arduino depois de instalado( se estiver usando Windows 10 da para baixar pela Microsoft store) depois de ter baixado o arquivo do freeRTOS e colocado na pasta libraries do Arduino. Basta apenas, abrir o Arduino IDE ir em arquivos, exemplos, ir até exemplos de bibliotecas personalizadas, e abrir o exemplo aqui proposto.
#include <Arduino_FreeRTOS.h>
void TaskBlink( void *pvParameters );
void TaskAnalogRead( void *pvParameters );
void setup() {
Serial.begin(9600);
while (!Serial) {
;
}
xTaskCreate(
TaskBlink
, “Blink”
, 128
, NULL
, 2
, NULL );
xTaskCreate(
TaskAnalogRead
, “AnalogRead”
, 128
, NULL
, 1
, NULL );
}
void loop()
{
}
void TaskBlink(void *pvParameters)
{
(void) pvParameters;
pinMode(LED_BUILTIN, OUTPUT);
for (;;)
{
digitalWrite(LED_BUILTIN, HIGH);
vTaskDelay( 1000 / portTICK_PERIOD_MS );
digitalWrite(LED_BUILTIN, LOW);
vTaskDelay( 1000 / portTICK_PERIOD_MS );
}
}
void TaskAnalogRead(void *pvParameters) // This is a task.
{
(void) pvParameters;
for (;;)
{
int sensorValue = analogRead(A0);
Serial.println(sensorValue);
vTaskDelay(1);
}
}
Após tiras alguns comentários apenas para simplificar a demonstração e esboçar mais ou menos o que deve se achar lá no Arduino.
Algumas analizes desse software: Na primeira linha vemos o #include <Arduino_FreeRTOS.h>, que é a header padrão para freeRTOS, comando padrão mínimo para o uso do rtos no Arduino, com ele pode se ter as definições mais básicas, que permitem a criação e funcionamento das tasks. Se for necessário utilizar outros recursos, será necessário usar os arquivos header necessários para a sua necessidade especifica.
Logo após vem os protótipos das funções tasks( que cria as tasks):
TaskBlink( void *pvParameters );
TaskAnalogRead( void *pvParameters );
Seus nomes são sugestivos para suas ações, sempre retornam void e recebem um ponteiro genérico para void.
Seguindo a ordem , vem a parte de criação das tasks na função setup(), são criadas duas tasks usando a função xTaskCreate, cada uma atribui alguns parâmetros, com destaque para a primeira que é o nome da função task
Logo após, se encontra a função loop vazia, onde poderia estar o código de piscar o led( lê uma entrada analógica), esta vazia. Justamente porque agora as operações ficarão principalmente nas taks e quando necessário nas interrupções.
A seguir, temos uma inicialização no pino ,linha 75 do programa no Arduino, referente as primeiras linhas das task, já que o pino é assunto dela e só ela irá usá-lo. Esse código roda apenas uma vez. Entre as linhas 77 e 83 existe o loop que pisca o led, primeiro acende , espera, apaga e volta a acender. Agora, olhando a segunda função task começa na linha 86 indo ate a 107, na linha 102 temos a leitura da entrada analógica para a variável sensorValue que é colocada dentro do loop, na 104 o valor é enviado para o serial, notasse que aqui não foi necessário usar um semáforo pois apenas uma task envia coisas para o serial. Se você usar um recurso com apenas uma task, ok sem problemas, mas se usa-lo em vários lugares irá precisar controlar o acesso a ele.
Se quiser rodar o programa no arduino utilizar um led com o catodo ligado ao GND e um resistor de 10kΩ no anodo ao pino 12
Acesse as publicações do grupo VISIOROB no Instagram /https://www.instagram.com/visiorob/. Não se esqueça as outras matérias disponíveis no blog /https://visiorob.com.br/index.php/grupo-visiorob/.
Para ficar por dentro de tudo que acontece! Enfim, nos vemos na próxima.
Faça um comentário