Realizzazione di un cronometro automatico per corridori, atleti e sportivi

In questo post costruiremo un cronometro che avvia automaticamente il timer quando il corridore inizia a correre e il timer si ferma quando il corridore raggiunge la fine. Il tempo trascorso tra il punto iniziale e quello finale viene visualizzato su un LCD 16 x 2.

Per prima cosa iniziamo imparando come configurare un circuito del cronometro Arduino semplice ed estremamente preciso.

Un cronometro è un dispositivo orologio a controllo manuale progettato per misurare la durata del tempo che può essere trascorso a partire da un determinato momento in cui è stato attivato e dal momento in cui è stato finalmente disattivato.Una variante più grande dello stesso dispositivo è chiamata il cronometro che viene utilizzato per monitorare l'azione a distanza e si trova normalmente negli stadi sportivi ecc.

Cronometro meccanico vs elettronico

In precedenza il tradizionale cronometro manuale meccanico era più comune e utilizzato da tutti per lo scopo.

Nel sistema meccanico avevamo due pulsanti per eseguire le funzioni del cronometro. Uno per avviare il cronometro premendo una volta e per fermare il tempo premendo di nuovo lo stesso pulsante per registrare il tempo trascorso .... il secondo pulsante è stato utilizzato per azzerare l'orologio.

Il cronometro meccanico funzionava fondamentalmente tramite la forza della molla, che richiedeva un periodo di carica manuale ruotando la manopola zigrinata nella parte superiore del dispositivo dell'orologio.

Tuttavia, rispetto ai moderni cronometri digitali, i tipi meccanici possono essere considerati significativamente primitivi e imprecisi nell'ordine dei millisecondi.

Utilizzando un Arduino

E oggi con l'avvento del microcontrollore, questi cronometri sono diventati estremamente precisi e affidabili nella gamma dei microsecondi.

Il circuito del cronometro Arduino presentato qui è uno di questi moderni design alimentati da microcontrollore che è più preciso ci si può aspettare che sia alla pari con i moderni gadget commerciali per cronometri.

Impariamo come costruire il circuito del cronometro Arduino proposto:

Avrai bisogno della seguente distinta base per la costruzione:

Hardware richiesto

Uno schermo per tastiera LCD Arduino (SKU: DFR0009)

Una scheda Arduino ONE

Un cavo USB Arduino

Dopo aver acquisito il materiale di cui sopra e averli collegati tra loro, si tratta solo di configurare il seguente codice di schizzo nella scheda Arduino e osservare la magia delle funzioni del cronometro.

Il codice

/*
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 ')
}
}
}

Aggiunta di un display a 7 segmenti

Procediamo ora con i dettagli riguardanti la costruzione di un circuito cronometro utilizzando display LED a 7 segmenti e Arduino. Esploreremo i concetti relativi agli interrupt e ai circuiti integrati dei driver di visualizzazione che sono cruciali per comprendere questo progetto. Questo progetto è stato suggerito dal Sig. Abu-Hafss, uno degli avidi lettori di questo sito.

Come già sappiamo, Stopwatch è un dispositivo che aiuta a tenere traccia di un breve periodo di tempo da ore a millisecondi (principalmente). Quasi tutti gli orologi da polso digitali economici dotati di funzionalità di cronometro, ma nessuno degli orologi può dare il gusto di crearne uno per noi stessi e anche trovare un cronometro con display LED a 7 segmenti è eccezionale.

Il signor Abu-Hafss ci ha suggerito di progettare un cronometro con 4 display, due per i minuti e due per i secondi (MM: SS). Ma per la maggior parte di noi potrebbe non essere un progetto fattibile, quindi abbiamo aggiunto altri due display per l'intervallo di millisecondi, quindi ora il design proposto sarà nella configurazione MM: SS: mS.

Se per qualche motivo è necessaria solo la configurazione MM: SS, non è necessario collegare i display a 7 segmenti con intervallo di millisecondi e i suoi circuiti integrati di pilotaggio, l'intera funzionalità del circuito rimane inalterata.

Il circuito:

Il cronometro proposto è composto da sei IC 4026 che è un driver del display a sette segmenti, sei display LED a 7 segmenti, una scheda Arduino, un paio di pulsanti e un paio di resistenze da 10K.

Ora vediamo come collegare l'IC 4026 al display a 7 segmenti.

Il display a 7 segmenti può essere qualsiasi display a catodo comune di qualsiasi colore. Il display a 7 segmenti può essere facilmente ucciso da un'alimentazione a 5V, quindi una resistenza da 330 ohm è obbligatoria su ogni segmento del display.

Ora vediamo il diagramma dei pin di IC 4026:

• Il pin # 1 è l'ingresso dell'orologio.
• Il pin # 2 è disabilitato dall'orologio, disabilita il conteggio sul display se questo pin è alto.
• Il pin # 3 è abilitato al display se questo pin è basso il display verrà disattivato e viceversa.
• Il pin # 5 viene eseguito, che diventa alto quando IC conta 10.
• I pin 6, 7, 9, 10, 11, 12, 13 sono uscite di visualizzazione.
• Il pin # 8 è GND.
• Il pin # 16 è Vcc.
• Il pin # 15 viene resettato, se alziamo questo pin il conteggio si azzera.
• I pin # 4 e # 14 non vengono utilizzati.

Visualizza schema di collegamento:

Uno qualsiasi dei pin GND del display a 7 segmenti può essere collegato a terra. L'IC deve essere alimentato da un'alimentazione a 5 V o dal pin di uscita 5V di Arduino.

Lo schema precedente per un solo display, ripeti lo stesso per altri cinque display.

Ecco il resto dello schema:

Il circuito può essere alimentato da una batteria da 9V. Ci sono due pulsanti qui forniti uno per l'avvio del tempo e un altro per l'arresto. Premendo il pulsante di ripristino su Arduino, il conteggio del tempo verrà azzerato sul display.

I due pulsanti sono collegati ai pin # 2 e # 3 che sono interrupt hardware del microcontrollore Arduino / Atmega328P.

Capiamo cos'è l'interruzione:

Esistono due tipi di interrupt: interrupt hardware e interrupt software. Qui stiamo usando solo l'interrupt hardware.

Un interrupt è un segnale al microcontrollore, che farà sì che il microcontrollore risponda immediatamente a un evento.

Ci sono solo due pin di interrupt hardware nelle schede Arduino con pin del microcontrollore ATmega328P # 2 e # 3. Arduino mega ha più di due pin di interruzione hardware.

I microcontrollori non possono svolgere due funzioni contemporaneamente. Ad esempio il controllo della pressione dei pulsanti e il conteggio dei numeri.

I microcontrollori non possono eseguire due eventi contemporaneamente, se scriviamo un codice per controllare la pressione del pulsante e il conteggio dei numeri, la pressione del pulsante verrà rilevata solo quando il microcontrollore legge il pezzo di codice di rilevamento della pressione del pulsante, il resto del tempo (conta i numeri) il il pulsante non funziona.

Quindi ci sarà un ritardo nel rilevamento della pressione del pulsante e per qualche motivo se il codice viene interrotto temporaneamente, la pressione del pulsante potrebbe non essere mai rilevata. Per evitare questo tipo di problemi viene introdotto l'interrupt.

Al segnale di interruzione viene sempre data la massima priorità, la funzione principale (righe di codice principali) verrà interrotta ed esegue la funzione (un altro pezzo di codice) assegnata per quel particolare interrupt.

Questo è molto importante per applicazioni critiche in termini di tempo come cronometro o sistemi di sicurezza, ecc. In cui il processore deve agire immediatamente in risposta a un evento.

In Arduino assegniamo interrupt hardware come:

attachInterrupt (0, start, RISING)

• '0' significa il numero di interrupt zero (nei microcontrollori tutto inizia da zero) che è il pin # 2.
• 'Inizio' è il nome della funzione di interruzione, qui puoi nominare qualsiasi cosa.
• 'RISING' se il pin # 2 (che è interrupt zero) diventa alto, viene eseguita la funzione di interrupt.

attachInterrupt (1, Stop, RISING)

• '1' indica il numero di interruzione uno che è il pin # 3.
• 'Stop' è il nome dell'interruzione.

Possiamo anche sostituire 'RISING' con 'FALLING', ora quando il pin di interrupt diventa LOW la funzione di interrupt viene eseguita.

Possiamo anche sostituire 'RISING' con 'CHANGE', ora ogni volta che il pin di interrupt passa da alto a basso o da basso ad alto, viene eseguita la funzione di interruzione.

La funzione di interruzione può essere assegnata come segue:

void start () // start è il nome dell'interrupt.

{

// programma qui

}

La funzione di interruzione deve essere più breve possibile e la funzione delay () non può essere utilizzata.

Ciò conclude che l'interrupt software di interrupt hardware relativo ad Arduino verrà spiegato nel prossimo articolo.

Ora sai perché abbiamo collegato i pulsanti di avvio e arresto per interrompere i pin.

Collegare il circuito secondo lo schema, il resto del circuito è autoesplicativo.

Programma:

//----------------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---------------//
Ora questo conclude il codice.

Cronometro sviluppato appositamente per gli atleti

Infine, impariamo come i concetti di cui sopra possono essere effettivamente aggiornati per gli atleti che desiderano sviluppare le proprie capacità di corsa senza dipendere da altri per l'avvio e l'arresto necessari del timer / cronometro. È meglio avviare automaticamente il timer rilevando il movimento rispetto a qualcuno che avvia / arresta il cronometro, il che potrebbe aggiungere anche il loro tempo di reazione.

NOTA: questo progetto è progettato per misurare il tempo tra il punto 'A' e il punto 'B' coperto da UN utente alla volta.

La configurazione consiste in due laser posizionati nel punto iniziale e nel punto finale, due LDR sono anche posizionati di fronte a due moduli laser. Quando l'atleta interrompe il laser di 'partenza', il tempo inizia a calcolare e quando l'atleta raggiunge la fine, interrompe il laser di 'fine' e il timer si ferma e visualizza il tempo trascorso tra due punti. Questo è il metodo utilizzato per misurare il tempo trascorso nell'idea proposta.

Esaminiamo in dettaglio ogni singolo componente del circuito.

Dettagli di funzionamento dei componenti

Il circuito è abbastanza semplice, consiste in un modulo LCD 16 x 2, poche resistenze, due LDR e un pulsante.

L'interfaccia tra LCD e arduino è standard e possiamo trovare una connessione simile in molti altri progetti basati su LCD.

Due pin analogici A0 e A1 vengono utilizzati per rilevare le interruzioni del laser. Il pin analogico A2 è collegato al pulsante che viene utilizzato per armare il cronometro.

Tre resistori, due da 4.7K e uno da 10K sono resistori pull-down che aiutano i pin di ingresso a rimanere bassi.

Il potenziometro 10K è fornito per regolare il contrasto nel modulo LCD per una visibilità ottimale.

Il circuito proposto è progettato con meccanismo di rilevamento dei guasti per i laser. Se uno qualsiasi dei laser è guasto o non allineato correttamente con LDR, viene visualizzato un messaggio di errore sul display LCD.

· Se il laser START non funziona, viene visualizzato 'il laser' start 'non funziona'

· Se il laser STOP non funziona, viene visualizzato il messaggio 'laser' stop 'non funzionante'

· Se entrambi i laser non funzionano, viene visualizzato il messaggio 'Entrambi i laser non funzionano'

· Se entrambi i laser funzionano correttamente, viene visualizzato il messaggio 'Entrambi i laser funzionano correttamente'

Il messaggio di errore viene visualizzato fino a quando il modulo laser non viene riparato o l'allineamento non viene eseguito correttamente con LDR.

Una volta che questo passaggio è privo di problemi, il sistema entra in modalità standby e visualizza '-system standby-'. A questo punto l'utente può attivare la configurazione premendo il pulsante in qualsiasi momento.

Una volta premuto il pulsante, il sistema è pronto a rilevare il movimento dell'utente e visualizza 'Il sistema è pronto'.

Il corridore potrebbe trovarsi a pochi centimetri dal laser di 'partenza'.

Se il laser di 'avvio' viene interrotto, il tempo inizia a contare e sul display viene visualizzato il messaggio 'Tempo in corso di calcolo .......' Il tempo viene calcolato sullo sfondo.

Il tempo trascorso non verrà visualizzato finché il corridore non raggiunge / interrompe il laser di 'arresto'. Questo perché la visualizzazione del tempo trascorso sull'LCD come fa il cronometro tradizionale, richiede l'esecuzione di diverse istruzioni aggiuntive nel microcontrollore, il che deteriora in modo significativo la precisione della configurazione.

NOTA: premere il pulsante di ripristino su arduino per cancellare le letture.

Come impostare il circuito su pista da corsa:

Utilizzare fili spessi per collegare gli LDR e il circuito arduino poiché la distanza tra questi due può essere di diversi metri e la tensione non deve diminuire in modo significativo. La distanza tra LDR1 e LDR2 può essere al massimo di poche centinaia di metri.

Come montare LDR:

L'LDR deve essere montato all'interno del tubo opaco cavo e anche la parte anteriore deve essere coperta e viene praticato solo un foro di pochi millimetri di diametro per consentire l'ingresso del raggio laser.

L'LDR deve essere protetto dalla luce solare diretta poiché non può differenziarsi dal raggio laser e da altre fonti di luce e potrebbe non registrare il movimento dell'utente.

Codice programma:

//-------- 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-------//

Prototipo dell'autore:

Aggiornamento con una funzione Split Timer

Il circuito del cronometro automatico proposto con timer parziale è un'estensione del circuito del cronometro automatico, in cui il cronometro tiene traccia del tempo automaticamente non appena il corridore solitario lascia il punto di partenza e il timer si ferma e mostra il tempo trascorso quando il corridore raggiunge il punto finale.

introduzione

Questo progetto è stato suggerito da uno degli avidi lettori di questo sito web, il signor Andrew Walker.

In questo progetto stiamo introducendo altri 4 LDR per misurare il tempo parziale del corridore solista. Ci sono 6 LDR in totale, tutti possono essere posizionati sulla pista da corsa con una distanza uniforme tra loro o in base alle circostanze e alla scelta dell'utente.

La maggior parte dell'hardware è rimasta invariata tranne l'aggiunta di 4 LDR, ma il codice ha subito enormi modifiche.

Diagramma schematico che mostra il tempo parziale:

Il circuito sopra è composto da pochi componenti e adatto ai principianti. Non sono necessarie ulteriori spiegazioni, basta collegare come da schema elettrico.

Come cablare LDR:

L'LDR 2 è mostrato sullo schema del circuito principale collegare altri 4 LDR in parallelo come mostrato nello schema sopra.

Diagramma di layout:

Quanto sopra è la disposizione di base su come posizionare il laser. Si noti che la distanza tra gli LDR può essere scelta dall'utente in base alla lunghezza del binario.

Programma:

//------------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-------//

Come utilizzare questo cronometro automatico:

• Al termine della configurazione, accendere prima i laser e poi il circuito Arduino.
• Se tutti i laser sono correttamente allineati con gli LDR, il display non visualizzerà messaggi di errore. Se ce ne sono, allinearli correttamente.
• Ora il circuito visualizza 'Il sistema è in standby'. Ora premere il pulsante 'start' e verrà visualizzato 'System is ready'.
• A questo punto, quando il giocatore solista interrompe il raggio di luce LDR 1, il timer si avvia e viene visualizzato il messaggio 'Il tempo viene calcolato ...'.
• Non appena il lettore raggiunge il punto finale, ovvero LDR 6, il timer si ferma e visualizza i 5 tempi intermedi registrati dal circuito.
• L'utente deve premere il pulsante di ripristino su arduino per ripristinare il timer.
Perché questo cronometro automatico non può mostrare il cronometro in tempo reale sul display come fa il cronometro tradizionale (ma piuttosto visualizza un testo statico 'Il tempo viene calcolato ...')?
Per visualizzare i tempi in tempo reale, Arduino deve eseguire istruzioni aggiuntive sul display LCD. Ciò aggiungerà un ritardo da pochi microsecondi a pochi millisecondi al pezzo di codice di monitoraggio del tempo principale, il che porterà a risultati imprecisi.

Se hai ulteriori domande, ti preghiamo di esprimere attraverso la sezione commenti.