Automaattisen sekuntikellon tekeminen juoksijoille, urheilijoille ja urheilijoille

Tässä viestissä aiomme rakentaa sekuntikellon, joka käynnistää ajastimen automaattisesti, kun juoksija alkaa juosta, ja ajastin pysähtyy, kun juoksija saavuttaa lopun. Kulunut aika aloitus- ja loppupisteen välillä näytetään 16 x 2 nestekidenäytössä.

Aloitetaan ensin oppimalla yksinkertaisen ja erittäin tarkan Arduino-sekuntikellopiirin määrittäminen.

Sekuntikello on manuaalisesti ohjattu aikakellolaite, joka on suunniteltu mittaamaan ajanjakso, joka on saattanut kulua tietystä ajankohdasta lähtien, kun se aktivoitiin, ja siihen aikaan, kun se lopulta deaktivoitiin. sekuntikello, jota käytetään toiminnan seurantaan etäisyydeltä ja joka tavallisesti löytyy urheilustadionilta jne.

Mekaaninen vs. elektroninen sekuntikello

Aikaisemmin perinteinen mekaaninen kädessä pidettävä sekuntikello oli yleisempi, ja kaikki käyttivät sitä tähän tarkoitukseen.

Mekaanisessa järjestelmässä meillä oli kaksi painonappia sekuntikellotoimintojen suorittamiseksi. Yksi pysäytyskellon käynnistämiseksi painamalla kerran, ja ajan pysäyttämiseksi painamalla samaa painiketta uudelleen, kun haluat tallentaa kuluneen ajan ... toista painiketta käytettiin kellon palauttamiseksi takaisin nollaan.

Mekaaninen pysäytyskello toimi pohjimmiltaan jousitehon kautta, mikä vaati ajanjakson manuaalista kelaamista kääntämällä annettua pyällettyä nuppia kellolaitteen yläosassa.

Nykyaikaisiin digitaalisiin sekuntikelloihin verrattuna mekaanisia tyyppejä voidaan kuitenkin pitää merkittävästi alkeellisina ja epätarkkoina millisekuntien alueella.

Arduinon käyttäminen

Ja tänään mikrokontrollerin myötä nämä sekuntikellot ovat tulleet erittäin tarkoiksi ja luotettaviksi mikrosekunnin alueelle.

Tässä esitetty Arduino-sekuntikellopiiri on yksi näistä moderneista mikrokontrollerikäyttöisistä muotoiluista, jotka ovat tarkimpia, ja niiden voidaan odottaa olevan kaupallisten nykyaikaisten sekuntikellolaitteiden kanssa.

Opitaan rakentamaan ehdotettu Arduino-kellokytkentäpiiri:

Tarvitset seuraavan rakennusselosteen:

Laitteisto vaaditaan

Arduino LCD -näppäimistösuoja (SKU: DFR0009)

Arduino ONE -taulu

Arduino-USB-kaapeli

Kun olet hankkinut yllä olevan materiaalin ja kiinnittänyt ne toisiinsa, kyse on vain seuraavan annetun luonnoskoodin määrittämisestä Arduino-levyllesi ja katsella sekuntikellotoimintojen taikaa.

Koodi

/*
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-segmenttisen näytön lisääminen

Jatka nyt sekuntikellopiirin rakentamisen yksityiskohtia 7-segmenttisellä LED-näytöllä ja Arduinolla. Tutkimme keskeytyksiin ja näyttöajurien IC: hin liittyviä käsitteitä, jotka ovat ratkaisevan tärkeitä tämän projektin ymmärtämiseksi. Tämän projektin ehdotti Abu-Hafss, joka on yksi tämän verkkosivuston innokkaista lukijoista.

Kuten jo tiedämme, sekuntikello on laite, joka auttaa seuraamaan lyhyttä aikaa tunteista millisekunteihin (enimmäkseen). Lähes kaikki halvat digitaalikellot, jotka on varustettu sekuntikellotoiminnoilla, mutta mikään kelloista ei voi antaa innokkuutta tehdä yksi itsellemme ja löytää myös sekuntikello, jossa on 7 segmentin LED-näyttö, on poikkeuksellista.

Herra Abu-Hafss ehdotti, että suunnittelemme sekuntikellon, jossa on 4 näyttöä, kaksi minuuttia minuutteina ja kaksi sekuntia (MM: SS). Mutta useimmille meistä se ei ehkä ole toteutettavissa oleva muotoilu, joten lisäsimme vielä kaksi näyttöä millisekunnin alueelle, joten nyt ehdotettu muotoilu on MM: SS: mS-kokoonpanossa.

Jos tarvitset vain jostakin syystä MM: SS-kokoonpanoa, sinun ei tarvitse liittää millisekunnin alueen 7 segmenttinäyttöjä ja niiden ohjain-IC: itä, piirin koko toiminto ei silti vaikuta.

Piiri:

Ehdotettu sekuntikello koostuu kuudesta IC 4026: stä, joka on seitsemän segmentin näyttöohjainta, kuusi 7 segmentin LED-näyttöä, yhden Arduino-kortin, muutaman painikkeen ja muutaman 10K-vastuksen.

Ymmärretään nyt, kuinka IC 4026 kytketään 7 segmentin näyttöön.

7-segmenttinen näyttö voi olla mikä tahansa yleinen katodinäyttö, mikä tahansa väri. 7-segmenttinäyttö voi helposti tappaa 5 V: n virtalähteellä, joten 330 ohmin vastus on pakollinen jokaisessa näytön osassa.

Katsotaan nyt IC 4026: n piikkikaavio:

• Tappi # 1 on kellotulo.
• Tappi # 2 on kellon poissa käytöstä, se poistaa näytöllä olevan määrän, jos tämä tappi on korkea.
• Tappi # 3 on näytön käytössä, jos tämä tappi on matala, näyttö viritetään pois ja päinvastoin.
• Tappi # 5 on suoritettu, josta tulee korkea, kun IC laskee 10.
• Nastat 6, 7, 9, 10, 11, 12, 13 ovat näyttölähtöjä.
• Tappi # 8 on GND.
• Tappi # 16 on Vcc.
• Tappi # 15 nollataan, jos nostamme tämän nastan, lukema muuttuu nollaksi.
• Tapoja # 4 ja # 14 ei käytetä.

Näytä liitäntäkaavio:

Mikä tahansa 7 segmentin näytön GND-nasta voidaan liittää maahan. IC: n on oltava kytkettynä 5 V: n virtalähteeseen tai Arduinon 5 V: n lähtöliittimeen.

Yllä oleva kaavio vain yhdelle näytölle, toista sama viidelle muulle näytölle.

Tässä on loput kaaviosta:

Piiri voidaan virtaa 9 V: n paristosta. Tässä on kaksi nappia, joista yksi alkaa aikaa ja toinen pysähtyy. Painamalla Arduinon nollauspainiketta, aikalaskuri nollataan näytöllä.

Kaksi painonappia on kytketty nastoihin 2 ja 3, jotka ovat Arduino / Atmega328P-mikrokontrollerin laitteistokatkos.

Ymmärretään mikä keskeytys on:

Keskeytyksiä on kahdenlaisia: laitteiston keskeytys ja ohjelmiston keskeytys. Tässä käytämme vain laitteiston keskeytystä.

Keskeytys on signaali mikrokontrollerille, joka saa mikrokontrollerin reagoimaan välittömästi tapahtumaan.

Arduino-levyillä on vain kaksi laitteiston keskeytystappia, joissa on ATmega328P-mikrokontrolleri-nastat # 2 ja # 3. Arduino megalla on enemmän kuin kaksi laitteiston keskeytystappia.

Mikrokontrollerit eivät voi tehdä kahta toimintoa samanaikaisesti. Esimerkiksi napin painalluksen tarkistaminen ja numeroiden laskeminen.

Mikrokontrollerit eivät voi suorittaa kahta tapahtumaa samanaikaisesti, jos kirjoitamme koodin painallusten tarkistamiseen ja numeroiden laskemiseen, painikkeen painallus havaitaan vasta, kun mikrokontrolleri lukee näppäimen painalluksen tunnistuskoodin, loppuajan (laskee numerot) -painike ei toimi.

Joten napin painalluksen havaitseminen viivästyy ja jostain syystä, jos koodi pysäytetään väliaikaisesti, painikkeen painamista ei ehkä koskaan löydetä. Tällaisten ongelmien välttämiseksi otetaan käyttöön keskeytys.

Keskeytyssignaalille annetaan aina korkein prioriteetti, päätoiminto (pääkoodirivit) pysähtyy ja suorittaa kyseiselle keskeytykselle määritetyn (toinen koodikappale) -toiminnon.

Tämä on erittäin tärkeää aikakriittisissä sovelluksissa, kuten sekuntikello, turvajärjestelmät jne., Joissa prosessorin on ryhdyttävä välittömiin toimiin vastauksena tapahtumaan.

Arduinossa laitteiston keskeytys määritetään seuraavasti:

attachInterrupt (0, alku, RISING)

• '0' tarkoittaa keskeytyslukua nolla (mikro-ohjaimissa kaikki alkaa nollasta), joka on nasta # 2.
• “Start” on keskeytystoiminnon nimi, voit nimetä mitä tahansa täällä.
• “RISING”, jos tappi # 2 (joka on keskeytysnolla) menee korkealle, keskeytystoiminto suoritetaan.

attachInterrupt (1, Stop, RISING)

• '1' tarkoittaa keskeytysnumeroa yksi, joka on tappi # 3.
• “Stop” on keskeytyksen nimi.

Voimme myös korvata “RISING” sanoilla “FALLING” nyt, kun keskeytysnasta menee LOW, keskeytystoiminto suoritetaan.

Voimme myös korvata 'RISING' sanalla 'CHANGE', nyt kun keskeytystappi menee korkealta matalalle tai matalalta korkealle, keskeytystoiminto suoritetaan.

Keskeytystoiminto voidaan määrittää seuraavasti:

void start () // start on keskeytyksen nimi.

{

// Ohjelma täällä

}

Keskeytystoiminnon on oltava mahdollisimman lyhyt, eikä viive () -toimintoa voida käyttää.

Tämä päättelee Arduinoon liittyvän laitteiston keskeytysohjelmiston keskeytyksen, joka selitetään tulevassa artikkelissa.

Nyt tiedät miksi yhdistimme aloitus- ja pysäytyspainikkeet katkaisemaan nastat.

Liitä piiri kaavion mukaisesti piirin loppuosa on itsestään selvä.

Ohjelmoida:

//----------------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---------------//
Nyt koodi on valmis.

Sekuntikello kehitetty erityisesti Atheletesille

Lopuksi opitaan, miten yllä olevia käsitteitä voidaan todella päivittää urheilijoille, jotka haluavat kehittää juoksutaitojaan riippumattomasti muista tarvittavan aloituksen ja pysäytyksen ajaksi / sekuntikelloksi. On parempi käynnistää ajastin automaattisesti tunnistamalla liike kuin joku, joka käynnistää / pysäyttää sekuntikellon, mikä saattaa lisätä myös reaktioaikaa.

HUOMAUTUS: Tämä projekti on suunniteltu mittaamaan aika pisteestä A pisteeseen B, jonka yksi käyttäjä kerrallaan peittää.

Asennus koostuu kahdesta laserista, jotka on sijoitettu lähtö- ja loppupisteeseen, kaksi LDR: ää on myös sijoitettu vastapäätä kahta lasermoduulia. Kun urheilija keskeyttää ”käynnistyslaserin”, aika alkaa laskea ja kun urheilija saavuttaa loppu, keskeyttää ”loppu” -laserin ja ajastin pysähtyy ja näyttää kuluneen ajan kahden pisteen välillä. Tätä menetelmää käytetään ehdotetun idean kuluneen ajan mittaamiseen.

Katsotaanpa piirin jokainen osa yksityiskohtaisesti.

Komponenttien työskentelytiedot

Piiri pidetään melko yksinkertaisena, se koostuu 16 x 2 LCD-moduulista, muutamasta vastuksesta, kahdesta LDR: stä ja painikkeesta.

LCD-näytön ja arduinon välinen käyttöliittymä on vakiona. Löydämme samanlaisen yhteyden moniin muihin LCD-pohjaisiin projekteihin.

Kahta analogista nastaa A0 ja A1 käytetään laserkatkosten havaitsemiseen. Analoginen tappi A2 on kytketty painikkeella, jota käytetään sekuntikellon virittämiseen.

Kolme vastusta, kaksi 4,7 K ja yksi 10 K ovat alasvetovastuksia, jotka auttavat syöttönastoja pysymään alhaisina.

10K-potentiometri on tarkoitettu LCD-moduulin kontrastin säätämiseen optimaalisen näkyvyyden saavuttamiseksi.

Ehdotettu piiri on suunniteltu vianilmaisumekanismilla lasereille. Jos jokin laserista on viallinen tai sitä ei ole kohdistettu oikein LDR: n kanssa, se näyttää virheilmoituksen LCD-näytössä.

· Jos START-laser ei toimi, se näyttää ”käynnistyslaseri ei toimi”

· Jos STOP-laser ei toimi, se näyttää ”pysäytyslaseri ei toimi”

· Jos molemmat laserit eivät toimi, se näyttää 'Molemmat laserit eivät toimi'

· Jos molemmat laserit toimivat oikein, näytössä lukee ”Molemmat laserit toimivat hyvin”.

Virhesanoma tulee näkyviin, kunnes lasermoduuli on kiinnitetty tai kohdistaminen on tehty oikein LDR: n kanssa.

Kun tässä vaiheessa ei ole ongelmia, järjestelmä siirtyy valmiustilaan ja näyttää '-järjestelmän valmiustila'. Tässä vaiheessa käyttäjä voi virittää asetukset painamalla painiketta milloin tahansa.

Kun painiketta painetaan, järjestelmä on valmis havaitsemaan käyttäjän liikkeen ja näyttää ”Järjestelmä on valmis”.

Juoksija voi olla muutaman tuuman päässä ”start” -laserista.

Jos “käynnistyslaseri” keskeytyy, aika alkaa laskea ja näytössä näkyy ”Aika lasketaan…”. Aika lasketaan takapinnalta.

Kulunutta aikaa ei näytetä, ennen kuin juoksija saavuttaa / keskeyttää “pysäytyslaserin”. Tämä johtuu siitä, että kuluneen ajan esittäminen LCD-näytöllä perinteisen sekuntikellon tapaan edellyttää mikro-ohjaimessa useita lisäohjeita, mikä heikentää asetusten tarkkuutta merkittävästi.

HUOMAUTUS: Tyhjennä lukemat painamalla arduinon nollauspainiketta.

Kuinka asettaa piiri juoksuradalle:

Käytä LDR: n ja arduino-piirin yhdistämiseen paksuja johtoja, koska näiden kahden välinen etäisyys voi olla useita metrejä toisistaan, eikä jännite saa pudota merkittävästi. LDR1: n ja LDR2: n välinen etäisyys voi olla enintään muutama sata metriä.

Kuinka asentaa LDR:

LDR on asennettava ontton läpinäkymättömän putken sisälle ja etuosa on myös peitettävä, ja lasersäteen pääsemiseksi sisään tehdään vain reikä, jonka halkaisija on muutama millimetri.

LDR on suojattava suoralta auringonvalolta, koska se ei voi erota lasersäteestä ja muusta valonlähteestä eikä välttämättä rekisteröi käyttäjän liikettä.

Ohjelmakoodi:

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

Kirjoittajan prototyyppi:

Päivittäminen jaetun ajastimen avulla

Ehdotettu automaattinen sekuntikellopiiri, jossa on jaettu ajastin, on automaattisen sekuntikellopiirin jatke, jossa sekuntikello seuraa aikaa automaattisesti heti, kun soolojuoksija lähtee lähtöpisteestä ja ajastin pysähtyy ja näyttää kuluneen ajan juoksijan saavuttaessa loppupisteen.

Johdanto

Tämän projektin ehdotti yksi tämän sivuston innokkaista lukijoista Andrew Walker.

Tässä projektissa esittelemme vielä 4 LDR: ää soolojuoksijaajan mittaamiseksi. LDR: itä on yhteensä 6, kaikki ne voidaan sijoittaa juoksuradalle tasaisen etäisyyden välillä tai olosuhteiden ja käyttäjän valinnan mukaan.

Suurin osa laitteistosta pidetään muuttumattomana lukuun ottamatta 4 LDR: n lisäämistä, mutta koodiin on tehty suuria muutoksia.

Kaavio, joka näyttää väliajan:

Yllä oleva piiri koostuu muutamasta komponentista ja on sopiva aloittelijoille. Enempää selitystä ei tarvita, vain johdin kytkentäkaavion mukaisesti.

Kuinka kytkeä LDR: t:

LDR 2 on esitetty pääpiirikaaviossa, kytke vielä 4 LDR: ää rinnakkain, kuten yllä olevassa kaaviossa on esitetty.

Asettelukaavio:

Edellä on perusjärjestely laserin sijoittamiseksi. Huomaa, että LDR: ien välinen etäisyys voi olla käyttäjän valinta raidan pituudesta riippuen.

Ohjelmoida:

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

Kuinka käyttää tätä automaattista sekuntikelloa:

• Kun asennus on valmis, käynnistä ensin laserit ja kytke sitten Arduino-piiri päälle.
• Jos kaikki laserit on kohdistettu oikein LDR: ien kanssa, näyttöön ei tule virhesanomia. Jos sellaisia ​​on, kohdista ne oikein.
• Piirissä näkyy nyt 'Järjestelmä on valmiustilassa'. Paina nyt Käynnistä-painiketta ja se näyttää 'Järjestelmä on valmis'.
• Tässä vaiheessa, kun soolopelaaja keskeyttää LDR 1 -valonsäteen, ajastin käynnistyy ja näytössä lukee 'Aikaa lasketaan ...'.
• Heti kun pelaaja saavuttaa loppupisteen eli LDR 6: n, ajastin pysähtyy ja se näyttää piirin tallentaman 5 jakoajan.
• Käyttäjän on painettava arduinon nollauspainiketta ajastimen nollaamiseksi.
Miksi tämä automaattinen sekuntikello ei voi näyttää suoraa ajoitusta näytöllä kuten perinteinen sekuntikello (mutta se näyttää pikemminkin staattisen tekstin 'Aikaa lasketaan ...')?
Ajastuksen näyttämiseksi reaaliajassa Arduinon on suoritettava lisäohjeet LCD-näytölle. Tämä lisää muutaman mikrosekunnin muutamaan millisekunnin viiveeseen tärkeimpään ajanseurantakoodiin, mikä johtaa epätarkkoihin tuloksiin.

Jos sinulla on kysyttävää, ilmaise kommenttiosion kautta.