Изработване на автоматичен хронометър за бегачи, спортисти и спортисти

В тази публикация ще конструираме хронометър, който автоматично стартира таймера, когато бегачът започне да работи, и таймерът спира, когато бегачът стигне до края. Изминалото време между началната и крайната точка се показва на 16 x 2 LCD.

Първо нека започнем, като научим как да конфигурираме проста и изключително точна верига на хронометър Arduino.

Хронометърът е ръчно управляван часовник, проектиран за измерване на продължителността на времето, което може да е изтекло, започвайки от определен момент от времето, когато е бил активиран и до момента, в който е бил окончателно деактивиран. По-голям вариант на същото устройство се нарича спирачният часовник, който се използва за наблюдение на действието от разстояние и обикновено се намира на спортен стадион и т.н.

Механичен срещу електронен хронометър

По-рано традиционният механичен ръчен хронометър беше по-често срещан и се използваше от всички за целта.

В механичната система имахме два бутона за натискане за изпълнение на функциите на хронометъра. Един за стартиране на стоп часовника чрез еднократно натискане и за спиране на времето чрез повторно натискане на същия бутон за записване на изминалото време .... вторият бутон е използван за нулиране на часовника обратно.

Механичният часовник за спиране основно работи чрез пружинна мощност, което изисква период на навиване ръчно чрез завъртане на дадения назъбен копче в горната част на часовника.

Въпреки това в сравнение със съвременните цифрови хронометри, механичните типове могат да се считат за значително примитивни и неточни в рамките на милисекунди.

Използване на Arduino

И днес с появата на микроконтролера, тези хронометри са станали изключително точни и надеждни за микросекундния диапазон.

Представената тук схема за хронометър Arduino е една от тези модерни конструкции с микроконтролер, която е най-точна, може да се очаква да бъде наравно с търговските съвременни джаджи за хронометър.

Нека да научим как да изградим предложената верига за спиране на часовника Arduino:

За изграждането ще ви е необходим следният Списък на материалите:

Необходим хардуер

Arduino LCD KeyPad Shield (SKU: DFR0009)

Дъска Arduino ONE

USB кабел Arduino

След като придобиете горния материал и ги свържете един с друг, става въпрос само за конфигуриране на следния даден код на скица във вашата дъска Arduino и наблюдение на магията на функциите на стоп часовника.

Кодът

/*
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-сегментен дисплей

Сега да продължим с подробностите относно изграждането на хронометър с помощта на 7 сегментен LED дисплей и Arduino. Ще проучим концепциите, свързани с прекъсванията и драйверите на дисплея, които са от решаващо значение за разбирането на този проект. Този проект беше предложен от г-н Abu-Hafss, който е един от запалените читатели на този уебсайт.

Както вече знаем, хронометърът е устройство, което помага да се проследява кратък период от време от часове до милисекунди (предимно). Почти всички евтини цифрови ръчни часовници, оборудвани с функционалност на хронометъра, но нито един от часовниците не може да даде желание да направим такъв за себе си, а освен това намирането на хронометър със 7-сегментен LED дисплей е изключително.

Г-н Abu-Hafss ни предложи да проектираме хронометър с 4 дисплея, два за минути и два за секунди (MM: SS). Но за повечето от нас това може да не е осъществим дизайн, така че добавихме още два дисплея за милисекунда обхват, така че сега предложеният дизайн ще бъде в MM: SS: mS конфигурация.

Ако просто се нуждаете от MM: SS конфигурация по някаква причина, не е необходимо да свързвате милисекундните 7-сегментни дисплеи и нейните интегрални схеми за драйвери, цялата функционалност на веригата все още ще бъде незасегната.

Веригата:

Предложеният хронометър се състои от шест IC 4026, което е седем сегментен драйвер за дисплей, шест 7-сегментни LED дисплея, една платка Arduino, няколко бутони и няколко 10K резистора.

Сега нека разберем как да свържете IC 4026 към 7 сегментен дисплей.

7-сегментният дисплей може да бъде всеки често срещан катоден дисплей от всякакъв цвят. 7-сегментният дисплей може лесно да бъде убит от 5V захранване, така че резистор 330 ома е задължителен за всеки сегмент на дисплея.

Сега нека видим схемата на щифтовете на IC 4026:

• ПИН # 1 е вход за часовник.
• ПИН # 2 е деактивиран на часовника, той деактивира броя на дисплея, ако този пин е висок.
• ПИН # 3 е активиран на дисплея, ако този пин е нисък, дисплеят ще бъде настроен и обратно.
• ПИН # 5 е износ, който става висок, когато IC брои 10.
• Пиновете 6, 7, 9, 10, 11, 12, 13 са дисплейни изходи.
• ПИН # 8 е GND.
• ПИН # 16 е Vcc.
• ПИН # 15 се нулира, ако го увеличим, броят се превръща в нула.
• Пиновете # 4 и # 14 не се използват.

Диаграма на свързване на дисплея:

Всеки от GND щифт на 7 сегментен дисплей може да бъде свързан към земята. IC трябва да се захранва от 5V захранване или 5V изходен щифт на Arduino.

Горната схема само за един дисплей, повторете същото за пет други дисплея.

Ето и останалата част от схемата:

Веригата може да се захранва от 9V батерия. Тук са предвидени два бутона, един за стартиране на часа и друг за спиране. Чрез натискане на бутона за нулиране на Arduino, броят на времето ще бъде нулиран на дисплея.

Двата бутона са свързани към щифтове №2 и №3, които са хардуерно прекъсване на микроконтролера Arduino / Atmega328P.

Нека разберем какво е прекъсване:

Има два вида прекъсвания: хардуерно прекъсване и софтуерно прекъсване. Тук използваме само хардуерното прекъсване.

Прекъсването е сигнал към микроконтролера, който кара микроконтролера да реагира незабавно на събитие.

Има само два щифта за хардуерни прекъсвания в платките на Arduino с микроконтролерни щифтове №2 и №3 на ATmega328P. Arduino mega има повече от два хардуерни щифта за прекъсване.

Микроконтролерите не могат да изпълняват две функции едновременно. Например проверка за натискане на бутон и преброяване на числа.

Микроконтролерите не могат да изпълняват две събития едновременно, ако напишем код за проверка на натискането на бутона и преброяване на числата, натискането на бутона ще бъде открито само когато микроконтролерът прочете парче код за откриване на натискане на бутон, през останалото време (брои числата) бутонът не работи.

Така че ще има забавяне в откриването на натискането на бутона и по някаква причина, ако кодът бъде спрян временно, натискането на бутона може никога да не бъде открито. За да се избегнат подобни проблеми, се въвежда прекъсване.

На сигнала за прекъсване винаги се дава най-висок приоритет, основната функция (основните редове на кода) ще бъде спряна и изпълнява функцията (друга част от кода), назначена за това конкретно прекъсване.

Това е много важно за критични за времето приложения като хронометър или системи за сигурност и т.н., при които процесорът трябва да предприеме незабавни действия в отговор на събитие.

В Arduino присвояваме хардуерно прекъсване като:

attachInterrupt (0, старт, RISING)

• „0“ означава номер на прекъсване нула (в микроконтролерите всичко започва от нула), което е пин # 2.
• “Start” е името на функцията за прекъсване, можете да назовете каквото и да е тук.
• „RISING“, ако щифтът № 2 (който е нула на прекъсване) отиде високо, функцията за прекъсване се изпълнява.

attachInterrupt (1, Stop, RISING)

• „1“ означава прекъсване номер едно, което е ПИН # 3.
• „Стоп“ е името на прекъсването.

Също така можем да заменим “RISING” с “FALLING”, сега когато прекъсващият щифт отива НИСКО, функцията за прекъсване се изпълнява.

Също така можем да заменим “RISING” с “CHANGE”, сега когато прекъсващият щифт преминава от високо на ниско или от ниско на високо, функцията за прекъсване се изпълнява.

Функцията за прекъсване може да бъде присвоена, както следва:

void start () // start е името на прекъсването.

{

// програма тук

}

Функцията за прекъсване трябва да бъде възможно най-кратка и функцията delay () не може да се използва.

Това заключава, че прекъсването на софтуерното прекъсване на хардуера, свързано с Arduino, ще бъде обяснено в следваща статия.

Сега знаете защо свързахме бутоните за стартиране и спиране, за да прекъснем щифтовете.

Свържете веригата, както е показано на диаграмата, останалата част от схемата се обяснява сама по себе си.

Програма:

//----------------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---------------//
Сега това завършва кода.

Хронометър, специално разработен за атлетите

И накрая, нека научим как горепосочените концепции всъщност могат да бъдат надградени за спортисти, които искат да развият своите умения за бягане, без да зависят от другите за необходимото стартиране и спиране на таймера / хронометъра. По-добре е автоматично да стартирате таймера, като откриете движението си, отколкото някой, който стартира / спира хронометъра, което може да добави и времето за реакция.

ЗАБЕЛЕЖКА: Този проект е предназначен за измерване на времето между точка „А“ до точка „Б“, обхваната от ЕДИН потребител наведнъж.

Настройката се състои от два лазера, поставени в начална и крайна точка, два LDR също са поставени срещу два лазерни модула. Когато спортистът прекъсне „стартовия“ лазер, времето започва да се изчислява и когато спортистът стигне до края, прекъсва „крайния“ лазер и таймерът спира и показва изминалото време между две точки. Това е методът, използван за измерване на изминалото време в предложената идея.

Нека разгледаме всеки компонент на веригата в детайли.

Подробности за работните компоненти

Веригата е доста проста, тя се състои от 16 x 2 LCD модул, малко резистори, два LDR и бутон.

Интерфейсът между LCD и arduino е стандартен, можем да намерим подобна връзка в много други проекти, базирани на LCD.

Два аналогови щифта A0 и A1 се използват за откриване на лазерни прекъсвания. Аналоговият щифт A2 е свързан с бутон, който се използва за активиране на хронометъра.

Три резистора, два 4.7K и един 10K са падащи надолу резистори, което помага на входните щифтове да останат на ниско ниво.

Предвиден е 10K потенциометър за регулиране на контраста в LCD модула за оптимална видимост.

Предложената схема е проектирана с механизъм за откриване на неизправности за лазери. Ако някой от лазерите е повреден или не е подравнен правилно с LDR, той показва съобщение за грешка на LCD дисплея.

· Ако лазерът START не функционира, той показва „лазерът„ старт “не работи“

· Ако лазерът STOP не функционира, той показва „лазерът„ стоп “не работи“

· Ако и двата лазера не функционират, той показва „И двата лазера не работят“

· Ако и двата лазера функционират правилно, той показва „И двата лазера работят добре“

Съобщението за грешка се появява, докато лазерният модул бъде фиксиран или подравняването е направено правилно с LDR.

След като тази стъпка е безпроблемна, системата преминава в режим на готовност и показва „-система в готовност-“. В този момент потребителят може да активира настройката чрез натискане на бутона по всяко време.

С едно натискане на бутон системата е готова да открие движение от потребителя и показва „Системата е готова“.

Бегачът може да е на няколко сантиметра от лазера „старт“.

Ако лазерът „старт” бъде прекъснат, времето започва да се брои и на дисплея се изписва „Времето се изчислява ...” Времето се изчислява в задната част.

Изминалото време няма да се покаже, докато бегачът достигне / прекъсне лазера „стоп“. Това е така, защото показването на изтичащото време на LCD, както прави традиционният хронометър, изисква няколко допълнителни инструкции, които трябва да бъдат изпълнени в микроконтролера, което значително влошава точността на настройката.

ЗАБЕЛЕЖКА: Натиснете бутона за нулиране на arduino, за да изчистите показанията.

Как да настроите веригата на писта за бягане:

Моля, използвайте дебели проводници за свързване между LDR и ардуиновата верига, тъй като разстоянието между тези две може да е на няколко метра един от друг и напрежението не трябва да пада значително. Разстоянието между LDR1 и LDR2 може да бъде максимум няколкостотин метра.

Как да монтирате LDR:

LDR трябва да се монтира в куха непрозрачна тръба, а предната част също трябва да бъде покрита и да се направи само отвор с диаметър няколко милиметра, за да може лазерният лъч да влезе.

LDR трябва да бъде защитен от пряка слънчева светлина, тъй като не може да се различава от лазерния лъч и друг източник на светлина и може да не регистрира движение от потребителя.

Код на програмата:

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

Прототип на автора:

Надстройка с механизъм за разделен таймер

Предложената схема за автоматичен хронометър с разделен таймер е продължение на автоматична хронометърна верига, където хронометърът проследява времето автоматично, веднага щом соло бегачът напусне началната точка и таймерът спре и покаже изминалото време, когато бегачът достигне крайната точка.

Въведение

Този проект беше предложен от един от запалените читатели на този уебсайт г-н Андрю Уокър.

В този проект въвеждаме още 4 LDR за измерване на времето за разделяне на соло бегача. Общо има 6 LDR, като всички те могат да бъдат поставени в пистата за бягане с еднакво разстояние между тях или в зависимост от обстоятелствата и избора на потребителя.

По-голямата част от хардуера се запазва непроменен, с изключение на добавянето на 4 LDR, но кодът е претърпял огромна модификация.

Схематична диаграма, показваща времето на разделяне:

Горната схема се състои от няколко компонента и е удобна за начинаещи. Не се изискват допълнителни обяснения, а само проводник според схемата.

Как да свържете LDR:

LDR 2 е показан на основната електрическа схема, свързва паралелно още 4 LDR, както е показано на горната схема.

Диаграма на оформлението:

Горното е основното подреждане как да поставите лазера. Моля, обърнете внимание, че разстоянието между LDR може да бъде избор на потребителя в зависимост от дължината на пистата.

Програма:

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

Как да управлявате този автоматичен хронометър:

• След завършена настройка първо включете лазерите и след това включете следващата схема на Arduino.
• Ако всички лазери са правилно подравнени с LDR, на дисплея няма да се появи съобщение за грешка. Ако има такива, моля, подравнете ги правилно.
• Сега схемата показва „Системата е в режим на готовност“. Сега натиснете бутона „старт“ и ще се покаже „Системата е готова“.
• В този момент, когато соло плейърът прекъсне светлинния лъч LDR 1, таймерът стартира и показва „Времето се изчислява ...“.
• Веднага след като плейърът достигне крайната точка, т.е. LDR 6, таймерът спира и показва времето за разделяне 5, записано от веригата.
• Потребителят трябва да натисне бутона за нулиране на arduino, за да нулира таймера.
Защо този автоматичен хронометър не може да показва времето на живо на дисплея, както прави традиционният хронометър (а по-скоро показва статичен текст „Времето се изчислява ...“)?
За да покаже времето в реално време, Arduino трябва да изпълни допълнителни инструкции към LCD дисплея. Това ще добави няколко микросекунди до няколко милисекунди закъснение към основния код за проследяване на времето, което ще доведе до неточни резултати.

Ако имате допълнителни запитвания, моля, изразете чрез раздела за коментари.