Arduino Millis vs Atraso
O que é a função Millis () em Arduino?
Esta função dá o tempo total a partir da execução do código Arduino e continuará a ser executado até que o programa esteja em execução. Da mesma forma, essa função dá o tempo decorrido em milissegundos e tem capacidade para funcionar por 50 dias depois disso, essa função redefinirá seu valor para zero e começar de novo.
O significado dessa função é que ela pode ser usada no programa Arduino se uma instrução for executada apenas em um horário específico apenas. Para uma ilustração adicional, explicamos o funcionamento da função de milis pelo exemplo.
Suponha que tenhamos que executar uma instrução a cada 5 segundos, então primeiro definimos o tempo em milissegundos, após o qual a instrução específica será executada.
tempo de execução longa não assinado = 5000;
Então, definimos a variável constante nomeada tempo de execução Tendo um valor de 5000 milissegundos para verificar a hora atual do programa, usaremos a função Millis e armazenaremos seu valor no tempo presente variável.
tempo atual não assinado;
presente de tempo = millis ();
Em seguida, temos que tomar a condição para o tempo em que a instrução será executada. Portanto, criamos uma condição IF que será verdadeira quando a diferença de tempo presente e passado atingir 5000 milissegundos e as instruções dentro da condição se executarão. Para tais condições, também precisamos declarar outra variável que salvará o horário anterior ou o tempo passado.
Podemos projetar essa condição de tal maneira que, quando a diferença da corrente e do tempo anterior é maior que igual ao tempo de execução, execute a seguinte instrução. Depois que a respectiva instrução é executada, exceto o horário atual na variável de passatempo.
passatempo longo não assinado = 0;
if (presente-tempo-PASTTIME> = execução
// Execute a instrução
Passado = CurrentTime;
Aqui, uma coisa é lembrar que usamos o tipo de dados longo devido à função Millis (), pois possui valores consideravelmente grandes.
Código Arduino para o funcionamento da função Millis ()
O código completo para entender o funcionamento da função de Millis é dado como:
const UNSigned Long ExecutionTime = 5000; /*Tempo em que a instrução será executada*/
Passado longo não assinado = 0; // variável para forte no passado
Longo tempo não assinado = 0; // variável para armazenar o tempo presente
Void Setup ()
Serial.comece (9600); // inicializando a comunicação serial
Void Loop ()
presente de tempo = millis (); // Atualizando o valor do tempo presente
/ * Este é o evento */
if (presente -time - Passado> = ExecutionTime) / *Condição do tempo em que a instrução será executada * /
Serial.print ("O tempo presente é:");
Serial.println (presente de tempo); // exibindo o tempo presente
Serial.print (""); // incluindo espaço
Serial.print ("Instruções a serem executadas:");
Serial.println ("Welcome to linuxhint"); // instruções a serem executadas
Passado = presente de tempo; // Atualizando o valor do tempo passado
O Código Arduino estará funcionando de tal maneira que, por exemplo, na primeira iteração, o valor do passatempo é zero e digamos que a hora atual seja de 400 milissegundos. De acordo com a condição se a resposta será 400, que é inferior a 5000 milissegundos, portanto a condição se será falsa.
Da mesma forma, na terceira ou quarta iteração, o “tempo presente” é de 5000 milissegundos, então a diferença será de 5000 milissegundos, pois o valor do “passado” ainda é zero. Portanto, a instrução será executada e o valor para o passatempo será atualizado.
Dessa forma, podemos usar a função Millis para executar uma instrução específica em um horário específico.
Saída do código Arduino para a função Millis ()
No monitor serial, pode -se ver claramente que quando houver uma diferença de "tempo atual" e "no passado" é 5000, a condição será verdadeira. A imagem postada abaixo mostra os valores do "tempo atual" em que a condição se é verdadeira e a instrução que deve ser executada.
Se simplesmente imprimirmos o valor da função Millis () que é armazenado no nome da variável "presente de tempo" será assim como na imagem dada abaixo:
O que é uma função de atraso () em Arduino
A função de atraso () é usada principalmente para pausar o código do Arduino por algum tempo. Em outras palavras, essa função cria um atraso em algum momento especificado pelo usuário no funcionamento do código Arduino.
Esta função pode ser usada no programa em que o valor de qualquer variável deve ser atualizado com frequência. Portanto, ao dar a pausa ao programa Arduino, ele dará tempo para o sensor atualizar seu valor.
Da mesma forma, podemos usar a função de atraso para dar uma pausa entre a execução de múltiplas instruções. A função de atraso leva o tempo em milissegundos à medida que sua entrada e a sintaxe para a função de atraso são dadas abaixo:
atraso (tempo em milissegundos);
Código Arduino para o uso da função de atraso
Para demonstrar a funcionalidade da função de atraso (), compilamos um código Arduino que é dado como:
Void Setup ()
Serial.comece (9600); // inicializando a comunicação serial
Void Loop ()
Serial.print ("Olá e bem -vindo"); // Instruções antes do atraso
atraso (5000); // Criando uma pausa de 5000 milissegundos
Serial.println ("\ n para linuxhint.com "); // instruções após atraso
No código Arduino, damos duas instruções que imprimirão os dados no monitor serial. Ambas as instruções são executadas com um atraso de 5000 milissegundos. Em outras palavras, após a execução da primeira instrução, usamos uma função de atraso que pausará o código do Arduino por 5000 milissegundos. Após 5000 milissegundos, o programa será iniciado de onde foi interrompido e a segunda instrução será executada.
Saída do código Arduino para usar a função de atraso ()
A imagem postada abaixo é a primeira instrução dada antes da função de atraso () ser usada.
Após esta instrução, o programa é pausado por 5000 milissegundos e, em seguida, a execução da segunda instrução ocorre. A figura abaixo mostra que o programa executou a segunda instrução.
Comparando a função millis () e a função de atraso ()
As diferenças entre os millis () e a função de atraso são apresentadas na tabela abaixo:
| Millis () função | função () função |
|---|---|
| Pode ser usado para executar uma instrução específica em horário específico | Esta função apenas cria uma pausa no fluxo do código Arduino |
| Esta função dá o tempo em milissegundos de quando o código do Arduino for iniciado e pode subir até 50 dias | Esta função leva tempo em milissegundos como entrada do usuário e é executada por esse horário específico |
| Esta função não pausa ou interrompe o código | Esta função interrompe todo o código por algum tempo |
Como posso usar o millis () em vez de atraso ()
Usamos a função Millis em vez de atraso, simplesmente usando a condição IF para o horário específico em que queremos executar cada instrução. Fazer isso dará um atraso automaticamente entre a execução de duas ou mais instruções e o objetivo do atraso pode ser servido. A principal vantagem para usar o millis em vez de atraso é que todo o programa Arduino não interrompe; Somente a execução de alguma determinada instrução é colocada para parar. No entanto, a função de atraso interrompe todo o programa e o uso da função de atraso pode perder as entradas externas do programa porque todo o programa é interrompido.
Para ilustrar ainda mais, fornecemos o código Arduino de como podemos usar a função Millis em vez da função de atraso:
const não assinado longa execução tempo = 6000; /*Tempo em que a primeira instrução será executada*/
const não assinado longa execuçãoTime1 = 2000; /*Tempo em que a segunda instrução será executada*/
Passado longo não assinado = 0; // variável para forte o tempo passado da primeira instrução
Longo tempo não assinado = 0; // variável para armazenar o tempo presente
não assinado long Pasttime1 = 0; // variável para forte o tempo passado da segunda instrução
Void Setup ()
Serial.comece (9600); // inicializando a comunicação serial
Void Loop ()
presente de tempo = millis (); // Atualizando o valor do tempo presente
/ * Este é o evento */
if (presente -time - Passado> = ExecutionTime) / *Condição do tempo em que a instrução será executada * /
Serial.print ("O tempo presente é:");
Serial.println (presente de tempo); // exibindo o tempo presente
Serial.print (""); // incluindo espaço
Serial.print ("Instruções a serem executadas:");
Serial.println ("Mantenha as luzes apagadas"); // instruções a serem executadas
Passado = presente de tempo; // Atualizando o valor do tempo passado
if (presente -time - pasttime1> = executionTime1) / * Condição do tempo em que a instrução será executada * /
Serial.print ("o tempo presente");
Serial.println (presente de tempo); // exibindo o tempo presente
Serial.print (""); // incluindo o espaço
Serial.print ("Instruções a serem executadas:");
Serial.println ("ligue as luzes"); // instrcution a ser executado
PASSTIME1 = presente de tempo; // Atualizando o tempo presente da instrução SCODN
Aqui no código, usamos a função Millis para executar as duas instruções com um atraso de quase 4 segundos. Publicamos uma imagem da saída do código Arduino compilado para explicar como a função Millis pode ser usada substituindo -a pela função de atraso.
Na saída, podemos ver que, quando a hora for de 2 segundos, a segunda instrução é executada até o tempo atingir 6 segundos. Quando o tempo atingir 6 segundos, a primeira instrução é executada.
Conclusão
Para criar uma lógica de qualquer tarefa que precise ser executada usando Arduino, existem várias funções que podem ser usadas. Essas funções tornam a funcionalidade do código Arduino eficiente e fácil de implementar a lógica criada.Há duas funções que discutimos em detalhes, uma é a função de millis e a outra é a função de atraso. A função Millis executa uma instrução específica em um horário específico, enquanto a função de atraso interrompe o código do Arduino por algum tempo.