Oprettelse af et automatisk stopur til løbere, atleter og sportspersoner

I dette indlæg skal vi konstruere et stopur, der automatisk starter timeren, når løberen begynder at løbe, og timeren stopper, når løberen når slutningen. Den forløbne tid mellem start- og slutpunkt vises på en 16 x 2 LCD.

Lad os først begynde med at lære at konfigurere et simpelt og ekstremt nøjagtigt Arduino stopur-kredsløb.

Et stopur er en manuelt styret tidsurindretning designet til at måle den tid, der muligvis er gået startende fra et bestemt tidspunkt, da den blev aktiveret, og da den endelig blev deaktiveret. En større variant af den samme enhed kaldes stopuret, der bruges til at overvåge handlingen på afstand og normalt findes på sportsstadion osv.

Mekanisk vs elektronisk stopur

Tidligere var det traditionelle mekaniske håndholdte stopur mere almindeligt og brugt af alle til formålet.

I det mekaniske system havde vi to trykknapper til at udføre stopur-funktionerne. Én til at starte stopuret ved at trykke en gang, og til at stoppe tiden ved at trykke på den samme knap igen for at optage den forløbne tid .... den anden knap blev brugt til at nulstille uret til nul.

Mekanisk stopur arbejdede grundlæggende igennem fjederkraft, hvilket krævede tidsoprulning manuelt ved at dreje den givne riflede knap øverst på urenheden.

Men sammenlignet med de moderne digitale stopure kan de mekaniske typer betragtes som væsentligt primitive og unøjagtige inden for intervallet millisekunder.

Brug af en Arduino

Og i dag med fremkomsten af ​​mikrokontroller er disse stopure blevet ekstremt nøjagtige og pålidelige til mikrosekundområdet.

Arduino stopurskredsløb, der præsenteres her, er et af disse moderne mikrocontroller-drevne design, der er mest nøjagtigt, kan forventes at være på niveau med de kommercielle moderne stopur-gadgets.

Lad os lære at opbygge det foreslåede Arduino stopurskredsløb:

Du skal bruge følgende regning med materialer til konstruktionen:

Hardware krævet

Et Arduino LCD KeyPad Shield (SKU: DFR0009)

Et Arduino ONE-bræt

Et Arduino USB-kabel

Når du først har erhvervet ovennævnte materiale og tilsluttet dem med hinanden, handler det bare om at konfigurere følgende givne skitsekode på dit Arduino-kort og se magien ved stopur-funktionerne.

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

Tilføjelse af et 7-segment display

Lad os nu gå videre med detaljerne vedrørende konstruktion af et stopurskredsløb ved hjælp af 7-segment LED-skærm og Arduino. Vi vil undersøge begreberne relateret til afbrydelser og displaydriver-IC'er, der er afgørende for at forstå dette projekt. Dette projekt blev foreslået af hr. Abu-Hafss, som er en af ​​den ivrige læser på dette websted.

Som vi allerede ved, at Stopwatch er en enhed, der hjælper med at spore kort periode fra timer til millisekunder (for det meste). Næsten alle billige digitale armbåndsure udstyret med stopur-funktionalitet, men ingen af ​​ure kan give lysten til at lave en til os selv, og det er også enestående at finde et stopur med 7-segment LED-skærm.

Hr. Abu-Hafss foreslog os at designe et stopur med 4 skærme, to i minutter og to i sekunder (MM: SS) konfiguration. Men for de fleste af os er det muligvis ikke et gennemførligt design, så vi tilføjede yderligere to skærme i millisekundområdet, så det foreslåede design vil nu være i MM: SS: mS-konfiguration.

Hvis du bare har brug for MM: SS-konfiguration af en eller anden grund, behøver du ikke at forbinde millisekund 7-segmentskærme og dens driver-IC'er, hele kredsløbets funktionalitet er stadig upåvirket.

Kredsløbet:

Det foreslåede stopur består af seks IC 4026, der er syv segment displaydriver, seks 7 segment LED-skærme, et Arduino-kort, et par trykknapper og et par 10K-modstande.

Lad os nu forstå, hvordan man forbinder IC 4026 til 7 segment display.

7-segment displayet kan være en hvilken som helst almindelig katodevisning i enhver farve. 7-segment displayet kan let dræbes af 5V forsyning, så en 330 ohm modstand er obligatorisk på hvert segment af skærmen.

Lad os nu se pin-diagrammet for IC 4026:

• Stiften nr. 1 er urindgang.
• Stift nr. 2 er ur deaktiveret, det deaktiverer antallet på displayet, hvis denne pin er høj.
• Stift nr. 3 er displayaktiveret, hvis denne stift er lav, vil displayet blive afstemt og omvendt.
• Stiften nr. 5 er gennemført, som bliver høj, når IC tæller 10.
• Stifterne 6, 7, 9, 10, 11, 12, 13 er displayudgange.
• Stiften nr. 8 er GND.
• Stiften nr. 16 er Vcc.
• Stiften nr. 15 nulstilles, hvis vi hæver denne stift, bliver antallet til nul.
• Stifterne # 4 og # 14 bruges ikke.

Vis tilslutningsdiagram:

Enhver af GND-stifterne i 7-segmentet kan tilsluttes jorden. IC'en skal have strøm fra 5V forsyning eller Arduinos 5V output pin.

Ovenstående skema for kun en skærm, gentag det samme for fem andre skærme.

Her er resten af ​​skematisk:

Kredsløbet får muligvis strøm fra 9V batteri. Det er to knapper, der er angivet her, en til start af tiden og en anden til stop. Ved at trykke på reset-knappen på Arduino nulstilles tidstallet til nul på displayet.

De to trykknapper er forbundet til pin # 2 og # 3, som er hardwareafbrydelse af Arduino / Atmega328P mikrocontroller.

Lad os forstå, hvad afbrydelse er:

Der er to typer afbrydelser: hardwareafbrydelse og softwareafbrydelse. Her bruger vi kun hardwareafbrydelsen.

En afbrydelse er et signal til mikrokontrolleren, hvilket får mikrokontrolleren til at reagere straks på en begivenhed.

Der er kun to hardware-afbrydestifter i Arduino-kort med ATmega328P-mikrocontrollerstift nr. 2 og # 3. Arduino mega har mere end to hardware afbrydestifter.

Mikrocontrollerne kan ikke udføre to funktioner på samme tid. For eksempel kontrollere for knap tryk og tælle tal.

Mikrocontrollerne kan ikke udføre to begivenheder samtidigt, hvis vi skriver en kode til kontrol af knaptryk og tælling af numre, registreres knaptrykket kun, når mikrokontrolleren læser knappen tryk på detektering stykke kode, resten af ​​tiden (tæller numrene) knappen virker ikke.

Så der vil være forsinkelse i detektering af knaptrykket, og af en eller anden grund, hvis koden stoppes midlertidigt, bliver knaptrykket muligvis aldrig registreret. For at undgå denne slags problemer introduceres afbrydelse.

Afbrydelsessignalet får altid højeste prioritet, hovedfunktionen (kodelinjens hovedlinjer) standses og udfører funktionen (et andet stykke kode), der er tildelt den pågældende afbrydelse.

Dette er meget vigtigt for tidskritiske applikationer som stopur eller sikkerhedssystemer osv., Hvor processoren har brug for øjeblikkelig handling som reaktion på en begivenhed.

I Arduino tildeler vi hardwareafbrydelse som:

attachInterrupt (0, start, RISING)

• '0' betyder interruptnummeret nul (i mikrocontrollere starter alt fra nul), som er pin nr. 2.
• “Start” er navnet på afbrydelsesfunktionen, du kan navngive alt her.
• “RISING” hvis pin nr. 2 (som er interrupt nul) bliver høj, udføres interrupt-funktionen.

attachInterrupt (1, Stop, RISING)

• '1' betyder afbrydelse nummer et, der er pin nr. 3.
• 'Stop' er navnet på afbrydelsen.

Vi kan også erstatte “RISING” med “FALLING”, nu når afbrydelsesstiften går LAVT, udføres afbrydelsesfunktionen.

Vi kan også erstatte 'RISING' med 'CHANGE', nu når afbrydelsesstiften går fra høj til lav eller lav til høj, udføres afbrydelsesfunktionen.

Afbrydelsesfunktionen kan tildeles som følger:

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

{

// program her

}

Afbrydelsesfunktionen skal være kort som mulig, og forsinkelsesfunktionen () kan ikke bruges.

Det konkluderer, at hardwareafbrydelse af softwareafbrydelse relateret til Arduino vil blive forklaret i den kommende artikel.

Nu ved du, hvorfor vi forbandt start- og stop-trykknapperne for at afbryde stifter.

Forbind kredsløbet ifølge diagrammet, resten af ​​kredsløbet 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---------------//
Nu afsluttes koden.

Stopur specielt udviklet til Atheletes

Lad os endelig lære, hvordan ovenstående begreber faktisk opgraderes til atleter, der ønsker at udvikle deres løbeevner uden at være afhængige af andre for den nødvendige start og stoppe timeren / stopuret. Det er bedre at starte timeren automatisk ved at registrere din bevægelse end nogen, der starter / stopper stopuret, hvilket også kan tilføje deres reaktionstid.

BEMÆRK: Dette projekt er designet til at måle tiden mellem punkt 'A' til punkt 'B' dækket af EN bruger ad gangen.

Opsætningen består af to lasere placeret ved startpunktet og slutpunktet, to LDR'er er også placeret modsat to lasermoduler. Når atleten afbryder 'start' laseren begynder tiden at beregne, og når atleten når slutningen, afbryder 'slutter' laser og timeren stopper og viser den forløbne tid mellem to punkter. Dette er metoden, der bruges til at måle den forløbne tid i den foreslåede idé.

Lad os se på hver eneste komponent i kredsløbet i detaljer.

Komponenters arbejdsdetaljer

Kredsløbet holdes ret simpelt, det består af 16 x 2 LCD-modul, få modstande, to LDR'er og en trykknap.

Grænsefladen mellem LCD og arduino er standard, vi kan finde lignende forbindelser i mange andre LCD-baserede projekter.

To analoge ben A0 og A1 bruges til at detektere laserafbrydelser. Analog pin A2 er forbundet med trykknap, der bruges til at tilkoble stopuret.

Tre modstande, to 4,7K og en 10K er nedadgående modstande, som hjælper inputstifter med at holde sig lave.

10K potentiometer leveres til justering af kontrast i LCD-modul for optimal synlighed.

Det foreslåede kredsløb er designet med fejldetekteringsmekanisme til lasere. Hvis en af ​​laseren er fejl eller ikke er justeret korrekt med LDR, viser den en fejlmeddelelse på LCD-displayet.

· Hvis START-laser ikke fungerer, viser den '' start-laser virker ikke '

· Hvis STOP-laser ikke fungerer, vises 'stop-laser fungerer ikke'

· Hvis begge lasere ikke fungerer, viser den 'Begge lasere fungerer ikke'

· Hvis begge lasere fungerer korrekt, viser det 'Begge lasere fungerer fint'

Fejlmeddelelsen vises, indtil lasermodulet er rettet eller justeret korrekt med LDR.

Når dette trin er frit for problemer, går systemet i standbytilstand og viser “-system standby-“. På dette tidspunkt kan brugeren tilkoble opsætningen ved at trykke på trykknappen når som helst.

Én trykknap er trykket ned, systemet er klar til at registrere bevægelse fra brugeren og viser “Systemet er klar”.

Løberen kan være få centimeter fra 'start' laseren.

Hvis “start” laseren afbrydes, begynder tiden at tælle, og displayet viser “Tid beregnes ……” Tiden beregnes i baggrunden.

Den forløbne tid vises først, før løberen når / afbryder 'stop' -laseren. Dette skyldes, at visning af den forløbne tid på LCD, som traditionelt stopur, kræver, at der udføres flere yderligere instruktioner i mikrocontrolleren, hvilket forværrer opsætningsnøjagtigheden betydeligt.

BEMÆRK: Tryk på reset-knappen på arduino for at rydde aflæsningerne.

Sådan indstilles kredsløbet på løbebane:

Brug tykke ledninger til at forbinde mellem LDR'er og arduino-kredsløb, da afstanden mellem disse to kan være adskillige meter fra hinanden, og spændingen må ikke falde markant. Afstanden mellem LDR1 og LDR2 kan maksimalt være nogle få hundrede meter.

Sådan monteres LDR:

LDR skal monteres inde i et hul, uigennemsigtigt rør, og den forreste del skal også være tildækket, og kun et hul med få millimeter i diameter er lavet, så laserstrålen kan komme ind.

LDR skal beskyttes mod direkte sollys, da den ikke kan skelne fra laserstråle og anden lyskilde og muligvis ikke registrerer bevægelse fra brugeren.

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:

Opgradering med en split-timer-facilitet

Det foreslåede automatiske stopurskredsløb med split timer er en udvidelse af det automatiske stopurskredsløb, hvor stopuret sporer tiden automatisk, så snart solo-løberen forlader startpunktet, og timeren stopper og viser den forløbne tid, når løberen når slutpunktet.

Introduktion

Dette projekt blev foreslået af en af ​​de ivrige læsere af dette websted, Andrew Walker.

I dette projekt introducerer vi 4 flere LDR'er til at måle splitløbet for solo-løberen. Der er i alt 6 LDR'er, som alle kan placeres i løbebanen med ensartet afstand mellem dem eller afhængigt af omstændighederne og brugerens valg.

Det meste af hardwaren holdes uændret undtagen tilføjelsen af ​​4 LDR'er, men koden har gennemgået enorme ændringer.

Skematisk diagram, der viser deltid:

Ovenstående kredsløb består af få komponenter og nybegyndervenlig. Der kræves ingen yderligere forklaring, bare ledning i henhold til kredsløbsdiagrammet.

Sådan tilsluttes LDR'er:

LDR 2 er vist på hovedkredsløbsdiagrammet, og tilslut yderligere 4 LDR'er parallelt som vist i ovenstående diagram.

Layoutdiagram:

Ovenstående er det grundlæggende arrangement for, hvordan laseren placeres. Bemærk, at afstanden mellem LDR'er kan vælges af brugeren afhængigt af sporets længde.

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

Sådan betjenes dette automatiske stopur:

• Når du er færdig med opsætningen, skal du tænde laserne først og derefter tænde for Arduino-kredsløbet.
• Hvis alle lasere er korrekt justeret med LDR'er, vil displayet ikke bede om fejlmeddelelser. Hvis nogen, bedes du justere dem korrekt.
• Nu viser kredsløbet 'System er standby'. Tryk nu på “start” -knappen, så vises “Systemet er klar”.
• På dette tidspunkt når solospilleren afbryder LDR 1-lysstrålen, starter timeren, og den viser 'Tid beregnes ...'.
• Så snart afspilleren når slutpunktet, dvs. LDR 6, stopper timeren, og den viser 5 split-tid registreret af kredsløbet.
• Brugeren skal trykke på nulstillingsknappen på arduinoen for at nulstille timeren.
Hvorfor kan dette automatiske stopur ikke vise live timing på skærmen, som traditionelt stopur gør (men det viser snarere en statisk tekst 'Tid beregnes….')?
For at vise timingen i realtid skal Arduino udføre yderligere instruktioner til LCD-skærm. Dette vil tilføje få mikrosekunder til få millisekunder forsinkelse til det vigtigste tidssporingsstykke kode, hvilket vil føre til unøjagtige resultater.

Hvis du har yderligere spørgsmål, bedes du udtrykke gennem kommentarsektionen.