Arduino – Utilizando a função millis

Nesta prática você vai aprender a utilizar a função millis e executar um exemplo de utilização da mesma a partir de um circuito com dois LEDs. Esta função é uma excelente alternativa ao uso do delay.

Delay é o termo técnico usado para designar o retardo de sinais em circuitos eletrônicos. Na programação com Arduino, o delay é utilizado quando se precisa de intervalos entre um comando e outro.

Vale ressaltar que o delay faz a execução do código parar por completo até que o tempo estabelecido seja executado. Se o delay for de 10 segundos então o código vai ficar parado por 10 segundos e em seguida volta a ser executado. Como o código do Arduino é um loop (repetição contínua das instruções), seguindo o exemplo de um delay de 10 segundos, concluímos que toda vez que o loop passar pelo delay, uma interrupção de 10 segundos será executada.

Mas e se o código precisar que um intervalo de tempo seja executado, porém sem que a execução do código seja interrompida?!

Neste este tipo de situação podemos utilizar a função millis. A função irá retornar o tempo em milissegundos desde o momento em que o Arduino foi ligado ou reiniciado. Desta forma, é possível verificar a quanto tempo o programa está em execução e programar ações sem que o código seja interrompido.

Para demonstrar o uso da função millis, utilizei dois LEDs conectados ao Arduino, onde um dos LEDs vai piscar em intervalos de 2 segundos e o outro vai piscar em intervalos de 500ms. Os dois processos vão ocorrer simultaneamente e sem interrupções.

Você vai precisar dos seguintes itens para execução da prática:

– Arduino
– LEDs
– Resistor 150Ω
– Protoboard
– Cabo Jumper Macho-macho

Monte o esquema de ligação conforme a imagem abaixo:

A seguir, você deverá carregar o código na IDE do Arduino. Se você ainda não instalou a IDE do Arduino, acesse o link abaixo e em seguida retorne para continuar:

Arduino – Instalação e Configuração da IDE no Windows

Conecte o Arduino ao computador, abra a IDE, confira a placa e a porta selecionada e carregue o código na placa:

int pinoLedAmarelo = 7; //DEFINE O PINO DIGITAL EM QUE O LED AMARELO ESTÁ CONECTADO
int pinoLedVermelho = 8; //DEFINE O PINO DIGITAL EM QUE O LED VERMELHO ESTÁ CONECTADO

int statusLedAmarelo = LOW; //DEFINE QUE O ESTADO INICIAL DO LED AMARELO É DESLIGADO
int statusLedVermelho = LOW; //DEFINE QUE O ESTADO INICIAL DO LED VERMELHO É DESLIGADO

long previousMillisAmarelo = 0; //VARIÁVEL QUE CONTROLA O TEMPO DO LED AMARELO
long previousMillisVermelho = 0; //VARIÁVEL QUE CONTROLA O TEMPO DO LED VERMELHO

long amareloLedInterval = 2000; //VARIÁVEL QUE REGISTRA O INTERVALO DO LED AMARELO (2000ms = 2 SEGUNDOS)
long vermelhoLedInterval = 500; //VARIÁVEL QUE REGISTRA O INTERVALO DO LED VERMELHO (500ms = 500 MILISSEGUNDOS)

void setup(){  
  pinMode(pinoLedAmarelo, OUTPUT); //DEFINE O PINO COMO SAÍDA
  pinMode(pinoLedVermelho, OUTPUT); //DEFINE O PINO COMO SAÍDA 
}
void loop()
{
  //INICIO DO CONTROLE DO LED AMARELO
  unsigned long currentMillisAmarelo = millis(); //VARIÁVEL RECEBE O TEMPO ATUAL EM MILISSEGUNDOS

  if (currentMillisAmarelo - previousMillisAmarelo > amareloLedInterval) { //SE O TEMPO ATUAL MENOS O TEMPO ANTERIOR FOR MENOR QUE O INTERVALO, FAZ
    previousMillisAmarelo = currentMillisAmarelo; //TEMPO ANTERIOR GUARDA O TEMPO ATUAL

    if (statusLedAmarelo == LOW) { //VERIFICA O ESTADO ATUAL DO LED E SE ESTIVER EM DESLIGADO MUDA PARA LIGADO
      statusLedAmarelo = HIGH; //VARIÁVEL RECEBE ESTADO HIGH(LIGA O LED)
    } else { //SENÃO, FAZ
      statusLedAmarelo = LOW; //VARIÁVEL RECEBE ESTADO LOW(DESLIGA O LED)
    }
    digitalWrite(pinoLedAmarelo, statusLedAmarelo); //ESCREVE NO PINO DIGITAL O ESTADO ATUAL (LIGADO OU DESLIGADO)
  }
  //FIM DO CONTROLE DO LED AMARELO
  //-----------------------------------------------------------------------------------------------------------------------------------------
  //INICIO DO CONTROLE DO LED VERMELHO
  unsigned long currentMillisVermelho = millis(); //VARIÁVEL RECEBE O TEMPO ATUAL EM MILISSEGUNDOS

  if (currentMillisVermelho - previousMillisVermelho > vermelhoLedInterval) { //SE O TEMPO ATUAL MENOS O TEMPO ANTERIOR FOR MENOR QUE O INTERVALO, FAZ
    previousMillisVermelho = currentMillisVermelho; //TEMPO ANTERIOR GUARDA O TEMPO ATUAL

    if (statusLedVermelho == LOW) { //VERIFICA O ESTADO ATUAL DO LED E SE ESTIVER EM DESLIGADO MUDA PARA LIGADO
      statusLedVermelho = HIGH; //VARIÁVEL RECEBE ESTADO HIGH(LIGA O LED)
    } else { //SENÃO, FAZ
      statusLedVermelho = LOW; //VARIÁVEL RECEBE ESTADO LOW(DESLIGA O LED)
    }
    digitalWrite(pinoLedVermelho, statusLedVermelho); //ESCREVE NA PORTA DIGITAL 9 O ESTADO DO LED VERDE (HIGH OU LOW)
  }
  //FIM DO CONTROLE DO LED VERMELHO
}

int pinoLedAmarelo = 7; //DEFINE O PINO DIGITAL EM QUE O LED AMARELO ESTÁ CONECTADO

int pinoLedVermelho = 8; //DEFINE O PINO DIGITAL EM QUE O LED VERMELHO ESTÁ CONECTADO

int statusLedAmarelo = LOW; //DEFINE QUE O ESTADO INICIAL DO LED AMARELO É DESLIGADO

int statusLedVermelho = LOW; //DEFINE QUE O ESTADO INICIAL DO LED VERMELHO É DESLIGADO

long previousMillisAmarelo = 0; //VARIÁVEL QUE CONTROLA O TEMPO DO LED AMARELO

long previousMillisVermelho = 0; //VARIÁVEL QUE CONTROLA O TEMPO DO LED VERMELHO

long amareloLedInterval = 2000; //VARIÁVEL QUE REGISTRA O INTERVALO DO LED AMARELO (2000ms = 2 SEGUNDOS)

long vermelhoLedInterval = 500; //VARIÁVEL QUE REGISTRA O INTERVALO DO LED VERMELHO (500ms = 500 MILISSEGUNDOS)

void setup(){

pinMode(pinoLedAmarelo, OUTPUT); //DEFINE O PINO COMO SAÍDA

pinMode(pinoLedVermelho, OUTPUT); //DEFINE O PINO COMO SAÍDA

}

void loop()

{

//INICIO DO CONTROLE DO LED AMARELO

unsigned long currentMillisAmarelo = millis(); //VARIÁVEL RECEBE O TEMPO ATUAL EM MILISSEGUNDOS

if (currentMillisAmarelo - previousMillisAmarelo > amareloLedInterval) { //SE O TEMPO ATUAL MENOS O TEMPO ANTERIOR FOR MENOR QUE O INTERVALO, FAZ

previousMillisAmarelo = currentMillisAmarelo; //TEMPO ANTERIOR GUARDA O TEMPO ATUAL

if (statusLedAmarelo == LOW) { //VERIFICA O ESTADO ATUAL DO LED E SE ESTIVER EM DESLIGADO MUDA PARA LIGADO

statusLedAmarelo = HIGH; //VARIÁVEL RECEBE ESTADO HIGH(LIGA O LED)

} else { //SENÃO, FAZ

statusLedAmarelo = LOW; //VARIÁVEL RECEBE ESTADO LOW(DESLIGA O LED)

}

digitalWrite(pinoLedAmarelo, statusLedAmarelo); //ESCREVE NO PINO DIGITAL O ESTADO ATUAL (LIGADO OU DESLIGADO)

}

//FIM DO CONTROLE DO LED AMARELO

//-----------------------------------------------------------------------------------------------------------------------------------------

//INICIO DO CONTROLE DO LED VERMELHO

unsigned long currentMillisVermelho = millis(); //VARIÁVEL RECEBE O TEMPO ATUAL EM MILISSEGUNDOS

if (currentMillisVermelho - previousMillisVermelho > vermelhoLedInterval) { //SE O TEMPO ATUAL MENOS O TEMPO ANTERIOR FOR MENOR QUE O INTERVALO, FAZ

previousMillisVermelho = currentMillisVermelho; //TEMPO ANTERIOR GUARDA O TEMPO ATUAL

if (statusLedVermelho == LOW) { //VERIFICA O ESTADO ATUAL DO LED E SE ESTIVER EM DESLIGADO MUDA PARA LIGADO

statusLedVermelho = HIGH; //VARIÁVEL RECEBE ESTADO HIGH(LIGA O LED)

} else { //SENÃO, FAZ

statusLedVermelho = LOW; //VARIÁVEL RECEBE ESTADO LOW(DESLIGA O LED)

}

digitalWrite(pinoLedVermelho, statusLedVermelho); //ESCREVE NA PORTA DIGITAL 9 O ESTADO DO LED VERDE (HIGH OU LOW)

}

//FIM DO CONTROLE DO LED VERMELHO

}

Após o arquivo ser carregado, veja os LEDs funcionando simultaneamente, onde um deles muda o estado a cada dois segundos e o outro alterna o estado a cada 500ms. Note que o funcionamento deles é independente e suas ações executam de forma simultânea.

Se tivéssemos utilizado a função delay, o funcionamento dos dois LEDs não seria de forma simultânea, pois primeiro seria necessário executar as ações de um LED para em seguida executar as ações do outro.

Na construção de braços robóticos a partir do uso de servos, a função millis é comumente utilizada, pois para esse tipo de projeto quanto menos interrupções existir no código melhor será o desempenho do braço.

Gostou deste tutorial? Então deixa seu comentário, dúvida ou sugestão aí embaixo!

Loja online: https://www.masterwalkershop.com.br
Fan page no Facebook: https://www.facebook.com/masterwalkershop

Nos ajude a espalhar conhecimento clicando no botão de compartilhar (f Like) que está mais abaixo.

Obrigado e até a próxima!

Seu feedback é muito importante! Que tal dar uma nota para esta postagem?! Faça sua avaliação aqui embaixo.

Postagem anterior: Arduino – Exibindo e lendo dados da serial

Próxima postagem: Arduino – Controle de Servo Motor SG90 9g através de Potenciômetro

Postagem feita por

Euler Oliveira

Formado em Engenharia da Computação, Técnico em Eletroeletrônica, Fundador e Diretor da MasterWalker Electronic Shop. Se preocupa com o aprendizado dos seus clientes e daqueles interessados em aprender sobre Arduino e plataformas embarcadas em geral.

Existem 12 comentários para esta postagem

Marcio 15 de julho de 2020 às 19:27

Olá, parabéns pelo conteúdo de qualidade.

Estou com uma dúvida, no meu projeto eu quero medir a quanto tempo o Arduino está ligado.
Gostaria de medir assim:
0 dias, 00 horas 00 minutos 00 segundos
E imprimir na serial.
Aí no caso quando ligar o Arduino ele comece a
marcar o tempo.
Vou deixar ele ligado por 1 mês.

Gostaria de marcar esse tempo com precisão. Pensei em usar um RTC
Mas estou perdido.
Pode me dar uma ajuda??
Obrigado
Igor Mota 30 de novembro de 2018 às 09:52

Show de bola a forma que você explicou a função Millis ( ), não achei outro com essa clareza…Parabéns!
- Euler Oliveira Autor 30 de novembro de 2018 às 11:54
  
  Olá Igor.
  
  Agradeço pelo reconhecimento!
  
  Vlw!
Alexandro Fernandes Domingos 18 de agosto de 2018 às 22:31

Poderia me ajudar com um erro de stray no meu codigo?

if (tempoInicial > (tempoAtual + 90000)){// 90 segundos

ligado = true; //botão de ligar aparece
Serial.println(tempoAtual);
Serial.println((tempoInicial);
}
Márcus 13 de agosto de 2018 às 20:01

Olá, ótimo post.

Gostaria de esclarecer uma dúvida em relação ao millis. De certa forma fazendo-se uma analogia, o tempo de intervalo definido como inteiro dos dois leds, seria em específico o delay? Só que atribuindo ao millis.
- Euler Oliveira Autor 13 de agosto de 2018 às 21:07
  
  Olá Márcus.
  
  De certa forma sim, pois o millis nada mais é que intervalo entre uma ação e outra, ou seja, faz a mesma função do delay,
Renato 26 de dezembro de 2017 às 19:17

Show muito bom!!
- Euler Oliveira Autor 27 de dezembro de 2017 às 07:36
  
  Olá Renato.
  
  Agradeço pelo comentário!
  
  Fico satisfeito em saber que este artigo foi útil.
Filipe David 27 de novembro de 2017 às 22:02

boa noite amigo, estou projetando uma envasadora de liquido e necessito utilizar essa função.

Voce poderia me dar uma ajuda…

Funcionamento seria mais ou menos assim… vai ter um sensor de nivel em um reservatorio principal no qual ira conter o liquido que vai para os potes menores.

Se nivel do tanque Ok liga uma esteira onde correram as embalagens vazia…

Coloquei no fim da esteira um sensor de barreira… se identificar o pote ele rotaciona um compartimento como se fosse uma roda com 4 posições… até uma segunda posição aonde tem a bomba que vai alimentar as embalagens menores. Além disso, corta a alimentação da esteira.

problema 1 – ele deve rotacionar até a posição da bomba (problema é o tempo que ele fica acionado), quando ele rotaciona a esteira tem que voltar a funcionar.

problema 2 – tempo que a bomba deve ficar acionada, sem rotacionar porem esteira ligada.

vc teria alguma ideia?
- Euler Oliveira Autor 28 de novembro de 2017 às 06:35
  
  Olá Filipe David.
  
  Agradeço pelo seu comentário!
  
  Estude a biblioteca SimpleTimer e veja se ela atende ao que precisa.
Paulo 21 de novembro de 2017 às 16:45

Esse esquema da para fazer enquanto um DHT11 vai vendo o tempo e mandando para uma base de dados a cada 10 minutos … um sensor de presença pode ir trabalhando …. e se detectou alguem passando na frente pode mandar um instrução de aviso ?
- Euler Oliveira Autor 22 de novembro de 2017 às 06:42
  
  Olá Paulo.
  
  Até daria, mas há bibliotecas que executam com mais eficácia isto que precisa fazer.
  
  Dê uma olhada: https://github.com/ivanseidel/ArduinoThread