Criando um cronômetro automático para corredores, atletas e esportistas

Neste artigo, 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 o ponto final é exibido em um LCD 16 x 2.

Primeiro, vamos começar aprendendo como configurar um circuito de cronômetro Arduino simples e extremamente preciso.

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

Cronômetro Mecânico vs Eletrônico

Anteriormente, o cronômetro de mão mecânico tradicional era mais comum e usado por todos para esse fim.

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

O relógio de parada mecânico funcionava basicamente por meio de força de mola, que exigia um período de finalização manual girando o botão serrilhado fornecido na parte superior do dispositivo de relógio.

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

Usando um Arduino

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

O circuito de cronômetro do Arduino apresentado aqui é um desses modernos designs alimentados por microcontroladores, que é mais preciso, podendo estar no mesmo nível dos modernos cronômetros comerciais.

Vamos aprender como construir o circuito de stop clock proposto do Arduino:

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

Hardware necessário

Um Arduino LCD KeyPad Shield (SKU: DFR0009)

Uma placa Arduino ONE

Um cabo USB Arduino

Depois de adquirir o material acima e conectá-los uns aos outros, basta configurar o seguinte código de esboço fornecido em sua placa Arduino e observar a mágica das funções de 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 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 ')
}
}
}

Adicionando um Display de 7 Segmentos

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

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

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

Se você só precisa da configuração MM: SS por algum motivo, não há necessidade de conectar os visores de 7 segmentos de intervalo de milissegundos e seus ICs de driver, toda a funcionalidade do circuito ainda não será afetada.

O circuito:

O cronômetro proposto consiste em seis IC 4026, que é um driver de display de sete segmentos, seis displays de LED de 7 segmentos, uma placa Arduino, alguns botões de pressão e dois resistores de 10K.

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

O display de 7 segmentos pode ser qualquer display de cátodo comum de qualquer cor. O display de 7 segmentos pode ser facilmente eliminado por uma alimentação de 5 V, portanto, um resistor de 330 ohms é obrigatório em cada segmento do display.

Agora vamos ver o diagrama de pinos do IC 4026:

• O pino nº 1 é a entrada do relógio.
• O pino 2 é desabilitado do relógio, ele desabilita a contagem no display se este pino estiver alto.
• O pino nº 3 é habilitado para exibição, se este pino for baixo, a exibição será desligada e vice-versa.
• O pino # 5 é transportado, que se torna alto 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 elevarmos este pino a contagem volta a zero.
• Os pinos 4 e 14 não são usados.

Exibir diagrama de conexão:

Qualquer um dos pinos GND do display de 7 segmentos pode ser conectado ao aterramento. O IC deve ser alimentado por uma fonte de 5 V ou pino de saída de 5 V do Arduino.

O esquema acima para apenas um display, repita o mesmo para cinco outros displays.

Aqui está o resto do esquema:

O circuito pode ser alimentado por bateria de 9V. Existem dois botões fornecidos aqui, um para iniciar o tempo e outro para parar. Ao pressionar o botão reset no Arduino, a contagem de tempo será zerada no display.

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

Vamos entender o que é interrupção:

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

Uma interrupção é um sinal para o microcontrolador, 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 pino # 2 e # 3. O Arduino mega tem mais de dois pinos de interrupção de hardware.

Os microcontroladores não podem fazer duas funções ao mesmo tempo. Por exemplo, verificar se há pressão no botão e contar números.

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

Portanto, haverá um atraso na detecção do pressionamento do botão e, por algum motivo, se o código for interrompido temporariamente, o pressionamento do botão pode nunca ser detectado. Para evitar esses tipos de problemas, a interrupção é introduzida.

O sinal de interrupção sempre recebe a prioridade mais alta, a função principal (linhas principais de código) será interrompida e executará a função (outra parte do código) atribuída para aquela interrupção específica.

Isso é muito importante para aplicativos de tempo crítico, como cronômetro ou sistemas de segurança, etc., onde o processador precisa tomar uma ação imediata em resposta a um evento.

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

attachInterrupt (0, iniciar, RISING)

• “0” significa o número de interrupção zero (em microcontroladores tudo começa do zero) que é o pino # 2.
• “Start” é o nome da função de interrupção, você pode nomear qualquer coisa aqui.
• “RISING” se o pino # 2 (que é a interrupção zero) ficar alto, a função de interrupção é executada.

attachInterrupt (1, Stop, RISING)

• “1” significa a interrupção número um que é o pino # 3.
• “Stop” é o nome da interrupção.

Também podemos substituir “RISING” por “FALLING”, agora quando o pino de interrupção fica BAIXO, a função de interrupção é executada.

Também podemos substituir “RISING” por “CHANGE”, agora sempre que o pino de interrupção vai 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.

{

// programe aqui

}

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

Isso conclui que a interrupção do software de hardware 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 é autoexplicativo.

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 isso conclui o código.

Cronômetro especialmente desenvolvido para atletas

Finalmente, vamos aprender como os conceitos acima podem ser realmente atualizados para atletas que desejam desenvolver suas habilidades de corrida sem depender de outros para iniciar e parar o cronômetro / cronômetro. É melhor iniciar o cronômetro automaticamente detectando seu movimento do que alguém iniciando / parando o cronômetro, o que também pode adicionar seu tempo de reação.

NOTA: Este projeto é projetado para medir o tempo entre o ponto 'A' e o ponto 'B' coberto por UM usuário por vez.

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

Vejamos cada um dos componentes do circuito em detalhes.

Detalhes de funcionamento dos componentes

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

A interface entre LCD e 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 de laser. O pino analógico A2 é conectado com o botão que é usado para armar o cronômetro.

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

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

O circuito proposto foi projetado com mecanismo de detecção de falhas para lasers. Se algum dos lasers apresentar falha ou não estiver alinhado corretamente com o LDR, será exibida uma mensagem de erro no visor LCD.

· Se o laser START não estiver funcionando, ele exibe ''iniciar' o laser não está funcionando'

· Se o laser STOP não estiver funcionando, será exibido ''parar' o laser não está funcionando'

· Se ambos os lasers não estiverem funcionando, será exibido 'Os dois lasers não estão funcionando'

· Se ambos os lasers estiverem funcionando corretamente, será exibido 'Os dois lasers estão funcionando bem'

A mensagem de erro aparece até que o módulo do laser seja consertado ou o alinhamento seja feito corretamente com o LDR.

Assim que esta etapa estiver livre de problemas, o sistema vai para o modo de espera e exibe “-sistema em espera-“. Neste 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 movimento do usuário e exibe “O sistema está pronto”.

O corredor pode estar a poucos centímetros do laser de ‘partida’.

Se o laser “iniciar” for interrompido, o tempo começa a ser contado e exibe “Tempo está sendo calculado ……”. O tempo é calculado em segundo plano.

O tempo decorrido não será exibido até que o corredor alcance / interrompa o laser de “parada”. Isso ocorre porque a exibição do tempo decorrido no LCD, como o cronômetro tradicional faz, exige a execução de várias instruções adicionais no microcontrolador, o que deteriora significativamente a precisão da configuração.

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

Como definir o circuito na pista de corrida:

Use fios grossos para conectar os LDRs e o circuito Arduino, pois a distância entre os dois pode ser de vários metros 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 do tubo opaco oco e a parte frontal também deve ser coberta e apenas um orifício com 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 diferenciar do feixe de laser e de outra fonte 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:

Atualizando com uma facilidade Split Timer

O circuito de cronômetro automático proposto com temporizador parcial é uma extensão do circuito de cronômetro automático, em que o cronômetro monitora o tempo automaticamente assim que o corredor solo sai do ponto inicial e o cronômetro para e mostra o tempo decorrido conforme o corredor atinge o ponto final.

Introdução

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

Neste projeto, estamos introduzindo mais 4 LDRs para medir o tempo parcial do corredor solo. Existem 6 LDRs no total, todos eles podem ser colocados na pista de corrida com distância uniforme entre eles ou dependendo das circunstâncias e da escolha do usuário.

A maior parte do hardware é mantida inalterada, exceto a adição de 4 LDRs, mas o código passou por grandes modificações.

Diagrama esquemático mostrando o tempo fracionado:

O circuito acima consiste em poucos componentes e é amigável para iniciantes. Nenhuma explicação adicional é necessária, apenas conecte conforme o diagrama de circuito.

Como conectar LDRs:

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

Diagrama de layout:

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

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 os lasers primeiro e, em seguida, ligue o circuito do Arduino.
• Se todos os lasers estiverem alinhados corretamente com LDRs, o display não exibirá mensagens de erro. Se houver, alinhe-os corretamente.
• Agora o circuito exibe “Sistema em espera”. Agora pressione o botão “iniciar” e será exibido “Sistema está pronto”.
• Neste ponto, quando o jogador solo interrompe o feixe de luz LDR 1, o cronômetro é iniciado e exibe 'O tempo está sendo calculado ...'
• Assim que o jogador atinge o ponto final, ou seja, LDR 6, o cronômetro para e exibe os 5 tempos intermediários registrados pelo circuito.
• O usuário deve pressionar o botão de reset no arduino para zerar o cronômetro.
Por que este cronômetro automático não pode mostrar a cronometragem ao vivo no visor como o cronômetro tradicional (mas em vez disso exibe um texto estático “O tempo está sendo calculado ...”)?
Para exibir o tempo em tempo real, o Arduino precisa executar instruções adicionais no display LCD. Isso adicionará alguns microssegundos a alguns milissegundos de atraso ao trecho de código de rastreamento de tempo principal, o que levará a resultados imprecisos.

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