Å lage et automatisk stoppeklokke for løpere, idrettsutøvere og sportspersoner

I dette innlegget skal vi lage et stoppeklokke som automatisk starter tidtakeren når løperen begynner å løpe og tidtakeren stopper når løperen når slutten. Forløpt tid mellom start- og sluttpunkt vises på en 16 x 2 LCD.

La oss først begynne med å lære å konfigurere en enkel og ekstremt nøyaktig Arduino stoppeklokke.

En stoppeklokke er en manuelt styrt tidsklokke som er designet for å måle lengden på tiden som kan ha gått fra et bestemt tidspunkt da den ble aktivert, og da den til slutt ble deaktivert. En større variant av samme enhet kalles stoppeklokken som brukes til å overvåke handlingen på avstand og vanligvis finnes på sportsstadion etc.

Mekanisk vs elektronisk stoppeklokke

Tidligere var det tradisjonelle mekaniske håndholdte stoppeklokken mer vanlig og brukt av alle til formålet.

I det mekaniske systemet hadde vi to trykknapper for å utføre stoppeklokkefunksjonene. Én for å starte stoppeklokken ved å trykke en gang, og for å stoppe tiden ved å trykke på den samme knappen igjen for å registrere forløpt tid .... den andre knappen ble brukt til å tilbakestille klokken til null.

Mekanisk stoppeklokke fungerte i utgangspunktet gjennom fjærkraft, noe som krevde tidsrulling manuelt ved å vri på den gitte riflede knappen på toppen av klokkeenheten.

Men sammenlignet med moderne digitale stoppeklokker, kan de mekaniske typene betraktes som betydelig primitive og unøyaktige innen millisekunder.

Bruke en Arduino

Og i dag med fremkomsten av mikrokontroller, har disse stoppeklokkene blitt ekstremt nøyaktige og pålitelige for mikrosekunder.

Arduino stoppeklokke krets presentert her er en av disse moderne mikrokontroller drevet design som er mest nøyaktig kan forventes å være på nivå med de kommersielle moderne stoppeklokke gadgets.

La oss lære hvordan du bygger den foreslåtte Arduino stoppeklokke kretsen:

Du trenger følgende papirregistrering for konstruksjonen:

Maskinvare kreves

Et Arduino LCD KeyPad Shield (SKU: DFR0009)

Et Arduino ONE-brett

En Arduino USB-kabel

Når du har anskaffet materialet ovenfor og koblet dem til hverandre, handler det bare om å konfigurere følgende gitte skissekode i Arduino-kortet ditt og se magien til stoppeklokkefunksjonene.

Koden

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

Legge til en 7-segment skjerm

La oss nå fortsette med detaljene angående konstruksjon av en stoppeklokke med 7-segment LED-skjerm og Arduino. Vi vil utforske konseptene relatert til avbrudd og skjermdriver-IC som er avgjørende for å forstå dette prosjektet. Dette prosjektet ble foreslått av Abu-Hafss, som er en av de ivrige leserne på dette nettstedet.

Som vi allerede vet at Stopwatch er en enhet som hjelper med å spore kort tid fra timer til millisekunder (hovedsakelig). Nesten alle billige digitale armbåndsur utstyrt med stoppeklokkefunksjonalitet, men ingen av klokkene kan gi glede i å lage en for oss selv, og det er også enestående å finne et stoppeklokke med 7-segment LED-skjerm.

Abu-Hafss foreslo oss å utforme et stoppeklokke med 4 skjermer, to i minutter og to i sekunder (MM: SS). Men for de fleste av oss er det kanskje ikke en gjennomførbar design, så vi la til ytterligere to skjermer for millisekunder, så den foreslåtte designen vil nå være i MM: SS: mS-konfigurasjon.

Hvis du bare trenger MM: SS-konfigurasjon av en eller annen grunn, trenger du ikke å koble til millisekund 7-segmentskjermene og driver-IC-ene, hele kretsfunksjonen er fortsatt upåvirket.

Kretsen:

Den foreslåtte stoppeklokken består av seks IC 4026 som er sju-segment skjermdriver, seks 7-segment LED-skjermer, ett Arduino-kort, et par trykknapper og et par 10K-motstander.

La oss nå forstå hvordan du kobler IC 4026 til 7-segmentvisning.

7-segmentskjermen kan være hvilken som helst vanlig katodevisning i hvilken som helst farge. 7-segmentskjermen kan lett drepes av 5V-forsyning, så en 330 ohm motstand er obligatorisk på hvert segment av skjermen.

La oss nå se pin-diagrammet til IC 4026:

• Pin nr. 1 er klokkeinngang.
• Pinnen nr. 2 er deaktivert, den deaktiverer tellingen på skjermen hvis denne pinnen er høy.
• Stift nr. 3 er visningsaktiverende hvis denne stiften er lav, vil skjermen bli avstemt og omvendt.
• Pinnen # 5 er gjennomføring, som blir høy når IC teller 10.
• Pinnene 6, 7, 9, 10, 11, 12, 13 er skjermutganger.
• Pinnen # 8 er GND.
• Pin # 16 er Vcc.
• Pinnen nr. 15 tilbakestilles. Hvis vi høyer denne pinnen, blir tellingen til null.
• Pinnene nr. 4 og nr. 14 brukes ikke.

Vis tilkoblingsskjema:

En hvilken som helst av GND-pinnen på 7-segmentskjermen kan kobles til bakken. IC-en må drives fra 5V-forsyning eller Arduinos 5V-utgangsstift.

Ovenstående skjema for bare en skjerm, gjenta det samme for fem andre skjermer.

Her er resten av skjematisk:

Kretsen kan drives av 9V batteri. Det er to knapper som er gitt her, en for å starte tiden og en annen for å stoppe. Ved å trykke på tilbakestillingsknappen på Arduino, blir tidstallet nullstilt på skjermen.

De to trykknappene er koblet til pin 2 og 3 som er maskinvareavbrudd av Arduino / Atmega328P mikrokontroller.

La oss forstå hva avbrudd er:

Det er to typer avbrudd: maskinvareavbrudd og programvareavbrudd. Her bruker vi bare maskinvareavbruddet.

Et avbrudd er et signal til mikrokontrolleren, noe som får mikrokontrolleren til å svare umiddelbart på en hendelse.

Det er bare to maskinvareavbruddspinner i Arduino-kort med ATmega328P mikrokontroller pin 2 og 3. Arduino mega har mer enn to maskinvareavbruddspinner.

Mikrokontrollerne kan ikke utføre to funksjoner samtidig. For eksempel å se etter knappetrykk og telle tall.

Mikrokontrollerne kan ikke utføre to hendelser samtidig. Hvis vi skriver en kode for å sjekke knappetrykk og telle tall, vil knappetrykket bare oppdages når mikrokontrolleren leser knappen trykk deteksjon stykke kode, resten av tiden (teller tallene) knappen fungerer ikke.

Så det blir forsinkelse i deteksjonen av knappetrykket, og av en eller annen grunn, hvis koden blir stoppet midlertidig, kan det hende at knappetrykket aldri blir oppdaget. For å unngå slike problemer avbrytes det.

Avbruddssignalet blir alltid gitt høyeste prioritet, hovedfunksjonen (hovedlinjer med kode) blir stoppet og utfører (en annen kode) funksjonen som er tildelt for den aktuelle avbruddet.

Dette er veldig viktig for tidskritiske applikasjoner som stoppeklokke eller sikkerhetssystemer etc. der prosessoren trenger å iverksette umiddelbare tiltak som svar på en hendelse.

I Arduino tildeler vi maskinvareavbrudd som:

attachInterrupt (0, start, RISING)

• '0' betyr avbruddstallet null (i mikrokontrollere starter alt fra null) som er pin nr. 2.
• “Start” er navnet på avbruddsfunksjonen, du kan nevne noe her.
• “RISING” hvis pinnen nr. 2 (som er avbruddsnull) blir høy, utføres avbruddsfunksjonen.

attachInterrupt (1, Stop, RISING)

• “1” betyr avbrudd nummer én som er pin nr. 3.
• “Stopp” er navnet på avbruddet.

Vi kan også erstatte “RISING” med “FALLING”, nå når avbruddspinnen går LAV, utføres avbruddsfunksjonen.

Vi kan også erstatte “RISING” med “CHANGE”, nå når avbruddspinnen går fra høy til lav eller lav til høy, utføres avbruddsfunksjonen.

Avbrytingsfunksjonen kan tilordnes som følger:

ugyldig start () // start er navnet på avbruddet.

{

// program her

}

Avbrytingsfunksjonen må være kort som mulig, og forsinkelsesfunksjonen () kan ikke brukes.

Som konkluderer med maskinvareavbruddsprogramvareavbrudd relatert til Arduino vil bli forklart i fremtidig artikkel.

Nå vet du hvorfor vi koblet start- og stoppknappene for å avbryte pinnene.

Koble kretsen i henhold til diagrammet, resten av kretsen er selvforklarende.

Program:

//----------------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---------------//
Nå avsluttes koden.

Stoppeklokke spesielt utviklet for Atheletes

Til slutt, la oss lære hvordan de ovennevnte konseptene faktisk kan oppgraderes for idrettsutøvere som ønsker å utvikle sine løpeferdigheter uten å være avhengig av andre for den nødvendige start og stopper tidtakeren / stoppeklokken. Det er bedre å starte timeren automatisk ved å oppdage bevegelsen din enn noen som starter / stopper stoppeklokken, noe som også kan øke reaksjonstiden.

MERKNAD: Dette prosjektet er designet for å måle tiden mellom punkt 'A' til punkt 'B' dekket av EN bruker om gangen.

Oppsettet består av to lasere plassert ved startpunkt og sluttpunkt, to LDRer er også plassert motsatt to lasermoduler. Når idrettsutøveren avbryter 'start-laser' begynner tiden å beregne, og når utøveren når slutten, avbryter 'slutt' laser og tidsur stopper og viser den forløpne tiden mellom to punkter. Dette er metoden som brukes til å måle den forløpne tiden i den foreslåtte ideen.

La oss se på hver eneste komponent i kretsen i detalj.

Komponenter Arbeidsdetaljer

Kretsen holdes ganske enkel, den består av 16 x 2 LCD-modul, få motstander, to LDR og en trykknapp.

Grensesnittet mellom LCD og arduino er standard. Vi kan finne lignende forbindelser i mange andre LCD-baserte prosjekter.

To analoge pinner A0 og A1 brukes til å oppdage laseravbrudd. Analog pin A2 er koblet til med trykknapp som brukes til å tilkoble stoppeklokken.

Tre motstander, to 4.7K og en 10K er nedtrekkbare motstander som hjelper inngangspinnene til å holde seg lave.

10K potensiometer er gitt for justering av kontrast i LCD-modul for optimal synlighet.

Den foreslåtte kretsen er designet med feildeteksjonsmekanisme for lasere. Hvis en av laseren er feil eller ikke er riktig innrettet med LDR, viser den en feilmelding på LCD-skjermen.

· Hvis START-laseren ikke fungerer, vises 'start-laser' virker ikke '

· Hvis STOPP-laser ikke fungerer, viser den at “stopp” -laser ikke fungerer ”

· Hvis begge laserne ikke fungerer, vises 'begge lasere fungerer ikke'

· Hvis begge laserne fungerer som de skal, vises 'begge lasere fungerer bra'

Feilmeldingen vises til lasermodulen er løst eller justeringen er riktig med LDR.

Når dette trinnet er uten problemer, går systemet i standby-modus og viser “-system standby-“. På dette tidspunktet kan brukeren tilkoble oppsettet ved å trykke på trykknappen når som helst.

Når du trykker på trykknappen, er systemet klart til å oppdage bevegelse fra brukeren og viser 'Systemet er klart'.

Løperen kan være noen centimeter fra 'start' laseren.

Hvis “start” -laseren blir avbrutt, begynner tiden å telle og displayet “Time blir kalkulert ……” Tiden blir beregnet i bakken.

Den forløpne tiden vises ikke før løperen når / avbryter “stopp” -laseren. Dette skyldes at det å vise den forløpende tiden på LCD som tradisjonell stoppeklokke krever flere tilleggsinstruksjoner som skal utføres i mikrokontrolleren, noe som forverrer nøyaktigheten av oppsettet betydelig.

MERK: Trykk på tilbakestillingsknappen på arduino for å fjerne avlesningene.

Slik setter du kretsen på løpebane:

Bruk tykke ledninger for å koble mellom LDR og arduino-krets, da avstanden mellom disse to kan være flere meter fra hverandre, og spenningen ikke må synke betydelig. Avstanden mellom LDR1 og LDR2 kan være maksimalt noen hundre meter.

Hvordan montere LDR:

LDR må monteres inne i hul, ugjennomsiktig rør, og frontdelen må også være tildekket, og bare et hull med få millimeter i diameter er laget for å la laserstrålen komme inn.

LDR må beskyttes mot direkte sollys, da den ikke kan skille seg fra laserstråle og annen lyskilde og kanskje ikke registrerer bevegelse fra brukeren.

Programkode:

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

Forfatterens prototype:

Oppgradering med en delt timerinnretning

Den foreslåtte automatiske stoppeklokke-kretsen med delt timer er en utvidelse av den automatiske stoppeklokke-kretsen, der stoppeklokken sporer tiden automatisk så snart solo-løperen forlater startpunktet og tidtakeren stopper og viser den forløpne tiden når løperen når sluttpunktet.

Introduksjon

Dette prosjektet ble foreslått av en av de ivrige leserne på dette nettstedet, Andrew Walker.

I dette prosjektet introduserer vi fire flere LDR-er for å måle deltid for solo-løperen. Det er totalt 6 LDR-er som alle kan plasseres i løpebanen med jevn avstand mellom dem, eller avhengig av omstendigheter og brukerens valg.

Det meste av maskinvaren holdes uendret bortsett fra tillegg av 4 LDR-er, men koden har gjennomgått enorm modifisering.

Skjematisk diagram som viser deltid:

Ovennevnte krets består av få komponenter og nybegynnervennlig. Ingen ytterligere forklaring er nødvendig, bare ledning i henhold til kretsskjemaet.

Hvordan koble til LDR-er:

LDR 2 er vist på hovedkretsskjemaet, og koble til 4 flere LDRer parallelt som vist i diagrammet ovenfor.

Oppsettdiagram:

Ovennevnte er den grunnleggende ordningen for hvordan du plasserer laseren. Vær oppmerksom på at avstanden mellom LDR-er kan være brukerens valg, avhengig av sporlengde.

Program:

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

Slik betjener du dette automatiske stoppeklokken:

• Når ferdig oppsett er slått på, begynner laserne først og deretter slår du på Arduino-kretsen.
• Hvis alle lasere er riktig innrettet med LDR, vil skjermen ikke be om feilmeldinger. Hvis noen, vennligst juster dem riktig.
• Nå viser kretsen “System is standby”. Trykk nå på “start” -knappen for å vise “Systemet er klart”.
• På dette tidspunktet når solospilleren avbryter lysstrålen LDR 1, starter tidtakeren og den viser 'Tiden beregnes ...'.
• Så snart spilleren når endepunktet, dvs. LDR 6, stopper tidtakeren og den viser 5 deltid registrert av kretsen.
• Brukeren må trykke på tilbakestillingsknappen på arduinoen for å tilbakestille timeren.
Hvorfor kan ikke dette automatiske stoppeklokken vise live timing på skjermen slik tradisjonell stoppeklokke gjør (men snarere viser den en statisk tekst 'Tiden beregnes ...')?
For å vise timingen i sanntid, må Arduino utføre tilleggsinstruksjoner til LCD-skjermen. Dette vil legge til få mikrosekunder til få millisekunder forsinkelse til hovedsporingskoden, noe som vil føre til unøyaktige resultater.

Hvis du har ytterligere spørsmål, vennligst uttrykk gjennom kommentarseksjonen.