Fabricação de um cronômetro automático para corredores, atletas e atletas

[the_ad_placement id="article-top-ad"]

Neste post, vamos construir um cronômetro que inicia automaticamente o cronômetro quando o corredor começa a correr e o cronômetro para quando o corredor chega ao fim. O tempo decorrido entre o ponto inicial e final é exibido em uma tela LCD de 16 x 2.

Vamos começar primeiro aprendendo a configurar um circuito simples e extremamente preciso para o cronômetro do Arduino.

Um cronômetro é um dispositivo de relógio de ponto controlado manualmente, projetado para medir o tempo que pode ter decorrido a partir de um determinado momento no momento em que foi ativado e quando foi finalmente desativado. Uma variante maior do mesmo dispositivo é chamada de cronômetro, usada para monitorar a ação à distância e normalmente é encontrada em estádios esportivos, etc.

Cronômetro mecânico vs eletrônico

Anteriormente, o cronômetro mecânico manual tradicional era mais comum e era usado por todos para essa finalidade.

No sistema mecânico, tínhamos dois botões para executar as funções do cronômetro. Um para iniciar o cronômetro pressionando uma vez e para parar o tempo pressionando o mesmo botão mais uma vez para registrar o tempo decorrido … o segundo botão foi usado para zerar o relógio.

O cronômetro mecânico trabalhava basicamente com a energia da mola, exigindo um período de corda manual girando o botão serrilhado na parte superior do dispositivo do relógio.

No entanto, em comparação com os temporizadores digitais modernos, os tipos mecânicos podem ser considerados significativamente primitivos e imprecisos na faixa de milissegundos.

Usando um Arduino

[the_ad_placement id="article-inline-ad-1-post-unico-17"]

E hoje, com o advento do microcontrolador, esses temporizadores tornaram-se extremamente precisos e confiáveis ​​na faixa de microssegundos.

O circuito de cronômetro do Arduino apresentado aqui é um desses designs modernos de microcontroladores mais precisos do que o esperado para equiparar-se aos modernos dispositivos de cronômetro comercial.

Vamos aprender como construir o circuito de cronômetro proposto para o Arduino:

Você precisará da seguinte lista de materiais de construção:

Hardware necessário

Um protetor de teclado LCD Arduino (SKU: DFR0009)

[the_ad_placement id="article-inline-ad-2"]

Um protetor de teclado LCD Arduino (SKU: DFR0009)

Uma placa UNO Arduino

Arduino UNO

Um cabo USB do Arduino

cabo usb arduino

Depois de comprar o material acima e conectá-lo, é apenas uma questão de configurar o seguinte código de esboço fornecido no seu painel do Arduino e ver a mágica das funções do cronômetro.

O código

/*
Standalone Arduino StopWatch
By Conor M - 11/05/15
Modified by Elac - 12/05/15
*/
// call the necessary libraries
#include
#include
// these are the pins used on the shield for this sketch
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);
// variables used on more than 1 function need to be declared here
unsigned long start, finished, elapsed;
boolean r = false;
// Variables for button debounce time
long lastButtonPressTime = 0; // the last time the button was pressed
long debounceDelay = 50; // the debounce time; keep this as low as possible
void setup()
{
lcd.begin(16, 2); // inicialize the lcd (16 chars, 2 lines)
// a little introduction :)
lcd.setCursor(4, 0); // set the cursor to first character on line 1 - NOT needed (it sets automatically on lcd.begin()
lcd.print("Arduino");
lcd.setCursor(3, 1); // set the cursor to 4th character on line 2
lcd.print("StopWatch");
delay(2000); // wait 2 seconds
lcd.clear(); // clear the display
lcd.print("Press select for");
lcd.setCursor(2, 1); // set the cursor to 3rd character on line 2
lcd.print("Start & Stop");
}
void loop()
{
CheckStartStop();
DisplayResult();
}
void CheckStartStop()
{
int x = analogRead (0); // assign 'x' to the Arduino's AnalogueInputs (Shield's buttons)
if (x < 800 && x > 600 ) // if the button is SELECT
{
if ((millis() - lastButtonPressTime) > debounceDelay)
{
if (r == false)
{
lcd.clear();
lcd.setCursor(2, 0); // needed
lcd.print("Elapsed Time");
start = millis(); // saves start time to calculate the elapsed time
}
else if (r == true)
{
lcd.setCursor(2, 0); // needed
lcd.print(" Final Time ");
}
r = !r;
}
lastButtonPressTime = millis();
}
}
void DisplayResult()
{
if (r == true)
{
finished = millis(); // saves stop time to calculate the elapsed time
// declare variables
float h, m, s, ms;
unsigned long over;
// MATH time!!!
elapsed = finished - start;
h = int(elapsed / 3600000);
over = elapsed % 3600000;
m = int(over / 60000);
over = over % 60000;
s = int(over / 1000);
ms = over % 1000;
// display the results
lcd.setCursor(0, 1);
lcd.print(h, 0); // display variable 'h' - the 0 after it is the
number of algorithms after a comma (ex: lcd.print(h, 2); would print
0,00
lcd.print("h "); // and the letter 'h' after it
lcd.print(m, 0);
lcd.print("m ");
lcd.print(s, 0);
lcd.print("s ");
if (h < 10) { lcd.print(ms, 0); lcd.print("ms "); } } }

Adicionar uma exibição de 7 segmentos

Agora, vamos prosseguir com os detalhes relacionados à construção de um circuito de cronômetro usando um display LED de 7 segmentos e o Arduino. Vamos explorar os conceitos relacionados a interrupções e exibir os ICs de driver que são cruciais para a compreensão deste projeto. Este projeto foi sugerido pelo Sr. Abu-Hafss, que é um dos leitores ávidos deste site.

Como já sabemos, o cronômetro é um dispositivo que ajuda a rastrear um curto período de tempo, de horas a um intervalo de milissegundos (principalmente). Quase todos os relógios de pulso digitais baratos equipados com a função de cronômetro, mas nenhum dos relógios oferece o prazer de fazer um para nós e também é excepcional encontrar um cronômetro com display de 7 segmentos em LED.

O Sr. Abu-Hafss sugeriu que projetássemos um cronômetro com 4 displays, dois por minutos e dois por segundos (MM: SS). Mas para a maioria de nós, pode não ser um projeto viável, por isso adicionamos mais duas telas para a faixa de milissegundos; agora, o design proposto estará na configuração MM: SS: mS.

Se você precisar apenas da configuração MM: SS por algum motivo, não precisará conectar os displays de segmento de 7 milissegundos e os respectivos ICs do controlador, toda a funcionalidade do circuito ainda não será afetada.

O circuito:

O cronômetro proposto consiste em seis IC 4026s, que são um controlador de exibição de sete segmentos, seis displays de LED de 7 segmentos, uma placa Arduino, um par de botões e um par de resistores de 10K.

Agora vamos entender como conectar o IC 4026 ao monitor de 7 segmentos.

[the_ad_placement id="article-inline-ad-3"]

A tela de 7 segmentos pode ser qualquer tela comum de cátodo de qualquer cor. O display de 7 segmentos pode ser facilmente desligado com uma fonte de 5V, portanto um resistor de 330 ohm é obrigatório em cada segmento do display.

Agora, vejamos o diagrama de pinos do IC 4026:

  • O pino 1 é a entrada do relógio.
  • O pino 2 é desativar o relógio, desabilite a contagem na tela se esse pino estiver alto.
  • O pino nº 3 é a tela de habilitação; Se esse pino estiver baixo, a tela será desligada e vice-versa.
  • O pino 5 é mantido, o que aumenta quando o IC conta 10.
  • Os pinos 6, 7, 9, 10, 11, 12, 13 são saídas de exibição.
  • O pino 8 é GND.
  • O pino 16 é Vcc.
  • O pino 15 é reiniciado. Se aumentarmos esse pino, a contagem se tornará zero.
  • Os pinos 4 e 14 não são usados.

Exibir diagrama de conexão:

Diagrama de conexão da tela LCD:

Qualquer um dos pinos GND no visor de 7 segmentos pode ser aterrado. O IC deve ser alimentado por uma fonte de 5V ou um pino de saída Arduino 5V.

O esquema acima para uma única tela, repita o mesmo para outras cinco telas.

Aqui está o resto do esquema:

Cronômetro com Arduino com display de 7 segmentos

O circuito pode ser alimentado por uma bateria de 9V. Aqui estão dois botões, um para iniciar a hora e outro para parar. Quando você pressiona o botão de reset no Arduino, a contagem de tempo é redefinida para zero na tela.

Os dois botões estão conectados aos pinos 2 e 3, que são interrupções de hardware no microcontrolador Arduino / Atmega328P.

Vamos entender o que é interrupção:

Existem dois tipos de interrupções: interrupção de hardware e software. Aqui estamos usando apenas a interrupção do hardware.

Uma interrupção é um sinal para o microcontrolador, o que fará com que o microcontrolador responda imediatamente a um evento.

Existem apenas dois pinos de interrupção de hardware nas placas Arduino com microcontrolador ATmega328P; pinos 2 e 3. O Arduino Mega possui mais de dois pinos de interrupção de hardware.

Microcontroladores não podem executar duas funções ao mesmo tempo. Por exemplo, verifique a pressão do botão e conte os números.

Os microcontroladores não podem executar dois eventos simultaneamente; se escrevermos um código para verificar a pressão do botão e contar os números, a pressão do botão será detectada apenas quando o microcontrolador ler o código de detecção de pressão do botão o resto do tempo (conta o números) O botão não funciona.

Portanto, haverá um atraso na detecção da pressão do botão e, por algum motivo, se o código parar temporariamente, a pressão do botão nunca poderá ser detectada. Para evitar esses problemas, a interrupção é introduzida.

O sinal de interrupção sempre tem a prioridade mais alta, a função principal (linhas principais de código) para e executa a função (outro trecho de código) atribuída a essa interrupção específica.

Isso é muito importante para aplicativos de tempo crítico, como cronômetros ou sistemas de segurança etc., em que o processador deve executar uma ação imediata em resposta a um evento.

No Arduino, atribuímos interrupção de hardware como:

attachInterrupt (0, start, RISING);

  • "0" significa o número de interrupção zero (nos microcontroladores tudo começa do zero), que é o pino # 2.
  • "Iniciar" é o nome da função de interrupção, você pode nomear qualquer coisa aqui.
  • "RISING" se o pino 2 (que é zero de interrupção) subir, a função de interrupção será executada.

attachInterrupt (1, Stop, RISING);

  • "1" significa a interrupção número um, que é o pino nº 3.
  • "Stop" é o nome da interrupção.

Também podemos substituir "RISING" por "FALLING"; agora, quando o pino de interrupção cai, a função de interrupção é executada.

Também podemos substituir "RISING" por "CHANGE", agora sempre que o pino de interrupção passa de alto para baixo ou de baixo para alto, a função de interrupção é executada.

A função de interrupção pode ser atribuída da seguinte forma:

void start () // start é o nome da interrupção.

{

// programa aqui

}

A função de interrupção deve ser a mais curta possível e a função delay () não pode ser usada.

Isso conclui a queda de hardware; A falta de software relacionada ao Arduino será explicada em um artigo futuro.

Agora você sabe por que conectamos os botões de início e parada para interromper os pinos.

Conecte o circuito de acordo com o diagrama; O resto do circuito é auto-explicativo.

Programa:

//----------------Program Developed by R.GIRISH---------------//
int vmin = 0;
int vsec = 0;
int vms = 0;
boolean Run = false;
const int Min = 7;
const int sec = 6;
const int ms = 5;
const int reset_pin = 4;
void setup()
{
pinMode(Min, OUTPUT);
pinMode(sec, OUTPUT);
pinMode(ms, OUTPUT);
pinMode(reset_pin, OUTPUT);
digitalWrite(Min, LOW);
digitalWrite(sec, LOW);
digitalWrite(ms, LOW);
digitalWrite(reset_pin, HIGH);
digitalWrite(reset_pin, LOW);
attachInterrupt(0, start, RISING);
attachInterrupt(1, Stop, RISING);
}
void loop()
{
if (Run)
{
vms = vms + 1;
digitalWrite(ms, HIGH);
delay(5);
digitalWrite(ms, LOW);
delay(5);
if (vms == 100)
{
vsec = vsec + 1;
digitalWrite(sec, HIGH);
digitalWrite(sec, LOW);
vms = 0;
}
if (vsec == 60)
{
vmin = vmin + 1;
digitalWrite(Min, HIGH);
digitalWrite(Min, LOW);
digitalWrite(reset_pin, HIGH);
digitalWrite(reset_pin, LOW);
vsec = 0;
}
}
}
void start()
{
Run = true;
}
void Stop()
{
Run = false;
}
//----------------Program Developed by R.GIRISH---------------//

Agora que o código termina.

Cronômetro desenvolvido especialmente para atletas

Por fim, vamos aprender como os conceitos acima podem realmente ser atualizados para atletas que desejam desenvolver suas habilidades de corrida sem depender de outros para o início e o cronômetro / cronômetro necessários. É melhor iniciar automaticamente o cronômetro detectando seu movimento do que alguém que inicia / para o cronômetro, o que também pode aumentar o tempo de reação.

NOTA: Este projeto foi desenvolvido para medir o tempo entre o ponto "A" e o ponto "B" coberto por UM usuário de cada vez.

A configuração consiste em dois lasers posicionados no ponto inicial e final, dois LDRs também estão posicionados em frente a dois módulos a laser. Quando o atleta interrompe o laser "inicial", o tempo começa a ser calculado e, quando o atleta chega ao fim, o laser "final" é interrompido e o cronômetro para e exibe o tempo decorrido entre dois pontos. Este é o método usado para medir o tempo decorrido na ideia proposta.

Vamos ver todos e cada um dos componentes do circuito em detalhes.

Detalhes do trabalho do componente

O circuito é mantido bastante simples, consiste em um módulo LCD de 16 x 2, poucos resistores, dois LDRs e um botão.

A interface entre o LCD e o arduino é padrão; Podemos encontrar conexões semelhantes em muitos outros projetos baseados em LCD.

Dois pinos analógicos A0 e A1 são usados ​​para detectar interrupções do laser. O pino analógico A2 é conectado a um botão usado para armar o cronômetro.

Três resistores, dois de 4,7 K e um de 10 K, são resistores pull-down que ajudam a manter baixos os pinos de entrada.

Um potenciômetro de 10K é fornecido para ajustar o contraste no módulo LCD para uma visibilidade ideal.

O circuito proposto foi projetado com um mecanismo de detecção de falhas a laser. Se algum dos lasers estiver com defeito ou não estiver alinhado corretamente com o LDR, ele exibirá uma mensagem de erro na tela LCD.

· Se o laser START não funcionar, mostra "o laser" start "não funciona"

· Se o laser STOP não funcionar, mostra "o laser" stop "não funciona"

· Se os dois lasers não funcionarem, será exibido "Ambos os lasers não funcionam"

· Se os dois lasers funcionarem corretamente, será exibido "Ambos os lasers funcionam bem"

A mensagem de erro aparece até que o módulo a laser seja corrigido ou o alinhamento seja bem-sucedido com o LDR.

Uma vez que esta etapa está livre de problemas, o sistema entra no modo de espera e exibe "-system-standby-". Nesse ponto, o usuário pode armar a configuração pressionando o botão a qualquer momento.

Quando o botão é pressionado, o sistema está pronto para detectar o movimento do usuário e exibe "O sistema está pronto".

O corredor pode estar a centímetros do laser "start".

Se o laser "iniciar" for interrompido, o tempo começará a contar e "Tempo está sendo calculado ......" será exibido. O tempo é calculado em segundo plano.

O tempo decorrido não será exibido até que o corredor alcance / interrompa o laser "stop". Isso ocorre porque a exibição do tempo decorrido na tela LCD, como o cronômetro tradicional, requer várias instruções adicionais a serem executadas no microcontrolador, o que prejudica significativamente a precisão da configuração.

NOTA: Pressione o botão de reset no arduino para limpar as leituras.

Como configurar o circuito na pista de corrida:

Use cabos grossos para conectar-se entre os LDRs e o circuito do arduino, pois a distância entre esses dois pode estar a vários metros de distância e a tensão não deve cair significativamente. A distância entre LDR1 e LDR2 pode ser de algumas centenas de metros no máximo.

Como montar o LDR:

O LDR deve ser montado dentro de um tubo opaco oco e a frente também deve ser coberta, e apenas um orifício de alguns milímetros de diâmetro é feito para permitir a entrada do feixe de laser.

O LDR deve ser protegido da luz solar direta, pois não pode ser diferenciado do raio laser e de outras fontes de luz e pode não registrar o movimento do usuário.

Código do programa:

//-------- Program developed by R.GIRISH-------//
#include
LiquidCrystal lcd(12,11,5,4,3,2);
int strt = A0;
int stp = A1;
int btn = A2;
int M = 0;
int S = 0;
int mS = 0;
float dly = 10.0;
void setup()
{
lcd.begin(16,2);
pinMode(strt,INPUT);
pinMode(stp,INPUT);
pinMode(btn,INPUT);
}
void loop()
{
if(digitalRead(strt)==HIGH && digitalRead(stp)==HIGH)
{
lcd.setCursor(0,0);
lcd.print("Both lasers are");
lcd.setCursor(0,1);
lcd.print(" working fine");
delay(4000);
{
while(digitalRead(btn)==LOW)
{
lcd.clear();
lcd.print("-System Standby-");
lcd.setCursor(0,1);
lcd.print("Press Start btn");
delay(100);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("System is ready");
lcd.setCursor(0,1);
lcd.print("----------------");
while(digitalRead(strt)==HIGH)
{
delay(1);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Time is being");
lcd.setCursor(0,1);
lcd.print("Calculated......");
while(digitalRead(stp)==HIGH)
{
delay(dly);
mS = mS+1;
if(mS==100)
{
mS=0;
S = S+1;
}
if(S==60)
{
S=0;
M = M+1;
}
}
while(true)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print(M);
lcd.print(":");
lcd.print(S);
lcd.print(":");
lcd.print(mS);
lcd.print(" (M:S:mS)");
lcd.setCursor(0,1);
lcd.print("Press Reset");
delay(1000);
}
}
}
if(digitalRead(strt)==HIGH && digitalRead(stp)==LOW)
{
lcd.setCursor(0,0);
lcd.print("'Stop' laser is");
lcd.setCursor(0,1);
lcd.print(" not working");
delay(100);
}
if(digitalRead(strt)==LOW && digitalRead(stp)==HIGH)
{
lcd.setCursor(0,0);
lcd.print("'Start' laser is");
lcd.setCursor(0,1);
lcd.print(" not working");
delay(100);
}
if(digitalRead(strt)==LOW && digitalRead(stp)==LOW)
{
lcd.setCursor(0,0);
lcd.print("Both lasers are");
lcd.setCursor(0,1);
lcd.print(" not working");
delay(100);
}
lcd.clear();
}
//-------- Program developed by R.GIRISH-------//

Protótipo do autor:

Fazendo upgrade com uma instalação de timer dividido

O circuito de cronômetro automático proposto para cronômetro é uma extensão do circuito de cronômetro automático, em que o cronômetro registra a hora automaticamente assim que o corredor individual sai do ponto de partida e o cronômetro para e exibe o tempo decorrido quando o corredor chega até o ponto final.

Introdução

Este projeto foi sugerido por um dos ávidos leitores deste site, Andrew Walker.

Neste projeto, apresentaremos mais 4 LDRs para medir o corredor solitário em meio período. Existem 6 LDRs no total; tudo pode ser colocado na pista de corrida com uma distância uniforme entre eles ou de acordo com as circunstâncias e a escolha do usuário.

A maioria do hardware permanece inalterada, exceto pela adição de 4 LDRs, mas o código passou por uma grande reforma.

Diagrama esquemático mostrando o tempo dividido:

Cronômetro automático com tempo parcial

O circuito acima tem poucos componentes e é adequado para iniciantes. Nenhuma explicação adicional é necessária, basta conectar de acordo com o diagrama de circuitos.

Como conectar o LDR:

LDR 2 é mostrado no diagrama de circuito principal; conecte mais 4 LDRs em paralelo, como mostrado no diagrama acima.

Diagrama de projeto:

A descrição acima é a disposição básica sobre como colocar o laser. Observe que a distância entre os LDRs pode ser escolhida pelo usuário, dependendo do comprimento da pista.

Programa:

//------------Developed By R.Girish-------//
#include
LiquidCrystal lcd(12,11,5,4,3,2);
const int start = A2;
const int strt = A0;
const int END = A1;
boolean y = true;
boolean x = true;
unsigned int s1 = 0;
unsigned int s2 = 0;
unsigned int s3 = 0;
unsigned int s4 = 0;
unsigned int s5 = 0;
unsigned int m1 = 0;
unsigned int m2 = 0;
unsigned int m3 = 0;
unsigned int m4 = 0;
unsigned int m5 = 0;
unsigned int ms1 = 0;
unsigned int ms2 = 0;
unsigned int ms3 = 0;
unsigned int ms4 = 0;
unsigned int ms5 = 0;
unsigned int S = 0;
unsigned int M = 0;
unsigned int mS = 0;
unsigned int count = 0;
void setup()
{
lcd.begin(16,2);
pinMode(start, INPUT);
pinMode(strt, INPUT);
pinMode(END, INPUT);
if(digitalRead(strt) == LOW)
{
while(true)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Start Laser is");
lcd.setCursor(0,1);
lcd.print(" not working");
delay(2500);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Please align the");
lcd.setCursor(0,1);
lcd.print("lasers properly");
delay(2500);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("and press reset.");
delay(2500);
}
}
if(digitalRead(END) == LOW)
{
while(true)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("All 5 lasers");
lcd.setCursor(0,1);
lcd.print("are misaligned");
delay(2500);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Please align the");
lcd.setCursor(0,1);
lcd.print("lasers properly");
delay(2500);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("and press reset.");
delay(2500);
}
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("-System Standby-");
lcd.setCursor(0,1);
lcd.print("Press Start btn");
if(digitalRead(start) == LOW)
{
while(x)
{
if(digitalRead(start) == HIGH)
{
x = false;
}
}
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("System is ready");
lcd.setCursor(0,1);
lcd.print("----------------");
while(y)
{
if(digitalRead(strt) == LOW)
{
y = false;
}
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Time is being");
lcd.setCursor(0,1);
lcd.print("Calculated....");
mS = 12;
}
void loop()
{
delay(1);
mS = mS + 1;
if(mS==1000)
{
mS=0;
S = S+1;
}
if(S==60)
{
S=0;
M = M+1;
}
if(digitalRead(END) == LOW)
{
count = count + 1;
if(count == 1)
{
ms1 = mS;
s1 = S;
m1 = M;
delay(500);
}
if(count == 2)
{
ms2 = mS;
s2 = S;
m2 = M;
delay(500);
}
if(count == 3)
{
ms3 = mS;
s3 = S;
m3 = M;
delay(500);
}
if(count == 4)
{
ms4 = mS;
s4 = S;
m4 = M;
delay(500);
}
if(count == 5)
{
ms5 = mS;
s5 = S;
m5 = M;
Display();
}
}
}
void Display()
{
ms1 = ms1 + 500;
ms2 = ms2 + 500;
ms3 = ms3 + 500;
ms4 = ms4 + 500;
ms5 = ms5 + 500;
if(ms1 >= 1000)
{
ms1 = ms1 - 1000;
s1 = s1 + 1;
if(s1 >= 60)
{
m1 = m1 + 1;
}
}
if(ms2 >= 1000)
{
ms2 = ms2 - 1000;
s2 = s2 + 1;
if(s2 >= 60)
{
m2 = m2 + 1;
}
}
if(ms3 >= 1000)
{
ms3 = ms3 - 1000;
s3 = s3 + 1;
if(s3 >= 60)
{
m3 = m3 + 1;
}
}
if(ms4 >= 1000)
{
ms4 = ms4 - 1000;
s4 = s4 + 1;
if(s4 >= 60)
{
m4 = m4 + 1;
}
}
if(ms5 >= 1000)
{
ms5 = ms5 - 1000;
s5 = s5 + 1;
if(s5 >= 60)
{
m5 = m5 + 1;
}
}
while(true)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Spilt 1)");
lcd.print(m1);
lcd.print(":");
lcd.print(s1);
lcd.print(":");
lcd.print(ms1);
lcd.setCursor(0,1);
lcd.print("Split 2)");
lcd.print(m2);
lcd.print(":");
lcd.print(s2);
lcd.print(":");
lcd.print(ms2);
delay(2500);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Split 3)");
lcd.print(m3);
lcd.print(":");
lcd.print(s3);
lcd.print(":");
lcd.print(ms3);
lcd.setCursor(0,1);
lcd.print("Split 4)");
lcd.print(m4);
lcd.print(":");
lcd.print(s4);
lcd.print(":");
lcd.print(ms4);
delay(2500);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Split 5)");
lcd.print(m5);
lcd.print(":");
lcd.print(s5);
lcd.print(":");
lcd.print(ms5);
lcd.setCursor(0,1);
lcd.print("---Press Reset--");
delay(2500);
}
}
//------------Developed By R.Girish-------//

Como operar este cronômetro automático:

• Com a configuração concluída, ligue primeiro os lasers e, em seguida, ligue o circuito do Arduino abaixo.
• Se todos os lasers estiverem alinhados corretamente com os LDRs, a tela não exibirá mensagens de erro. Se houver, alinhe-os corretamente.
• O circuito agora exibe "O sistema está em espera". Agora pressione o botão "Iniciar" e ele mostrará "O sistema está pronto".
• Nesse ponto, quando o player solo interrompe o feixe de luz LDR 1, o timer inicia e exibe "O tempo está sendo calculado ...".
• Assim que o reprodutor atinge o ponto final, ou seja, LDR 6, o temporizador para e exibe os 5 tempos divididos registrados pelo circuito.
• O usuário precisa pressionar o botão de reset no arduino para redefinir o timer.
Por que esse cronômetro automático não pode exibir o tempo ao vivo na tela como o cronômetro tradicional (em vez disso, exibe um texto estático "O tempo está sendo calculado ...")?
Para exibir a hora em tempo real, o Arduino precisa executar instruções adicionais para o LCD. Isso adicionará alguns microssegundos a alguns milissegundos de atraso ao código de rastreamento de tempo principal, levando a resultados imprecisos.

Se você tiver mais perguntas, expresse através da seção de comentários.



FONTE

Nota: Este foi traduzido do Inglês para português (auto)

Pode conter erros de tradução

Olá, se tiver algum erro de tradução (AUTO), falta de link para download etc...

Veja na FONTE até ser revisado o post.

Status (Não Revisado)

Se tiver algum erro coloque nos comentários

Mas se gostou compartilhe!!!


[the_ad_placement id="article-bottom-ad"]
[the_ad_placement id="final-do-post"]

Veja mais

[the_ad_placement id="correspodente-para-imagens"]
Axtudohttps://axtudo.com/
“Solidários, seremos união. Separados uns dos outros seremos pontos de vista. Juntos, alcançaremos a realização de nossos propósitos.” (Bezerra de Menezes)

Comentários

DEIXE UMA RESPOSTA

Por favor digite seu comentário!
Por favor, digite seu nome aqui

Compartilhe

[the_ad_placement id="barra-lateral-topo"]
[the_ad_placement id="correspodente-para-imagens"]
[the_ad_placement id="barra-lateral-inferior"]

Últimos Posts

00:02:22

VOU ENSINAR A PROFISSÃO DO FUTURO PRA ELE –...

#VOU #ENSINAR #PROFISSÃO #FUTURO #PRA #ELE #Tiago #Fonseca FAÇA PARTE DA COMUNIDADE SECRETA- link➤https:dominacaodigital.com.br/video1/ Neste vídeo Tiago Fonseca...
00:10:39

STROGONOFF DE SALSICHA SIMPLES, FÁCIL, RÁPIDO E DELICIOSO

Nesse vídeo te ensino a fazer um Strogonoff de Salsicha super diferente mas que é muito simples, fácil, rápido de fazer e muito Delicioso....
00:02:18

COMPREI UM PRESENTE PARA ELE! com Tiago Fonseca.

#COMPREI #PRESENTE #PARA #ELE #Tiago #Fonseca FAÇA PARTE DA COMUNIDADE SECRETA- link➤https:dominacaodigital.com.br/video1/ Neste vídeo o nosso convidado eucomprei um presente para um entregador, veja o porque...

Moto G9 Plus ENFIM com Câmeras Boas e um...

#Moto #ENFIM #Câmeras #Boas #Design #Lindo #REVIEW #CanalJMS CLICA AQUI PRA SE INSCREVER ?→ link➤http:goo.gl/vSPsIH Assista...

COMO CONSEGUIR MILHARES DE ACESSOS NOS PRIMEIROS MINUTOS

#COMO #CONSEGUIR #MILHARES #ACESSOS #NOS #PRIMEIROS #MINUTOS Leadlovers: link➤http:amoleads.com/leadlovers-peterj Copymaker: link➤https:amoleads.com/copymaker-peterj Os primeiros minutos de um post, seja ele...

O Luxo e a sofisticação dos Weintraub – Um...

#Luxo #sofisticação #dos #Weintraub #abraço #Lusa #para #Presidente #nossa #nova #aquisição FONTE - Duração...
[the_ad_placement id="barra-lateral-inferior"]