Gör ett automatiskt stoppur för löpare, idrottare och sportpersoner

I det här inlägget ska vi konstruera ett stoppur som automatiskt startar timer när löparen börjar springa och timern stannar när löparen når slutet. Den förflutna tiden mellan start- och slutpunkt visas på en 16 x 2 LCD.

Låt oss först börja med att lära oss hur man konfigurerar en enkel och extremt exakt Arduino stoppur-krets.

Ett stoppur är en manuellt styrd klockanordning som är utformad för att mäta den tid som kan ha förflutit från en viss tidpunkt när den aktiverades och när den äntligen inaktiverades. En större variant av samma enhet kallas stoppklockan som används för att övervaka åtgärden på distans och normalt finns i sportstadion etc.

Mekaniskt kontra elektroniskt stoppur

Tidigare var det traditionella mekaniska handhållna stoppuret vanligare och användes av alla för ändamålet.

I det mekaniska systemet hade vi två tryckknappar för att utföra stoppurfunktionerna. En för att starta stoppklockan genom att trycka en gång och för att stoppa tiden genom att trycka på samma knapp en gång till för att spela in den förflutna tiden .... den andra knappen användes för att återställa klockan till noll.

Mekanisk stoppklocka fungerade i grund och botten genom fjäderkraft, vilket krävde period avlindning manuellt genom att vrida den angivna räfflade ratten längst upp på klockanordningen.

Men jämfört med de moderna digitala stoppurarna kan de mekaniska typerna betraktas som betydande primitiva och felaktiga inom millisekunder.

Använda en Arduino

Och idag med tillkomsten av mikrokontroller har dessa stoppur blivit extremt exakta och tillförlitliga för mikrosekundområdet.

Arduino stoppur krets presenteras här är en av dessa moderna mikrokontroller drivs design som är mest exakt kan förväntas vara i nivå med de kommersiella moderna stoppur prylar.

Låt oss lära oss hur man bygger den föreslagna Arduino stoppklockkretsen:

Du behöver följande materialförteckning för konstruktionen:

Maskinvara krävs

En Arduino LCD KeyPad Shield (SKU: DFR0009)

Ett Arduino ONE-kort

En Arduino USB-kabel

När du väl har förvärvat ovanstående material och anslutit dem till varandra handlar det bara om att konfigurera följande givna skisskod i ditt Arduino-kort och titta på magin med stoppklockfunktionerna.

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

Lägga till en 7-segmentsdisplay

Låt oss nu gå vidare med detaljerna om konstruktion av en stoppurkrets med 7-segment LED-skärm och Arduino. Vi kommer att utforska begreppen relaterade till avbrott och IC: er för displaydrivrutiner som är avgörande för att förstå detta projekt. Detta projekt föreslogs av Abu-Hafss, som är en av de ivriga läsarna på denna webbplats.

Som vi redan vet är Stopwatch en enhet som hjälper till att spåra kort tid från timmar till millisekunder (mestadels). Nästan alla billiga digitala armbandsur utrustade med stoppurfunktionalitet, men ingen av klockorna kan ge det bästa att skapa en för oss själv och det är också enastående att hitta ett stoppur med 7-segment LED-skärm.

Herr Abu-Hafss föreslog oss att utforma ett stoppur med fyra skärmar, två i minuter och två i sekunder (MM: SS). Men för de flesta av oss kanske det inte är en genomförbar design, så vi lade till ytterligare två skärmar för millisekunder, så nu kommer den föreslagna designen att vara i MM: SS: mS-konfiguration.

Om du bara behöver MM: SS-konfiguration av någon anledning behöver du inte ansluta millisekundens 7-segmentskärmar och dess IC-drivrutiner, hela kretsens funktion påverkas fortfarande.

Kretsen:

Det föreslagna stoppuret består av sex IC 4026 som är sju segment display driver, sex 7 segment LED displayer, ett Arduino kort, ett par tryckknappar och ett par 10K motstånd.

Låt oss nu förstå hur du ansluter IC 4026 till 7-segmentsdisplay.

7-segmentsdisplayen kan vara vilken vanlig katodvisning som helst i vilken färg som helst. 7-segmentsdisplayen kan enkelt dödas av 5 V-matning, så ett 330 ohm-motstånd är obligatoriskt på varje segment av skärmen.

Låt oss nu se stiftdiagrammet för IC 4026:

• Stift nr 1 är klockingång.
• Stift nr 2 är klockavaktiverat, det inaktiverar räkningen på displayen om denna stift är hög.
• Stift nr 3 är visningsaktiverat om denna stift är låg kommer skärmen att stängas av och tvärtom.
• Stift nr 5 är genomförbar, vilket blir högt när IC räknar 10.
• Stiften 6, 7, 9, 10, 11, 12, 13 är displayutgångar.
• Stift nr 8 är GND.
• Stift nr 16 är Vcc.
• Stift nr 15 återställs, om vi höjer denna stift blir antalet till noll.
• Stiften # 4 och # 14 används inte.

Visa anslutningsdiagram:

Vilken som helst av GND-stiften på 7-segmentsdisplayen kan anslutas till jord. IC: n måste drivas från 5V-matning eller Arduinos 5V-utgångsstift.

Ovanstående schema för bara en skärm, upprepa samma för fem andra skärmar.

Här är resten av schemat:

Kretsen kan drivas från 9V batteri. Det finns två knappar som finns här, för att starta tiden och en annan för att stoppa. Genom att trycka på återställningsknappen på Arduino återställs tidsräkningen till noll på displayen.

De två tryckknapparna är anslutna till stift nr 2 och # 3 som är hårdvarustörning av Arduino / Atmega328P mikrokontroller.

Låt oss förstå vad avbrott är:

Det finns två typer av avbrott: hårdvaruavbrott och programavbrott. Här använder vi bara hårdvaruavbrottet.

Ett avbrott är en signal till mikrokontrollern, vilket gör att mikrokontrollen reagerar omedelbart på en händelse.

Det finns bara två hårdvaruavbrottsstift i Arduino-kort med ATmega328P mikrokontrollerstift nr 2 och # 3. Arduino mega har mer än två hårdvaruproppar.

Mikrokontrollerna kan inte utföra två funktioner samtidigt. Till exempel söka efter knapptryckning och räkna siffror.

Mikrokontrollerna kan inte utföra två händelser samtidigt, om vi skriver en kod för att trycka på knapptryckning och räkna siffror, kommer knapptrycket att upptäckas först när mikrokontrollern läser av knapptryckningsdetektering kod, resten av tiden (räknar siffrorna) knappen fungerar inte.

Så det kommer att finnas fördröjning i detekteringen av knapptryckningen och av någon anledning om koden stoppas tillfälligt kanske knapptrycket aldrig upptäcks. För att undvika denna typ av problem introduceras avbrott.

Avbrottssignalen ges alltid högsta prioritet, huvudfunktionen (kodens huvudrader) kommer att stoppas och exekverar den (en annan bit kod) -funktionen som tilldelats för det aktuella avbrottet.

Detta är mycket viktigt för tidskritiska applikationer som stoppur eller säkerhetssystem etc. där processorn behöver vidta omedelbara åtgärder som svar på en händelse.

I Arduino tilldelar vi hårdvaruavbrott som:

attachInterrupt (0, start, RISING)

• '0' betyder avbrottsnumret noll (i mikrokontroller börjar allt från noll) vilket är stift nr 2.
• “Start” är namnet på avbrottsfunktionen, du kan namnge vad som helst här.
• “RISING” om stift nr 2 (som är avbrottsnoll) blir högt, avbryter funktionen.

attachInterrupt (1, Stop, RISING)

• '1' betyder avbrott nummer ett som är stift nr 3.
• 'Stopp' är namnet på avbrottet.

Vi kan också ersätta 'RISING' med 'FALLING', nu när avbrottsstiftet går LÅG körs avbrottsfunktionen.

Vi kan också ersätta 'RISING' med 'CHANGE', nu när avbrottsstiftet går från högt till lågt eller lågt till högt utförs avbrottsfunktionen.

Avbrytningsfunktionen kan tilldelas enligt följande:

void start () // start är namnet på avbrottet.

{

// program här

}

Avbrytningsfunktionen måste vara kort som möjligt och fördröjningsfunktionen () kan inte användas.

Det avslutar hårdvaruavbrottsprogramavbrott relaterat till Arduino kommer att förklaras i framtida artikel.

Nu vet du varför vi kopplade start- och stoppknapparna för att avbryta stiften.

Anslut kretsen enligt diagrammet resten av kretsen är självförklarande.

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---------------//
Nu avslutas koden.

Stoppur speciellt utvecklat för Atheletes

Slutligen, låt oss lära oss hur ovanstående begrepp kan uppgraderas för idrottare som vill utveckla sina löpefärdigheter utan att vara beroende av andra för den nödvändiga start och stoppa timern / stoppuret. Det är bättre att automatiskt starta timern genom att upptäcka din rörelse än någon som startar / stoppar stoppuret, vilket också kan öka deras reaktionstid.

OBS: Detta projekt är utformat för att mäta tiden mellan punkt 'A' och punkt 'B' som täcks av EN användare åt gången.

Installationen består av två lasrar placerade vid startpunkten och slutpunkten, två LDR-enheter är också placerade mittemot två lasermoduler. När idrottaren avbryter startlasern börjar tiden att beräkna och när idrottaren når slutet avbryter den 'slutande' lasern och timern stoppar och visar den förflutna tiden mellan två punkter. Detta är metoden som används för att mäta förfluten tid i den föreslagna idén.

Låt oss titta på varje komponent i kretsen i detalj.

Komponenters arbetsuppgifter

Kretsen hålls ganska enkel, den består av 16 x 2 LCD-modul, få motstånd, två LDR och en tryckknapp.

Gränssnittet mellan LCD och arduino är standard vi kan hitta liknande anslutning i många andra LCD-baserade projekt.

Två analoga stift A0 och A1 används för att detektera laseravbrott. Analog stift A2 är ansluten med tryckknapp som används för att aktivera stoppuret.

Tre motstånd, två 4.7K och en 10K är neddragbara motstånd som hjälper ingångsstiftet att hålla sig lågt.

10K potentiometer finns för att justera kontrasten i LCD-modulen för optimal synlighet.

Den föreslagna kretsen har utformats med feldetekteringsmekanism för lasrar. Om någon av lasern är felaktig eller inte är korrekt anpassad till LDR, visas ett felmeddelande på LCD-skärmen.

· Om START-lasern inte fungerar, visar den '' start-laser fungerar inte '

· Om STOP-lasern inte fungerar, visar den “” stopp ”lasern fungerar inte”

· Om båda lasrarna inte fungerar visas 'Båda lasrarna fungerar inte'

· Om båda lasrarna fungerar som de ska visas 'Båda lasrarna fungerar bra'

Felmeddelandet visas tills lasermodulen har fixats eller justerats korrekt med LDR.

När detta steg är problemfritt går systemet till standby-läge och visar “-system standby-“. Vid denna tidpunkt kan användaren aktivera installationen genom att trycka på tryckknappen när som helst.

När man trycker på tryckknappen är systemet redo att upptäcka rörelse från användaren och visar “Systemet är klart”.

Löparen kan vara några centimeter från start-lasern.

Om 'start' -lasern avbryts börjar tiden räknas och displayerna 'Time is calcular ……' Tiden beräknas i bakgrunden.

Den förflutna tiden visas inte förrän löparen når / avbryter 'stopp' -lasern. Detta beror på att för att visa den förflutna tiden på LCD som traditionellt stoppur, krävs flera ytterligare instruktioner i mikrokontrollen, vilket försämrar inställningens noggrannhet avsevärt.

OBS: Tryck på återställningsknappen på arduino för att rensa avläsningarna.

Hur man ställer in kretsen på löparbana:

Använd tjocka ledningar för att ansluta mellan LDR-enheter och arduino-kretsar eftersom avståndet mellan dessa två kan vara flera meter från varandra och spänningen inte får sjunka avsevärt. Avståndet mellan LDR1 och LDR2 kan vara maximalt några hundra meter.

Hur man monterar LDR:

LDR måste monteras inuti ihåligt ogenomskinligt rör och den främre delen måste också täckas och endast ett hål med några millimeter i diameter görs för att laserstrålen ska kunna tränga in.

LDR måste skyddas från direkt solljus eftersom den inte kan skilja sig från laserstrålar och andra ljuskällor och kanske inte registrerar rörelse från användaren.

Programkod:

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

Författarens prototyp:

Uppgradering med en split timer-anläggning

Den föreslagna automatiska stoppurskretsen med delad timer är en förlängning av den automatiska stoppurskretsen, där stoppuret spårar tiden automatiskt så snart solo-löparen lämnar startpunkten och timern stannar och visar den förflutna tiden när löparen når slutpunkten.

Introduktion

Detta projekt föreslogs av en av de ivriga läsarna på webbplatsen Andrew Walker.

I det här projektet introducerar vi ytterligare 4 LDR: er för att mäta deltidens löptid. Det finns totalt 6 LDR-enheter som alla kan placeras i löparbanan med jämnt avstånd mellan dem eller beroende på omständigheter och användarens val.

Det mesta av hårdvaran hålls oförändrad förutom tillägget av 4 LDR, men koden har genomgått enorma modifieringar.

Schematisk bild som visar delad tid:

Ovanstående krets består av få komponenter och nybörjarvänlig. Ingen ytterligare förklaring krävs, bara kabel enligt kretsschemat.

Hur man kopplar LDR:

LDR 2 visas på huvudkretsschemat och anslut ytterligare 4 LDR parallellt som visas i ovanstående diagram.

Layoutdiagram:

Ovanstående är det grundläggande arrangemanget för hur du placerar lasern. Observera att avståndet mellan LDR kan vara användarens val beroende på spårlängd.

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

Hur man använder detta automatiska stoppur:

• När installationen är klar, slå först på lasrarna och sätt sedan på Arduino-kretsen.
• Om alla lasrar är korrekt inriktade med LDR: er kommer inte felmeddelanden att visas på skärmen. Om någon, vänligen justera dem ordentligt.
• Nu visar kretsen “System is standby”. Tryck nu på 'start' -knappen så visas 'Systemet är klart'.
• Vid denna tidpunkt när solospelaren avbryter LDR 1-ljusstrålen, startar timern och den visar 'Tiden beräknas ...'.
• Så snart spelaren når slutpunkten, dvs. LDR 6, stannar timern och den visar den 5 delningstiden som registrerats av kretsen.
• Användaren måste trycka på återställningsknappen på arduino för att återställa timern.
Varför kan det här automatiska stoppuret inte visa live timing på skärmen som traditionellt stoppur (utan snarare visar den en statisk text 'Tiden beräknas ...'.)?
För att visa tidpunkten i realtid måste Arduino utföra ytterligare instruktioner till LCD-skärmen. Detta kommer att lägga till några mikrosekunder till några millisekunder fördröjning av huvudtidsspårningskoden, vilket leder till felaktiga resultat.

Om du har ytterligare frågor, vänligen uttryck genom kommentarsektionen.