Padaryti automatinį chronometrą bėgikams, sportininkams ir sportininkams

Šiame įraše sukursime chronometrą, kuris automatiškai paleidžia laikmatį, kai bėgikas pradeda bėgti, ir laikmatis sustoja, kai bėgikas pasiekia pabaigą. Praėjęs laikas tarp pradžios ir pabaigos taškų rodomas 16 x 2 skystųjų kristalų ekrane.

Pirmiausia pradėkime nuo to, kaip išmokti sukonfigūruoti paprastą ir itin tikslią „Arduino“ chronometro grandinę.

Chronometras yra rankiniu būdu valdomas laiko laikrodis, skirtas matuoti laiką, kuris gali praeiti nuo tam tikro laiko momento, kai jis buvo įjungtas, ir iki to laiko, kai jis buvo galutinai išjungtas. Vadinamas didesnis to paties įrenginio variantas. sustabdymo laikrodis, naudojamas stebėti veiksmus iš tolo ir paprastai randamas sporto stadione ir kt.

Mechaninis ir elektroninis chronometras

Anksčiau tradiciniai mechaniniai rankiniai chronometrai buvo labiau paplitę ir visi buvo naudojami tam tikslui.

Mechaninėje sistemoje mes turėjome du paspaudimo mygtukus chronometro funkcijoms vykdyti. Vienas skirtas sustabdyti laikrodį, paspaudus vieną kartą, ir sustabdyti laiką dar kartą paspaudus tą patį mygtuką, norint įrašyti praėjusį laiką .... antrasis mygtukas buvo naudojamas laikrodžiui atstatyti į nulį.

Mechaninis sustabdymo laikrodis iš esmės veikė per spyruoklinę jėgą, kuriai reikalingas laikotarpis, kai reikia atsukti rankiniu būdu, sukant nurodytą rankenėlę laikrodžio viršuje.

Tačiau, palyginti su šiuolaikiniais skaitmeniniais laikrodžiais, mechaninius tipus milisekundžių diapazone galima laikyti žymiai primityviais ir netiksliais.

Naudojant „Arduino“

Ir šiandien, atsiradus mikrovaldikliui, šie laikrodžiai tapo itin tikslūs ir patikimi mikrosekundžių diapazone.

Čia pateikiama „Arduino“ chronometro grandinė yra viena iš šių modernių mikrovaldikliais varomų konstrukcijų, kuri yra tiksliausia, galima tikėtis, kad ji prilygs komercinėms šiuolaikinėms chronometrų programėlėms.

Sužinokime, kaip sukurti siūlomą „Arduino“ laikrodžio grandinę:

Jums reikės šios statybinių medžiagų sąskaitos:

Būtina aparatinė įranga

„Arduino“ LCD klaviatūros ekranas (SKU: DFR0009)

„Arduino ONE“ lenta

„Arduino“ USB kabelis

Įsigiję aukščiau pateiktą medžiagą ir susieję jas tarpusavyje, tiesiog sukonfigūruokite šį pateiktą eskizo kodą savo „Arduino“ lentoje ir stebėkite chronometro funkcijų magiją.

Kodas

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

7 segmentų ekrano pridėjimas

Dabar tęskime išsamią informaciją apie chronometro grandinės statybą naudojant 7 segmentų LED ekraną ir „Arduino“. Mes nagrinėsime sąvokas, susijusias su pertraukimais ir ekrano tvarkyklių IC, kurios yra labai svarbios norint suprasti šį projektą. Šį projektą pasiūlė ponas Abu-Hafssas, kuris yra vienas iš aistringų šios svetainės skaitytojų.

Kaip mes jau žinome, kad „Chronometras“ yra prietaisas, kuris padeda stebėti trumpą laiką nuo valandų iki milisekundžių (dažniausiai). Beveik visi pigūs skaitmeniniai rankiniai laikrodžiai, kuriuose yra chronometro funkcionalumas, tačiau nė vienas iš laikrodžių negali suteikti malonumo pasigaminti vieną sau ir taip pat rasti chronometrą su 7 segmentų LED ekranu yra išskirtinis.

Ponas Abu-Hafssas pasiūlė mums sukurti chronometrą su 4 ekranais: dviem minutėms ir dviem sekundėms (MM: SS). Tačiau daugumai iš mūsų tai gali būti neįmanomas dizainas, todėl pridėjome dar du ekranus milisekundžių diapazone, todėl dabar siūlomas dizainas bus MM: SS: mS konfigūracija.

Jei dėl kokių nors priežasčių jums tiesiog reikalinga MM: SS konfigūracija, jums nereikia prijungti 7 milisekundžių diapazono segmentų ekranų ir jų tvarkyklių IC, tai vis tiek nepakenks visos grandinės funkcijoms.

Grandinė:

Siūlomą chronometrą sudaro šeši IC 4026, kuris yra septynių segmentų ekrano tvarkyklė, šeši 7 segmentų LED ekranai, viena „Arduino“ plokštė, pora mygtukų ir pora 10K rezistorių.

Dabar supraskime, kaip prijungti IC 4026 prie 7 segmentų ekrano.

7 segmentų ekranas gali būti bet koks įprastas bet kurios spalvos katodo ekranas. 5 segmentų maitinimas gali lengvai užmušti 7 segmentų ekraną, todėl kiekviename ekrano segmente privalomas 330 omų rezistorius.

Dabar pažiūrėkime IC 4026 kaiščių schemą:

• Kaištis Nr. 1 yra laikrodžio įvestis.
• Kaištis Nr. 2 yra išjungtas pagal laikrodį, jis išjungia rodomą skaičių, jei šis kaištis yra aukštas.
• Kaištis Nr. 3 yra įjungiamas, jei šio kaiščio yra mažai, ekranas bus išjungtas ir atvirkščiai.
• Kaištis Nr. 5 yra vykdomas, kuris tampa aukštas, kai IC skaičiuoja 10.
• 6, 7, 9, 10, 11, 12, 13 kaiščiai yra ekrano išėjimai.
• Kaištis Nr. 8 yra GND.
• Kaištis Nr. 16 yra Vcc.
• Smeigtukas Nr. 15 nustatomas iš naujo, jei pakelsime šį kaištį, skaičius bus nulinis.
• Kaiščiai Nr. 4 ir Nr. 14 nenaudojami.

Rodyti ryšio schemą:

Bet kurį iš 7 segmentų ekrano GND kaiščio galima prijungti prie žemės. IC turi būti maitinamas iš 5 V maitinimo šaltinio arba „Arduino“ 5 V išvesties kaiščio.

Aukščiau pateikta schema, skirta tik vienam ekranui, pakartokite tą patį penkiems kitiems ekranams.

Čia yra likusi schema:

Grandinė gali būti maitinama iš 9 V baterijos. Čia yra du mygtukai, skirti pradėti laiką, o kiti - sustoti. Paspaudus atstatymo mygtuką „Arduino“ ekrane, laikas bus nulis.

Du mygtukai yra prijungti prie kaiščių Nr. 2 ir Nr. 3, kurie yra „Arduino“ / „Atmega328P“ mikrovaldiklio aparatinės įrangos pertraukimas.

Supraskime, kas yra pertraukimas:

Yra dviejų tipų pertraukimai: aparatinės įrangos ir programinės įrangos pertraukimai. Čia mes naudojame tik aparatūros pertraukimą.

Pertraukimas yra signalas mikrovaldikliui, kuris privers mikrovaldiklį nedelsiant reaguoti į įvykį.

„Arduino“ plokštėse yra tik du aparatūros pertraukimo kaiščiai su „ATmega328P“ mikrovaldiklio kaiščiais Nr. 2 ir Nr. 3. „Arduino mega“ turi daugiau nei du aparatūros pertraukimo kaiščius.

Mikrovaldikliai negali atlikti dviejų funkcijų vienu metu. Pavyzdžiui, patikrinti, ar nėra mygtuko paspaudimo, ir skaičiuoti skaičius.

Mikrovaldikliai negali įvykdyti dviejų įvykių vienu metu. Jei parašysime kodą mygtuko paspaudimui patikrinti ir skaičiuoti, mygtuko paspaudimas bus aptiktas tik tada, kai mikrovaldiklis perskaitys mygtuko paspaudimo aptikimo kodą, likusį laiką (skaičiuoja skaičius) mygtukas neveikia.

Taigi bus vėluojama nustatyti mygtuko paspaudimą ir dėl kokių nors priežasčių, jei kodas laikinai bus sustabdytas, mygtuko paspaudimas niekada nebus aptiktas. Siekiant išvengti tokio pobūdžio problemų, įvedamas pertraukimas.

Nutraukimo signalui visada teikiamas didžiausias prioritetas, pagrindinė funkcija (pagrindinės kodo eilutės) bus sustabdyta ir vykdys (dar vieną kodo dalį) funkciją, priskirtą tam konkrečiam pertraukimui.

Tai labai svarbu kritiškai svarbioms programoms, tokioms kaip chronometras, apsaugos sistemos ir pan., Kur procesorius turi nedelsdamas imtis veiksmų reaguodamas į įvykį.

„Arduino“ priskiriame aparatūros pertraukimą kaip:

attachInterrupt (0, pradžia, RISING)

• „0“ reiškia pertraukimo skaičių nulį (mikrovaldikliuose viskas prasideda nuo nulio), kuris yra kaištis Nr. 2.
• „Start“ yra pertraukimo funkcijos pavadinimas, čia galite įvardyti bet ką.
• „RISING“, jei kaištis Nr. 2 (kuris yra nulinis pertraukimo taškas) eina aukštai, vykdoma pertraukimo funkcija.

attachInterrupt (1, Stop, RISING)

• „1“ reiškia pirmąjį pertraukimo numerį, kuris yra kaištis Nr. 3.
• „Stop“ yra pertraukimo pavadinimas.

Mes taip pat galime pakeisti „RISING“ į „FALLING“, dabar, kai pertraukimo kaištis eina žemai, vykdoma pertraukimo funkcija.

Mes taip pat galime pakeisti „RISING“ į „CHANGE“. Dabar, kai pertraukimo kaištis eina iš aukšto į žemą arba žemą į aukštą, pertraukimo funkcija yra vykdoma.

Pertraukimo funkciją galima priskirti taip:

void start () // start yra pertraukimo pavadinimas.

{

// programa čia

}

Pertraukimo funkcija turi būti kuo trumpesnė, o atidėjimo () funkcija negali būti naudojama.

Tai daro išvadą, kad aparatinės įrangos pertraukimo programinės įrangos pertraukimas, susijęs su „Arduino“, bus paaiškintas būsimame straipsnyje.

Dabar jūs žinote, kodėl mes sujungėme pradžios ir sustabdymo mygtukus, kad nutrauktume kaiščius.

Prijunkite grandinę, kaip nurodyta schemoje, likusi grandinė yra savaime suprantama.

Programa:

//----------------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---------------//
Dabar kodas baigtas.

Chronometras specialiai sukurtas „Atheletes“

Galiausiai, sužinokime, kaip iš tikrųjų atnaujinti pirmiau minėtas sąvokas sportininkams, norintiems tobulinti savo bėgimo įgūdžius, nepriklausomai nuo kitų, norint pradėti ir sustabdyti laikmatį / chronometrą. Geriau automatiškai paleisti laikmatį, nustatant jūsų judesį, nei kažkas, kuris pradeda / sustabdo chronometrą, kuris taip pat gali pridėti jų reakcijos laiką.

PASTABA: Šis projektas skirtas matuoti laiką nuo taško „A“ iki taško „B“, kurį vienu metu dengia VIENAS vartotojas.

Sąranka susideda iš dviejų lazerių, išdėstytų pradžios ir pabaigos taškuose, du LDR taip pat dedami priešais du lazerinius modulius. Sportininkui nutraukus „startinį“ lazerį, laikas pradedamas skaičiuoti, o kai sportininkas pasiekia pabaigą, pertraukia „pabaigos“ lazerį ir laikmatis sustoja ir parodo praėjusį laiką tarp dviejų taškų. Tai yra metodas, naudojamas matuoti praeitą laiką siūlomoje idėjoje.

Pažvelkime į kiekvieną grandinės komponentą išsamiai.

Komponentų darbo informacija

Grandinė yra gana paprasta, ją sudaro 16 x 2 skystųjų kristalų modulis, keli rezistoriai, du LDR ir mygtukas.

Sąsaja tarp LCD ir „arduino“ yra standartinė. Mes galime rasti panašų ryšį daugelyje kitų LCD pagrįstų projektų.

Lazerio pertraukimams aptikti naudojami du analoginiai kaiščiai A0 ir A1. Analoginis kaištis A2 yra sujungtas su mygtuku, kuris naudojamas chronometro įjungimui.

Trys rezistoriai, du 4,7 K ir vienas 10 K yra nulenkiami rezistoriai, kurie padeda įvesties kaiščiams išlikti žemai.

10K potenciometras yra pritaikytas norint reguliuoti LCD modulio kontrastą, kad būtų galima geriau matytis.

Siūloma grandinė suprojektuota su lazerių gedimų aptikimo mechanizmu. Jei kuris nors lazeris yra sugedęs arba netinkamai suderintas su LDR, LCD ekrane rodomas klaidos pranešimas.

· Jei neveikia „START“ lazeris, rodoma „neveikia“ paleidimo lazeris “

· Jei neveikia STOP lazeris, rodoma „neveikia„ stop “lazeris“

· Jei neveikia abu lazeriai, rodoma „Neveikia abu lazeriai“

· Jei abu lazeriai veikia tinkamai, rodoma „Abu lazeriai veikia gerai“

Klaidos pranešimas rodomas tol, kol lazerinis modulis bus užfiksuotas arba tinkamai atliktas derinimas su LDR.

Kai šiam žingsniui nekyla problemų, sistema persijungia į laukimo režimą ir parodo „-system standby-“. Šiuo metu vartotojas gali bet kada patvirtinti sąranką paspausdamas mygtuką.

Paspaudus mygtuką, sistema yra pasirengusi aptikti vartotojo judesį ir rodo „Sistema paruošta“.

Bėgikas gali būti keli centimetrai nuo „starto“ lazerio.

Nutraukus lazerio „paleidimą“, laikas pradedamas skaičiuoti, o ekrane rodomas pranešimas „Laikas skaičiuojamas ...“.

Praėjęs laikas nebus rodomas tol, kol bėgikas pasieks / nepertrauks „stop“ lazerio. Taip yra todėl, kad norint parodyti praėjusį laiką LCD kaip tradicinį chronometrą, mikrovaldiklyje reikia atlikti keletą papildomų instrukcijų, o tai žymiai pablogina sąrankos tikslumą.

PASTABA: Norėdami išvalyti rodmenis, paspauskite atstatymo mygtuką ant „arduino“.

Kaip nustatyti bėgimo tako grandinę:

Norėdami prijungti LDR ir „arduino“ grandinę, naudokite storus laidus, nes atstumas tarp šių dviejų gali būti kelių metrų atstumu, o įtampa neturi smarkiai kristi. Atstumas tarp LDR1 ir LDR2 gali būti maksimalus keli šimtai metrų.

Kaip prijungti LDR:

LDR turi būti sumontuotas tuščiaviduriame nepermatomame vamzdyje, o priekinė dalis taip pat turi būti uždengta ir padaryta tik kelių milimetrų skersmens skylė, leidžianti patekti lazerio spinduliui.

LDR turi būti apsaugotas nuo tiesioginių saulės spindulių, nes jis negali atskirti nuo lazerio spindulio ir kito šviesos šaltinio ir gali neužregistruoti vartotojo judesio.

Programos kodas:

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

Autoriaus prototipas:

Atnaujinimas naudojant „Split Timer“ įrenginį

Siūloma automatinio chronometro grandinė su padalytu laikmačiu yra automatinio chronometro grandinės pratęsimas, kai chronometras automatiškai stebi laiką, kai tik vienas bėgikas palieka starto tašką, o laikmatis sustoja ir rodo praėjusį laiką, kai bėgikas pasiekia galutinį tašką.

Įvadas

Šį projektą pasiūlė vienas iš aistringų šios svetainės skaitytojų Andrew Walkeris.

Šiame projekte pristatome dar 4 LDR, kad pamatuotume solo bėgiko laiko pertrauką. Iš viso yra 6 LDR, visi jie gali būti pastatyti bėgimo trasoje vienodu atstumu tarp jų arba atsižvelgiant į aplinkybes ir vartotojo pasirinkimą.

Didžioji aparatinės įrangos dalis nekeičiama, išskyrus 4 LDR pridėjimą, tačiau kodas buvo labai modifikuotas.

Scheminė diagrama, rodanti pertraukos laiką:

Pirmiau pateiktą grandinę sudaro keletas komponentų ir draugiškos pradedantiesiems. Daugiau paaiškinimų nereikia, tiesiog laidą, kaip nurodyta schemoje.

Kaip prijungti LDR:

LDR 2 parodytas pagrindinėje grandinės schemoje lygiagrečiai sujunkite dar 4 LDR, kaip parodyta aukščiau pateiktoje diagramoje.

Maketo schema:

Pirmiau pateikiama pagrindinė lazerio padėjimo tvarka. Atkreipkite dėmesį, kad atstumas tarp LDR gali būti vartotojo pasirinkimas, atsižvelgiant į kelio ilgį.

Programa:

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

Kaip valdyti šį automatinį chronometrą:

• Baigę sąranką, pirmiausia įjunkite lazerius ir tada įjunkite „Arduino“ grandinę.
• Jei visi lazeriai tinkamai suderinti su LDR, ekrane nebus raginama pranešti apie klaidas. Jei tokių yra, juos tinkamai sulygiuokite.
• Dabar grandinėje rodoma „Sistema yra budėjimo režime“. Dabar paspauskite mygtuką „Pradėti“ ir pasirodys „Sistema paruošta“.
• Šiuo metu, kai solo grotuvas pertraukia LDR 1 šviesos spindulį, paleidžiamas laikmatis ir rodoma „Laikas skaičiuojamas…“.
• Kai tik grotuvas pasiekia galutinį tašką, ty LDR 6, laikmatis sustoja ir jis parodo 5 pertraukimo laiką, užfiksuotą grandinėje.
• Norėdami iš naujo nustatyti laikmatį, vartotojas turi paspausti „arduino“ atstatymo mygtuką.
Kodėl šis automatinis chronometras negali rodyti tiesioginio laiko rodymo ekrane, kaip tai daro tradicinis chronometras (bet jis rodo statinį tekstą „Laikas skaičiuojamas ...“)?
Kad laikas būtų rodomas realiuoju laiku, „Arduino“ turi vykdyti papildomas LCD ekrano instrukcijas. Tai pridės kelias mikrosekundes prie kelių milisekundžių vėlavimo prie pagrindinio laiko stebėjimo kodo, o tai duos netikslius rezultatus.

Jei turite daugiau klausimų, pateikite komentarų skyriuje.