Realizarea unui cronometru automat pentru alergători, sportivi și sportivi

În acest post vom construi un cronometru care pornește automat cronometrul atunci când alergătorul începe să ruleze și cronometrul se oprește când alergătorul ajunge la final. Timpul scurs între punctul de pornire și cel de sfârșit este afișat pe un ecran LCD de 16 x 2.

Mai întâi să începem prin a învăța cum să configurăm un circuit de cronometru Arduino simplu și extrem de precis.

Un cronometru este un dispozitiv cu ceas de timp controlat manual conceput pentru măsurarea duratei de timp care poate să fi scurs începând dintr-un anumit punct de timp când a fost activat și până când a fost dezactivat în cele din urmă. O variantă mai mare a aceluiași dispozitiv se numește cronometrul care este utilizat pentru monitorizarea acțiunii de la distanță și se găsește în mod normal în stadionul sportiv etc.

Cronometru mecanic vs electronic

Anterior, tradiționalul cronometru portabil mecanic era mai comun și folosit de toți în acest scop.

În sistemul mecanic am avut două butoane de presare pentru executarea funcțiilor de cronometru. Unul pentru pornirea ceasului de oprire apăsând o dată și pentru oprirea timpului apăsând din nou același buton pentru înregistrarea timpului scurs .... al doilea buton a fost folosit pentru resetarea ceasului la zero.

Ceasul mecanic de oprire a funcționat practic prin intermediul arcului, ceea ce a necesitat lichidarea manuală a perioadei prin rotirea butonului moletat dat în partea de sus a dispozitivului de ceas.

Cu toate acestea, comparativ cu cronometrele digitale moderne, tipurile mecanice pot fi considerate semnificativ primitive și inexacte în intervalul de milisecunde.

Folosind un Arduino

Și astăzi, odată cu apariția microcontrolerului, aceste cronometre au devenit extrem de precise și fiabile în gama de microsecunde.

Circuitul cronometru Arduino prezentat aici este unul dintre aceste designuri moderne alimentate cu microcontroler, care este cel mai precis, poate fi de așteptat să fie la egalitate cu gadget-urile comerciale moderne.

Să învățăm cum să construim circuitul de ceas oprit Arduino propus:

Veți avea nevoie de următoarea listă de materiale pentru construcție:

Hardware necesar

Un ecran LCD pentru tastatură Arduino (SKU: DFR0009)

O placa Arduino ONE

Un cablu USB Arduino

Odată ce ați achiziționat materialul de mai sus și le-ați conectat unul cu celălalt, este vorba doar de configurarea următorului cod de schiță pe placa Arduino și de a urmări magia funcțiilor ceasului de oprire.

Codul

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

Adăugarea unui afișaj pe 7 segmente

Acum să continuăm cu detaliile referitoare la construcția unui circuit de cronometru folosind afișaj LED pe 7 segmente și Arduino. Vom explora conceptele legate de întreruperi și afișarea circuitelor IC ale driverelor, care sunt cruciale pentru înțelegerea acestui proiect. Acest proiect a fost sugerat de dl Abu-Hafss, care este unul dintre cititorii avizi ai acestui site web.

După cum știm deja, Stopwatch este un dispozitiv care ajută la urmărirea perioadei scurte de timp, de la ore la intervale de milisecunde (mai ales). Aproape toate ceasurile de mână digitale ieftine echipate cu funcționalitate cronometru, dar niciunul dintre ceasuri nu poate oferi pofta de a face unul pentru noi și, de asemenea, găsirea unui cronometru cu afișaj LED pe 7 segmente este excepțională.

Domnul Abu-Hafss ne-a sugerat să proiectăm un cronometru cu 4 afișaje, două pentru minute și două pentru secunde (MM: SS). Dar pentru majoritatea dintre noi s-ar putea să nu fie un design fezabil, așa că am adăugat încă două afișaje pentru gama de milisecunde, așa că acum proiectul propus va fi în configurația MM: SS: mS.

Dacă aveți nevoie doar de configurație MM: SS, dintr-un anumit motiv, nu este nevoie să conectați afișajele de segment de 7 milisecunde și IC-urile driverului său, întreaga funcționalitate a circuitului nu este încă afectată.

Circuitul:

Cronometrul propus este format din șase IC 4026, care este un driver de afișaj pe șapte segmente, șase afișaje LED pe 7 segmente, o placă Arduino, câteva butoane și câteva rezistențe de 10K.

Acum să înțelegem cum să conectăm IC 4026 la afișajul pe 7 segmente.

Afișajul pe 7 segmente poate fi orice afișaj comun de catod de orice culoare. Afișajul pe 7 segmente poate fi ușor distrus de alimentarea cu 5V, astfel încât un rezistor de 330 ohmi este obligatoriu pe fiecare segment al afișajului.

Acum, să vedem diagrama pin a IC 4026:

• Pinul 1 este intrarea de ceas.
• Pinul 2 este dezactivat de ceas, dezactivează numărul afișat dacă acest pin este ridicat.
• Pinul 3 este activat pentru afișare dacă acest pin este scăzut, afișajul va fi dezactivat și invers.
• Știftul # 5 este realizat, care devine ridicat atunci când IC numără 10.
• Pinii 6, 7, 9, 10, 11, 12, 13 sunt ieșiri de afișare.
• Pinul # 8 este GND.
• Pinul # 16 este Vcc.
• Pinul # 15 este resetat, dacă ridicăm acest pin, numărul se transformă la zero.
• Pinii # 4 și # 14 nu sunt folosiți.

Afișați schema de conexiune:

Oricare dintre pinul GND cu afișaj pe 7 segmente poate fi conectat la masă. IC-ul trebuie să fie alimentat de la o sursă de 5V sau pinul de ieșire de 5V al Arduino.

Schema de mai sus pentru un singur afișaj, repetați același lucru pentru alte cinci afișaje.

Iată restul schemei:

Circuitul poate fi alimentat de la o baterie de 9V. Sunt două butoane furnizate aici, unul pentru pornirea timpului și altul pentru oprire. Prin apăsarea butonului de resetare pe Arduino, numărul de timp va fi resetat la zero pe afișaj.

Cele două butoane sunt conectate la pinii # 2 și # 3, care sunt întreruperi hardware ale microcontrolerului Arduino / Atmega328P.

Să înțelegem ce este întreruperea:

Există două tipuri de întreruperi: întreruperea hardware și întreruperea software-ului. Aici folosim doar întreruperea hardware.

O întrerupere este un semnal către microcontroler, care îl face pe microcontroler să răspundă imediat la un eveniment.

Există doar două pini de întrerupere hardware pe plăcile Arduino cu pinul 2 și 3 al microcontrolerului ATmega328P. Arduino mega are mai mult de doi pini de întrerupere hardware.

Microcontrolerele nu pot îndeplini două funcții în același timp. De exemplu, verificarea apăsării butoanelor și numărarea numerelor.

Microcontrolerele nu pot executa două evenimente simultan, dacă scriem un cod pentru verificarea apăsării butoanelor și numărarea numerelor, apăsarea butonului va fi detectată numai atunci când microcontrolerul citește codul de detecție a apăsării butonului, restul timpului (numără numerele) butonul nu funcționează.

Deci, va exista o întârziere în detectarea apăsării butonului și, dintr-un anumit motiv, dacă codul este oprit temporar, este posibil ca apăsarea butonului să nu fie niciodată detectată. Pentru a evita aceste tipuri de probleme este introdusă întreruperea.

Semnalului de întrerupere i se acordă întotdeauna cea mai mare prioritate, funcția principală (liniile principale de cod) va fi oprită și execută funcția (o altă bucată de cod) atribuită pentru întreruperea respectivă.

Acest lucru este foarte important pentru aplicațiile critice în timp, cum ar fi cronometrul sau sistemele de securitate etc., în care procesorul trebuie să ia măsuri imediate ca răspuns la un eveniment.

În Arduino atribuim întreruperi hardware ca:

attachInterrupt (0, start, RISING)

• „0” înseamnă numărul de întrerupere zero (în microcontrolere totul începe de la zero) care este pinul 2.
• „Start” este numele funcției de întrerupere, puteți numi orice aici.
• „RISING” dacă pinul 2 (care este zero de întrerupere) crește, funcția de întrerupere se execută.

attachInterrupt (1, Stop, RISING)

• „1” înseamnă întreruperea numărul unu care este pinul 3.
• „Stop” este numele întreruperii.

De asemenea, putem înlocui „RISING” cu „FALLING”, acum, când pinul de întrerupere scade, funcția de întrerupere se execută.

Putem, de asemenea, să înlocuim „RISING” cu „CHANGE”, acum ori de câte ori pinul de întrerupere trece de la mare la scăzut sau de la scăzut la înalt, funcția de întrerupere se execută.

Funcția de întrerupere poate fi atribuită după cum urmează:

void start () // start este numele întreruperii.

{

// programează aici

}

Funcția de întrerupere trebuie să fie cât mai scurtă și funcția delay () nu poate fi utilizată.

Aceasta concluzionează că întreruperea software-ului de întrerupere hardware legată de Arduino va fi explicată în articolul viitor.

Acum știți de ce am conectat butoanele de pornire și oprire pentru a întrerupe pinii.

Conectați circuitul conform schemei restul circuitului se explică de la sine.

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---------------//
Acum, acesta încheie codul.

Cronometru special dezvoltat pentru Atheletes

În cele din urmă, să învățăm cum conceptele de mai sus pot fi actualizate de fapt pentru sportivii care doresc să-și dezvolte abilitățile de alergare fără a depinde de ceilalți pentru pornirea necesară și oprirea cronometrului / cronometru. Este mai bine să porniți automat cronometrul prin detectarea mișcării dvs. decât cineva care pornește / oprește cronometrul, ceea ce ar putea adăuga și timpul de reacție.

NOTĂ: Acest proiect este conceput pentru măsurarea timpului dintre punctul ‘A’ până la punctul ‘B’ acoperit de UN utilizator la un moment dat.

Setarea constă din două lasere plasate la punctul de pornire și la sfârșit, două LDR-uri sunt plasate, de asemenea, opuse celor două module laser. Când sportivul întrerupe laserul „de pornire”, timpul începe să se calculeze și când sportivul ajunge la final, întrerupe laserul „de încheiere” și temporizatorul se oprește și afișează timpul scurs între două puncte. Aceasta este metoda utilizată pentru a măsura timpul scurs în ideea propusă.

Să privim în detaliu fiecare componentă a circuitului.

Detalii de lucru ale componentelor

Circuitul este destul de simplu, este format din modul LCD 16 x 2, câteva rezistențe, două LDR și un buton.

Interfața dintre LCD și arduino este standard, putem găsi conexiuni similare în multe alte proiecte bazate pe LCD.

Pentru detectarea întreruperilor cu laser se utilizează doi pini analogici A0 și A1. Pinul analogic A2 este conectat cu un buton care este utilizat pentru armarea cronometrului.

Trei rezistențe, două 4.7K și una de 10K sunt rezistențe de tip vertical, care ajută pinii de intrare să rămână la un nivel scăzut.

Potențiometrul de 10K este prevăzut pentru reglarea contrastului în modulul LCD pentru o vizibilitate optimă.

Circuitul propus a fost proiectat cu mecanism de detectare a defectelor pentru lasere. Dacă vreunul dintre laser este defect sau nu este aliniat corect cu LDR, acesta afișează un mesaj de eroare pe ecranul LCD.

· Dacă laserul START nu funcționează, se afișează „laserul„ start ”nu funcționează”

· Dacă laserul STOP nu funcționează, se afișează „laserul„ stop ”nu funcționează”

· Dacă ambele lasere nu funcționează, se afișează „Ambele lasere nu funcționează”

· Dacă ambele lasere funcționează corect, se afișează „Ambele lasere funcționează bine”

Mesajul de eroare apare până când modulul laser nu este corect sau alinierea se face corect cu LDR.

Odată ce acest pas este lipsit de probleme, sistemul trece în modul de așteptare și afișează „-sistem de așteptare al sistemului“. În acest moment, utilizatorul poate înarma setarea apăsând butonul oricând.

La apăsarea butonului, sistemul este gata să detecteze mișcarea de la utilizator și afișează „Sistemul este gata”.

Alergătorul poate fi la câțiva centimetri de laserul „start”.

Dacă laserul „start” este întrerupt, timpul începe să se numere și afișează „Timpul este calculat ……” Timpul este calculat în terenul din spate.

Timpul scurs nu va fi afișat până când alergătorul nu atinge / întrerupe laserul „stop”. Acest lucru se datorează faptului că afișarea timpului scurs pe LCD, așa cum face cronometrul tradițional, necesită mai multe instrucțiuni suplimentare pentru a fi executate în microcontroler, ceea ce deteriorează semnificativ acuratețea setării.

NOTĂ: Apăsați butonul de resetare pe arduino pentru a șterge citirile.

Cum se setează circuitul pe pista de alergare:

Vă rugăm să utilizați fire groase pentru a vă conecta între LDR și circuitul arduino, deoarece distanța dintre aceste două poate fi la câțiva metri distanță, iar tensiunea nu trebuie să scadă semnificativ. Distanța dintre LDR1 și LDR2 poate fi de câteva sute de metri maximum.

Cum se montează LDR:

LDR-ul trebuie montat în interiorul unui tub opac gol, iar partea frontală trebuie de asemenea să fie acoperită și se face doar o gaură cu câțiva milimetri în diametru pentru a permite intrarea razei laser.

LDR trebuie protejat de lumina directă a soarelui, deoarece nu se poate diferenția de raza laser și de alte surse de lumină și ar putea să nu înregistreze mișcarea de la utilizator.

Codul programului:

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

Prototipul autorului:

Actualizarea cu un Split Timer Facility

Circuitul de cronometru automat propus cu cronometru divizat este o extensie a circuitului Cronometru automat, unde cronometrul urmărește automat timpul de îndată ce alergătorul solo părăsește punctul de start și cronometrul se oprește și arată timpul scurs pe măsură ce alergătorul ajunge la punctul final.

Introducere

Acest proiect a fost sugerat de unul dintre cititorii avizi ai acestui site web, dl Andrew Walker.

În acest proiect, introducem încă 4 LDR-uri pentru a măsura timpul împărțit al alergătorului solo. În total sunt 6 LDR-uri, toate pot fi plasate pe pista de alergare cu o distanță uniformă între ele sau în funcție de circumstanțe și de alegerea utilizatorului.

Cea mai mare parte a hardware-ului este menținută neschimbată, cu excepția adăugării a 4 LDR-uri, dar codul a suferit modificări uriașe.

Diagrama schematică care arată timpul împărțit:

Circuitul de mai sus este format din puține componente și pentru începători. Nu este necesară nicio explicație suplimentară, ci doar cablu conform schemei de circuit.

Cum să conectați LDR-uri:

LDR 2 este prezentat pe schema circuitului principal, conectează încă 4 LDR în paralel, așa cum se arată în diagrama de mai sus.

Diagrama aspectului:

Cele de mai sus reprezintă aranjamentul de bază cu privire la modul de plasare a laserului. Vă rugăm să rețineți că distanța dintre LDR-uri poate fi aleasă de utilizator în funcție de lungimea pistei.

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

Cum se operează acest cronometru automat:

• După configurarea finalizată, porniți mai întâi laserele și apoi porniți circuitul Arduino în continuare.
• Dacă toate laserele sunt aliniate corespunzător cu LDR-urile, afișajul nu va apărea cu mesaje de eroare. Dacă există, vă rugăm să le aliniați corect.
• Acum, circuitul afișează „Sistemul este în așteptare”. Acum apăsați butonul „Start” și va afișa „Sistemul este gata”.
• În acest moment, când jucătorul solo întrerupe raza de lumină LDR 1, cronometrul pornește și afișează „Timpul este calculat ....”
• De îndată ce playerul ajunge la punctul final, adică LDR 6, cronometrul se oprește și afișează timpul de 5 diviziuni înregistrat de circuit.
• Utilizatorul trebuie să apese butonul de resetare de pe arduino pentru a reseta temporizatorul.
De ce acest cronometru automat nu poate afișa sincronizarea live pe afișaj, așa cum face cronometrul tradițional (ci mai degrabă afișează un text static „Timpul este calculat ....”)?
Pentru a afișa sincronizarea în timp real, Arduino trebuie să execute instrucțiuni suplimentare pe ecranul LCD. Acest lucru va adăuga câteva microsecunde la câteva întârzieri de milisecunde la codul principal de urmărire a timpului, ceea ce va duce la rezultate inexacte.

Dacă aveți întrebări suplimentare, vă rugăm să exprimați prin secțiunea de comentarii.