a multitarefas levou os computadores a uma revolução onde um ou mais programas podem correr simultaneamente o que aumenta a eficiência, flexibilidade, adaptabilidade e produtividade. Em sistemas embarcados, microcontroladores também podem lidar com multitarefas e executar duas ou mais tarefas simultaneamente, sem parar as instruções atuais.

aqui neste tutorial vamos aprender como Arduino realiza multitarefas com a função Arduino millis. Geralmente uma função delay() é usada em Arduino para uma tarefa periódica como LED Blinking, mas esta função delay() interrompe o programa por algum tempo definitivo e não permite que outras operações para executar. Assim, este artigo explica como podemos evitar o uso da função delay() e substituí-la por millis() para executar mais de uma tarefa simultaneamente e fazer do Arduino um controlador multitarefa. Antes de entrar em detalhes, Vamos começar por subestimar multitarefas.o que é multitarefas?

multitarefas significa simplesmente executar mais de uma tarefa ou programa simultaneamente ao mesmo tempo. Quase todos os sistemas operacionais possuem multitarefas. Este tipo de sistemas operacionais são conhecidos como MOS (multitarefa Sistema Operacional). O MOS pode ser móvel ou desktop PC Sistema Operacional. O bom exemplo de multitarefas em computadores é quando os usuários executam a aplicação de E-mail, navegador de internet, media player, jogos, ao mesmo tempo e se os usuários não querem usar a aplicação que corre em segundo plano, se não estiver fechada. O Usuário Final usa todas essas aplicações ao mesmo tempo, mas o sistema operacional leva este conceito um pouco diferente. Vamos discutir como o OS gerencia multitarefas.

What is Multitasking in Arduino

conforme visto na imagem, a CPU divide o tempo nas três partes iguais e atribui cada parte a cada tarefa / aplicação. É assim que a multitarefa é feita na maioria dos sistemas. O conceito será quase o mesmo para a multitarefa Arduino, exceto que a distribuição de tempo será um pouco diferente. Uma vez que o Arduino é executado em baixa frequência e RAM comparar com Laptop/Móvel/PC de modo que o tempo dado a cada tarefa também será diferente. Arduino também tem uma função delay() que é amplamente utilizada. Mas antes de começar vamos discutir isso porque não devemos usar a função delay() em qualquer projeto.

por que ignorar o atraso() no Arduino?

Se a documentação de referência de Arduino é considerada então há dois tipos de funções de atraso, o primeiro é delaymicrosegundos (). Ambas as funções são idênticas em termos de geração de atraso. A única diferença é que, na função delay (), o parâmetro inteiro passado é em milisegundos I. e se nós escrevermos atraso(1000), então o atraso será de 1000 milisegundos, ou seja, 1 segundo. Da mesma forma na função delayMicroseconds (), o parâmetro passado é em microssegundos, ou seja, se escrevermos delayMicroseconds(1000), então o atraso será de 1000 microssegundos, ou seja, 1 milisegundos.

Aqui vem o ponto, ambas as funções pausam o programa para a quantidade de tempo passado na função de atraso. Então, se estamos dando um atraso de 1 segundo, então o processador não pode ir para a instrução seguinte até 1 segundo passado. Da mesma forma, se o atraso for de 10 segundos, então o programa vai parar por 10 segundos e o processador não vai permitir ir para as instruções seguintes até que os 10 segundos passados. Isso dificulta o desempenho do microcontrolador em termos de velocidade e execução das instruções.

O melhor exemplo para explicar a desvantagem da função de atraso é usando dois botões de pressão. Considere que queremos alternar dois LEDs usando dois botões de pressão. Assim, se um botão de pressão é pressionado, então o LED correspondente deve brilhar durante 2 segundos, da mesma forma se o segundo for pressionado, então o LED deve brilhar durante 4 segundos. Mas quando usamos delay (), se o usuário estiver pressionando o primeiro botão, então o programa vai parar por 2 segundos e se o usuário pressionar o segundo botão Antes de 2 segundos de atraso, então o microcontrolador não vai aceitar a entrada como o programa está em fase de parada.

a documentação oficial de Arduino menciona isso claramente em suas notas e avisos de atraso() descrição da função. Pode passar e verificar isto para que fique mais claro.por que utilizar millis() ?

para superar o problema causado pelo uso do delay, um desenvolvedor deve usar a função millis () que é fácil de usar uma vez que você se torne habitual e ele irá usar 100% de desempenho da CPU sem gerar qualquer atraso na execução das instruções. millis() é uma função que apenas retorna a quantidade de milisegundos que decorreram desde que a placa Arduino começou a executar o programa atual sem congelar o programa. Este número de tempo vai transbordar (I. E. voltar a zero), após aproximadamente 50 dias.assim como Arduino tem delaymicrosegundos(), ele também tem a micro versão de millis() como micros(). A diferença entre micros e millis é que, o micros() vai transbordar após aproximadamente 70 minutos, em comparação com millis() que é de 50 dias. Assim, dependendo da aplicação você pode usar millis () ou micros ().

Using millis() instead of delay():

para usar o millis () para o tempo e atraso, você precisa gravar e armazenar a hora em que a ação ocorreu para iniciar o tempo e, em seguida, verificar em intervalos se o tempo definido passou. Então, como indicado, armazenar o tempo atual em uma variável.

unsigned long currentMillis = millis();

precisamos de mais duas variáveis para descobrir se o tempo necessário passou. Guardámos o tempo actual na variável currentMillis, mas também precisamos de saber quando começou o período de tempo e quanto tempo é o período. Assim, o intervalo e o número anterior são declarados. O intervalo nos dirá o atraso de tempo e o previosMillis armazenará a última vez que o evento ocorreu.

unsigned long previousMillis;unsigned long period = 1000;

para entender isso, vamos tomar um exemplo de um LED piscar simples. Período = 1000 vai nos dizer que o LED vai piscar por 1 segundo ou 1000ms.

const int ledPin = 4; // the LED pin number connectedint ledState = LOW; // used to set the LED stateunsigned long previousMillis = 0; //will store last time LED was blinkedconst long period = 1000; // period at which to blink in msvoid setup() { pinMode(ledPin, OUTPUT); // set ledpin as output}void loop() { unsigned long currentMillis = millis(); // store the current time if (currentMillis - previousMillis >= period) { // check if 1000ms passed previousMillis = currentMillis; // save the last time you blinked the LED if (ledState == LOW) { // if the LED is off turn it on and vice-versa ledState = HIGH; } else {ledState = LOW;} digitalWrite(ledPin, ledState);//set LED with ledState to blink again }}

Aqui, a instrução <se (currentMillis – previousMillis >= período)> verifica se o 1000ms passou. Se 1000ms passou, então o LED blink e novamente vem ao mesmo estado. E isto continua. É isso, aprendemos a usar millis em vez de atrasar. Desta forma, ele não vai parar o programa para um intervalo particular.

Interrupts in Arduino works same as in other microcontrollers. A placa Arduino UNO tem dois pinos separados para anexar interrupções na GPIO pin 2 e 3. Temos coberto em detalhe no manual de interrupções Arduino, onde você pode aprender mais sobre interrupções e como usá-las.aqui mostraremos várias tarefas de Arduino, lidando com duas tarefas ao mesmo tempo. As tarefas incluem piscar de dois LEDs em atraso de tempo diferente, juntamente com um botão de pressão que será usado para controlar o estado ON/OFF de LED. Assim, três tarefas serão realizadas simultaneamente.

Diagrama de Circuito para o Arduino Multitarefa

Componentes Necessários

  • o Arduino UNO
  • Três Diodos emissores de luz(Qualquer Cor)
  • Resistências (470, 10k)
  • Jumpers
  • Protoboard

Diagrama de Circuitos

O diagrama de circuito para demonstrar o uso do Arduino Millis() fuction é muito fácil e não tem muita componentes para anexar como mostrado abaixo.

Diagrama de Circuito para o Arduino Multitarefa usando Arduino Millis() Função

de Programação Arduino UNO para Multitarefa

Programação Arduino UNO para multitarefa só vai exigir a lógica por trás de como millis() trabalho que está explicado acima. Recomenda-se a prática blink LED usando millis de novo e de novo para tornar a lógica clara e se tornar confortável com millis() antes de começar a programar Arduino UNO para Multitarefas. Neste tutorial a interrupção também é usada com millis() simultaneamente para Multitarefas. O botão será uma interrupção. Assim, sempre que uma interrupção é gerada, ou seja, o botão de pressão é pressionado, o LED vai mudar para o estado ligado ou desligado.

a programação começa com a declaração de números pin onde LEDs e botão de pressão estão conectados.

int led1 = 6;int led2 = 7;int toggleLed = 5;int pushButton = 2;

em seguida, escrevemos uma variável para armazenar o estado dos LEDs para uso futuro.

int ledState1 = LOW;int ledState2 = LOW;

tal como explicado acima no exemplo blink, as variáveis para o período E o anteriormillis é declarado para comparar e gerar atraso para LEDs. As primeiras piscas de LED a cada 1 segundo e outras piscas de LED após 200ms.

unsigned long previousMillis1 = 0; const long period1 = 1000;unsigned long previousMillis2 = 0;const long period2 = 200; 

outra função millis será utilizada para gerar o atraso de lançamento para evitar as múltiplas prensas do botão de pressão. Haverá uma abordagem semelhante à anterior.

int debouncePeriod = 20; int debounceMillis = 0;

as três variáveis serão usadas para guardar o estado do botão de pressão à medida que interrompe, activa ou desactiva o estado do botão de pressão.

bool buttonPushed = false;int ledChange = LOW; int lastState = HIGH;

Define a acção do pin que o pin irá funcionar como entrada ou saída.

 pinMode(led1, OUTPUT); pinMode(led2, OUTPUT); pinMode(toggleLed, OUTPUT); pinMode(pushButton, INPUT);

agora defina o PIN de interrupção, anexando a interrupção com a definição de ISR e modo de interrupção. Note que é recomendado usar digitalPinToInterrupt (pin_number) ao declarar anexinterrupt () função para traduzir o pin digital real para o número de interrupção específico.

attachInterrupt(digitalPinToInterrupt(pushButton), pushButton_ISR, CHANGE); 

a subrotina de interrupção é escrita e só irá mudar a bandeira buttonpacked. Note que, interromper subrotina deve ser o mais curto possível, então tente escrevê-lo e minimizar as instruções extras.

void pushButton_ISR(){ buttonPushed = true; }

Loop começa com o armazenamento do valor de millis numa variável currentMillis que irá armazenar o valor do tempo decorrido de cada vez que o loop itera.

unsigned long currentMillis = millis();

há no total três funções em multitarefa, blink um LED a 1 segundo, Blink segundo LED a 200ms e se o botão de pressão é pressionado, em seguida, desligar/ON LED. Então vamos escrever três partes para fazer essa tarefa.

o primeiro é comutar o estado LED após cada 1 segundo, comparando o Milis decorridos.

 if (currentMillis - previousMillis1 >= period1) { previousMillis1 = currentMillis; if (ledState1 == LOW) { ledState1 = HIGH; } else { ledState1 = LOW; } digitalWrite(led1, ledState1); }

Similarmente o segundo que activa ou desactiva o LED após cada 200ms, comparando o Milis decorrido. A explicação já foi explicada anteriormente neste artigo.

 if (currentMillis - previousMillis2 >= period2) { previousMillis2 = currentMillis; if (ledState2 == LOW) { ledState2 = HIGH; } else { ledState2 = LOW; } digitalWrite(led2, ledState2); }

por último, a bandeira buttonpotada é monitorizada e, depois de gerar um atraso de lançamento de 20ms, apenas activa ou desactiva o estado do LED corresponde ao botão de pressão ligado à interrupção.

 if (buttonPushed = true) // check if ISR is called { if ((currentMillis - debounceMillis) > debouncePeriod && buttonPushed) // generate 20ms debounce delay to avoid multiple presses { debounceMillis = currentMillis; // save the last debounce delay time if (digitalRead(pushButton) == LOW && lastState == HIGH) // change the led after push button is pressed { ledChange = ! ledChange; digitalWrite(toggleLed, ledChange); lastState = LOW; } else if (digitalRead(pushButton) == HIGH && lastState == LOW) { lastState = HIGH; } buttonPushed = false; } }

isto termina o Tutorial Arduino millis (). Note que, a fim de se tornar habitual com millis (), basta praticar para implementar esta lógica em algumas outras aplicações. Você também pode expandi-lo para usar motores, servomotores, sensores e outros periféricos. Em caso de qualquer dúvida, por favor, escreva para o nosso fórum ou comentário abaixo.apresenta-se a seguir o código completo e o vídeo para demonstrar a utilização da função millis em Arduino.

Deixe uma resposta

O seu endereço de email não será publicado.