Automaatse stopperi valmistamine jooksjatele, sportlastele ja sportlastele

Proovige Meie Instrumenti Probleemide Kõrvaldamiseks





Selles postituses ehitame stopperi, mis käivitab taimeri automaatselt, kui jooksja hakkab jooksma, ja taimer peatub, kui jooksja jõuab lõpuni. Kulunud aeg algus- ja lõpp-punkti vahel kuvatakse 16 x 2 LCD-ekraanil.

Kõigepealt alustame õppimisega, kuidas konfigureerida lihtsat ja ülitäpset Arduino stopperi vooluringi.



Stopper on käsitsi juhitav ajakellaseade, mis on ette nähtud selle aja mõõtmiseks, mis võib olla möödunud teatud ajahetkest, kui see aktiveeriti, ja selleks ajaks, kui see lõpuks deaktiveeriti. Nimetatakse sama seadme suuremat varianti stopper, mida kasutatakse tegevuse jälgimiseks distantsilt ja mis tavaliselt asub spordistaadionil jne.

Mehaaniline vs elektrooniline stopper

Varem olid tavalisemad mehaanilised pihuarvuti stopperid tavalisemad ja seda kasutasid kõik selleks otstarbeks.



Mehaanilises süsteemis oli meil stopperi funktsioonide täitmiseks kaks vajutusnuppu. Üks peatamiskella käivitamiseks ühe korra vajutamisega ja aja peatamiseks, vajutades veel kord sama nuppu möödunud aja salvestamiseks .... teist nuppu kasutati kella nullimiseks.

Mehaaniline stopper töötas põhimõtteliselt vedru jõul, mis nõudis perioodilist käsitsi kerimist, keerates etteantud rihveldatud nuppu kella seadme ülaosas.

Kuid võrreldes tänapäevaste digitaalsete stopperitega saab mehaanilisi tüüpe pidada millisekundite vahemikus märkimisväärselt primitiivseteks ja ebatäpseteks.

Arduino kasutamine

Ja täna on mikrokontrolleri tulekuga need stopperid muutunud mikrosekundite ulatuses ülitäpseks ja usaldusväärseks.

Siin esitatud Arduino stopperi vooluring on üks neist moodsatest mikrokontrolleriga töötavatest konstruktsioonidest, mis on kõige täpsem, võib eeldada, et see on samaväärne kaasaegsete kaubanduslike stopperikomplektidega.

Õppime, kuidas üles ehitada kavandatud Arduino peatuskella vooluring:

Ehitamiseks vajate järgmist materjalide arve:

Vajalik riistvara

Arduino LCD-klahvistikukilp (tootekood: DFR0009)

Arduino LCD-klahvistikukilp (tootekood: DFR0009)

Arduino ONE tahvel

Arduino UNO

Arduino USB-kaabel

arduino usb kaabel

Kui olete ülaltoodud materjali omandanud ja omavahel ühendanud, on see lihtsalt järgmise antud eskiiskoodi konfigureerimine oma Arduino tahvlile ja stopperi funktsioonide maagia jälgimine.

Kood

/*
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-segmendilise kuva lisamine

Nüüd jätkame stopperi vooluahela ehitamise üksikasjadega, kasutades 7 segmendi LED-ekraani ja Arduino. Uurime katkestuste ja draiveri IC-dega seotud mõisteid, mis on selle projekti mõistmiseks üliolulised. Selle projekti soovitas hr Abu-Hafss, kes on selle veebisaidi üks innukamaid lugejaid.

Nagu me juba teame, on stopper seade, mis aitab jälgida lühikest ajavahemikku tundidest millisekunditeni (enamasti). Peaaegu kõik odavad digitaalsed käekellad, mis on varustatud stopperi funktsionaalsusega, kuid ükski kelladest ei saa anda rõõmu selle valmistamiseks meie enda jaoks ja ka 7-segmendilise LED-ekraaniga stopperi leidmine on erakordne.

Hr Abu-Hafss soovitas meil kujundada stopper, millel on 4 kuvarit, kaks minutit ja kaks sekundit (MM: SS). Kuid enamikule meist ei pruugi see olla teostatav disain, nii et lisasime veel kaks kuvasekundit millisekundite vahemikus, nii et nüüd on kavandatav disain MM: SS: mS konfiguratsioonis.

Kui vajate mingil põhjusel lihtsalt MM: SS-i konfiguratsiooni, pole vaja ühendada millisekundilisi vahemikke 7 segmendinäidikut ja selle draiveri IC-sid, see ei mõjuta endiselt kogu vooluahela funktsionaalsust.

Vooluring:

Kavandatav stopper koosneb kuuest IC 4026-st, mis on seitsme segmendiga ekraanidraiver, kuuest 7-segmendilisest LED-ekraanist, ühest Arduino plaadist, paarist nupust ja paarist 10K takisti.

Mõistame nüüd, kuidas ühendada IC 4026 seitsme segmendiga kuvariga.

7-segmendiline ekraan võib olla mis tahes värvi tavaline katoodekraan. 7-segmendiline ekraan võib 5V toiteallika tõttu kergesti tappa, seega on ekraani igas segmendis kohustuslik 330-oomine takisti.

Vaatame nüüd IC 4026 tihvtdiagrammi:

  • Tihvt nr 1 on kella sisend.
  • Tihvt nr 2 on kella keelatud, see keelab ekraanil oleva loendamise, kui see tihvt on kõrge.
  • Kui nööpnõel on madalal, on tihvt nr 3 ekraanil lubatud, häälestatakse ekraan välja ja vastupidi.
  • Tihvt nr 5 on läbi viidud, mis muutub kõrgeks, kui IC loeb 10.
  • Tihvtid 6, 7, 9, 10, 11, 12, 13 on ekraaniväljundid.
  • Tihvt nr 8 on GND.
  • Tihvt nr 16 on Vcc.
  • Tihvt nr 15 lähtestatakse, kui selle tihvti kõrgele tõsta, loendub null.
  • Nööpnõelu nr 4 ja nr 14 ei kasutata.

Kuva ühendusskeem:

LCD-ekraani ühendusskeem:

Maaga saab ühendada ükskõik millise 7-segmendilise ekraani GND-tihvti. IC peab olema toiteallikas 5V toiteallikast või Arduino 5V väljundpistikust.

Ülaltoodud skeem ainult ühe kuva jaoks, korrake sama veel viie kuvari puhul.

Siin on ülejäänud skeem:

Stopper Arduino kasutamine 7 segmendinäidikuga

Vooluahela toiteallikaks võib olla 9 V aku. Siin on kaks nuppu, üks kellaaja alustamiseks ja teine ​​peatamiseks. Arduino lähtestusnuppu vajutades lähtestatakse kuvaril ajaarv.

Kaks nuppu on ühendatud tihvtidega nr 2 ja nr 3, mis on Arduino / Atmega328P mikrokontrolleri riistvaralised katkestused.

Saame aru, mis on katkestus:

Katkestusi on kahte tüüpi: riistvaraline ja tarkvara katkestus. Siin kasutame ainult riistvarakatkestust.

Katkestus on signaal mikrokontrollerile, mis paneb mikrokontrolleri reageerima sündmusele kohe.

Arduino tahvlitel on ainult kaks riistvarakatkestuse tihvti koos mikrokontrolleri ATmega328P tihvtidega nr 2 ja # 3. Arduino megal on rohkem kui kaks riistvarakatkestuse tihvti.

Mikrokontrollerid ei saa teha kahte funktsiooni korraga. Näiteks nupuvajutuse kontrollimine ja numbrite loendamine.

Mikrokontrollerid ei saa kahte sündmust samaaegselt käivitada. Kui kirjutame koodi nupuvajutuse kontrollimiseks ja numbrite loendamiseks, tuvastatakse nupuvajutus ainult siis, kui mikrokontroller loeb nupuvajutuse tuvastamise koodi, ülejäänud aja (loeb numbrid) nupp ei tööta.

Nii et nupuvajutuse tuvastamine viibib ja kui kood ajutiselt peatatakse, ei pruugi mingil põhjusel nupuvajutust kunagi tuvastada. Selliste probleemide vältimiseks kehtestatakse katkestus.

Katkestussignaalile antakse alati kõrgeim prioriteet, põhifunktsioon (koodiread) peatatakse ja see täidab selle konkreetse katkestuse jaoks määratud (teine ​​koodiosa) funktsiooni.

See on väga oluline ajakriitiliste rakenduste jaoks nagu stopper või turvasüsteemid jms, kus protsessor peab sündmusele reageerima viivitamatult.

Arduinos määrame riistvarakatkestuse järgmiselt:

attachInterrupt (0, algus, RISING)

  • '0' tähendab katkestusarvu nulli (mikrokontrollerites algab kõik nullist), mis on tihvt nr 2.
  • “Start” on katkestusfunktsiooni nimi, siin saate nimetada ükskõik mida.
  • “RISING”, kui tihvt nr 2 (mis on katkestuse null) läheb kõrgeks, täidab katkestusfunktsioon.

attachIn Interrupt (1, Stop, RISING)

  • “1” tähendab katkestus number üks, mis on tihvt nr 3.
  • “Stopp” on katkestuse nimi.

Samuti võime asendada “RISING” sõnaga “FALLING”, nüüd kui katkestustihvt läheb LOW, siis katkestusfunktsioon käivitub.

Samuti võime asendada “RISING” sõnaga “CHANGE”. Nüüd, kui katkestustihvt läheb kõrgelt madalale või madalalt kõrgele, käivitatakse katkestusfunktsioon.

Katkestusfunktsiooni saab määrata järgmiselt:

void start () // start on katkestuse nimi.

{

// programm siin

}

Katkestusfunktsioon peab olema võimalikult lühike ja viivitusfunktsiooni () ei saa kasutada.

Sellest järeldub, et Arduinoga seotud riistvarakatkestuse tarkvara katkestust selgitatakse tulevases artiklis.

Nüüd teate, miks ühendasime nööpnõelade katkestamiseks algus- ja peatusnupud.

Ühendage vooluring skeemi järgi, ülejäänud vooluahel on enesestmõistetav.

Programm:

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

Nüüd on see kood lõpetatud.

Spetsiaalselt Atheletesele välja töötatud stopper

Lõpuks õpime, kuidas ülaltoodud kontseptsioone saab tegelikult täiendada sportlaste jaoks, kes soovivad oma jooksmisoskusi arendada ilma teistest sõltumata vajalikuks stardiks ja taimeri / stopperi peatamiseks. Parem on taimer automaatselt käivitada, tuvastades teie liikumise, kui keegi käivitab / peatab stopperi, mis võib lisada ka nende reaktsiooniaja.

MÄRKUS. See projekt on ette nähtud aja mõõtmiseks punkti A ja punkti B vahel, mida korraga katab ÜKS kasutaja.

Seadistus koosneb kahest laserist, mis on paigutatud algus- ja lõpp-punkti ning kaks LDR-i on paigutatud ka kahe lasermooduli vastas. Kui sportlane katkestab „alustava“ laseri, hakkab aeg arvutama ja kui sportlane jõuab lõpuni, katkestab „lõppeva“ laseri ja taimer peatub ning kuvab kahe punkti vahel kulunud aja. Seda meetodit kasutatakse pakutud idees kulunud aja mõõtmiseks.

Vaatame skeemi kõiki komponente üksikasjalikult.

Komponentide töö üksikasjad

Vooluahelat hoitakse üsna lihtsana, see koosneb 16 x 2 LCD-moodulist, vähestest takistitest, kahest LDR-ist ja nupust.

LCD ja arduino vaheline liides on standardne. Leiame sarnase ühenduse paljudes teistes LCD-põhistes projektides.

Laserkatkestuste tuvastamiseks kasutatakse kahte analoognõela A0 ja A1. Analoog tihvt A2 on ühendatud nupuga, mida kasutatakse stopperi sisselülitamiseks.

Kolm takistit, kaks 4,7K ja üks 10K on allakäidetakistid, mis aitavad sisendtappidel madalal püsida.

Optimaalse nähtavuse tagamiseks on LCD-mooduli kontrastsuse reguleerimiseks ette nähtud 10K potentsiomeeter.

Kavandatud vooluahel on kavandatud laserite tõrke tuvastamise mehhanismiga. Kui mõni laser on rike või pole LDR-iga õigesti joondatud, kuvab see LCD-ekraanil veateate.

· Kui START-laser ei tööta, kuvatakse sellel teade „start-laser ei tööta”

· Kui STOP-laser ei tööta, kuvatakse ekraanil teade „stopp-laser ei tööta”

· Kui mõlemad laserid ei tööta, kuvatakse teade „Mõlemad laserid ei tööta”

· Kui mõlemad laserid töötavad korralikult, kuvatakse teade „Mõlemad laserid töötavad hästi”

Veateade kuvatakse seni, kuni lasermoodul on fikseeritud või joondamine on LDR-iga korralikult tehtud.

Kui see samm on probleemideta, läheb süsteem ooterežiimi ja kuvatakse teade „-süsteemi ooterežiim”. Siinkohal saab kasutaja seadistuse häälestada, vajutades mis tahes ajal nuppu.

Kui vajutatakse nuppu, on süsteem kasutaja liikumist tuvastanud ja kuvatakse teade „Süsteem on valmis“.

Jooksja võib olla mõne tolli kaugusel start-laserist.

Kui start-laser katkestatakse, hakkab aeg loendama ja ekraanile ilmub teade „Aega arvutatakse ...”. Aeg arvutatakse tagaplaanil.

Möödunud aega ei kuvata enne, kui jooksja jõuab / katkestab laseri 'stop'. Selle põhjuseks on asjaolu, et möödunud aja kuvamine LCD-ekraanil tavapärase stopperina nõuab mikrokontrolleris mitmete täiendavate juhiste täitmist, mis halvendab seadistamise täpsust oluliselt.

MÄRKUS. Näitude kustutamiseks vajutage arduino lähtestusnuppu.

Raja määramine jooksurajal:

LDR-de ja arduino vooluringi ühendamiseks kasutage pakse traate, kuna nende kahe vaheline kaugus võib olla mitu meetrit ja pinge ei tohi oluliselt langeda. LDR1 ja LDR2 vaheline kaugus võib olla maksimaalselt paarsada meetrit.

LDR-i paigaldamine:

LDR tuleb paigaldada õõnes läbipaistmatu toru sisse ja ka esiosa peab olema kaetud ning laseri kiirte sisenemiseks on tehtud ainult mõne millimeetri läbimõõduga auk.

LDR peab olema kaitstud otsese päikesevalguse eest, kuna see ei erine laserkiirest ega muust valgusallikast ega pruugi kasutaja liikumist registreerida.

Programmi kood:

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

Autori prototüüp:

Uuendamine jagatud taimeriga

Kavandatav automaatne stopperi lülitusajaga taimer on automaatse stopperi ahela pikendus, kus stopper jälgib aega automaatselt kohe, kui soolojooksja lahkub stardipaigast ja taimer peatub ning näitab jooksja lõpppunkti jõudmiseks kulunud aega.

Sissejuhatus

Selle projekti soovitas üks selle veebisaidi kirglikke lugejaid hr Andrew Walker.

Selles projektis tutvustame veel 4 LDR-i soolojooksja jagatud aja mõõtmiseks. Kokku on 6 LDR-i, kõik need võidakse rajale paigutada ühtlase vahemaaga või olenevalt asjaoludest ja kasutaja valikust.

Suurem osa riistvarast hoitakse muutumatuna, välja arvatud 4 LDR-i lisamine, kuid kood on tohutult muudetud.

Skeem, mis näitab vaheaega:

Automaatne stopper koos jagatud ajaga

Ülaltoodud vooluring koosneb vähestest komponentidest ja sobib algajatele. Täiendavat selgitust pole vaja, piisab lihtsalt juhtmestikust vastavalt skeemile.

LDR-ide ühendamine:

LDR 2 on näidatud põhilülitusskeemil, ühendades paralleelselt veel 4 LDR-i, nagu on näidatud ülaltoodud skeemil.

Paigutuse skeem:

Ülaltoodu on põhiline korraldus laseri paigutamiseks. Pange tähele, et LDR-de vaheline kaugus võib olla kasutaja valitud, sõltuvalt raja pikkusest.

Programm:

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

Selle automaatse stopperi kasutamine:

• Pärast täielikku seadistamist lülitage laserid kõigepealt sisse ja seejärel lülitage Arduino vooluring sisse.
• Kui kõik laserid on LDR-idega õigesti joondatud, ei kuvata ekraanil veateateid. Kui on, joondage need korralikult.
• Nüüd kuvatakse vooluringil teade „Süsteem on ooterežiimis”. Nüüd vajutage nuppu „Start“ ja kuvatakse teade „Süsteem on valmis“.
• Sel hetkel, kui soolomängija katkestab LDR 1 valgusvihu, käivitub taimer ja kuvatakse teade „Aega arvutatakse…”.
• Niipea kui mängija jõuab lõpp-punkti ehk LDR 6-ni, peatub taimer ja see kuvab vooluringi salvestatud 5 jagatud aega.
• Taimeri lähtestamiseks peab kasutaja vajutama arduino lähtestusnuppu.
Miks ei saa see automaatne stopper kuvada ekraanil reaalajas ajastust nagu traditsiooniline stopper (pigem kuvatakse staatiline tekst „Aega arvutatakse ...”)?
Ajastuse reaalajas kuvamiseks peab Arduino LCD-ekraanil täitma täiendavad juhised. See lisab peamisele ajajälgimiskoodile paar mikrosekundit mõne millisekundilise viivitusega, mis viib ebatäpsete tulemusteni.

Kui teil on täiendavaid küsimusi, palun väljendage seda kommentaaride jaotises.




Eelmine: Arduino LCD KeyPad Shield (tootekood: DFR0009) andmeleht Järgmine: Arduino juhusliku RGB valguse generaatori vooluring