Koşucular, Sporcular ve Sporcular için Otomatik Kronometre Yapma

Bu yazıda, koşucu koşmaya başladığında zamanlayıcıyı otomatik olarak başlatan ve koşucu sona ulaştığında zamanlayıcı duran bir kronometre inşa edeceğiz. Başlangıç ​​ve bitiş noktası arasında geçen süre 16 x 2 LCD ekranda görüntülenir.

Öncelikle basit ve son derece hassas bir Arduino kronometre devresinin nasıl yapılandırılacağını öğrenerek başlayalım.

Kronometre, etkinleştirildiği ve nihayet devre dışı bırakıldığı zamana kadar belirli bir zaman noktasından başlayarak geçmiş olabilecek zamanın uzunluğunu ölçmek için tasarlanmış, manuel olarak kontrol edilen bir zaman saati cihazıdır. Eylemi uzaktan izlemek için kullanılan ve normalde spor stadyumunda vb. bulunan durma saati.

Mekanik ve Elektronik Kronometre

Daha önce geleneksel mekanik el tipi kronometre daha yaygındı ve herkes tarafından bu amaçla kullanılıyordu.

Mekanik sistemde kronometre işlevlerini yürütmek için iki adet basma düğmesi vardı. Birine bir kez basarak durdurma saatini başlatmak ve aynı düğmeye bir kez daha basarak zamanı durdurmak için geçen süreyi kaydetmek için .... ikinci düğme saati sıfırlamak için kullanıldı.

Mekanik durdurma saati temelde yay gücüyle çalışıyordu, bu da saat cihazının tepesindeki belirli tırtıklı düğmeyi çevirerek manuel olarak sarılması gereken süreyi gerektiriyordu.

Bununla birlikte, modern dijital kronometre ile karşılaştırıldığında, mekanik tipler, milisaniye aralığında önemli ölçüde ilkel ve hatalı olarak kabul edilebilir.

Arduino kullanmak

Ve bugün mikrodenetleyicinin gelişiyle, bu kronometreler mikrosaniye aralığında son derece hassas ve güvenilir hale geldi.

Burada sunulan Arduino kronometre devresi, bu modern mikrodenetleyici ile çalışan tasarımlardan biridir ve en doğru olanı, ticari modern kronometre araçlarına eşit olması beklenebilir.

Önerilen Arduino stop clock devresinin nasıl kurulacağını öğrenelim:

İnşaat için aşağıdaki malzeme listesine ihtiyacınız olacak:

Donanım Gerekli

Bir Arduino LCD KeyPad Shield (SKU: DFR0009)

Bir Arduino ONE kurulu

Bir Arduino USB kablosu

Yukarıdaki materyali edindikten ve bunları birbirine bağladıktan sonra, sadece aşağıdaki verilen taslak kodunu Arduino kartınıza yapılandırmak ve durdurma saati işlevlerinin büyüsünü izlemekle ilgilidir.

Kod

/*
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 Segmentli Ekran Ekleme

Şimdi 7 segment LED ekran ve Arduino kullanarak bir kronometre devresinin yapımı ile ilgili detaylara geçelim. Bu projeyi anlamak için çok önemli olan kesintiler ve ekran sürücü IC'leri ile ilgili kavramları keşfedeceğiz. Bu proje, bu web sitesinin hevesli okuyucularından biri olan Bay Abu-Hafss tarafından önerildi.

Kronometrenin, saatlerden milisaniye aralığına (çoğunlukla) kısa bir süreyi takip etmeye yardımcı olan bir cihaz olduğunu zaten bildiğimiz gibi. Kronometre işlevine sahip neredeyse tüm ucuz dijital kol saatleri, ancak saatlerin hiçbiri kendimiz için bir tane yapma zevki veremez ve ayrıca 7 segment LED ekranlı bir kronometre bulmak olağanüstü.

Sayın Abu-Hafss, ikisi dakika ve ikisi saniye (MM: SS) yapılandırması için 4 ekranlı bir kronometre tasarlamamızı önerdi. Ancak çoğumuz için uygun bir tasarım olmayabilir, bu nedenle milisaniye aralığı için iki ekran daha ekledik, böylece şimdi önerilen tasarım MM: SS: mS konfigürasyonunda olacak.

Herhangi bir nedenle yalnızca MM: SS yapılandırmasına ihtiyacınız varsa, milisaniye aralığı 7 segment ekranlarını ve sürücü IC'lerini bağlamanıza gerek yoktur, devrenin tüm işlevselliği yine de etkilenmez.

Devre:

Önerilen kronometre, yedi segmentli ekran sürücüsü olan altı IC 4026, altı 7 segment LED ekran, bir Arduino kartı, birkaç buton ve birkaç 10K dirençten oluşuyor.

Şimdi IC 4026'yı 7 segment ekrana nasıl bağlayacağımızı anlayalım.

7 segmentli ekran, herhangi bir renkteki herhangi bir ortak katot ekranı olabilir. 7 segmentli ekran, 5V besleme ile kolayca kesilebilir, bu nedenle ekranın her bir segmentinde 330 ohm'luk bir direnç zorunludur.

Şimdi IC 4026'nın pin şemasına bakalım:

• Pim # 1, saat girişidir.
• Pim # 2 saat devre dışıdır, bu pin yüksekse ekrandaki sayımı devre dışı bırakır.
• Pim # 3, bu pim düşükse ekran etkinleştirilir ve ekran kapatılır ve bunun tersi de geçerlidir.
• Pim # 5, IC 10'u saydığında yüksek hale gelen gerçekleştirmedir.
• 6, 7, 9, 10, 11, 12, 13 pinleri görüntü çıkışlarıdır.
• 8 numaralı pim GND'dir.
• # 16 numaralı pin Vcc'dir.
• Pim # 15 sıfırlanır, bu pimi yükseltirsek sayım sıfıra döner.
• # 4 ve # 14 pinleri kullanılmaz.

Ekran bağlantı şeması:

7 segment ekranın GND pinlerinden herhangi biri toprağa bağlanabilir. IC, 5V beslemeden veya Arduino’nun 5V çıkış pininden beslenmelidir.

Sadece bir ekran için yukarıdaki şema, diğer beş ekran için aynı şeyi tekrarlayın.

İşte şemanın geri kalanı:

Devre, 9V pil ile çalıştırılabilir. Burada biri zamanı başlatmak ve diğeri durdurmak için iki düğme sağlanmıştır. Arduino üzerindeki reset butonuna bastığınızda ekranda zaman sayacı sıfırlanacaktır.

İki düğme, Arduino / Atmega328P mikrodenetleyicisinin donanım kesintisi olan pin # 2 ve # 3'e bağlanır.

Kesmenin ne olduğunu anlayalım:

İki tür kesinti vardır: donanım kesintisi ve yazılım kesintisi. Burada sadece donanım kesintisini kullanıyoruz.

Kesinti, mikro denetleyiciye gönderilen ve mikro denetleyicinin bir olaya anında yanıt vermesini sağlayan bir sinyaldir.

ATmega328P mikrodenetleyici pin # 2 ve # 3 ile Arduino kartlarında sadece iki donanım kesme pini vardır. Arduino mega, ikiden fazla donanım kesme pinine sahiptir.

Mikrodenetleyiciler aynı anda iki işlevi yerine getiremez. Örneğin, düğmeye basma ve sayıları sayma kontrolü.

Mikrodenetleyiciler aynı anda iki olayı yürütemezler, düğmeye basma ve sayıları sayma için bir kod yazarsak, düğmeye basma yalnızca mikro denetleyici düğmeye basma algılama kod parçasını okuduğunda algılanacaktır, kalan süre (sayıları sayar) düğmesi çalışmıyor.

Bu nedenle, düğmeye basmanın algılanmasında gecikme olacaktır ve herhangi bir nedenle kod geçici olarak durdurulursa, düğmeye basma hiçbir zaman algılanmayabilir. Bu tür sorunları önlemek için interrupt başlatılır.

Kesme sinyaline her zaman en yüksek öncelik verilir, ana işlev (ana kod satırları) durdurulur ve söz konusu kesme için atanan (başka bir kod parçası) işlevi yürütür.

Bu, işlemcinin bir olaya yanıt olarak hemen harekete geçmesi gereken kronometre veya güvenlik sistemleri gibi zaman açısından kritik uygulamalar için çok önemlidir.

Arduino'da donanım kesintisini şu şekilde atarız:

attachInterrupt (0, start, RISING)

• '0', pim # 2 olan sıfır kesme numarası anlamına gelir (mikro denetleyicilerde her şey sıfırdan başlar).
• 'Başlangıç', kesme işlevinin adıdır, burada herhangi bir ad verebilirsiniz.
• 'YÜKSELEN' pim # 2 (kesinti sıfır olan) yükseğe çıkarsa, kesme işlevi yürütülür.

attachInterrupt (1, Durdur, YÜKSELEN)

• '1', pin # 3 olan bir numaralı kesinti anlamına gelir.
• 'Durdur', kesmenin adıdır.

Ayrıca 'YÜKSELME' yi 'DÜŞME' ile değiştirebiliriz, artık kesme pini DÜŞÜK olduğunda, kesme işlevi yürütülür.

Ayrıca, 'RISING' i 'CHANGE' ile değiştirebiliriz, artık kesme pimi yüksekten düşüğe veya düşükten yükseğe gittiğinde, kesme işlevi yürütülür.

Kesme işlevi aşağıdaki şekilde atanabilir:

void start () // start, kesmenin adıdır.

{

// burayı programlayın

}

Kesme işlevi olabildiğince kısa olmalıdır ve gecikme () işlevi kullanılamaz.

Bu, Arduino ile ilgili donanım kesintisi yazılım kesintisinin sonraki makalede açıklanacağı sonucuna varıyor.

Artık pinleri kesmek için başlat ve durdur butonlarını neden bağladığımızı biliyorsunuz.

Devreyi, devrenin geri kalan diyagramına göre bağlayın, kendinden açıklamalıdır.

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---------------//
Şimdi bu kodu tamamlıyor.

Atletler İçin Özel Olarak Geliştirilmiş Kronometre

Son olarak, gerekli zamanlayıcı / kronometreyi başlatmak ve durdurmak için başkalarına güvenmeden koşu becerilerini geliştirmek isteyen sporcular için yukarıdaki kavramların nasıl yükseltileceğini öğrenelim. Kronometreyi başlatan / durduran birine göre hareketinizi algılayarak zamanlayıcıyı otomatik olarak başlatmak daha iyidir, bu da onların tepki sürelerini artırabilir.

NOT: Bu proje, bir seferde BİR kullanıcı tarafından kapsanan 'A' noktası ile 'B' noktası arasındaki süreyi ölçmek için tasarlanmıştır.

Kurulum, başlangıç ​​ve bitiş noktalarına yerleştirilmiş iki lazerden oluşur, iki LDR de iki lazer modülünün karşısına yerleştirilir. Sporcu 'başlangıç' lazerini kestiğinde süre hesaplanmaya başlar ve sporcu sona ulaştığında 'bitiş' lazerini keser ve zamanlayıcı durur ve iki nokta arasında geçen süreyi gösterir. Önerilen fikirde geçen süreyi ölçmek için kullanılan yöntem budur.

Devrenin her bir bileşenine ayrıntılı olarak bakalım.

Bileşenlerin Çalışma Ayrıntıları

Devre oldukça basit tutulur, 16 x 2 LCD modülü, birkaç direnç, iki LDR ve bir basma düğmesinden oluşur.

LCD ve arduino arasındaki arayüz standarttır, diğer birçok LCD tabanlı projede benzer bağlantı bulabiliriz.

Lazer kesintilerini tespit etmek için iki analog pin A0 ve A1 kullanılır. Analog pin A2, kronometreyi kurmak için kullanılan basma düğmesi ile bağlanır.

Üç direnç, iki 4.7K ve bir 10K, giriş pinlerinin düşük kalmasına yardımcı olan aşağı çekme dirençleridir.

Optimum görünürlük için LCD modülünde kontrastı ayarlamak için 10K potansiyometre sağlanmıştır.

Önerilen devre, lazerler için arıza tespit mekanizması ile tasarlanmıştır. Lazerden herhangi biri arızalıysa veya LDR ile doğru şekilde hizalanmamışsa, LCD ekranda bir hata mesajı görüntüler.

· START lazeri çalışmıyorsa, '‘ start ’lazer çalışmıyor' mesajı görüntülenir

· STOP lazeri çalışmıyorsa, ''durdur' lazer çalışmıyor' mesajı görüntülenir

· Her iki lazer de çalışmıyorsa, 'Her iki lazer de çalışmıyor' mesajı görüntülenir

· Her iki lazer de düzgün çalışıyorsa, 'Her iki lazer de iyi çalışıyor' mesajı görüntülenir

Hata mesajı, lazer modülü sabitlenene veya LDR ile hizalama doğru şekilde yapılana kadar görünür.

Bu adım sorunsuz olduğunda, sistem bekleme moduna geçer ve “-sistem bekleme-” mesajını görüntüler. Bu noktada kullanıcı, herhangi bir zamanda butona basarak kurulumu kurabilir.

Basma düğmesine bir kez basıldığında, sistem kullanıcıdan gelen hareketi algılamaya hazırdır ve 'Sistem hazır' mesajı görüntülenir.

Koşucu, 'başlangıç' lazerinden birkaç inç uzakta olabilir.

'Başlat' lazeri kesintiye uğrarsa, zaman saymaya başlar ve 'Zaman hesaplanıyor ……' görüntülenir. Zaman arka planda hesaplanır.

Koşucu lazer 'durdur' lazere ulaşana / onu durdurana kadar geçen süre gösterilmeyecektir. Bunun nedeni, geçen süreyi geleneksel kronometrenin yaptığı gibi LCD'de görüntülemenin, mikrodenetleyicide uygulanacak birkaç ek talimat gerektirmesidir, bu da kurulumun doğruluğunu önemli ölçüde bozar.

NOT: Okumaları temizlemek için arduino üzerindeki sıfırlama düğmesine basın.

Koşu parkurunda devre nasıl ayarlanır:

Bu ikisi arasındaki mesafe birkaç metre uzakta olabileceğinden ve voltaj önemli ölçüde düşmemesi gerektiğinden, LDR'ler ile arduino devresi arasında bağlantı kurmak için lütfen kalın kablolar kullanın. LDR1 ve LDR2 arasındaki mesafe maksimum birkaç yüz metre olabilir.

LDR nasıl monte edilir:

LDR, içi boş opak tüpün içine monte edilmelidir ve ön kısım da kapatılmalıdır ve lazer ışınının içeri girmesine izin vermek için yalnızca birkaç milimetre çapında bir delik açılmalıdır.

LDR, lazer ışını ve diğer ışık kaynaklarından ayırt edilemeyeceği ve kullanıcıdan hareket kaydetmeyebileceği için doğrudan güneş ışığından korunmalıdır.

Program kodu:

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

Yazarın prototipi:

Bölünmüş Zamanlayıcı Tesisi ile Yükseltme

Bölünmüş zamanlayıcı ile önerilen otomatik kronometre devresi Otomatik Kronometre devresinin bir uzantısıdır; kronometre, tek başına koşucu başlangıç ​​noktasından ayrılır ayrılmaz zamanı otomatik olarak izler ve kronometre durur ve koşucu bitiş noktasına ulaştığında geçen süreyi gösterir.

Giriş

Bu proje, bu web sitesinin hevesli okuyucularından biri olan Bay Andrew Walker tarafından önerildi.

Bu projede, tekli koşucunun ayrılma süresini ölçmek için 4 tane daha LDR sunuyoruz. Toplamda 6 adet LDR vardır, hepsi aralarında eşit mesafe olacak şekilde veya koşullara ve kullanıcının tercihine bağlı olarak koşu parkuruna yerleştirilebilir.

Donanımın çoğu, 4 LDR'nin eklenmesi dışında değişmeden tutulur, ancak kod büyük bir değişiklik geçirmiştir.

Ayrık Zamanı Gösteren Şematik Diyagram:

Yukarıdaki devre birkaç bileşenden oluşur ve başlangıç ​​dostu. Daha fazla açıklamaya gerek yoktur, sadece devre şemasına göre kablolayın.

LDR'lerin kablolanması:

LDR 2, ana devre şemasında gösterilmektedir, yukarıdaki şemada gösterildiği gibi 4 tane daha LDR'yi paralel olarak bağlayın.

Yerleşim Şeması:

Yukarıdaki, lazerin nasıl yerleştirileceğine ilişkin temel düzenlemedir. Lütfen LDR'ler arasındaki mesafenin hat uzunluğuna bağlı olarak kullanıcının seçimi olabileceğini unutmayın.

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

Bu Otomatik Kronometre nasıl çalıştırılır:

• Kurulum tamamlandıktan sonra, önce lazerleri açın ve sonra Arduino devresini açın.
• Tüm lazerler LDR'lerle doğru şekilde hizalanmışsa, ekranda hata mesajları görüntülenmez. Varsa, lütfen düzgün şekilde hizalayın.
• Şimdi devre 'Sistem beklemede' gösterir. Şimdi 'başlat' düğmesine basın ve 'Sistem hazır' mesajını gösterecektir.
• Bu noktada, solo oyuncu LDR 1 ışık demetini kestiğinde, zamanlayıcı başlar ve 'Zaman hesaplanıyor ...' mesajı görüntülenir.
• Oyuncu bitiş noktasına, yani LDR 6'ya ulaşır ulaşmaz, zamanlayıcı durur ve devre tarafından kaydedilen 5 ayrık zamanı görüntüler.
• Kullanıcı, zamanlayıcıyı sıfırlamak için arduino üzerindeki sıfırlama düğmesine basmalıdır.
Bu Otomatik kronometre neden geleneksel kronometrenin gösterdiği gibi canlı zamanlamayı ekranda gösteremiyor (bunun yerine statik bir 'Zaman hesaplanıyor ...' metni görüntülüyor)?
Zamanlamayı gerçek zamanlı olarak görüntülemek için Arduino'nun LCD ekrana ek talimatlar uygulaması gerekir. Bu, ana zaman izleme kod parçasına birkaç mikrosaniye veya birkaç milisaniye gecikmesi ekleyerek hatalı sonuçlara yol açar.

Başka sorunuz varsa, lütfen yorum bölümü aracılığıyla açıklayın.