Gumagawa ng isang Awtomatikong Stopwatch para sa Mga Runner, Athletes at Sportpersons

Sa post na ito magtatayo kami ng isang stopwatch na awtomatikong nagsisimulang timer kapag nagsimulang tumakbo ang runner at huminto ang timer kapag naabot na ng runner ang dulo. Ang lumipas na oras sa pagitan ng pagsisimula at pagtatapos ng punto ay ipinapakita sa isang 16 x 2 LCD.

Magsimula muna tayo sa pamamagitan ng pag-alam kung paano i-configure ang isang simple at lubos na tumpak na Arduino stop watch circuit.

Ang isang stopwatch ay isang manu-manong kinokontrol na aparato ng orasan ng oras na idinisenyo para sa pagsukat ng haba ng oras na maaaring lumipas simula sa isang partikular na punto ng oras kapag na-aktibo ito, at sa oras na sa wakas ay na-deactivate ito. Ang isang mas malaking variant ng parehong aparato ay tinawag ang stop relo na ginagamit para sa pagsubaybay ng aksyon mula sa isang distansya at karaniwang matatagpuan sa sports stadium atbp.

Mekanikal kumpara sa Electronic Stopwatch

Mas maaga ang tradisyunal na mekanikal na paghawak ng relo ng kamay ay mas karaniwan, at ginagamit ng lahat para sa hangarin.

Sa mekanikal na sistema mayroon kaming dalawang pindutan ng pagpindot para sa pagpapatupad ng mga pagpapaandar ng stop relo. Isa para sa pagsisimula ng stop relo sa pamamagitan ng pagpindot nang isang beses, at para sa paghinto ng oras sa pamamagitan ng pagpindot muli sa parehong pindutan para sa pagtatala ng lumipas na oras .... ang pangalawang pindutan ay ginamit para sa pag-reset ng orasan pabalik sa zero.

Ang mekanikal na orasan ng paghinto ay karaniwang gumana sa pamamagitan ng lakas ng tagsibol, na kung saan kinakailangan ng manu-manong pag-ikot ng panahon sa pamamagitan ng pag-on ng ibinigay na knurled knob sa tuktok ng aparato ng orasan.

Gayunpaman kumpara sa modernong mga digital na relo ng paghinto, ang mga uri ng mekanikal ay maaaring maituring na makabuluhang primitive at hindi tumpak sa saklaw ng milliseconds.

Paggamit ng isang Arduino

At ngayon sa pag-usbong ng microcontroller, ang mga stop relo na ito ay naging lubos na tumpak at maaasahan sa saklaw ng microsecond.

Ang Arduino stop relo circuit na ipinakita dito ay isa sa mga modernong disenyo na pinapatakbo ng microcontroller na kung saan ang pinaka-tumpak ay maaaring asahan na maging par sa komersyal na mga modernong gadget ng stop relo.

Alamin natin kung paano bumuo ng ipinanukalang Arduino stop clock circuit:

Kakailanganin mo ang sumusunod na Bill ng mga materyales para sa konstruksyon:

Kinakailangan ang Hardware

Isang Arduino LCD KeyPad Shield (SKU: DFR0009)

Isang Arduino ONE board

Isang Arduino USB cable

Sa sandaling nakuha mo ang materyal sa itaas at naiugnay ang mga ito sa bawat isa, ito ay tungkol lamang sa pag-configure ng sumusunod na ibinigay na sketch code sa iyong Arduino board at panoorin ang mahika ng mga pag-andar ng stop relo.

Ang Code

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

Pagdaragdag ng isang 7 Segment Display

Ngayon ay magpatuloy tayo sa mga detalye tungkol sa pagtatayo ng isang stopwatch circuit gamit ang 7 segment LED display at Arduino. Susuriin namin ang mga konsepto na nauugnay sa mga nakakagambala at ipakita ang mga driver ng IC na mahalaga para maunawaan ang proyektong ito. Ang proyektong ito ay iminungkahi ni G. Abu-Hafss na isa sa masugid na mambabasa ng website na ito.

Tulad ng alam na natin na ang Stopwatch ay isang aparato na makakatulong upang subaybayan ang maikling panahon mula sa oras hanggang sa saklaw ng milliseconds (karamihan). Halos lahat ng murang mga digital na relo ng pulso ay nilagyan ng pag-andar ng stopwatch, ngunit wala sa mga relo ang maaaring magbigay ng kasiyahan sa paggawa ng isa para sa ating sarili at makahanap din ng isang stopwatch na may 7 segment na LED display ay pambihira.

Iminungkahi sa amin ni G. Abu-Hafss na magdisenyo ng isang segundometro na may 4 na pagpapakita, dalawa para sa minuto at dalawa para sa segundo (MM: SS) na pagsasaayos. Ngunit para sa karamihan sa atin maaaring hindi ito isang magagawa na disenyo, kaya nagdagdag kami ng dalawa pang pagpapakita para sa hanay ng millisecond kaya ngayon ang iminungkahing disenyo ay nasa MM: SS: mS pagsasaayos.

Kung kailangan mo lamang ng MM: Ang pagsasaayos ng SS para sa ilang kadahilanan, hindi mo na kailangang ikonekta ang mga display ng segment na hanay na millisecond at ang mga driver ng IC, ang buong pag-andar ng circuit ay hindi pa rin maaapektuhan.

Ang circuit:

Ang ipinanukalang stopwatch ay binubuo ng anim na IC 4026 na pitong segment display driver, anim na 7 segment LED display, isang Arduino board, isang pares ng mga push button at ilang 10K resistors.

Ngayon ay unawain natin kung paano ikonekta ang IC 4026 sa 7 segment na pagpapakita.

Ang pagpapakita ng 7 segment ay maaaring maging anumang karaniwang pagpapakita ng cathode ng anumang kulay. Ang display ng 7 segment ay maaaring madaling mapatay ng 5V supply, kaya't ang isang 330 ohm resistor ay sapilitan sa bawat segment ng display.

Tingnan natin ang diagram ng pin ng IC 4026:

• Ang pin # 1 ay input ng orasan.
• Ang pin # 2 ay hindi pinagana ang orasan, hindi pinagana nito ang bilang sa ipinapakita kung ang pin na ito ay mataas.
• Ang pin # 3 ay ipinapakita ang paganahin kung ang pin na ito ay mababa ang display ay maa-tune off at kabaligtaran.
• Ang pin # 5 ay isinasagawa, na nagiging mataas kapag binibilang ng IC ang 10.
• Ang mga pin na 6, 7, 9, 10, 11, 12, 13 ay mga output na ipinapakita.
• Ang pin # 8 ay GND.
• Ang pin # 16 ay Vcc.
• Ang pin # 15 ay na-reset, kung mataas natin ang pin na ito, ang bilang ay magiging zero.
• Ang mga pin # 4 at # 14 ay hindi ginagamit.

Ipakita ang diagram ng koneksyon:

Anumang isa sa pin ng GND ng 7 segment na pagpapakita ay maaaring konektado sa lupa. Ang IC ay dapat na pinapatakbo mula sa 5V supply o 5 pin na output ng Arduino.

Ang iskemat sa itaas para sa isang display lamang, ulitin ang pareho para sa limang iba pang mga ipinapakita.

Narito ang natitirang iskema:

Ang circuit ay maaaring pinalakas mula sa 9V na baterya. Ang dalawang mga pindutan na ibinigay dito isa para sa pagsisimula ng oras at isa pa para sa pagtigil. Sa pamamagitan ng pagpindot sa pindutan ng pag-reset sa Arduino, ang bilang ng oras ay mai-reset sa zero sa display.

Ang dalawang pindutan ng push ay konektado sa pin # 2 at # 3 na kung saan ay nakakagambala ng hardware ng Arduino / Atmega328P microcontroller.

Unawain natin kung ano ang makagambala:

Mayroong dalawang uri ng mga nakakagambala: makagambala ng hardware at makagambala ng software. Narito ginagamit lamang namin ang pagambala ng hardware.

Ang isang nakakagambala ay isang senyas sa microcontroller, na ginagawang tugon kaagad ng microcontroller sa isang kaganapan.

Mayroon lamang dalawang mga nakakagambala na pin ng hardware sa mga board ng Arduino na may ATmega328P microcontroller pin # 2 at # 3. Ang Arduino mega ay may higit sa dalawang mga nakakagambala na mga pin ng hardware.

Hindi maaaring gumawa ang mga microcontroller ng dalawang pagpapaandar nang sabay. Halimbawa ng pagsuri para sa pindutan ng pagpindot at pagbibilang ng mga numero.

Ang mga microcontrollers ay hindi maaaring magpatupad ng dalawang mga kaganapan nang sabay-sabay, kung nagsusulat kami ng isang code para sa pag-check ng pindutan ng pagpindot at pagbibilang ng mga numero, ang pindutan ng pindutan ay makakakita lamang kapag binasa ng microcontroller ang pindutan ng pindutan ng pagtuklas ng code, natitirang oras (binibilang ang mga numero) ang hindi gagana ang pindutan.

Kaya't magkakaroon ng pagkaantala sa pagtuklas ng pindutin ang pindutan at sa ilang kadahilanan kung pansamantalang napahinto ang code, maaaring hindi kailanman makita ang pindot ng pindutan. Upang maiwasan ang mga ganitong uri ng mga isyu ay nakakagambala ay ipinakilala.

Ang makagambala signal ay palaging binibigyan ng pinakamataas na priyoridad, ang pangunahing pag-andar (pangunahing mga linya ng code) ay titigil at isagawa ang (ibang piraso ng code) na pagpapaandar na nakatalaga para sa partikular na makagambala.

Napakahalaga nito para sa mga kritikal na oras na aplikasyon tulad ng stopwatch o mga system ng seguridad atbp kung saan kailangang gumawa ng agarang aksyon ang processor bilang tugon sa isang kaganapan.

Sa Arduino nagtatalaga kami ng hardware makagambala bilang:

attachInterrupt (0, start, RISING)

• Ang '0' ay nangangahulugang ang makagambala na bilang na zero (sa mga microcontroller lahat ay nagsisimula mula sa zero) na kung saan ay ang pin # 2.
• Ang 'start' ay pangalan ng nakakagambala na pag-andar, maaari mong pangalanan ang anuman dito.
• 'RISING' kung ang pin # 2 (na nakakagambala sa zero) ay mataas, ang gumagalaw na pagpapaandar ay naisagawa.

maglakip ng Interrupt (1, Itigil, RISING)

• Ang ibig sabihin ng '1' ay ang nagambala na numero uno na kung saan ay ang pin # 3.
• Ang 'Itigil' ang pangalan ng nakakagambala.

Maaari din nating palitan ang 'RISING' ng 'FALLING', ngayon kapag ang maputol na pin ay napapabagsak na LOW the interrupt function executes.

Maaari din nating palitan ang 'RISING' ng 'PAGBABAGO', ngayon tuwing ang nakakagambala na pin ay mula sa mataas hanggang sa mababa o mababa hanggang sa mataas, ang gumagambala na function ay naisagawa.

Maaaring italaga ang makagambala na pag-andar tulad ng sumusunod:

void start () // start ay ang pangalan ng makagambala.

{

// program dito

}

Ang makagambala na pag-andar ay dapat na maikli hangga't maaari at hindi magamit ang pagpapaandar na () pagpapaandar.

Tinapos nito ang makagambala ng software na makagambala ng software na nauugnay sa Arduino ay ipapaliwanag sa hinaharap na artikulo.

Ngayon alam mo kung bakit nakakonekta namin ang pagsisimula at itigil ang mga pindutan ng push upang makagambala ang mga pin.

Ikonekta ang circuit ayon sa diagram na natitira sa circuit na nagpapaliwanag sa sarili.

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---------------//
Ngayon na nagtatapos ang code.

Espesyal na Binuo para sa mga Atheletes ang Stopwatch

Sa wakas, alamin natin kung paano ang mga konsepto sa itaas na cam ay talagang na-upgrade para sa mga atleta na nais na paunlarin ang kanilang mga kasanayan sa pagtakbo nang hindi nakasalalay sa iba para sa kinakailangang pagsisimula at itigil ang timer / stopwatch. Mas mahusay na awtomatikong simulan ang timer sa pamamagitan ng pagtuklas ng iyong paggalaw kaysa sa isang taong nagsisimula / tumitigil sa stopwatch, na maaaring idagdag din ang oras ng kanilang reaksyon.

TANDAAN: Ang proyektong ito ay dinisenyo para sa pagsukat ng oras sa pagitan ng puntong 'A' upang ituro ang 'B' na sakop ng ONE gumagamit nang paisa-isa.

Ang setup ay binubuo ng dalawang mga laser na inilagay sa panimulang punto at pagtatapos na punto, ang dalawang LDR ay inilalagay din sa tapat ng dalawang module ng laser. Kapag ginambala ng atleta ang laser na 'nagsisimula' ang oras ay nagsisimulang kalkulahin at kapag naabot ng wakas ang atleta, nagagambala ng 'pagtatapos' na laser at timer na humihinto at ipinapakita ang lumipas na oras sa pagitan ng dalawang puntos. Ito ang pamamaraang ginamit upang sukatin ang lumipas na oras sa iminungkahing ideya.

Tingnan natin nang detalyado ang bawat bahagi ng circuit.

Mga Detalye ng Paggawa ng Mga Bahagi

Ang circuit ay pinananatiling medyo simple, binubuo ito ng 16 x 2 LCD module, kaunting resistors, dalawang LDR at isang push button.

Ang interface sa pagitan ng LCD at arduino ay pamantayan maaari kaming makahanap ng katulad na koneksyon sa maraming iba pang mga proyekto batay sa LCD.

Ang dalawang mga analogue pin na A0 at A1 ay ginagamit upang makita ang mga pagkagambala ng laser. Ang Analogue pin A2 ay konektado sa pindutan ng push na ginagamit upang braso ang stopwatch.

Tatlong resistors, dalawang 4.7K at isang 10K ay pull-down down na resistors na makakatulong sa mga pin ng input upang manatili sa mababa.

Ang 10K potentiometer ay ibinibigay para sa pag-aayos ng kaibahan sa LCD module para sa pinakamainam na kakayahang makita.

Ang ipinanukalang circuit ay dinisenyo na may mekanismo ng pagtuklas ng kasalanan para sa mga laser. Kung ang alinman sa laser ay may pagkakamali o hindi nakahanay nang maayos sa LDR, nagpapakita ito ng isang mensahe ng error sa LCD display.

· Kung ang pagsisimula ng laser ay hindi gumagana, ipinapakita nito ang ''start' laser ay hindi gumagana'

· Kung ang STOP laser ay hindi gumagana, ipinapakita nito ang ''stop' laser ay hindi gumagana'

· Kung ang parehong mga laser ay hindi gumagana, ipinapakita nito ang 'Parehong mga laser ay hindi gumagana'

· Kung ang parehong mga laser ay gumagana nang maayos, ipinapakita nito ang 'Parehong mga laser ay gumagana nang maayos'

Lumilitaw ang mensahe ng error hanggang sa maayos ang module ng laser o pagkakahanay na ginawa nang maayos sa LDR.

Kapag ang hakbang na ito ay walang problema, ang system ay pupunta sa mode na standby at ipinapakita ang '-system na standby-'. Sa puntong ito ang gumagamit ay maaaring braso ang pag-setup sa pamamagitan ng pagpindot sa pindutan ng push anumang oras.

Ang isang pindutan ng push ay pinindot ang system ay handa na upang tuklasin ang paggalaw mula sa gumagamit at ipinapakita ang 'System ay handa na'.

Ang runner ay maaaring ilang pulgada mula sa 'start' laser.

Kung ang 'pagsisimula' na laser ay nagambala ang oras ay nagsisimulang bilangin at ipinapakita ang 'Oras ay kinakalkula ……' Ang oras ay kinakalkula sa likod na lupa.

Ang lumipas na oras ay hindi ipapakita hanggang sa maabot / matakpan ng runner ang 'stop' laser. Ito ay dahil sa pagpapakita ng lumipas na oras sa LCD tulad ng tradisyonal na stopwatch, nangangailangan ng maraming karagdagang mga tagubilin upang maipatupad sa microcontroller, na lumala ng kawastuhan ng pag-setup nang malaki.

TANDAAN: Pindutin ang pindutan ng pag-reset sa arduino upang i-clear ang mga pagbabasa.

Paano maitakda ang circuit sa pagpapatakbo ng track:

Mangyaring gumamit ng makapal na mga wire upang kumonekta sa pagitan ng LDRs at arduino circuit dahil ang distansya sa pagitan ng dalawang ito ay maaaring ilang metro ang pagitan, at ang boltahe ay hindi dapat mahulog nang malaki. Ang distansya sa pagitan ng LDR1 at LDR2 ay maaaring ilang daang metro ang maximum.

Paano i-mount ang LDR:

Ang LDR ay dapat na mai-mount sa loob ng guwang opaque tube at harap na bahagi ay dapat ding takpan at isang butas lamang na may ilang diameter na diameter ang ginawa para payagan ang laser beam na pumasok.

Dapat protektahan ang LDR mula sa direktang sikat ng araw dahil hindi nito naiiba ang pagkakaiba mula sa laser beam at iba pang mapagkukunan ng ilaw at maaaring hindi magrehistro ng paggalaw mula sa gumagamit.

Code ng Programa:

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

Prototype ng may-akda:

Pag-a-upgrade sa isang Split Timer Facility

Ang ipinanukalang awtomatikong circuit ng stopwatch na may split timer ay isang extension ng Awtomatikong Stopwatch circuit, kung saan awtomatikong sinusubaybayan ng stopwatch ang oras sa sandaling umalis ang solo runner sa panimulang punto at huminto ang timer at ipakita ang lumipas na oras habang ang runner ay umabot sa end point.

Panimula

Ang proyektong ito ay iminungkahi ng isa sa masugid na mambabasa ng website na ito na si G. Andrew Walker.

Sa proyektong ito ipinakikilala namin ang 4 pang mga LDR upang masukat ang split time ng solo runner. Mayroong 6 LDRs sa kabuuan lahat ng mga ito ay maaaring mailagay sa tumatakbo na track na may pare-parehong distansya sa pagitan nila o depende sa mga pangyayari at pagpipilian ng gumagamit.

Ang karamihan sa hardware ay pinananatiling hindi nagbabago maliban sa pagdaragdag ng 4 LDRs, ngunit ang code ay sumailalim sa malaking pagbabago.

Pagpapakita ng Hating Hating:

Ang circuit sa itaas ay binubuo ng ilang mga bahagi at friendly na nagsisimula. Walang karagdagang paliwanag ang kinakailangan, wire lamang ayon sa circuit diagram.

Paano mag-wire ng LDRs:

Ang LDR 2 ay ipinapakita sa pangunahing diagram ng circuit na kumonekta sa 4 pang mga LDR na kahanay tulad ng ipinakita sa diagram sa itaas.

Diagram ng Layout:

Ang nasa itaas ay ang pangunahing pag-aayos sa kung paano ilagay ang laser. Mangyaring tandaan na ang distansya sa pagitan ng LDRs ay maaaring mapili ng gumagamit depende sa haba ng track.

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

Paano patakbuhin ang Awtomatikong Stopwatch na ito:

• Sa kumpletong pag-set up, i-power muna ang mga laser at pagkatapos ay i-on ang susunod na Arduino circuit.
• Kung ang lahat ng mga laser ay maayos na nakahanay sa mga LDR, ang display ay hindi mag-uudyok kasama ng mga mensahe ng error. Kung mayroon man, mangyaring ihanay nang maayos ang mga ito.
• Ngayon ay ipinapakita ng circuit ang 'System ay naka-standby'. Pindutin ngayon ang pindutang 'magsimula' at ipapakita nito ang 'Handa na ang system'.
• Sa puntong ito kapag nagambala ng solo player ang LDR 1 light beam, nagsisimula ang timer at ipinapakita nito ang 'Oras ay kinakalkula .....'
• Sa sandaling maabot ng manlalaro ang punto ng pagtatapos ibig sabihin LDR 6, humihinto ang timer at ipinapakita nito ang 5 split time na naitala ng circuit.
• Kailangang pindutin ng gumagamit ang pindutan ng pag-reset sa arduino upang i-reset ang timer.
Bakit hindi maipakita ng awtomatikong stopwatch ang live na tiyempo sa display tulad ng ginagawa ng tradisyunal na stopwatch (ngunit ipinapakita nito ang isang static na teksto na 'Kinakalkula ang oras .....')?
Upang maipakita ang tiyempo sa real time, kailangang magpatupad ng karagdagang mga tagubilin ang Arduino sa pagpapakita ng LCD. Ito ay magdaragdag ng ilang mga microsecond sa ilang mga millisecond na pagkaantala sa pangunahing oras ng pagsubaybay ng piraso ng code, na hahantong sa mga hindi tumpak na resulta.

Kung mayroon kang anumang karagdagang mga katanungan, mangyaring ipahayag sa pamamagitan ng seksyon ng komento.