Tworzenie automatycznego stopera dla biegaczy, sportowców i sportowców

W tym poście skonstruujemy stoper, który automatycznie uruchamia stoper, gdy biegacz zacznie biec, a stoper zatrzyma się, gdy biegacz dotrze do końca. Czas, jaki upłynął od początku do końca, jest wyświetlany na wyświetlaczu LCD 16 x 2.

Najpierw zacznijmy od nauczenia się, jak skonfigurować prosty i niezwykle dokładny obwód stopera Arduino.

Stoper to ręcznie sterowany zegar czasu przeznaczony do pomiaru czasu, jaki mógł upłynąć od określonego momentu, w którym został aktywowany, do czasu, gdy został ostatecznie wyłączony. Większy wariant tego samego urządzenia to tzw. stoper, który służy do monitorowania akcji na odległość i zwykle znajduje się na stadionach sportowych itp.

Stoper mechaniczny vs elektroniczny

Wcześniej tradycyjny mechaniczny stoper ręczny był bardziej powszechny i ​​używany przez wszystkich do tego celu.

W układzie mechanicznym mieliśmy dwa przyciski do wykonywania funkcji stopera. Jeden do uruchamiania stopera przez jednokrotne naciśnięcie i do zatrzymywania czasu przez ponowne naciśnięcie tego samego przycisku w celu zapisania upływającego czasu .... drugi przycisk służył do resetowania zegara do zera.

Mechaniczny zegar stopu działał w zasadzie na zasadzie siły sprężyny, co wymagało ręcznego nakręcenia przez przekręcenie danego pokrętła radełkowanego na górze urządzenia zegarowego.

Jednak w porównaniu do nowoczesnych cyfrowych stoperów, typy mechaniczne można uznać za znacznie prymitywne i niedokładne w zakresie milisekund.

Korzystanie z Arduino

A dziś, wraz z pojawieniem się mikrokontrolera, te stopery stały się niezwykle dokładne i niezawodne z dokładnością do mikrosekund.

Przedstawiony tutaj obwód stopera Arduino jest jednym z tych nowoczesnych projektów zasilanych mikrokontrolerem, który jest najdokładniejszy i dorównuje komercyjnym nowoczesnym gadżetom stopera.

Nauczmy się, jak zbudować proponowany obwód zegara zatrzymania Arduino:

Będziesz potrzebował następującego zestawienia materiałów do budowy:

Wymagany sprzęt

Osłona klawiatury Arduino LCD (SKU: DFR0009)

Płytka Arduino ONE

Kabel USB Arduino

Po zdobyciu powyższego materiału i połączeniu ich ze sobą, wystarczy skonfigurować poniższy kod szkicu na tablicy Arduino i obserwować magię funkcji zegara stopera.

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

Dodawanie 7-segmentowego wyświetlacza

Przejdźmy teraz do szczegółów dotyczących budowy obwodu stopera z wykorzystaniem 7-segmentowego wyświetlacza LED i Arduino. Będziemy badać pojęcia związane z przerwaniami i układami scalonymi sterownika ekranu, które są kluczowe dla zrozumienia tego projektu. Projekt ten zasugerował pan Abu-Hafss, który jest jednym z zapalonych czytelników tej strony internetowej.

Jak już wiemy, Stoper to urządzenie, które pomaga śledzić krótkie okresy czasu od godzin do milisekund (głównie). Prawie wszystkie tanie cyfrowe zegarki na rękę wyposażone w funkcję stopera, ale żaden z nich nie jest w stanie dać takiej zapału dla siebie, a także znalezienie stopera z 7-segmentowym wyświetlaczem LED jest wyjątkowe.

Pan Abu-Hafss zaproponował nam zaprojektowanie stopera z konfiguracją 4 wyświetlaczy, dwóch minut i dwóch sekund (MM: SS). Ale dla większości z nas może to nie być wykonalny projekt, więc dodaliśmy dwa kolejne wyświetlacze dla zakresu milisekund, więc teraz proponowany projekt będzie w konfiguracji MM: SS: mS.

Jeśli z jakiegoś powodu potrzebujesz tylko konfiguracji MM: SS, nie musisz podłączać 7-segmentowych wyświetlaczy z zakresem milisekund i jego układów scalonych sterownika, cała funkcjonalność obwodu nadal pozostaje nienaruszona.

Obwód:

Proponowany stoper składa się z sześciu IC 4026, który jest siedmiosegmentowym sterownikiem wyświetlacza, sześciu siedmiosegmentowych wyświetlaczy LED, jednej płytki Arduino, kilku przycisków i kilku rezystorów 10K.

Teraz zrozumiemy, jak podłączyć IC 4026 do 7-segmentowego wyświetlacza.

Wyświetlacz 7-segmentowy może być dowolnym wspólnym wyświetlaczem katodowym w dowolnym kolorze. 7-segmentowy wyświetlacz można łatwo wyłączyć przy zasilaniu 5 V, dlatego rezystor 330 omów jest obowiązkowy w każdym segmencie wyświetlacza.

Teraz zobaczmy schemat pinów IC 4026:

• Pin # 1 to wejście zegara.
• Pin # 2 jest wyłączony zegar, wyłącza licznik na wyświetlaczu, jeśli ten pin jest wysoki.
• Pin # 3 to włączanie wyświetlania, jeśli ten pin jest niski, wyświetlacz zostanie wyłączony i odwrotnie.
• Pin # 5 jest wyprowadzony, który staje się wysoki, gdy IC liczy 10.
• Piny 6, 7, 9, 10, 11, 12, 13 to wyjścia wyświetlacza.
• Pin # 8 to GND.
• Pin # 16 to Vcc.
• Pin # 15 jest resetowany, jeśli podniesiemy ten pin, licznik zmieni się na zero.
• Kołki 4 i 14 nie są używane.

Schemat połączeń wyświetlacza:

Każdy z pinów GND 7-segmentowego wyświetlacza może być podłączony do masy. Układ scalony musi być zasilany z zasilania 5 V lub z pinu wyjściowego 5 V Arduino.

Powyższy schemat tylko dla jednego wyświetlacza, powtórz to samo dla pięciu innych wyświetlaczy.

Oto reszta schematu:

Układ może być zasilany z baterii 9V. Są tu dwa przyciski, jeden do uruchamiania czasu, a drugi do zatrzymywania. Naciskając przycisk resetowania na Arduino, licznik czasu zostanie zresetowany do zera na wyświetlaczu.

Dwa przyciski są podłączone do pinów # 2 i # 3, które stanowią przerwanie sprzętowe mikrokontrolera Arduino / Atmega328P.

Zrozummy, czym jest przerwanie:

Istnieją dwa rodzaje przerwań: przerwania sprzętowe i programowe. Tutaj używamy tylko przerwania sprzętowego.

Przerwanie to sygnał do mikrokontrolera, który zmusi mikrokontroler do natychmiastowej odpowiedzi na zdarzenie.

W płytkach Arduino z pinami # 2 i # 3 mikrokontrolera ATmega328P są tylko dwa piny przerwań sprzętowych. Arduino mega ma więcej niż dwa piny przerwań sprzętowych.

Mikrokontrolery nie mogą wykonywać dwóch funkcji jednocześnie. Na przykład sprawdzanie naciśnięcia przycisku i liczenie liczb.

Mikrokontrolery nie mogą wykonywać dwóch zdarzeń jednocześnie, jeśli napiszemy kod sprawdzający naciśnięcie przycisku i zliczanie cyfr, naciśnięcie przycisku zostanie wykryte tylko wtedy, gdy mikrokontroler odczyta fragment kodu detekcji naciśnięcia przycisku, resztę czasu (zlicza liczby) przycisk nie działa.

Zatem wykrycie naciśnięcia przycisku będzie opóźnione iz jakiegoś powodu, jeśli kod zostanie tymczasowo zatrzymany, naciśnięcie przycisku może nigdy nie zostać wykryte. Aby uniknąć tego rodzaju problemów, wprowadzono przerwanie.

Sygnał przerwania ma zawsze najwyższy priorytet, główna funkcja (główne linie kodu) zostanie zatrzymana i wykona (inny fragment kodu) funkcję przypisaną do danego przerwania.

Jest to bardzo ważne w przypadku aplikacji, w których czas jest krytyczny, takich jak stoper, systemy bezpieczeństwa itp., W których procesor musi podjąć natychmiastowe działanie w odpowiedzi na zdarzenie.

W Arduino przerwanie sprzętowe przypisujemy jako:

attachInterrupt (0, start, RISING)

• „0” oznacza przerwanie numer zero (w mikrokontrolerach wszystko zaczyna się od zera), czyli pin nr 2.
• „Start” to nazwa funkcji przerywającej, tutaj możesz nazwać wszystko.
• „RISING” jeśli pin # 2 (który jest przerwaniem zerowym) osiągnie stan wysoki, funkcja przerwania zostanie wykonana.

attachInterrupt (1, Stop, RISING)

• „1” oznacza przerwanie numer jeden, czyli pin # 3.
• „Stop” to nazwa przerwania.

Możemy również zamienić „RISING” na „FALLING”, teraz, gdy pin przerwania idzie na LOW, funkcja przerwania jest wykonywana.

Możemy również zamienić „RISING” na „CHANGE”, teraz za każdym razem, gdy pin przerwania przechodzi z wysokiego na niski lub z niskiego na wysoki, wykonywana jest funkcja przerwania.

Funkcję przerwania można przypisać w następujący sposób:

void start () // start to nazwa przerwania.

{

// program tutaj

}

Funkcja przerwania musi być jak najkrótsza, a funkcja delay () nie może być używana.

Podsumowując, przerwanie programowe przerwania sprzętowego związane z Arduino zostanie wyjaśnione w przyszłym artykule.

Teraz wiesz, dlaczego połączyliśmy przyciski start i stop, aby przerywać szpilki.

Podłącz obwód zgodnie ze schematem, reszta obwodu jest oczywista.

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---------------//
Na tym kończy się kod.

Stoper opracowany specjalnie dla sportowców

Na koniec dowiedzmy się, jak powyższe koncepcje mogą zostać ulepszone dla sportowców, którzy chcą rozwijać swoje umiejętności biegowe bez polegania na innych w zakresie niezbędnego uruchamiania i zatrzymywania stopera / stopera. Lepiej jest automatycznie uruchomić stoper po wykryciu ruchu niż ktoś, kto uruchamia / zatrzymuje stoper, co może również dodać czas reakcji.

UWAGA: Ten projekt jest przeznaczony do pomiaru czasu między punktem „A” a punktem „B”, który jest pokonywany przez JEDNEGO użytkownika na raz.

Zestaw składa się z dwóch laserów umieszczonych w punkcie początkowym i końcowym, dwa LDR są również umieszczone naprzeciw dwóch modułów laserowych. Kiedy sportowiec przerywa działanie lasera „startowego”, zaczyna się obliczanie czasu, a kiedy atleta dochodzi do końca, przerywa laser „kończący”, a stoper zatrzymuje się i wyświetla czas, który upłynął między dwoma punktami. Jest to metoda używana do pomiaru czasu, jaki upłynął w proponowanym pomyśle.

Przyjrzyjmy się szczegółowo każdemu elementowi obwodu.

Szczegóły robocze komponentów

Układ jest dość prosty, składa się z modułu LCD 16 x 2, kilku rezystorów, dwóch LDR i przycisku.

Interfejs między LCD a arduino jest standardem, podobne połączenie możemy znaleźć w wielu innych projektach opartych na LCD.

Dwa analogowe piny A0 i A1 służą do wykrywania zakłóceń lasera. Pin analogowy A2 jest połączony z przyciskiem, który służy do uzbrojenia stopera.

Trzy rezystory, dwa 4.7K i jeden 10K to rezystory pull-down, które pomagają pinom wejściowym pozostać na niskim poziomie.

Potencjometr 10K służy do regulacji kontrastu w module LCD w celu uzyskania optymalnej widoczności.

Proponowany obwód został zaprojektowany z mechanizmem wykrywania uszkodzeń laserów. Jeśli którykolwiek z laserów jest uszkodzony lub nie jest prawidłowo wyrównany z LDR, wyświetla komunikat o błędzie na wyświetlaczu LCD.

· Jeśli laser START nie działa, wyświetla komunikat „Start laser nie działa”

· Jeśli laser STOP nie działa, wyświetla komunikat „stop” laser nie działa ”

· Jeśli oba lasery nie działają, wyświetla się „Oba lasery nie działają”

· Jeśli oba lasery działają prawidłowo, wyświetla się komunikat „Oba lasery działają poprawnie”

Komunikat o błędzie pojawia się, dopóki moduł laserowy nie zostanie naprawiony lub wyrównany za pomocą LDR.

Gdy ten krok jest bezproblemowy, system przechodzi w tryb gotowości i wyświetla „-system standby-”. W tym momencie użytkownik może uzbroić konfigurację, naciskając przycisk w dowolnym momencie.

Po naciśnięciu przycisku system jest gotowy do wykrycia ruchu użytkownika i wyświetla komunikat „System jest gotowy”.

Biegacz może znajdować się kilka cali od lasera „startowego”.

W przypadku przerwania pracy lasera „start” czas zaczyna się odliczać, a na wyświetlaczu pojawia się „Obliczanie czasu ……” Czas jest obliczany w tle.

Upływający czas nie będzie wyświetlany, dopóki biegacz nie osiągnie / przerwie laser „stop”. Dzieje się tak, ponieważ wyświetlanie upływającego czasu na wyświetlaczu LCD, tak jak robi to tradycyjny stoper, wymaga wykonania kilku dodatkowych instrukcji w mikrokontrolerze, co znacznie pogarsza dokładność konfiguracji.

UWAGA: Naciśnij przycisk resetowania na arduino, aby wyczyścić odczyty.

Jak ustawić tor na bieżni:

Do połączenia między LDR a obwodem arduino należy używać grubych przewodów, ponieważ odległość między nimi może wynosić kilka metrów, a napięcie nie może znacznie spaść. Odległość między LDR1 i LDR2 może wynosić maksymalnie kilkaset metrów.

Jak zamontować LDR:

LDR musi być zamontowany wewnątrz pustej, nieprzezroczystej rurki, a przednia część musi być również zakryta, a tylko otwór o średnicy kilku milimetrów jest wykonany, aby umożliwić wejście wiązki laserowej.

LDR musi być chroniony przed bezpośrednim działaniem promieni słonecznych, ponieważ nie może odróżniać się od wiązki lasera i innego źródła światła i może nie rejestrować ruchu użytkownika.

Kod programu:

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

Prototyp autora:

Aktualizacja za pomocą funkcji Split Timer

Proponowany automatyczny obwód stopera z podzielonym zegarem jest rozszerzeniem obwodu automatycznego stopera, w którym stoper automatycznie śledzi czas, gdy tylko biegacz solo opuści punkt startowy, a stoper zatrzyma się i pokaże upływający czas, gdy biegacz osiągnie punkt końcowy.

Wprowadzenie

Ten projekt został zasugerowany przez jednego z zapalonych czytelników tej witryny, pana Andrew Walkera.

W tym projekcie wprowadzamy 4 kolejne LDR, aby zmierzyć międzyczas biegacza solo. Łącznie jest 6 LDRów, wszystkie mogą być umieszczone na bieżni z jednakową odległością między nimi lub w zależności od okoliczności i wyboru użytkownika.

Większość sprzętu pozostaje niezmieniona, z wyjątkiem dodania 4 LDR, ale kod przeszedł ogromną modyfikację.

Schematyczny diagram przedstawiający międzyczas:

Powyższy obwód składa się z kilku elementów i jest przyjazny dla początkujących. Nie są wymagane żadne dalsze wyjaśnienia, wystarczy okablowanie zgodnie ze schematem obwodu.

Jak podłączyć LDR:

LDR 2 jest pokazany na głównym schemacie obwodu, podłącz 4 kolejne LDR równolegle, jak pokazano na powyższym schemacie.

Schemat układu:

Powyższe przedstawia podstawowe ustalenia dotyczące umieszczania lasera. Należy pamiętać, że odległość między LDR może być wybrana przez użytkownika w zależności od długości toru.

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

Jak obsługiwać ten automatyczny stoper:

• Po zakończeniu konfiguracji włącz najpierw lasery, a następnie włącz obwód Arduino.
• Jeśli wszystkie lasery są prawidłowo wyrównane z LDR, na wyświetlaczu nie pojawią się komunikaty o błędach. Jeśli tak, wyrównaj je prawidłowo.
• Teraz obwód wyświetla „System jest w gotowości”. Teraz naciśnij przycisk „Start”, co spowoduje wyświetlenie komunikatu „System jest gotowy”.
• W tym momencie, gdy gracz solo przerywa wiązkę światła LDR 1, uruchamia się licznik czasu i wyświetla komunikat „Trwa obliczanie czasu…”.
• Gdy tylko gracz osiągnie punkt końcowy, tj. LDR 6, stoper zatrzyma się i wyświetli 5 międzyczasów zarejestrowanych przez tor.
• Użytkownik musi nacisnąć przycisk resetowania na arduino, aby zresetować timer.
Dlaczego ten automatyczny stoper nie może pokazywać czasu na żywo na wyświetlaczu, tak jak robi to tradycyjny stoper (ale raczej wyświetla statyczny tekst „Obliczany jest czas…”)?
Aby wyświetlić taktowanie w czasie rzeczywistym, Arduino musi wykonać dodatkowe instrukcje na wyświetlaczu LCD. Spowoduje to dodanie kilku mikrosekund do kilku milisekund opóźnienia głównego fragmentu kodu śledzenia czasu, co doprowadzi do niedokładnych wyników.

Jeśli masz dalsze pytania, prosimy o wyrażenie ich w sekcji komentarzy.