Membuat Stopwatch Otomatis untuk Pelari, Atlet, dan Olahragawan

Dalam posting ini kita akan membangun stopwatch yang secara otomatis memulai pengatur waktu ketika pelari mulai berlari dan pengatur waktu berhenti ketika pelari mencapai akhir. Waktu yang telah berlalu antara titik awal dan akhir ditampilkan pada LCD 16 x 2.

Pertama mari kita mulai dengan mempelajari cara mengonfigurasi rangkaian stopwatch Arduino yang sederhana dan sangat akurat.

Stopwatch adalah perangkat jam waktu yang dikontrol secara manual yang dirancang untuk mengukur lamanya waktu yang mungkin telah berlalu mulai dari titik waktu tertentu ketika diaktifkan, dan pada saat itu akhirnya dinonaktifkan. Varian yang lebih besar dari perangkat yang sama disebut jam berhenti yang digunakan untuk memantau aksi dari kejauhan dan biasanya ditemukan di stadion olahraga dll.

Stopwatch Mekanis vs Elektronik

Sebelumnya stopwatch genggam mekanis tradisional lebih umum, dan digunakan oleh semua orang untuk tujuan tersebut.

Dalam sistem mekanis kami memiliki dua tombol tekan untuk menjalankan fungsi stopwatch. Satu untuk memulai jam berhenti dengan menekan sekali, dan untuk menghentikan waktu dengan menekan tombol yang sama sekali lagi untuk merekam waktu yang telah berlalu .... tombol kedua digunakan untuk menyetel ulang jam kembali ke nol.

Jam penghenti mekanis pada dasarnya bekerja melalui tenaga pegas, yang membutuhkan waktu putaran secara manual dengan memutar kenop knurled yang diberikan di bagian atas perangkat jam.

Namun dibandingkan dengan stopwatch digital modern, tipe mekanis dapat dianggap sangat primitif dan tidak akurat dalam kisaran milidetik.

Menggunakan Arduino

Dan hari ini dengan munculnya mikrokontroler, jam tangan stop ini telah menjadi sangat akurat dan andal untuk kisaran mikrodetik.

Rangkaian stopwatch Arduino yang disajikan di sini adalah salah satu desain bertenaga mikrokontroler modern yang paling akurat dapat diharapkan setara dengan gadget stopwatch modern komersial.

Mari pelajari cara membangun rangkaian stop clock Arduino yang diusulkan:

Anda akan membutuhkan Bill of material berikut untuk konstruksi:

Hardware Diperlukan

Pelindung Papan Tombol LCD Arduino (SKU: DFR0009)

Papan Arduino ONE

Kabel USB Arduino

Setelah Anda memperoleh bahan di atas dan menghubungkannya satu sama lain, ini hanya tentang mengonfigurasi kode sketsa yang diberikan berikut ini ke papan Arduino Anda dan melihat keajaiban fungsi jam berhenti.

Kode

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

Menambahkan Tampilan 7 Segmen

Sekarang mari kita lanjutkan dengan detail mengenai pembangunan rangkaian stopwatch menggunakan tampilan LED 7 segmen dan Arduino. Kami akan mengeksplorasi konsep yang terkait dengan interupsi dan IC driver tampilan yang sangat penting untuk memahami proyek ini. Proyek ini disarankan oleh Tuan Abu-Hafss yang merupakan salah satu pembaca setia situs ini.

Seperti yang sudah kita ketahui bahwa Stopwatch adalah perangkat yang membantu melacak periode waktu singkat dari jam ke rentang milidetik (kebanyakan). Hampir semua jam tangan digital murah dilengkapi dengan fungsi stopwatch, tetapi tidak ada satu pun jam tangan yang dapat memberikan semangat untuk membuat sendiri dan menemukan stopwatch dengan tampilan LED 7 segmen adalah luar biasa.

Bapak Abu-Hafss menyarankan kami untuk merancang stopwatch dengan 4 tampilan, dua untuk menit dan dua untuk detik (MM: SS) konfigurasi. Tetapi bagi sebagian besar dari kita ini mungkin bukan desain yang layak, jadi kita menambahkan dua tampilan lagi untuk kisaran milidetik jadi sekarang desain yang diusulkan akan dalam konfigurasi MM: SS: mS.

Jika Anda hanya memerlukan konfigurasi MM: SS karena alasan tertentu, Anda tidak perlu menghubungkan tampilan segmen milidetik 7 segmen dan IC drivernya, seluruh fungsionalitas rangkaian tetap tidak terpengaruh.

Sirkuit:

Stopwatch yang diusulkan terdiri dari enam IC 4026 yang merupakan driver tampilan tujuh segmen, enam tampilan LED 7 segmen, satu papan Arduino, sepasang tombol tekan, dan sepasang resistor 10K.

Sekarang mari kita pahami cara menghubungkan IC 4026 ke tampilan 7 segmen.

Tampilan 7 segmen dapat berupa tampilan katoda umum dengan warna apa pun. Tampilan 7 segmen dapat dengan mudah dimatikan oleh suplai 5V, jadi resistor 330 ohm wajib ada pada setiap segmen tampilan.

Sekarang mari kita lihat diagram pin IC 4026:

• Pin # 1 adalah input jam.
• Pin # 2 adalah penonaktifan jam, ini menonaktifkan penghitungan pada tampilan jika pin ini tinggi.
• Pin # 3 adalah tampilan aktif jika pin ini rendah, tampilan akan disetel off dan sebaliknya.
• Pin # 5 adalah carry-out, yang menjadi tinggi ketika IC menghitung 10.
• Pin 6, 7, 9, 10, 11, 12, 13 adalah output tampilan.
• Pin # 8 adalah GND.
• Pin # 16 adalah Vcc.
• Pin # 15 direset, jika kita tinggi pin ini hitungan berubah menjadi nol.
• Pin # 4 dan # 14 tidak digunakan.

Diagram koneksi tampilan:

Salah satu pin GND dari tampilan 7 segmen dapat dihubungkan ke ground. IC harus diberi daya dari suplai 5V atau pin keluaran 5V Arduino.

Skema di atas hanya untuk satu tampilan, ulangi hal yang sama untuk lima tampilan lainnya.

Berikut skema lainnya:

Sirkuit ini dapat didukung dari baterai 9V. Ada dua tombol yang disediakan di sini, satu untuk memulai waktu dan satu lagi untuk berhenti. Dengan menekan tombol reset pada Arduino, hitungan waktu akan diatur ulang ke nol pada tampilan.

Kedua push button tersebut dihubungkan dengan pin # 2 dan # 3 yang merupakan interupsi hardware mikrokontroler Arduino / Atmega328P.

Mari kita pahami apa itu interupsi:

Ada dua jenis interupsi: interupsi perangkat keras dan interupsi perangkat lunak. Di sini kami hanya menggunakan interupsi perangkat keras.

Interupsi adalah sinyal ke mikrokontroler, yang akan membuat mikrokontroler segera merespon suatu peristiwa.

Hanya ada dua pin interupsi perangkat keras di papan Arduino dengan pin mikrokontroler ATmega328P # 2 dan # 3. Arduino mega memiliki lebih dari dua pin interupsi perangkat keras.

Mikrokontroler tidak dapat melakukan dua fungsi pada waktu yang sama. Misalnya memeriksa penekanan tombol dan menghitung angka.

Mikrokontroler tidak dapat menjalankan dua kejadian secara bersamaan, jika kita menulis kode untuk memeriksa tekan tombol dan menghitung angka, penekanan tombol akan terdeteksi hanya ketika mikrokontroler membaca kode deteksi tekan tombol, sisa waktu (menghitung angka) tombol tidak berfungsi.

Jadi akan ada penundaan dalam mendeteksi penekanan tombol dan karena alasan tertentu jika kode dihentikan sementara, penekanan tombol mungkin tidak akan pernah terdeteksi. Untuk menghindari masalah semacam ini, interupsi diperkenalkan.

Sinyal interupsi selalu diberi prioritas tertinggi, fungsi utama (baris kode utama) akan dihentikan dan menjalankan fungsi (potongan kode lain) yang ditetapkan untuk interupsi tersebut.

Ini sangat penting untuk aplikasi waktu kritis seperti stopwatch atau sistem keamanan, dll. Di mana prosesor perlu mengambil tindakan segera sebagai respons terhadap suatu peristiwa.

Di Arduino kami menetapkan interupsi perangkat keras sebagai:

attachmentInterrupt (0, start, RISING)

• “0” artinya angka interupsi nol (di mikrokontroler semuanya dimulai dari nol) yaitu pin # 2.
• 'Start' adalah nama fungsi interupsi, Anda dapat memberi nama apa saja di sini.
• “RISING” jika pin # 2 (yang merupakan interupsi nol) menjadi tinggi, fungsi interupsi dijalankan.

attachmentInterrupt (1, Stop, RISING)

• “1” artinya nomor interupsi satu yaitu pin # 3.
• 'Stop' adalah nama interupsi.

Kita juga dapat mengganti “RISING” dengan “FALLING”, sekarang ketika pin interupsi LOW fungsi interupsi dijalankan.

Kita juga dapat mengganti 'RISING' dengan 'CHANGE', sekarang setiap kali pin interupsi berpindah dari tinggi ke rendah atau rendah ke tinggi, fungsi interupsi dijalankan.

Fungsi interupsi dapat ditetapkan sebagai berikut:

void start () // start adalah nama interupsi.

{

// program di sini

}

Fungsi interupsi harus sependek mungkin dan fungsi delay () tidak dapat digunakan.

Itu menyimpulkan interupsi perangkat lunak interupsi perangkat keras terkait dengan Arduino akan dijelaskan di artikel mendatang.

Sekarang Anda tahu mengapa kami menghubungkan tombol start dan stop untuk memotong pin.

Hubungkan sirkuit sesuai diagram sisa sirkuit sudah cukup jelas.

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---------------//
Sekarang selesai kode.

Stopwatch Dikembangkan Khusus untuk Atheletes

Terakhir, mari kita pelajari bagaimana konsep cam di atas sebenarnya ditingkatkan untuk atlet yang ingin mengembangkan keterampilan berlari mereka tanpa bergantung pada orang lain untuk memulai dan menghentikan pengatur waktu / stopwatch. Lebih baik memulai pengatur waktu secara otomatis dengan mendeteksi gerakan Anda daripada seseorang memulai / menghentikan stopwatch, yang mungkin juga menambah waktu reaksinya.

CATATAN: Proyek ini dirancang untuk mengukur waktu antara titik 'A' ke titik 'B' yang dicakup oleh SATU pengguna pada satu waktu.

Setup terdiri dari dua laser ditempatkan pada titik awal dan titik akhir, dua LDR juga ditempatkan berlawanan dengan dua modul laser. Saat atlet menyela laser 'mulai', waktu mulai menghitung dan saat atlet mencapai ujung, laser 'berakhir' dan pengatur waktu akan berhenti dan menampilkan waktu yang telah berlalu antara dua titik. Ini adalah metode yang digunakan untuk mengukur waktu yang telah berlalu dalam gagasan yang diajukan.

Mari kita lihat setiap komponen sirkuit secara mendetail.

Komponen Rincian Kerja

Rangkaian ini dibuat cukup sederhana, terdiri dari modul LCD 16 x 2, beberapa resistor, dua LDR dan satu tombol tekan.

Antarmuka antara LCD dan Arduino adalah standar, kita dapat menemukan koneksi serupa di banyak proyek berbasis LCD lainnya.

Dua pin analog A0 dan A1 digunakan untuk mendeteksi interupsi laser. Pin analog A2 dihubungkan dengan tombol tekan yang digunakan untuk mempersenjatai stopwatch.

Tiga resistor, dua 4,7K dan satu 10K adalah resistor pull-down yang membantu pin input tetap rendah.

Potensiometer 10K disediakan untuk mengatur kontras dalam modul LCD untuk visibilitas yang optimal.

Sirkuit yang diusulkan telah dirancang dengan mekanisme deteksi kesalahan untuk laser. Jika salah satu laser rusak atau tidak disejajarkan dengan benar dengan LDR, ini akan menampilkan pesan kesalahan pada layar LCD.

· Jika laser MULAI tidak berfungsi, laser 'mulai' tidak berfungsi 'ditampilkan

· Jika laser STOP tidak berfungsi, ini akan menampilkan 'laser 'berhenti' tidak berfungsi'

· Jika kedua laser tidak berfungsi, ini akan menampilkan 'Kedua laser tidak berfungsi'

· Jika kedua laser berfungsi dengan baik, ini akan menampilkan 'Kedua laser bekerja dengan baik'

Pesan kesalahan muncul sampai modul laser diperbaiki atau penyelarasan dilakukan dengan benar dengan LDR.

Setelah langkah ini bebas dari masalah, sistem masuk ke mode standby dan menampilkan '-sistem standby-'. Pada titik ini pengguna dapat mempersenjatai pengaturan dengan menekan tombol tekan kapan saja.

Setelah menekan tombol tekan sistem siap untuk mendeteksi gerakan dari pengguna dan menampilkan “Sistem sudah siap”.

Pelari mungkin hanya beberapa inci dari laser 'start'.

Jika laser 'mulai' terputus waktu mulai menghitung dan menampilkan 'Waktu sedang dihitung ……' Waktu dihitung di latar belakang.

Waktu yang telah berlalu tidak akan ditampilkan sampai pelari mencapai / menghentikan laser 'berhenti'. Ini karena menampilkan waktu yang berlalu pada LCD seperti halnya stopwatch tradisional, memerlukan beberapa instruksi tambahan untuk dijalankan di mikrokontroler, yang menurunkan akurasi pengaturan secara signifikan.

CATATAN: Tekan tombol reset pada arduino untuk menghapus pembacaan.

Cara mengatur sirkuit pada lintasan lari:

Harap gunakan kabel tebal untuk menghubungkan antara LDR dan sirkuit arduino karena jarak antara keduanya mungkin terpisah beberapa meter, dan tegangan tidak boleh turun secara signifikan. Jarak antara LDR1 dan LDR2 maksimum beberapa ratus meter.

Cara memasang LDR:

LDR harus dipasang di dalam tabung buram berongga dan bagian depan juga harus ditutup dan hanya dibuat lubang dengan diameter beberapa milimeter untuk memungkinkan sinar laser masuk.

LDR harus dilindungi dari sinar matahari langsung karena tidak dapat membedakan dari sinar laser dan sumber cahaya lain dan mungkin tidak menunjukkan gerakan dari pengguna.

Kode Program:

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

Prototipe penulis:

Mengupgrade dengan Fasilitas Split Timer

Rangkaian stopwatch otomatis yang diusulkan dengan pengatur waktu split merupakan perpanjangan dari rangkaian Stopwatch Otomatis, di mana stopwatch melacak waktu secara otomatis segera setelah pelari tunggal meninggalkan titik awal dan pengatur waktu berhenti dan menunjukkan waktu yang telah berlalu saat pelari mencapai titik akhir.

pengantar

Proyek ini disarankan oleh salah satu pembaca setia situs web ini Mr Andrew Walker.

Dalam proyek ini kami memperkenalkan 4 LDR lagi untuk mengukur waktu split solo runner. Ada total 6 LDR yang semuanya dapat ditempatkan di lintasan lari dengan jarak yang seragam di antara mereka atau tergantung pada keadaan dan pilihan pengguna.

Sebagian besar perangkat keras tidak berubah kecuali penambahan 4 LDR, tetapi kodenya telah mengalami modifikasi besar-besaran.

Diagram Skema Menampilkan Waktu Pisah:

Sirkuit di atas terdiri dari beberapa komponen dan ramah pemula. Tidak diperlukan penjelasan lebih lanjut, cukup sambungkan sesuai diagram sirkuit.

Cara menghubungkan LDR:

LDR 2 ditunjukkan pada diagram sirkuit utama yang menghubungkan 4 LDR lagi secara paralel seperti yang ditunjukkan pada diagram di atas.

Diagram Tata Letak:

Di atas adalah pengaturan dasar tentang cara memasang laser. Perlu diketahui bahwa jarak antar LDR dapat menjadi pilihan pengguna tergantung pada panjang lintasan.

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

Cara mengoperasikan Stopwatch Otomatis ini:

• Setelah penyiapan selesai, nyalakan laser terlebih dahulu dan kemudian nyalakan sirkuit Arduino berikutnya.
• Jika semua laser disejajarkan dengan benar dengan LDR, tampilan tidak akan menampilkan pesan kesalahan. Jika ada, harap sejajarkan dengan benar.
• Sekarang sirkuit menampilkan 'Sistem siaga'. Sekarang tekan tombol 'start' dan itu akan menampilkan 'Sistem sudah siap'.
• Pada titik ini, ketika pemain solo menginterupsi pancaran cahaya LDR 1, pengatur waktu akan dimulai dan menampilkan “Waktu sedang dihitung….”
• Segera setelah pemain mencapai titik akhir yaitu LDR 6, pengatur waktu berhenti dan ini menampilkan 5 waktu split yang direkam oleh sirkuit.
• Pengguna harus menekan tombol reset pada arduino untuk mengatur ulang timer.
Mengapa Stopwatch Otomatis ini tidak dapat menampilkan pengaturan waktu langsung pada tampilan seperti stopwatch tradisional (melainkan menampilkan teks statis 'Waktu sedang dihitung….')?
Untuk menampilkan waktu secara real time, Arduino harus menjalankan instruksi tambahan ke layar LCD. Ini akan menambahkan penundaan beberapa mikrodetik hingga beberapa milidetik ke bagian kode pelacakan waktu utama, yang akan menyebabkan hasil yang tidak akurat.

Jika Anda memiliki pertanyaan lebih lanjut, silakan ungkapkan melalui bagian komentar.