Arduino Delay [Tutorial]

neste tutorial você vai aprender como usar corretamente a função delay() para adicionar algum atraso entre 2 ações em seus programas Arduino. Então, você vai descobrir por que o uso de delay() muitas vezes não é uma boa idéia quando você quer fazer sua escala de programas, e como corrigir isso.Muito bem, vamos começar!

por que você precisa de atrasos em seus programas Arduino?

bem, um programa Arduino depende muito de entradas/saídas externas para trabalhar.

tomando um exemplo simples: você pode querer monitorar o estado de um botão de pressão 100 vezes por segundo, ou fazer um piscar LED a cada 0, 5 segundos.Como pode conseguir isso? Um programa Arduino funciona assim.:

• primeiro, a função setup() é executada uma vez.
• então a função loop() é executada uma e outra vez, até que você desligue o seu Arduino.

qualquer programa que escrever será executado a toda a velocidade. Então, se você estiver fazendo um piscar LED em seu código, o que vai acontecer é que o LED vai piscar a uma taxa muito alta (várias milhares de vezes por segundo, pelo menos).Está a aprender a usar o Arduino para construir os seus próprios projectos?

confira Arduino para iniciantes e aprenda passo a passo.

se você quiser controlar o tempo – isto é, certifique – se de que o LED pisca apenas a cada 0.5 segundos e não a toda a velocidade-você precisa adicionar algum atraso no seu código.

Implementing Arduino delay in your code

the Arduino delay() function

Here’s a code to make an LED blink (here we choose the built-in LED, no need to add any external LED) every 0.5 seconds – this is one of the most common examples you will see if you begin with Arduino.Como funciona este código?

primeiro você usa um “define” para que você não tenha que codificar o número “13” várias vezes em seu código e isso torna o seu programa mais legível.

você configura o modo do pin para saída com a função pinMode().

, na loop() função, você:

1. Power o LED
2. Use delay(500) para fazer o programa do sono para 500 milissegundos, ou seja, 0,5 segundos
3. desligar o LED
4. Use delay(500) para fazer o programa de dormir de novo para 0.5 segundos
5. E volte para o passo 1, porque o loop() função continua a ser executado novamente e novamente.

a função delay() espera que você dê um número de milisegundos – Não segundos-para dormir. Então, se você pensar em segundos, então multiplique o número por 1000 e você tem o valor que precisa.Se você quiser fazer o seu Arduino dormir por 1 minuto, ou por vários minutos, então é muito fácil.

tome o número de minutos, multiplique-o por 60 para obter o número de segundos, e depois multiplique-o por 1000 para obter o número de milisegundos.

Ex: delay(3 * 60 * 1000); fará o programa dormir durante 3 minutos.

a função Arduino delaymicrosegundos ()

se precisar de ser mais preciso pode ter de usar a função delayMicroseconds(). Com delayMicroseconds() você pode fornecer um número de microssegundos para dormir. A duração mínima para delay() é de 1 milissegundo, então se você precisa dormir por apenas 400 microssegundos, aqui você tem uma nova solução.Esta função pode ser muito útil quando se comunica com alguns componentes de hardware. Por exemplo, o Arduino precisa enviar alguns dados para o componente e, em seguida, ler alguma resposta. Digamos que o componente precisa de 6 microssegundos para processar o pedido e fornecer dados precisos.Então, no seu programa, pode ter algo assim.:

...void loop() { // send data to component delayMicroseconds(6); // reach out to component again to read data}

Não bloqueio de atraso – por que você deve evitar o uso de atraso()

Então, agora que você entende o que é um atraso no Arduino, e como implementá-lo com delay() e delayMicroseconds(), vamos ver como utilizar o atraso funcionalidade–, mas sem as funções.Porquê?Quando utilizar delay(), a execução do seu programa irá parar, e só será retomada após o atraso terminar.

isto é OK se você só tem uma ação a fazer-exemplo: blink a single LED-but what if you need to take care of multiple hardware components or communicate with other devices such as Arduino boards or your own computer?

usando o exemplo anterior, como você poderia fazer um LED piscar a cada 0.5 segundos, e outro piscar a cada 0.8 segundos?Nesse caso, ficará preso muito rapidamente. Se você ainda quiser usar delay(), você pode encontrar uma solução onde você usa atrasos mais curtos entre várias ações, mas isso vai tornar o seu programa mais complicado cada vez que você adicionar uma nova ação.

a solução para isso é simplesmente monitorar o tempo sem usar a função delay(), basicamente para encontrar uma maneira de reproduzir o comportamento de delay() sem usá-lo.

Code example-Arduino delay without delay()

Let’s rewrite our blink LED example without using delay().

#define LED_PIN 13unsigned int lastTimeLedBlinked = millis();unsigned int delayBetweenBlink = 500;byte ledState = LOW;void setup() { pinMode(LED_PIN, OUTPUT);}void loop() { unsigned int timeNow = millis(); if (timeNow - lastTimeLedBlinked > delayBetweenBlink) { if (ledState == LOW) { ledState = HIGH; } else { ledState = LOW; } digitalWrite(LED_PIN, ledState); lastTimeLedBlinked = timeNow; }}

vamos analisar este código linha por linha.

Inicialização

#define LED_PIN 13unsigned int lastTimeLedBlinked = millis();unsigned int delayBetweenBlink = 500;byte ledState = LOW;

Primeiro, você inicializar 3 variáveis no escopo global:

• lastTimeLedBlinked: esta variável será utilizada para armazenar a última vez que o LED piscava. Basicamente, cada vez que fizermos o blink LED, vamos atualizar esta variável com o tempo atual – usando a função millis ().
• delayBetweenBlink: este é o tempo que você quer esperar entre 2 ações – aqui a ação é piscar o LED.
• ledState: vamos precisar armazenar o estado atual do LED (alto ou baixo) para que possamos saber o que era o estado anterior, e tomar medidas em conformidade.

porquê no âmbito global? Bem, o que planejamos fazer é atualizar essas variáveis na função loop() e acessá-las novamente da próxima vez que entrarmos na loop(). Se criarmos as variáveis dentro do loop(), as variáveis serão variáveis locais e, portanto, serão destruídas quando você sair da função loop(). Assim, da próxima vez que loop() for chamado novamente, todos os valores serão perdidos e você vai criar variáveis novamente sem nenhum valor anterior dentro. Aqui, ao criar as variáveis fora da função podemos fazê-las” sobreviver ” e manter o seu valor cada vez que entramos na loop().

implementando a funcionalidade de atraso Arduino na função de laço

agora, vamos ver o que acontece na função loop().

void loop() { unsigned int timeNow = millis();

em primeiro lugar, você lê o tempo atual com a função millis().

 if (timeNow - lastTimeLedBlinked > delayBetweenBlink) {

e agora você compara o tempo atual que você acabou de ler, com o tempo anterior o LED pestanejou. Se o tempo suficiente passou (mais do que o valor armazenado em delayBetweenBlink), então isso significa que você pode digitar o if().

esta estrutura de código – lendo o tempo e comparando-o com o tempo anterior que você fez uma ação-é como você substitui a função delay(). Basicamente você está apenas computando uma duração aqui. E como você pode ver isso significa que seu programa contém mais linhas para uma aplicação simples, mas lhe dá muito mais controle e é muito mais escalável.Então, o que vai acontecer? Bem, o loop() continuará a ser executado a toda a velocidade. Cada vez, seu programa vai verificar se o tempo suficiente passou. Se não, então o loop() termina aqui, porque ele não vai entrar na estrutura if.

e, quando apenas o tempo suficiente passou, entramos no if().

executando a ação

 if (ledState == LOW) { ledState = HIGH; } else { ledState = LOW; } digitalWrite(LED_PIN, ledState);

OK, você acabou de entrar no if(), e aqui você vai fazer qualquer ação que você precisa fazer.Aqui fazemos o LED piscar. E como não podemos saber diretamente qual foi o estado anterior para o LED (já que entramos no loop() muitas vezes e perdemos todas as variáveis locais criadas no interior), obtemos esse estado a partir de uma variável global.

o que fazemos com esta variável global é simples: se era baixa, ajustamo-la para alta, e se era alta, ajustamo-la para baixa. E então, é claro, nós atualizamos o estado físico LED de acordo, com digitalWrite().Finalmente, e isso é super importante, Nós economizamos o tempo atual como a última vez que piscamos o LED. Se não fizermos isso, então o programa vai piscar o LED em plena velocidade, porque a condição dentro do if() será sempre verdade.Ao definir a hora anterior para a hora atual, “reiniciamos o temporizador”.

assim, nesse exemplo, o if() só será inserido a cada 500 milisegundos, ou 0,5 segundos.

e agora isso é ótimo porque seu programa não pára, então você pode continuar a executar diferentes ações independentes enquanto ainda “esperando” para piscar o LED.

2 ações “ao mesmo tempo”

por exemplo, digamos que você quer piscar um LED a cada 0.5 segundos, e outro a cada 0,8 segundos.Como podem ver, repetimos a estrutura de código para a segunda acção que adicionámos. E ambas as acções não se incomodarão!

Recap

se quiser fazer um atraso de Arduino sem utilizar delay():

1. crie uma variável global para armazenar a última vez que você fez uma ação específica.
2. crie outra variável global para guardar a duração que deseja entre 2 acções.
3. na função loop(), leia o tempo actual com millis().
4. pouco depois disso, use uma estrutura if, e use a condição (timeNow - lastTimeActionWasExecuted > delayBetweenActions).Depois de entrar no if(), faça a acção.
5. e ainda no if(), armazenar o tempo atual como o tempo anterior.

pode repetir os passos para cada acção para a qual necessita de um atraso de Arduino.

quando está ok usar delaymicrosegundos ()

existem ocasiões específicas quando o uso de delay() no seu código ainda está OK.

Aqui estão 2 desses:

• você precisa inicializar um componente durante a configuração do seu programa, e este componente precisa de algum tempo para ser inicializado – por exemplo, 1,5 segundos. Neste caso, usar delay(1500) na sua função setup() está perfeitamente bem. Basicamente, qualquer delay() na função setup() do seu programa Arduino não será um problema.
• como explicado na parte delayMicroseconds(), você precisa esperar por alguns microssegundos (não milisegundos!) ao comunicar com um componente externo. Se você achar que usar delayMicroseconds() com um pequeno número (por exemplo 10) não perturba o resto do seu programa, você ainda pode usá-lo sem ter que se preocupar demais. Mas considere-o como uma excepção, não como uma regra comum.

Conclusion-Use Arduino delay () com cuidado

devido à natureza dos programas Arduino, você muitas vezes terá que adicionar atrasos no seu código, para que você possa escolher quando executar algumas ações, e quantas vezes você quer executá-las.

as funções delay() e delayMicroseconds() são funções muito simples de usar e foram adicionadas à linguagem Arduino para que iniciantes completos pudessem começar com algo simples.

no entanto, como você viu neste tutorial, o uso de delay() pode fazer você ficar preso muito rapidamente. Então, é melhor primeiro entender por que você precisa dele, como usá-lo, e então como obter o mesmo comportamento sem usar a função Arduino delay() diretamente.Uma vez que você tenha entendido a estrutura de código para se livrar de delay(), você será capaz de melhorar seus programas Arduino muito, e multitarefas se tornará muito fácil.