Métodos de cronometragem do Arduino com Millis (): 4 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Neste artigo, apresentamos o millis (); função e colocá-la em uso para criar vários exemplos de tempo.

Millis? Nada a ver com sincronizadores labiais … espero que você tenha reconhecido milli como o prefixo numérico para um milésimo; isto é, multiplicar uma unidade de medida por 0,001 (ou dez elevado a 3 negativo).

Curiosamente, nossos sistemas Arduino contarão o número de milissegundos (milhares de segundos) desde o início de um esboço em execução até que a contagem alcance o número máximo capaz de ser armazenado no tipo de variável unsigned long (um inteiro de 32 bits [quatro bytes] - que varia de zero a (2 ^ 32) -1. (2 ^ 32) -1 ou 4294967295 milissegundos é convertido em 49,71027 dias ímpares.

O contador é zerado quando o Arduino é zerado, atinge o valor máximo ou um novo esboço é carregado. Para obter o valor do contador em uma determinada junção, basta chamar a função - por exemplo:

início = milis ();

Onde start é uma variável longa sem sinal. Aqui está um exemplo muito simples para mostrar a você millis () em ação:

/ * millis () demonstração * /

início longo não assinado, concluído, decorrido;

void setup ()

{Serial.begin (9600); }

void loop ()

{Serial.println ("Iniciar…"); início = milis (); atraso (1000); acabado = milis (); Serial.println ("Concluído"); decorrido = início concluído; Serial.print (decorrido); Serial.println ("milissegundos decorridos"); Serial.println (); atraso (500); }

O esboço armazena a contagem atual em milis no início, depois espera um segundo e, em seguida, armazena o valor em milis novamente no final. Finalmente, ele calcula o tempo decorrido do atraso. No seguinte dump de tela do monitor serial, você pode ver que a duração nem sempre foi exatamente 1000 milissegundos, como mostra a imagem.

Passo 1:

Simplificando, a função millis faz uso de um contador interno dentro do microcontrolador ATmega no coração do seu Arduino. Este contador incrementa a cada ciclo de clock - o que acontece (no Arduino padrão e compatíveis) a uma velocidade de clock de 16 Mhz. Essa velocidade é controlada pelo cristal na placa Arduino (a coisa prateada com T16.000 estampado).

Passo 2:

A precisão do cristal pode variar dependendo da temperatura externa e da tolerância do próprio cristal. Isso, por sua vez, afetará a precisão do seu resultado de milissegundos. A experiência anedótica relatou que o desvio na precisão do tempo pode ser de cerca de três ou quatro segundos por período de vinte e quatro horas.

Se você estiver usando uma placa ou sua própria versão que usa um ressonador de cerâmica em vez de um cristal, observe que eles não são tão precisos e introduzirão a possibilidade de níveis de deriva mais elevados. Se você precisa de um nível muito mais alto de precisão de temporização, considere CIs de temporizador específicos, como o Maxim DS3231.

Agora podemos usar os millis para várias funções de temporização. Conforme demonstrado no esboço de exemplo anterior, podemos calcular o tempo decorrido. Para levar essa ideia adiante, vamos fazer um cronômetro simples. Fazer isso pode ser tão simples ou tão complexo quanto necessário, mas, neste caso, mudaremos para o simples.

Na perspectiva do hardware, teremos dois botões - Iniciar e Parar - com os resistores pull-down de 10k ohm conectados aos pinos digitais 2 e 3, respectivamente. Quando o usuário pressiona iniciar, o esboço anotará o valor em milis - então, depois que parar é pressionado, o esboço novamente anotará o valor em milis, calculará e exibirá o tempo decorrido. O usuário pode então pressionar start para repetir o processo ou stop para atualizar os dados. Aqui está o esboço:

/ * Cronômetro superbásico usando millis (); * /

início longo não assinado, concluído, decorrido;

void setup ()

{Serial.begin (9600); pinMode (2, INPUT); // botão iniciar pinMode (3, INPUT); // botão de parada Serial.println ("Pressione 1 para iniciar / redefinir, 2 para o tempo decorrido"); }

void displayResult ()

{float h, m, s, ms; não assinado há muito tempo; decorrido = início concluído; h = int (decorrido / 3600000); over = decorrido% 3600000; m = int (acima de / 60.000); mais = mais de% 60000; s = int (acima de / 1000); ms = mais de% 1000; Serial.print ("Tempo decorrido bruto:"); Serial.println (decorrido); Serial.print ("Tempo decorrido:"); Serial.print (h, 0); Serial.print ("h"); Serial.print (m, 0); Serial.print ("m"); Serial.print (s, 0); Serial.print ("s"); Serial.print (ms, 0); Serial.println ("ms"); Serial.println (); }

void loop ()

{if (digitalRead (2) == HIGH) {start = millis (); atraso (200); // para debounce Serial.println ("Started…"); } if (digitalRead (3) == HIGH) {terminado = milis (); atraso (200); // para debounce displayResult (); }}

As chamadas para delay () são usadas para eliminar os switches - eles são opcionais e seu uso dependerá do seu hardware. A imagem é um exemplo da saída do monitor serial do esboço - o cronômetro foi iniciado e, em seguida, o botão dois foi pressionado seis vezes em períodos de tempo.

Etapa 3: velocímetro …

Se você tivesse um sensor no início e no final de uma distância fixa, a velocidade poderia ser calculada: velocidade = distância ÷ tempo.

Você também pode fazer um velocímetro para uma forma de movimento com rodas, por exemplo, uma bicicleta. No momento não temos uma bicicleta para mexer, no entanto, podemos descrever o processo para fazê-lo - é bastante simples. (Isenção de responsabilidade - faça-o por sua própria conta e risco, etc.)

Em primeiro lugar, vamos revisar a matemática necessária. Você precisará saber a circunferência da roda. Hardware - você precisará de um sensor. Por exemplo - uma chave de palheta e um ímã. Considere a chave reed como um botão normalmente aberto e conecte normalmente com um resistor pull-down de 10k ohm.

Outros podem usar um sensor de efeito Hall - cada um com o seu). Lembre-se da aula de matemática, para calcular a circunferência - use a fórmula: circunferência = 2πr onde r é o raio do círculo.

Agora que você tem a circunferência da roda, este valor pode ser considerado como nossa 'distância fixa' e, portanto, a velocidade pode ser calculada medindo o tempo decorrido entre uma rotação completa.

Seu sensor - uma vez instalado - deve agir da mesma forma que um botão normalmente aberto que é pressionado a cada rotação. Nosso esboço medirá o tempo decorrido entre cada pulso do sensor.

Para fazer isso, nosso exemplo terá a saída do sensor conectada ao pino digital 2 - já que irá disparar uma interrupção para calcular a velocidade. Caso contrário, o esboço exibirá a velocidade em um módulo LCD de interface I2C normal. A interface I2C é sugerida porque requer apenas 4 fios da placa Arduino para o LCD - quanto menos fios, melhor.

Aqui está o esboço para sua leitura:

/ * Velocímetro básico usando milis (); * /

#include "Wire.h" // para LCD de barramento I2C

#include "LiquidCrystal_I2C.h" // para módulo LCD de barramento I2C - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // define o endereço LCD para 0x27 para um display de 16 caracteres e 2 linhas

início da flutuação, finalizado;

flutuação decorrida, tempo; float circMetric = 1,2; // circunferência da roda em relação à posição do sensor (em metros) float circImperial; // usando 1 quilômetro = 0,621371192 milhas float speedk, speedm; // mantém valores de velocidade calculados em sistemas métricos e imperiais

void setup ()

{attachInterrupt (0, speedCalc, RISING); // interrupção chamada quando os sensores enviam digital 2 high (a cada rotação da roda) start = millis (); // configura o LCD lcd.init (); // inicializa o lcd lcd.backlight (); // liga a luz de fundo do LCD lcd.clear (); lcd.println ("Use um capacete!"); atraso (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric *.62137; // converter métrico em imperial para cálculos MPH}

void speedCalc ()

{decorrido = milis () - início; início = milis (); speedk = (3600 * circMetric) / decorrido; // km / h speedm = (3600 * circImperial) / decorrido; // Milhas por hora }

void loop ()

{lcd.setCursor (0, 0); lcd.print (int (speedk)); lcd.print ("km / h"); lcd.print (int (speedm)); lcd.print ("MPH"); lcd.setCursor (0, 1); lcd.print (int (decorrido)); lcd.print ("ms / rev"); atraso (1000); // ajuste a preferência pessoal para minimizar a oscilação}

Não há muito acontecendo - cada vez que a roda completa uma volta, o sinal do sensor vai de baixo para alto - disparando uma interrupção que chama a função speedCalc ().

Isso faz uma leitura de milis () e, em seguida, calcula a diferença entre a leitura atual e a leitura anterior - este valor torna-se o tempo para cobrir a distância (que é a circunferência da roda em relação ao sensor - armazenado em

float circMetric = 1,2;

e é medido em metros). Por fim, calcula a velocidade em km / he MPH. Entre as interrupções, o esboço exibe os dados de velocidade atualizados no LCD, bem como o valor de tempo bruto para cada revolução por curiosidade. Na vida real, não acho que alguém montaria um LCD em uma bicicleta, talvez um display LED fosse mais relevante.

Enquanto isso, você pode ver como esse exemplo funciona no breve videoclipe a seguir. Em vez de uma roda de bicicleta e uma combinação de interruptor de palheta / ímã, conectei a saída de onda quadrada de um gerador de função ao pino de interrupção para simular os pulsos do sensor, para que você possa ter uma ideia de como funciona.

Passo 4:

Isso resume o uso de millis () por enquanto. Também existe o micros (); função que conta microssegundos.

Então aí está - outra função prática que pode permitir que mais problemas sejam resolvidos por meio do mundo do Arduino. Como sempre, agora depende de você e sua imaginação encontrar algo para controlar ou fazer outras travessuras.

Esta postagem foi trazida a você por pmdway.com - tudo para fabricantes e entusiastas de eletrônicos, com entrega gratuita em todo o mundo.