Vytváření automatických stopek pro běžce, sportovce a sportovce

V tomto příspěvku vytvoříme stopky, které automaticky spustí časovač, když běžec začne běžet, a časovač se zastaví, když běžec dosáhne konce. Uplynulý čas mezi počátečním a koncovým bodem je zobrazen na LCD 16 x 2.

Nejprve začneme tím, že se naučíme konfigurovat jednoduchý a extrémně přesný obvod stopek Arduino.

Stopky jsou ručně ovládané hodinové zařízení určené k měření doby, která mohla uplynout od určitého okamžiku, kdy byla aktivována, a v době, kdy byla nakonec deaktivována. Větší varianta stejného zařízení se nazývá stopky, které se používají k monitorování akce z dálky a běžně se nacházejí na sportovním stadionu atd.

Mechanické vs elektronické stopky

Dříve byly tradiční mechanické ruční stopky běžnější a všichni je pro tento účel používali.

V mechanickém systému jsme měli dvě tlačítka pro provádění funkcí stopek. Jedno pro spuštění stop hodin jedním stisknutím a pro zastavení času dalším stisknutím stejného tlačítka pro záznam uplynulého času .... druhé tlačítko bylo použito pro resetování hodin zpět na nulu.

Mechanické stopky v zásadě fungovaly prostřednictvím síly pružiny, což vyžadovalo ruční navíjení periody otáčením daného vroubkovaného knoflíku v horní části hodinového zařízení.

Ve srovnání s moderními digitálními stopkami však lze mechanické typy považovat za výrazně primitivní a nepřesné v rozsahu milisekund.

Používání Arduina

A dnes s příchodem mikrokontroléru se tyto stopky staly extrémně přesnými a spolehlivými v rozsahu mikrosekund.

Zde prezentovaný obvod stopek Arduino je jedním z těchto moderních designů napájených mikrokontroléry, který je nejpřesnější a lze očekávat, že bude na stejné úrovni jako komerční moderní gadgety stopek.

Naučme se, jak sestavit navrhovaný obvod stop hodin Arduino:

Pro stavbu budete potřebovat následující kusovník:

Je vyžadován hardware

Štítek LCD klávesnice Arduino (SKU: DFR0009)

Deska Arduino ONE

Kabel USB Arduino

Jakmile jste získali výše uvedený materiál a spojili je navzájem, je to jen o konfiguraci následujícího daného kódu skici do vaší desky Arduino a sledovat kouzlo funkcí stop hodin.

Kód

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

Přidání 7segmentového displeje

Nyní pokračujme podrobnostmi týkajícími se konstrukce obvodu stopek pomocí 7 segmentového LED displeje a Arduina. Budeme zkoumat koncepty související s přerušeními a integrovanými obvody ovladače displeje, které jsou zásadní pro pochopení tohoto projektu. Tento projekt navrhl pan Abu-Hafss, který je jedním z vášnivých čtenářů tohoto webu.

Jak již víme, stopky jsou zařízení, které pomáhá sledovat krátké časové období od hodin do milisekund (většinou). Téměř všechny levné digitální náramkové hodinky vybavené funkcí stopek, ale žádné z hodinek nemohou dát chuť udělat si něco pro sebe a najít stopky se 7segmentovým LED displejem je výjimečné.

Pan Abu-Hafss nám navrhl, abychom navrhli stopky se 4 displeji, dva na minuty a dva na sekundy (MM: SS). Ale pro většinu z nás to nemusí být proveditelný design, a tak jsme přidali další dva displeje pro milisekundový rozsah, takže nyní bude navrhovaný design v konfiguraci MM: SS: mS.

Pokud z nějakého důvodu potřebujete pouze konfiguraci MM: SS, nemusíte připojovat 7segmentové displeje milisekundového rozsahu a jeho integrované obvody ovladače, celá funkčnost obvodu zůstane nedotčena.

Obvod:

Navrhované stopky se skládají ze šesti IC 4026, což je sedm segmentový ovladač displeje, šest 7 segmentových LED displejů, jedna deska Arduino, pár tlačítek a pár 10K rezistorů.

Nyní pochopíme, jak připojit IC 4026 k 7segmentovému displeji.

Sedmisegmentový displej může být jakýkoli běžný katodový displej jakékoli barvy. Sedmisegmentový displej může být snadno zabit napájením 5V, takže na každém segmentu displeje je povinný odpor 330 ohmů.

Nyní se podívejme na pinový diagram IC 4026:

• Pin # 1 je hodinový vstup.
• Pin # 2 je deaktivace hodin, deaktivuje počet na displeji, pokud je tento pin vysoký.
• Pin # 3 je povolit zobrazení, pokud je tento pin nízký, displej se vyladí a naopak.
• Pin # 5 je provedení, které se zvýší, když IC počítá 10.
• Kolíky 6, 7, 9, 10, 11, 12, 13 jsou výstupy displeje.
• Kolík # 8 je GND.
• Pin # 16 je Vcc.
• Pin # 15 se resetuje, pokud tento pin zvýšíme, počet se změní na nulu.
• Kolíky # 4 a # 14 se nepoužívají.

Zobrazit schéma zapojení:

K zemi lze připojit kterýkoli z pinů GND 7 segmentového displeje. Integrovaný obvod musí být napájen z 5V napájení nebo z 5V výstupního kolíku Arduina.

Výše uvedené schéma pouze pro jeden displej, opakujte to samé pro pět dalších displejů.

Zde je zbytek schématu:

Obvod může být napájen z 9V baterie. Jedná se o dvě tlačítka, která jsou zde k dispozici, jedno pro spuštění času a druhé pro zastavení. Stisknutím tlačítka reset na Arduinu se na displeji vynuluje čas.

Dvě tlačítka jsou připojena k pinům # 2 a # 3, což jsou hardwarová přerušení mikrokontroléru Arduino / Atmega328P.

Pojďme pochopit, co je to přerušení:

Existují dva typy přerušení: hardwarové přerušení a softwarové přerušení. Zde používáme pouze hardwarové přerušení.

Přerušení je signál do mikrokontroléru, díky němuž bude mikrokontrolér okamžitě reagovat na událost.

Na deskách Arduino s kolíky mikrokontroléru ATmega328P č. 2 a # 3 jsou pouze dva piny hardwarového přerušení. Arduino mega má více než dva piny hardwarového přerušení.

Mikrokontroléry nemohou dělat dvě funkce současně. Například kontrola stisknutí tlačítka a počítání čísel.

Mikrokontroléry nemohou provádět dvě události současně, pokud napíšeme kód pro kontrolu stisknutí tlačítka a počítání čísel, stisk tlačítka bude detekován pouze tehdy, když mikrokontrolér přečte část kódu detekující stisknutí tlačítka, zbytek času (spočítá čísla) tlačítko nefunguje.

Dojde tedy ke zpoždění detekce stisknutí tlačítka az nějakého důvodu, pokud dojde k dočasnému zastavení kódu, může dojít k detekci stisknutí tlačítka nikdy. Aby se předešlo těmto problémům, je zavedeno přerušení.

Signálu přerušení má vždy nejvyšší prioritu, hlavní funkce (hlavní řádky kódu) bude zastavena a provede funkci (další část kódu) přiřazenou k danému přerušení.

To je velmi důležité pro časově kritické aplikace, jako jsou stopky nebo bezpečnostní systémy atd., Kde procesor musí okamžitě reagovat na událost.

V Arduinu přiřadíme hardwarové přerušení jako:

attachInterrupt (0, start, RISING)

• „0“ znamená číslo přerušení nula (v mikrokontrolérech vše začíná od nuly), což je pin # 2.
• „Start“ je název funkce přerušení, zde můžete pojmenovat cokoli.
• “RISING” pokud pin # 2 (který je přerušení nula) jde vysoko, provede se funkce přerušení.

attachInterrupt (1, Stop, RISING)

• „1“ znamená přerušení číslo jedna, kterým je pin # 3.
• „Stop“ je název přerušení.

Můžeme také nahradit „RISING“ výrazem „FALLING“, nyní, když pin přerušení klesne na LOW, funkce přerušení se spustí.

Můžeme také nahradit „RISING“ slovem „CHANGE“, nyní, kdykoli se pin přerušení změní z vysoké na nízkou nebo nízkou na vysokou, provede se funkce přerušení.

Funkci přerušení lze přiřadit takto:

void start () // start je název přerušení.

{

// program zde

}

Funkce přerušení musí být co nejkratší a funkci delay () nelze použít.

Závěr o hardwarovém přerušení softwarového přerušení souvisejícího s Arduino bude vysvětlen v dalším článku.

Nyní víte, proč jsme připojili tlačítka start a stop k přerušení pinů.

Připojte obvod podle schématu, zbytek obvodu je vysvětlující.

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---------------//
Tím je kód uzavřen.

Stopky speciálně vyvinuté pro Atheletes

Nakonec se pojďme naučit, jak lze výše uvedené koncepty ve skutečnosti upgradovat pro sportovce, kteří chtějí rozvíjet své běžecké dovednosti, aniž by se museli spoléhat na ostatní pro nezbytné spuštění a zastavení časovače / stopek. Je lepší automaticky spouštět časovač detekcí vašeho pohybu než někdo, kdo spouští / zastavuje stopky, což může také přidat jejich reakční čas.

POZNÁMKA: Tento projekt je určen k měření času mezi bodem „A“ a bodem „B“, který pokrývá JEDEN uživatel najednou.

Nastavení se skládá ze dvou laserů umístěných v počátečním a koncovém bodě, dva LDR jsou také umístěny naproti dvěma laserovým modulům. Když sportovec přeruší „startovací“ laser, začne se počítat čas a když sportovec dosáhne konce, přeruší „končící“ laser a časovač se zastaví a zobrazí uplynulý čas mezi dvěma body. Toto je metoda používaná k měření uplynulého času v navrhovaném nápadu.

Podívejme se podrobně na všechny komponenty obvodu.

Podrobnosti o fungování komponent

Obvod je poměrně jednoduchý, sestává z 16 x 2 LCD modulu, několika odporů, dvou LDR a tlačítka.

Rozhraní mezi LCD a Arduino je standardní, podobné spojení najdeme v mnoha dalších projektech založených na LCD.

K detekci laserových přerušení se používají dva analogové piny A0 a A1. Analogový pin A2 je spojen s tlačítkem, které slouží k zapnutí stopek.

Tři rezistory, dva 4,7K a jeden 10K jsou stahovací rezistory, které pomáhají vstupním pinům zůstat na nízké úrovni.

10K potenciometr je k dispozici pro nastavení kontrastu v LCD modulu pro optimální viditelnost.

Navrhovaný obvod je navržen s mechanismem detekce poruch laserů. Pokud je některý z laserů vadný nebo není správně vyrovnán s LDR, zobrazí se na LCD displeji chybové hlášení.

· Pokud laser START nefunguje, zobrazí se „laser startu nefunguje“

· Pokud laser STOP nefunguje, zobrazí se „laser stop nefunguje“

· Pokud oba lasery nefungují, zobrazí se „Oba lasery nefungují“

· Pokud oba lasery fungují správně, zobrazí se „Oba lasery fungují dobře“

Chybová zpráva se zobrazuje, dokud nebude laserový modul zafixován nebo správně provedeno vyrovnání s LDR.

Jakmile bude tento krok bezproblémový, systém přejde do pohotovostního režimu a zobrazí „-systémový pohotovostní režim-“. V tomto okamžiku může uživatel aktivovat nastavení stisknutím tlačítka kdykoli.

Po stisknutí tlačítka je systém připraven detekovat pohyb od uživatele a zobrazí „Systém je připraven“.

Běžec může být několik palců od „startovacího“ laseru.

Pokud je laser „start“ přerušen, začne se počítat čas a zobrazí se „Čas se počítá ……“ Čas se počítá v pozadí.

Uplynulý čas se nezobrazí, dokud běžec nedosáhne / nepřeruší „stop“ laser. Je to proto, že zobrazení uplynulého času na LCD jako u tradičních stopek vyžaduje provedení několika dalších instrukcí v mikrokontroléru, což významně zhoršuje přesnost nastavení.

POZNÁMKA: Stisknutím tlačítka reset na arduino odečtete hodnoty.

Jak nastavit okruh na běžeckou dráhu:

Pro připojení mezi LDR a obvodem arduino použijte silné vodiče, protože vzdálenost mezi těmito dvěma může být několik metrů od sebe a napětí nesmí výrazně poklesnout. Vzdálenost mezi LDR1 a LDR2 může být maximálně několik stovek metrů.

Jak připojit LDR:

LDR musí být namontován uvnitř duté neprůhledné trubice a přední část musí být také zakryta a je vytvořen pouze otvor o průměru několika milimetrů pro umožnění vstupu laserového paprsku.

LDR musí být chráněn před přímým slunečním zářením, protože se nemůže odlišovat od laserového paprsku a jiného zdroje světla a nemusí registrovat pohyb uživatele.

Programový kód:

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

Autorův prototyp:

Aktualizace pomocí nástroje Split Timer

Navrhovaný obvod automatických stopek s časovačem je rozšířením obvodu automatických stopek, kde stopky automaticky sledují čas, jakmile sólo běžec opustí počáteční bod a časovač se zastaví a zobrazí uplynulý čas, když běžec dosáhne koncového bodu.

Úvod

Tento projekt navrhl jeden z nadšených čtenářů tohoto webu Andrew Walker.

V tomto projektu představujeme další 4 LDR pro měření mezičasu sólového běžce. Existuje celkem 6 LDR, všechny mohou být umístěny na běžecké trati s jednotnou vzdáleností mezi nimi nebo v závislosti na okolnostech a volbě uživatele.

Většina hardwaru zůstává nezměněna, kromě přidání 4 LDR, ale kód prošel obrovskou úpravou.

Schematický diagram ukazující mezičas:

Výše uvedený okruh se skládá z několika komponent a je vhodný pro začátečníky. Není třeba žádné další vysvětlení, stačí zapojit podle schématu zapojení.

Jak zapojit LDR:

LDR 2 je zobrazen na hlavním schématu zapojení paralelně připojte další 4 LDR, jak je uvedeno na výše uvedeném schématu.

Schéma rozložení:

Výše uvedené je základní uspořádání, jak umístit laser. Pamatujte, že vzdálenost mezi LDR může být zvolena uživatelem v závislosti na délce stopy.

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

Jak používat tyto automatické stopky:

• Po dokončení nastavení nejprve zapněte lasery a poté zapněte obvod Arduino.
• Pokud jsou všechny lasery správně zarovnány s LDR, displej nebude zobrazovat chybové zprávy. Pokud existují, správně je zarovnejte.
• Nyní obvod zobrazuje „Systém je v pohotovostním režimu“. Nyní stiskněte tlačítko „start“ a zobrazí se „Systém je připraven“.
• V tomto okamžiku, kdy sólový hráč přeruší světelný paprsek LDR 1, spustí se časovač a zobrazí „Čas se počítá ...“.
• Jakmile hráč dosáhne koncového bodu, tj. LDR 6, časovač se zastaví a zobrazí 5 mezičasů zaznamenaných okruhem.
• Uživatel musí stisknout resetovací tlačítko na arduinu, aby resetoval časovač.
Proč tyto automatické stopky nemohou zobrazovat živé časování na displeji jako tradiční stopky (spíše zobrazuje statický text „Čas se počítá ...“)?
Pro zobrazení časování v reálném čase musí Arduino provést další pokyny k LCD displeji. Tím se přidá několik mikrosekund ke zpoždění několika milisekund hlavní části kódu pro sledování času, což povede k nepřesným výsledkům.

Máte-li jakékoli další dotazy, vyjádřete to v sekci komentářů.