Realització d’un cronòmetre automàtic per a corredors, atletes i esportistes

En aquest post anem a construir un cronòmetre que engegui el temporitzador automàticament quan el corredor comenci a córrer i el temporitzador s’aturi quan el corredor arriba al final. El temps transcorregut entre el punt inicial i final es mostra en un LCD de 16 x 2.

Primer, comencem aprenent a configurar un circuit de cronòmetre Arduino senzill i extremadament precís.

Un cronòmetre és un dispositiu de rellotge de temps controlat manualment dissenyat per mesurar la durada del temps que pot haver transcorregut a partir d’un moment determinat quan es va activar i, fins al moment en què finalment es va desactivar. Una variant més gran del mateix dispositiu s’anomena el cronòmetre que s’utilitza per controlar l’acció des de la distància i que normalment es troba a l’estadi esportiu, etc.

Cronòmetre mecànic vs electrònic

Abans, el cronòmetre de mà mecànic tradicional era més comú i era utilitzat per tothom.

Al sistema mecànic teníem dos botons de pressió per executar les funcions del cronòmetre. Un per iniciar el rellotge de parada prement una vegada i per aturar el temps prement el mateix botó una vegada més per enregistrar el temps transcorregut ... el segon botó es va utilitzar per restablir el rellotge a zero.

El rellotge de parada mecànic funcionava bàsicament amb la força de la molla, que requeria un període de liquidació manual girant el pom molet donat a la part superior del dispositiu de rellotge.

No obstant això, en comparació amb els cronòmetres digitals moderns, els tipus mecànics es poden considerar significativament primitius i imprecisos en el rang de mil·lisegons.

Utilitzant un Arduino

I avui, amb l’arribada del microcontrolador, aquests cronòmetres s’han convertit en extremadament precisos i fiables en la gamma de microsegons.

El circuit de cronòmetre Arduino que es presenta aquí és un d’aquests moderns dissenys de microcontroladors, que és el més precís que es pot esperar que estigui al mateix nivell que els aparells comercials de cronòmetres moderns.

Aprenem a construir el circuit de rellotge de parada Arduino proposat:

Necessitareu la següent llista de materials per a la construcció:

Es requereix maquinari

Un escut del teclat LCD Arduino (SKU: DFR0009)

Una placa Arduino ONE

Un cable USB Arduino

Quan hàgiu adquirit el material anterior i els hàgiu connectat entre si, es tracta de configurar el següent codi d’esbós donat a la vostra placa Arduino i veure la màgia de les funcions del cronòmetre.

El codi

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

Afegir una pantalla de 7 segments

Ara anem a continuar amb els detalls sobre la construcció d’un circuit de cronòmetre mitjançant pantalla LED de 7 segments i Arduino. Explorarem els conceptes relacionats amb les interrupcions i els controladors de pantalla que són crucials per entendre aquest projecte. Aquest projecte va ser suggerit pel senyor Abu-Hafss, que és un dels àvids lectors d’aquest lloc web.

Com ja sabem, el cronòmetre és un dispositiu que ajuda a fer un seguiment del breu període de temps des de les hores fins al rang de mil·lisegons (principalment). Gairebé tots els rellotges de polsera digitals barats equipats amb funcionalitat de cronòmetre, però cap dels rellotges és capaç de crear-ne un per a nosaltres mateixos i també trobar un cronòmetre amb pantalla LED de 7 segments és excepcional.

Abu-Hafss ens va suggerir que dissenyéssim un cronòmetre amb 4 pantalles, dues per minuts i dues per segons (MM: SS). Però per a la majoria de nosaltres pot ser que no sigui un disseny factible, de manera que hem afegit dues pantalles més per al rang de mil·lisegons, de manera que ara el disseny proposat estarà en configuració MM: SS: mS.

Si per alguna raó només necessiteu la configuració MM: SS, no cal que connecteu les pantalles de segment de rang de mil·lisegons de 7 i els seus IC de controlador, tota la funcionalitat del circuit no es veurà afectada.

El circuit:

El cronòmetre proposat consta de sis IC 4026 que són controladors de pantalla de set segments, sis pantalles LED de 7 segments, una placa Arduino, un parell de botons i un parell de resistències de 10K.

Ara entenem com connectar IC 4026 a pantalla de 7 segments.

La pantalla de 7 segments pot ser qualsevol pantalla de càtode comuna de qualsevol color. La visualització de 7 segments es pot eliminar fàcilment mitjançant un subministrament de 5 V, de manera que és obligatòria una resistència de 330 ohms a cada segment de la pantalla.

Ara vegem el diagrama de clavilles de l'IC 4026:

• El pin # 1 és l'entrada de rellotge.
• El pin número 2 està desactivat per rellotge, desactiva el recompte a la pantalla si aquest pin és alt.
• El pin # 3 està habilitat per a la visualització si aquest pin és baix, la pantalla es sintonitzarà i viceversa.
• El pin # 5 es porta a terme, que augmenta quan IC compta amb 10.
• Els pins 6, 7, 9, 10, 11, 12, 13 són sortides de visualització.
• El pin # 8 és GND.
• El pin # 16 és Vcc.
• El pin # 15 es restableix, si elevem aquest pin, el recompte es torna zero.
• No es fan servir els pins # 4 i # 14.

Mostra el diagrama de connexió:

Qualsevol dels pins GND de pantalla de 7 segments es pot connectar a terra. El CI ha d’estar alimentat amb una font de 5 V o el pin de sortida de 5 V d’Arduino.

L'esquema anterior per a una sola pantalla, repetiu el mateix per a altres cinc pantalles.

Aquí teniu la resta de l’esquema:

El circuit es pot alimentar amb bateria de 9 V. Els dos botons que es proporcionen aquí són un per començar l'hora i un altre per aturar-se. En prémer el botó de reinici d'Arduino, el temps es restablirà a zero a la pantalla.

Els dos polsadors estan connectats als pins # 2 i # 3, que són una interrupció de maquinari del microcontrolador Arduino / Atmega328P.

Comprenguem què és la interrupció:

Hi ha dos tipus d’interrupcions: interrupció de maquinari i interrupció de programari. Aquí només estem utilitzant la interrupció de maquinari.

Una interrupció és un senyal al microcontrolador, que fa que el microcontrolador respongui immediatament a un esdeveniment.

Només hi ha dos pins d’interrupció de maquinari a les plaques Arduino amb els pins # 2 i # 3 del microcontrolador ATmega328P. Arduino mega té més de dos pins d’interrupció de maquinari.

Els microcontroladors no poden fer dues funcions alhora. Per exemple, comprovar si hi ha botons premuts i comptar números.

Els microcontroladors no poden executar dos esdeveniments simultàniament, si escrivim un codi per comprovar que es premen els botons i es comptabilitzen els números, només es detectarà quan es prem el botó quan el microcontrolador llegeixi el codi de detecció de premsa de botó, la resta del temps (compta els números) el botó no funciona.

Per tant, es produirà un retard en la detecció del botó premut i, per alguna raó, si el codi s’atura temporalment, és possible que el botó no es detecti mai. Per evitar aquest tipus de problemes, s'introdueix la interrupció.

El senyal d’interrupció sempre té la màxima prioritat, la funció principal (línies principals de codi) s’aturarà i executarà la funció (un altre tros de codi) assignada per a aquesta interrupció en particular.

Això és molt important per a aplicacions de temps crític com el cronòmetre o els sistemes de seguretat, etc., on el processador ha de prendre mesures immediates en resposta a un esdeveniment.

A Arduino assignem una interrupció de maquinari com:

attachInterrupt (0, start, RISING)

• '0' significa el número d'interrupció zero (en els microcontroladors tot comença des de zero) que és el pin número 2.
• 'Start' és el nom de la funció d'interrupció, aquí podeu anomenar qualsevol cosa.
• 'RISING' si el pin # 2 (que és zero d'interrupció) augmenta, s'executa la funció d'interrupció.

attachInterrupt (1, Stop, RISING)

• '1' significa la interrupció número u que és el pin número 3.
• 'Stop' és el nom de la interrupció.

També podem substituir 'RISING' per 'FALLING', ara quan el pin d'interrupció baixa, s'executa la funció d'interrupció.

També podem substituir 'RISING' per 'CHANGE', ara cada vegada que el pin d'interrupció passa de més alt a més baix o de més baix a més alt, s'executa la funció d'interrupció.

La funció d'interrupció es pot assignar de la següent manera:

void start () // start és el nom de la interrupció.

{

// programa aquí

}

La funció d’interrupció ha de ser la més curta possible i no es pot utilitzar la funció delay ().

Això conclou que la interrupció del programari de la interrupció de maquinari relacionada amb Arduino s'explicarà en el proper article.

Ara ja sabeu per què hem connectat els botons d’inici i d’aturada per interrompre els pins.

Connecteu el circuit segons el diagrama que la resta del circuit s’explica per si mateix.

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---------------//
Ara es conclou el codi.

Cronòmetre desenvolupat especialment per als Atheletes

Finalment, aprenem com s’actualitzen els conceptes anteriors per als esportistes que desitgin desenvolupar les seves habilitats de carrera sense dependre d’altres per a l’inici i l’aturada necessaris del cronòmetre / cronòmetre. És millor iniciar automàticament el temporitzador detectant el vostre moviment que algú que iniciï / aturi el cronòmetre, cosa que també pot afegir el seu temps de reacció.

NOTA: aquest projecte està dissenyat per mesurar el temps entre el punt 'A' i el punt 'B' cobert per un usuari a la vegada.

La configuració consisteix en dos làsers situats al punt de partida i al punt final, dos LDR també es col·loquen oposats a dos mòduls làser. Quan l’atleta interromp el làser ‘inicial’ es comença a calcular el temps i quan l’atleta arriba al final, interromp el làser ‘final’ i el temporitzador s’atura i mostra el temps transcorregut entre dos punts. Aquest és el mètode utilitzat per mesurar el temps transcorregut en la idea proposada.

Vegem amb detall tots els components del circuit.

Detalls de treball dels components

El circuit es manté força senzill, consta de mòdul LCD de 16 x 2, poques resistències, dos LDR i un polsador.

La interfície entre LCD i arduino és estàndard, podem trobar connexions similars en molts altres projectes basats en LCD.

S'utilitzen dos pins analògics A0 i A1 per detectar interrupcions làser. El pin analògic A2 està connectat amb un polsador que s’utilitza per armar el cronòmetre.

Tres resistències, dues de 4,7 K i una de 10 K són resistències desplegables que ajuden els pins d'entrada a mantenir-se al mínim.

Es proporciona un potenciòmetre de 10K per ajustar el contrast al mòdul LCD per obtenir una visibilitat òptima.

El circuit proposat s'ha dissenyat amb un mecanisme de detecció d'errors per a làsers. Si algun dels làsers té un error o no està alineat correctament amb LDR, es mostrarà un missatge d'error a la pantalla LCD.

· Si el làser START no funciona, es mostrarà 'el làser' start 'no funciona'

· Si el làser STOP no funciona, es mostra 'el làser' atura 'no funciona'

· Si els làsers no funcionen, es mostra 'Els dos làsers no funcionen'

· Si ambdós làsers funcionen correctament, es mostra 'Els dos làsers funcionen bé'

El missatge d'error apareix fins que el mòdul làser s'ha solucionat o l'alineació es fa correctament amb LDR.

Un cop aquest pas estigui lliure de problemes, el sistema passa al mode d'espera i mostra '-sistema d'espera del sistema'. En aquest moment, l'usuari pot armar la configuració prement el botó en qualsevol moment.

Quan es prem el botó, el sistema està preparat per detectar el moviment de l'usuari i mostra 'El sistema està preparat'.

El corredor pot estar a pocs centímetres del làser ‘start’.

Si el làser 'd'inici' s'interromp, el temps comença a comptar i es visualitza 'El temps s'està calculant ......' El temps es calcula a la part posterior.

El temps transcorregut no es mostrarà fins que el corredor arribi / interrompi el làser 'stop'. Això es deu al fet que per mostrar el temps transcorregut a la pantalla LCD com fa el cronòmetre tradicional, calen diverses instruccions addicionals per executar-se al microcontrolador, cosa que deteriora la precisió de la configuració de manera significativa.

NOTA: Premeu el botó de restabliment a arduino per esborrar les lectures.

Com configurar el circuit en pista:

Si us plau, utilitzeu cables gruixuts per connectar-vos entre els LDR i el circuit arduino, ja que la distància entre aquests dos pot ser de diversos metres i la tensió no ha de baixar significativament. La distància entre LDR1 i LDR2 pot ser de pocs centenars de metres com a màxim.

Com muntar LDR:

El LDR s'ha de muntar a l'interior d'un tub opac buit i la part frontal també s'ha de cobrir i només es fa un forat de pocs mil·límetres de diàmetre per permetre l'entrada del feix làser.

El LDR ha d'estar protegit de la llum solar directa, ja que no es pot diferenciar del feix làser i d'altres fonts de llum i pot no registrar el moviment de l'usuari.

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

Prototip de l'autor:

Actualització amb una funció de temporitzador dividit

El circuit de cronòmetre automàtic proposat amb temporitzador dividit és una extensió del circuit de cronòmetre automàtic, on el cronòmetre fa un seguiment automàtic del temps tan bon punt el corredor solitari surt del punt d’inici i el cronòmetre s’atura i mostra el temps transcorregut quan el corredor arriba al punt final.

Introducció

Aquest projecte va ser suggerit per un dels àvids lectors d’aquest lloc web, el senyor Andrew Walker.

En aquest projecte introduïm 4 LDR més per mesurar el temps dividit del corredor en solitari. Hi ha 6 LDR en total, tots es poden col·locar a la pista de carrera amb una distància uniforme entre ells o segons les circumstàncies i l’elecció de l’usuari.

La major part del maquinari es manté inalterat excepte l’addició de 4 LDR, però el codi ha sofert una enorme modificació.

Diagrama esquemàtic que mostra el temps dividit:

El circuit anterior consta de pocs components i és ideal per a principiants. No es necessita cap explicació addicional, només cal fer un cable segons el diagrama del circuit.

Com connectar LDR:

El LDR 2 es mostra al diagrama del circuit principal connecta 4 LDR més en paral·lel, tal com es mostra al diagrama anterior.

Diagrama de disseny:

L'anterior és la disposició bàsica sobre com col·locar el làser. Tingueu en compte que la distància entre LDR pot ser l’elecció de l’usuari en funció de la longitud de la 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-------//

Com s'utilitza aquest cronòmetre automàtic:

• Amb la configuració completa, engegueu primer els làsers i, a continuació, enceneu el circuit Arduino.
• Si tots els làsers estan correctament alineats amb els LDR, la pantalla no sol·licitarà cap missatge d'error. Si n’hi ha cap, alineeu-los correctament.
• Ara el circuit mostra 'El sistema està en espera'. Ara premeu el botó 'Inici' i es mostrarà 'El sistema està a punt'.
• En aquest moment, quan el jugador solista interromp el feix de llum LDR 1, s'inicia el temporitzador i mostra 'El temps s'està calculant ...'.
• Tan bon punt el jugador arriba al punt final, és a dir, LDR 6, el temporitzador s’atura i mostra el temps dividit de 5 registrats pel circuit.
• L'usuari ha de prémer el botó de restabliment de l'arduino per restablir el temporitzador.
Per què aquest cronòmetre automàtic no pot mostrar el temps en directe a la pantalla com ho fa el cronòmetre tradicional (sinó que mostra un text estàtic 'El temps s'està calculant ...')?
Per mostrar el temps en temps real, Arduino ha d'executar instruccions addicionals a la pantalla LCD. Això afegirà uns quants microsegons a uns quants mil·lisegons de retard al fragment principal de seguiment de temps, cosa que provocarà resultats inexactes.

Si teniu més preguntes, expresseu-ho a través de la secció de comentaris.