Automatikus stopperóra készítése futóknak, sportolóknak és sportolóknak

Ebben a bejegyzésben egy stoppert fogunk készíteni, amely automatikusan elindítja az időzítőt, amikor a futó futni kezd, és az időzítő leáll, amikor a futó eléri a végét. A kezdő és a végpont között eltelt idő megjelenik egy 16 x 2-es LCD-n.

Először kezdjük azzal, hogy megtanuljuk konfigurálni az egyszerű és rendkívül pontos Arduino stopper áramkört.

A stopper egy kézi vezérlésű időmérő eszköz, amelyet az adott időponttól kezdve, amikor aktiválták, és mire véglegesen deaktiválták, az eltelt idő hosszának mérésére tervezték. Ugyanannak az eszköznek egy nagyobb változatát hívják a stopperóra, amelyet a cselekvés távolról történő figyelésére használnak, és amely általában a sportstadionban található stb.

Mechanikus vs elektronikus stopper

Korábban a hagyományos mechanikus kézi stopperek gyakoribbak voltak, és mindenki ezt a célt használta.

A mechanikus rendszerben két nyomógombunk volt a stopper funkciók végrehajtására. Az egyik a stopper elindításához nyomja meg egyszer, és az idő leállításához ugyanazon gomb ismételt megnyomásával az eltelt idő rögzítéséhez ... a második gombbal az óra nullára állítható vissza.

A mechanikus stopper alapvetően a rugóerő segítségével működött, amihez időnként manuálisan kellett felcsavarodni az óra készülék tetején lévő adott recézett gomb forgatásával.

A modern digitális órákhoz képest azonban a mechanikus típusok jelentősen primitívnek és pontatlannak tekinthetők az ezredmásodpercek tartományában.

Arduino használata

És ma a mikrovezérlő megjelenésével ezek a stopperórák mikroszekundumos tartományban rendkívül pontosak és megbízhatóak lettek.

Az itt bemutatott Arduino stopper áramkör egyike ezeknek a modern mikrovezérlővel működő kiviteleknek, amelyek a legpontosabbak, és várhatóan megfelelnek a kereskedelmi modern stopperóráknak.

Tanuljuk meg, hogyan kell felépíteni a javasolt Arduino stopper áramkört:

Az építkezéshez a következő anyagjegyzékre lesz szüksége:

Hardver szükséges

Arduino LCD billentyűzet pajzs (Cikkszám: DFR0009)

Arduino ONE tábla

Arduino USB kábel

Miután megszerezte a fenti anyagot és összekapcsolta őket egymással, csak arról van szó, hogy az alábbi vázlatkódot konfigurálja az Arduino táblára, és figyeli a stopper funkcióinak varázslatát.

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

7 szegmenses kijelző hozzáadása

Most folytassuk a stopperóra megépítésének részleteit a 7 szegmenses LED kijelző és az Arduino segítségével. Megvizsgáljuk a megszakításokkal és a meghajtó IC-kkel kapcsolatos fogalmakat, amelyek döntő fontosságúak a projekt megértéséhez. A projektet Abu-Hafss javasolta, aki a weboldal egyik lelkes olvasója.

Mint azt már tudjuk, hogy a Stopper egy olyan eszköz, amely segít rövid időtartamok nyomon követésében óráktól milliszekundumokig (főleg). Szinte minden olcsó stopper funkcióval ellátott digitális karóra, de egyik óra sem ad lelket abban, hogy saját magunknak készítsünk egyet, és a 7 szegmenses LED-es stopperóra is kivételes.

Abu-Hafss úr azt javasolta nekünk, hogy tervezzünk egy stoppert 4 kijelzővel, kettő percig és kettő másodpercig (MM: SS). De a legtöbbünk számára nem biztos, hogy megvalósítható kialakítás, ezért hozzáadtunk még két kijelzőt ezredmásodperces tartományra, így most a javasolt kialakítás MM: SS: mS konfigurációban lesz.

Ha valamilyen okból csak MM: SS konfigurációra van szüksége, akkor nem kell összekapcsolnia a milliszekundumos 7 szegmens kijelzőket és azok meghajtó IC-jeit, az áramkör teljes funkcionalitása továbbra sem változik.

Az áramkör:

A javasolt stopperóra hat IC 4026-ból áll, amely hét szegmenses kijelző meghajtó, hat 7 szegmenses LED-kijelző, egy Arduino kártya, pár nyomógomb és pár 10K ellenállás.

Most értsük meg, hogyan lehet az IC 4026-ot 7 szegmenses kijelzőhöz csatlakoztatni.

A 7 szegmenses kijelző bármely tetszőleges színű katód-kijelző lehet. A 7 szegmenses kijelző könnyen elpusztulhat az 5 V-os tápellátás révén, így a kijelző minden szegmensében kötelező egy 330 ohmos ellenállás.

Most nézzük meg az IC 4026 csapdiagramját:

• Az 1. tű az óra bemenet.
• A # 2 tű az óra letiltása, letiltja a kijelzőn megjelenő számlálást, ha ez a tű magas.
• A # 3-as tű a kijelző számára engedélyezhető, ha ez a tű alacsony, a kijelző kikapcsolódik és fordítva.
• Az # 5 tű megtörtént, amely magas lesz, ha az IC 10-et számlál.
• A 6, 7, 9, 10, 11, 12, 13 csapok kimenetek.
• A # 8 tű a GND.
• A # 16-os tű Vcc.
• A # 15 tű visszaáll, ha ezt a csapot magasra emeljük, a szám nulla lesz.
• A # 4 és # 14 csapokat nem használják.

Kapcsolási rajz megjelenítése:

A 7 szegmenses kijelző GND-tűinek bármelyike ​​csatlakoztatható a földhöz. Az IC-t 5 V-os tápfeszültségről vagy az Arduino 5 V-os kimeneti tűjéről kell táplálni.

A fenti sémát csak egy kijelző esetében ismételje meg ugyanezt öt másik kijelzőnél.

Itt van a többi sematikus ábra:

Az áramkört 9 V-os elemről lehet táplálni. A két gomb itt található, az egyik az idő elindításához, a másik pedig a megálláshoz. Az Arduino reset gombjának megnyomásával az időszámítás nullára áll a kijelzőn.

A két nyomógomb a 2. és a 3. csatlakozóhoz csatlakozik, amelyek az Arduino / Atmega328P mikrokontroller hardveres megszakításai.

Értsük meg, mi a megszakítás:

Kétféle megszakítás létezik: a hardveres megszakítás és a szoftveres megszakítás. Itt csak a hardveres megszakítást használjuk.

A megszakítás egy jel a mikrovezérlő felé, amely arra készteti a mikrovezérlőt, hogy azonnal reagáljon egy eseményre.

Csak két hardveres megszakító csap van az Arduino táblákban az ATmega328P mikrokontroller # 2 és # 3 tűvel. Az Arduino mega kettőnél több hardveres megszakítócsappal rendelkezik.

A mikrovezérlők nem tudnak két funkciót egyszerre elvégezni. Például a gombnyomás ellenőrzése és a számok számlálása.

A mikrovezérlők nem hajthatnak végre két eseményt egyszerre, ha kódot írunk a gombnyomás ellenőrzéséhez és a számok számolásához, akkor a gombnyomás csak akkor kerül észlelésre, amikor a mikrovezérlő elolvassa a gombnyomás érzékelő kóddarabot, a többi idő alatt (megszámolja a számokat) a gomb nem működik.

Tehát késleltetni fogja a gombnyomás észlelését, és valamilyen oknál fogva, ha a kód ideiglenesen leáll, a gombnyomást soha nem lehet észlelni. Az ilyen jellegű problémák elkerülése érdekében megszakítás kerül bevezetésre.

A megszakítási jel mindig a legnagyobb prioritást kapja, a fő funkció (a kód fő sorai) leáll, és végrehajtja az adott megszakításhoz rendelt (másik kóddarab) funkciót.

Ez nagyon fontos az olyan kritikus fontosságú alkalmazásoknál, mint a stopper vagy a biztonsági rendszerek stb., Ahol a processzornak azonnal reagálnia kell egy eseményre.

Az Arduino-ban a hardver megszakítást hozzárendeljük

attachInterrupt (0, start, RISING)

• A „0” azt jelenti, hogy a megszakítás száma nulla (a mikrovezérlőkben minden nullától kezdődik), amely a # 2 tű.
• A „start” a megszakítás függvény neve, itt bármit megnevezhet.
• „RISING”, ha a # 2 tű (ami a nulla megszakítás) magasra kerül, a megszakítás funkció végrehajtásra kerül.

attachInterrupt (1, Stop, RISING)

• Az „1” az első számú megszakítást jelenti, amely a 3. tű.
• A „Stop” a megszakítás neve.

A „RISING” -et „FALLING” -re is cserélhetjük, most, amikor a megszakító csap LOW-ra megy, a megszakítás funkció végrehajtásra kerül.

A „RISING” -et „CHANGE” -re is cserélhetjük, most, amikor a megszakító tű magasról alacsonyra vagy alacsonyról magasra megy, a megszakítás funkció végrehajtásra kerül.

A megszakítás funkció az alábbiak szerint rendelhető hozzá:

void start () // start a megszakítás neve.

{

// program ide

}

A megszakítási funkciónak a lehető legrövidebbnek kell lennie, és a delay () funkció nem használható.

Ez arra a következtetésre jut, hogy az Arduino-val kapcsolatos hardvermegszakító szoftver megszakításait a következő cikkben ismertetjük.

Most már tudja, miért csatlakoztattuk a start és stop nyomógombokat a csapok megszakításához.

Csatlakoztassa az áramkört az ábra szerint, az áramkör többi része magától értetődő.

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---------------//
Most ezzel lezárult a kód.

Kifejezetten az Atheletes számára kifejlesztett stopper

Végül tanuljuk meg, hogyan lehet a fenti fogalmakat valóban továbbfejleszteni azoknak a sportolóknak, akik szeretnék fejleszteni futási készségeiket anélkül, hogy másoktól függenék a szükséges startot és megállítanák az időzítőt / stoppert. Jobb, ha automatikusan elindítja az időzítőt a mozgásának észlelésével, mint aki elindítja / leállítja a stoppert, ami megnövelheti a reakcióidejét is.

MEGJEGYZÉS: Ez a projekt az „A” és a „B” pont közötti idő mérésére szolgál, amelyet egyszerre EGY felhasználó fed le.

A beállítás két lézerből áll, amelyek a kiindulási és a végpontra vannak elhelyezve, két LDR-t szintén két lézermodulral szemben helyeznek el. Amikor a sportoló megszakítja a „kezdő” lézert, az idő elkezd számolni, és amikor a sportoló eléri a végét, megszakítja a „befejező” lézert és az időzítő leáll, és megjeleníti a két pont közötti eltelt időt. Ezt a módszert használják a javasolt ötletben eltelt idő mérésére.

Nézzük meg részletesen az áramkör minden egyes elemét.

Az alkatrészek működési részletei

Az áramkör meglehetősen egyszerű, 16 x 2 LCD modulból, kevés ellenállásból, két LDR-ből és egy nyomógombból áll.

Az LCD és az arduino közötti interfész alapfelszereltség, hasonló kapcsolatot találhatunk más LCD alapú projektekben is.

Két analóg A0 és A1 csapot használnak a lézeres megszakítások észlelésére. Az analóg A2 csap csatlakozik a nyomógombbal, amelyet a stopper élesítésére használnak.

Három ellenállás, két 4,7 K és egy 10 K lefelé húzható ellenállás, amely elősegíti a bemeneti csapok alacsony szinten tartását.

10K potenciométer áll rendelkezésre az LCD modul kontrasztjának beállításához az optimális láthatóság érdekében.

A javasolt áramkör hibajelző mechanizmussal rendelkezik a lézerek számára. Ha valamelyik lézer hibás, vagy nincs megfelelően beállítva az LDR-hez, hibaüzenetet jelenít meg az LCD-kijelzőn.

· Ha a START lézer nem működik, akkor a „start lézer nem működik” felirat jelenik meg

· Ha a STOP lézer nem működik, akkor a „stop” lézer nem működik ”felirat jelenik meg

· Ha mindkét lézer nem működik, a „Mindkét lézer nem működik” felirat jelenik meg

· Ha mindkét lézer megfelelõen mûködik, a „Mindkét lézer jól mûködik” felirat jelenik meg

A hibaüzenet mindaddig megjelenik, amíg a lézermodul rögzítése meg nem történik vagy az igazítás megfelelően megtörténik az LDR-rel.

Miután ez a lépés problémamentes, a rendszer készenléti állapotba lép, és megjeleníti a „-rendszer készenléti” üzenetet. Ekkor a felhasználó élesítheti a beállítást a nyomógomb bármikor történő megnyomásával.

Ha megnyomja a nyomógombot, a rendszer készen áll a felhasználó mozgásának észlelésére, és a „Rendszer készen” felirat jelenik meg.

A futó néhány centire lehet a „start” lézertől.

Ha a „start” lézer megszakad, akkor az idő elkezd számolni, és az „Idő kiszámításra kerül ...” felirat jelenik meg. Az idő kiszámítása a háttérben történik.

Az eltelt idő nem jelenik meg, amíg a futó el nem éri / meg nem szakítja a „stop” lézert. Ennek az az oka, hogy az eltelt idő LCD-n történő megjelenítéséhez, mint a hagyományos stopperórához, több kiegészítő utasítást kell végrehajtani a mikrovezérlőben, ami jelentősen rontja a beállítás pontosságát.

MEGJEGYZÉS: Az olvasás törléséhez nyomja meg az arduino reset gombját.

Az áramkör beállítása a futópályán:

Használjon vastag vezetékeket az LDR-ek és az arduino áramkör közötti összeköttetéshez, mivel a kettő közötti távolság több méter lehet, és a feszültség nem csökkenhet jelentősen. Az LDR1 és az LDR2 közötti távolság legfeljebb néhány száz méter lehet.

Az LDR felszerelése:

Az LDR-t az üreges, átlátszatlan csőbe kell felszerelni, és az elülső részt is le kell takarni, és csak néhány milliméter átmérőjű lyuk készül, amely lehetővé teszi a lézersugár bejutását.

Az LDR-t védeni kell a közvetlen napfénytől, mivel nem tud megkülönböztetni a lézersugártól és más fényforrástól, és előfordulhat, hogy nem regisztrálja a felhasználó mozgását.

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

A szerző prototípusa:

Frissítés osztott időzítővel

A javasolt automatikus stopperóra áramkör, osztott időzítővel, az Automatic Stopwatch áramkör kiterjesztése, ahol a stopper automatikusan követi az időt, amint az egyéni futó elhagyja a kiindulási pontot, és az időzítő leáll, és megmutatja az eltelt időt, amikor a futó eléri a végpontot.

Bevezetés

A projektet a weboldal egyik lelkes olvasója javasolta, Andrew Walker.

Ebben a projektben további 4 LDR-t mutatunk be az egyéni futó osztott idejének mérésére. Összesen 6 LDR van, mindegyik elhelyezhető a futópályán egyenletes távolsággal, vagy a körülményektől és a felhasználó választásától függően.

A hardverek nagy részét változatlan formában tartják, kivéve 4 LDR hozzáadását, de a kód hatalmas módosításokon ment keresztül.

A felosztási időt bemutató vázlatos diagram:

A fenti áramkör kevés alkatrészből áll és kezdőbarát. Nincs szükség további magyarázatra, csak a vezeték kapcsolata az áramköri ábra szerint.

Az LDR-ek bekötése:

Az LDR 2 a fő kapcsolási rajzon látható, és további 4 LDR-t csatlakoztasson párhuzamosan, a fenti ábra szerint.

Elrendezés diagram:

A fenti a lézer elhelyezésének alapvető elrendezése. Felhívjuk figyelmét, hogy az LDR-k közötti távolság a felhasználó választhat a pálya hosszától függően.

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

Az automatikus stopper működtetése:

• A befejezett beállítással először kapcsolja be a lézereket, majd kapcsolja be a következőt az Arduino áramkört.
• Ha az összes lézer megfelelően illeszkedik az LDR-ekhez, a kijelző nem kér hibaüzeneteket. Ha van ilyen, kérjük, illessze őket megfelelően.
• Most az áramkör kijelzi: „A rendszer készenlétben”. Most nyomja meg a „start” gombot, és megjelenik a „Rendszer kész” felirat.
• Ezen a ponton, amikor a szólójátékos megszakítja az LDR 1 fénysugarat, az időzítő elindul, és az „Időt számolják…” felirat jelenik meg.
• Amint a lejátszó eléri a végpontot, azaz az LDR 6-ot, az időzítő leáll, és megjeleníti az áramkör által rögzített 5 osztási időt.
• A felhasználónak meg kell nyomnia az arduino reset gombját az időzítő visszaállításához.
Miért nem jeleníti meg ez az automatikus stopper az élő időzítést a kijelzőn, mint a hagyományos stopperóra (inkább statikus szöveget jelenít meg: „Az idő számít ...”)?
Az időzítés valós időben történő megjelenítéséhez az Arduinónak további utasításokat kell végrehajtania az LCD kijelző számára. Ez néhány mikroszekundumot ad hozzá néhány ezredmásodperces késéshez a fő időkövető kódrészlethez, ami pontatlan eredményekhez vezet.

Ha további kérdése van, kérjük, fejtse ki a megjegyzés részben.