Tvorba automatických stopiek pre bežcov, športovcov a športovcov

V tomto príspevku zostrojíme stopky, ktoré automaticky spustia časovač, keď bežec začne bežať, a časovač sa zastaví, keď bežec dosiahne koniec. Uplynulý čas medzi začiatočným a konečným bodom sa zobrazuje na displeji 16 x 2.

Najprv sa začneme učiť, ako nakonfigurovať jednoduchý a mimoriadne presný obvod stopiek Arduino.

Stopky sú ručne ovládané časové hodiny určené na meranie času, ktorý mohol uplynúť od určitého okamihu, keď boli aktivované, a do času, keď boli nakoniec deaktivované. Väčší variant rovnakého zariadenia sa nazýva stopky, ktoré sa používajú na sledovanie akcie z diaľky a bežne sa nachádzajú na športovom štadióne atď.

Mechanické vs elektronické stopky

Predtým boli tradičné mechanické ručné stopky bežnejšie a používali ich všetci na tento účel.

V mechanickom systéme sme mali dve stlačovacie tlačidlá na vykonávanie funkcií stopiek. Jedno na spustenie stopiek jedným stlačením a na zastavenie času opätovným stlačením rovnakého tlačidla na zaznamenanie uplynulého času .... druhé tlačidlo sa použilo na vynulovanie hodín.

Mechanické stopky v zásade fungovali prostredníctvom pružinového napájania, ktoré vyžadovalo periódu manuálneho navíjania otáčaním daného vrúbkovaného gombíka v hornej časti hodinového zariadenia.

Avšak v porovnaní s modernými digitálnymi stopkami možno mechanické typy považovať za výrazne primitívne a nepresné v rozmedzí milisekúnd.

Používanie Arduina

A dnes s príchodom mikrokontroléra sa tieto stopky stali mimoriadne presnými a spoľahlivými v rozsahu mikrosekúnd.

Obvod stopiek Arduino, ktorý je tu predstavený, je jedným z týchto moderných mikroprocesorových napájacích prvkov, ktorý je najpresnejší a dá sa očakávať, že bude na rovnakej úrovni s komerčnými modernými pomôckami pre stopky.

Naučme sa, ako zostaviť navrhovaný obvod zastavenia hodín Arduino:

Na stavbu budete potrebovať nasledujúci kusovník:

Vyžaduje sa hardvér

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

Doska Arduino ONE

Kábel USB Arduino

Akonáhle získate vyššie uvedený materiál a spojíte ich navzájom, je to len o konfigurácii nasledujúceho kódu náčrtu do vašej dosky Arduino a sledujte kúzlo funkcií stop hodín.

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

Pridanie 7-segmentového displeja

Teraz pokračujme podrobnosťami o konštrukcii obvodu stopiek pomocou 7 segmentového LED displeja a Arduina. Budeme skúmať koncepty súvisiace s prerušeniami a integrovanými obvodmi ovládača displeja, ktoré sú zásadné pre pochopenie tohto projektu. Tento projekt navrhol pán Abu-Hafss, ktorý je jedným z vášnivých čitateľov tejto webovej stránky.

Ako už vieme, stopky sú zariadenie, ktoré pomáha sledovať krátke časové obdobie (väčšinou) od hodín do milisekúnd. Takmer všetky lacné digitálne náramkové hodinky vybavené stopkami, ale žiadne z nich nedokážu dodať šmrnc tomu, aby si ich vyrobili sami, a tiež nájsť stopky so 7-segmentovým LED displejom, je výnimočné.

Pán Abu-Hafss nám navrhol, aby sme navrhli stopky so 4 displejmi, dva na minúty a dva na sekundy (MM: SS). Pre väčšinu z nás to však nemusí byť uskutočniteľný dizajn, preto sme pridali ďalšie dva displeje pre milisekundový rozsah, takže navrhovaný dizajn bude teraz v konfigurácii MM: SS: mS.

Ak z nejakého dôvodu potrebujete iba konfiguráciu MM: SS, nemusíte pripájať segmentové displeje milisekundového rozsahu so 7 segmentmi a integrované obvody ovládača, takže celá funkčnosť obvodu zostane nedotknutá.

Obvod:

Navrhované stopky pozostávajú zo šiestich IC 4026, čo je sedem segmentový ovládač displeja, šesť 7 segmentových LED displejov, jedna doska Arduino, pár tlačidiel a pár 10K rezistorov.

Teraz poďme pochopiť, ako pripojiť IC 4026 k 7-segmentovému displeju.

Sedemsegmentový displej môže byť akýkoľvek bežný katódový displej akejkoľvek farby. Sedemsegmentový displej sa dá ľahko zabiť napájaním 5 V, takže na každom segmente displeja je povinný odpor 330 ohmov.

Teraz si pozrime pinový diagram IC 4026:

• Pin č. 1 je vstup hodín.
• Pin č. 2 je deaktivovaný taktom, deaktivuje počet na displeji, ak je tento pin vysoký.
• Pin # 3 je povolený displej, ak je tento pin nízky, displej sa vyladí a naopak.
• Pin č. 5 je prevedenie, ktoré sa stane vysokým, keď IC počíta 10.
• Kolíky 6, 7, 9, 10, 11, 12, 13 sú výstupy na displej.
• Kolík # 8 je GND.
• Pin # 16 je Vcc.
• Pin # 15 sa resetuje, ak tento pin zvýšime, počet sa zmení na nulu.
• Kolíky # 4 a # 14 sa nepoužívajú.

Schéma zapojenia displeja:

Ktorýkoľvek z pinov GND 7 segmentového displeja môže byť pripojený k zemi. Integrovaný obvod musí byť napájaný z 5V napájacieho zdroja alebo z 5V výstupného kolíka Arduina.

Vyššie uvedená schéma iba pre jeden displej, to isté opakujte pre päť ďalších displejov.

Tu je zvyšok schémy:

Obvod môže byť napájaný z 9V batérie. Sú to dve tlačidlá, ktoré sú tu poskytnuté, jedno na nastavenie času a druhé na zastavenie. Stlačením resetovacieho tlačidla na Arduine sa na displeji vynuluje čas.

Dve tlačidlá sú pripojené k pinom # 2 a # 3, ktoré sú hardvérovým prerušením mikrokontroléra Arduino / Atmega328P.

Poďme pochopiť, čo je prerušenie:

Existujú dva typy prerušenia: hardvérové ​​prerušenie a softvérové ​​prerušenie. Tu používame iba hardvérové ​​prerušenie.

Prerušenie je signál do mikrokontroléra, vďaka ktorému bude mikrokontrolér okamžite reagovať na udalosť.

Na doskách Arduino s pinmi mikrokontroléra ATmega328P č. 2 a # 3 sú iba dva piny na prerušenie hardvéru. Arduino mega má viac ako dva piny hardvérového prerušenia.

Mikrokontroléry nemôžu vykonávať dve funkcie súčasne. Napríklad kontrola stlačenia tlačidla a počítanie čísel.

Mikrokontroléry nemôžu vykonávať dve udalosti súčasne, ak napíšeme kód na kontrolu stlačenia tlačidla a počítanie čísel, stlačenie tlačidla sa zistí, až keď mikrokontrolér načíta časť kódu na detekciu stlačenia tlačidla, zvyšok času (počíta čísla) tlačidlo nefunguje.

Takže dôjde k oneskoreniu detekcie stlačenia tlačidla a z nejakého dôvodu, ak sa kód dočasne zastaví, sa stlačenie tlačidla nemusí nikdy zistiť. Aby sa zabránilo týmto druhom problémov, zavádza sa prerušenie.

Signálu prerušenia má vždy najvyššiu prioritu, hlavná funkcia (hlavné riadky kódu) bude zastavená a vykoná funkciu (ďalšia časť kódu) priradená k danému prerušeniu.

To je veľmi dôležité pre časovo dôležité aplikácie, ako sú stopky alebo zabezpečovacie systémy atď., Kde procesor musí okamžite reagovať na udalosť.

V Arduine priradíme hardvérové ​​prerušenie ako:

attachInterrupt (0, štart, RISING)

• „0“ znamená číslo prerušenia nula (v mikrokontroléroch všetko začína od nuly), čo je pin # 2.
• „Start“ je názov funkcie prerušenia, tu môžete pomenovať čokoľvek.
• “RISING”, ak je pin # 2 (ktorý je prerušením nula) vysoký, vykoná sa funkcia prerušenia.

attachInterrupt (1, Stop, RISING)

• „1“ znamená prerušenie číslo jedna, ktorým je pin # 3.
• „Stop“ je názov prerušenia.

Môžeme tiež nahradiť „RISING“ za „FALLING“, teraz keď pin prerušenia klesne na LOW, funkcia prerušenia sa vykoná.

Môžeme tiež nahradiť „RISING“ za „CHANGE“, teraz, kedykoľvek sa pin prerušenia zmení z vysokého na nízky alebo z nízkeho na vysoký, vykoná sa funkcia prerušenia.

Funkciu prerušenia je možné priradiť nasledovne:

void start () // start je názov prerušenia.

{

// program tu

}

Funkcia prerušenia musí byť čo najkratšia a funkciu delay () nie je možné použiť.

Záver o tom, že hardvérové ​​prerušenie softvérového prerušenia týkajúceho sa Arduina bude vysvetlené v budúcom článku.

Teraz viete, prečo sme pripojili tlačidlá štart a stop na prerušenie pinov.

Pripojte obvod podľa schémy, zvyšok obvodu je zrejmý.

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ýmto sa kód uzatvára.

Stopky špeciálne vyvinuté pre Atheletes

Na záver sa naučme, ako môžu byť vyššie uvedené koncepty skutočne vylepšené pre športovcov, ktorí chcú rozvíjať svoje bežecké schopnosti bez toho, aby boli závislí od ostatných, aby mohli spustiť a zastaviť časovač / stopky. Je lepšie automaticky spustiť časovač na základe detekcie vášho pohybu ako niekto, kto spustí / zastaví stopky, čo môže tiež pridať ich reakčný čas.

POZNÁMKA: Tento projekt je určený na meranie času medzi bodom „A“ a bodom „B“, ktorý pokrýva JEDEN používateľ naraz.

Zostava sa skladá z dvoch laserov umiestnených v počiatočnom a koncovom bode, dva LDR sú tiež umiestnené oproti dvom laserovým modulom. Keď športovec preruší „štartovací“ laser, začne sa počítať čas a keď športovec dosiahne koniec, preruší sa „končiaci sa“ laser a časovač sa zastaví a zobrazí uplynulý čas medzi dvoma bodmi. Toto je metóda použitá na meranie uplynulého času v navrhovanej myšlienke.

Pozrime sa podrobne na všetky komponenty obvodu.

Pracovné podrobnosti komponentov

Obvod je udržiavaný pomerne jednoduchý, skladá sa z 16 x 2 LCD modulu, niekoľkých rezistorov, dvoch LDR a tlačidla.

Rozhranie medzi LCD a Arduino je štandardné, podobné spojenie môžeme nájsť v mnohých ďalších projektoch založených na LCD.

Na detekciu prerušenia laserom sa používajú dva analógové kolíky A0 a A1. Analógový pin A2 je spojený s tlačidlom, ktoré slúži na zapnutie stopiek.

Tri odpory, dva 4,7 000 a jeden 10 000 sú rozporové odpory, ktoré pomáhajú vstupným pinom zostať na nízkej úrovni.

10K potenciometer je určený na nastavenie kontrastu v LCD module pre optimálnu viditeľnosť.

Navrhovaný obvod je navrhnutý s mechanizmom detekcie porúch pre lasery. Ak je niektorý z laserov chybný alebo nie je správne zarovnaný s LDR, zobrazí sa na LCD displeji chybové hlásenie.

· Ak laser START nefunguje, zobrazí sa hlásenie „laser start“ nefunguje “

· Ak laser STOP nefunguje, zobrazí sa hlásenie „laser stop“ nefunguje “.

· Ak obidva lasery nefungujú, zobrazí sa správa „Oba lasery nepracujú“

· Ak obidva lasery fungujú správne, zobrazí sa správa „Oba lasery fungujú dobre“

Chybové hlásenie sa zobrazuje, kým nie je laserový modul zafixovaný alebo kým nie je správne vykonané vyrovnanie s LDR.

Len čo bude tento krok bezproblémový, systém prejde do pohotovostného režimu a zobrazí sa hlásenie „-system standby-“. V tomto okamihu môže užívateľ aktivovať nastavenie stlačením tlačidla kedykoľvek.

Jedným stlačením tlačidla je systém pripravený detekovať pohyb od používateľa a zobrazí sa hlásenie „Systém je pripravený“.

Bežec môže byť vzdialený pár centimetrov od „štartovacieho“ laseru.

Ak je laser „štart“ prerušený, začne sa počítať čas a na displeji sa zobrazí „Čas sa počíta ...“. Čas sa počíta v pozadí.

Uplynulý čas sa nebude zobrazovať, kým bežec nedosiahne / nepreruší laser „stop“. Je to tak preto, lebo zobrazenie uplynulého času na LCD ako tradičné stopky vyžaduje vykonanie niekoľkých ďalších pokynov v mikrokontroléri, čo výrazne zhoršuje presnosť nastavenia.

POZNÁMKA: Stlačením resetovacieho tlačidla na arduine vymažete namerané hodnoty.

Ako nastaviť okruh na bežeckú dráhu:

Na pripojenie medzi LDR a obvodom arduino použite hrubé vodiče, pretože vzdialenosť medzi týmito dvoma vodičmi môže byť od seba vzdialená niekoľko metrov a napätie nesmie výrazne klesnúť. Vzdialenosť medzi LDR1 a LDR2 môže byť maximálne niekoľko stoviek metrov.

Ako pripojiť LDR:

LDR musí byť namontovaný vo vnútri dutej nepriehľadnej trubice a predná časť musí byť tiež zakrytá a je vyrobený iba otvor s priemerom niekoľkých milimetrov, ktorý umožňuje vstup laserového lúča.

LDR musí byť chránený pred priamym slnečným žiarením, pretože sa nemôže líšiť od laserového lúča a iného zdroja svetla a nemusí zaregistrovať pohyb používateľa.

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

Autorský prototyp:

Aktualizácia pomocou nástroja Split Timer

Navrhovaný obvod automatických stopiek s deleným časovačom je rozšírením obvodu automatických stopiek, kde stopky automaticky sledujú čas, akonáhle sólo bežec opustí počiatočný bod a časovač sa zastaví a zobrazí uplynulý čas, keď bežec dosiahne koncový bod.

Úvod

Tento projekt navrhol jeden z vášnivých čitateľov tohto webu Andrew Walker.

V tomto projekte predstavujeme ďalšie 4 LDR na meranie medzičasu sólo bežca. Celkovo je 6 LDR, všetky môžu byť umiestnené na bežeckej dráhe s rovnakou vzdialenosťou medzi nimi alebo v závislosti od okolností a voľby používateľa.

Väčšina hardvéru je ponechaná nezmenená, okrem pridania 4 LDR, ale kód prešiel obrovskou úpravou.

Schematický diagram zobrazujúci medzičas:

Vyššie uvedený okruh sa skladá z niekoľkých komponentov a je vhodný pre začiatočníkov. Nie je potrebné ďalšie vysvetlenie, stačí zapojiť vodič podľa schémy zapojenia.

Ako zapojiť LDR:

LDR 2 je zobrazený na hlavnej schéme zapojenia zapojte paralelne ďalšie 4 LDR, ako je to znázornené na schéme vyššie.

Schéma rozloženia:

Vyššie je uvedené základné usporiadanie, ako umiestniť laser. Upozorňujeme, že vzdialenosť medzi LDRs si môže používateľ zvoliť v závislosti od dĺžky 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-------//

Ako ovládať tieto automatické stopky:

• Po dokončení nastavenia najskôr zapnite lasery a potom zapnite obvod Arduino.
• Ak sú všetky lasery správne zarovnané s LDR, na displeji sa nezobrazia chybové správy. Ak existujú, správne ich zarovnajte.
• Teraz obvod zobrazuje „Systém je v pohotovostnom režime“. Teraz stlačte tlačidlo „Štart“ a zobrazí sa „Systém je pripravený“.
• V tomto okamihu, keď sólový hráč preruší svetelný lúč LDR 1, spustí sa časovač a zobrazí „Čas sa počíta ...“.
• Hneď ako hráč dosiahne koncový bod, tj. LDR 6, časovač sa zastaví a zobrazí 5 medzičasov zaznamenaných obvodom.
• Používateľ musí stlačiť resetovacie tlačidlo na arduine, aby vynuloval časovač.
Prečo tieto automatické stopky nemôžu zobrazovať živé časovanie na displeji tak, ako to robia tradičné stopky (skôr zobrazuje statický text „Čas sa počíta ...“)?
Na zobrazenie času v reálnom čase musí Arduino vykonať ďalšie pokyny k LCD displeju. Týmto sa do hlavnej časti kódu na sledovanie času pridá niekoľko mikrosekúnd až niekoľko milisekúnd oneskorených, čo povedie k nepresným výsledkom.

Ak máte ďalšie otázky, obráťte sa na komentár.