Herstellung einer automatischen Stoppuhr für Läufer, Sportler und Sportler

In diesem Beitrag werden wir eine Stoppuhr konstruieren, die den Timer automatisch startet, wenn der Läufer zu laufen beginnt, und den Timer stoppt, wenn der Läufer das Ende erreicht. Die verstrichene Zeit zwischen Start- und Endpunkt wird auf einem 16 x 2 LCD angezeigt.

Lassen Sie uns zunächst lernen, wie Sie eine einfache und äußerst genaue Arduino-Stoppuhrschaltung konfigurieren.

Eine Stoppuhr ist ein manuell gesteuertes Zeitschaltgerät, mit dem die Zeitspanne gemessen werden kann, die ab einem bestimmten Zeitpunkt der Aktivierung und zum Zeitpunkt der endgültigen Deaktivierung möglicherweise verstrichen ist. Eine größere Variante desselben Geräts wird aufgerufen die Stoppuhr, die zur Überwachung der Aktion aus der Ferne verwendet wird und normalerweise im Sportstadion usw. zu finden ist.

Mechanische vs elektronische Stoppuhr

Früher waren die traditionellen mechanischen Handstoppuhren üblicher und wurden von allen für diesen Zweck verwendet.

Im mechanischen System hatten wir zwei Drucktasten zur Ausführung der Stoppuhrfunktionen. Eine zum Starten der Stoppuhr durch einmaliges Drücken und zum Stoppen der Zeit durch erneutes Drücken derselben Taste zum Aufzeichnen der verstrichenen Zeit .... Die zweite Taste wurde zum Zurücksetzen der Uhr auf Null verwendet.

Die mechanische Stoppuhr arbeitete im Wesentlichen über die Federkraft, die ein manuelles Aufwickeln durch Drehen des angegebenen Rändelknopfs oben am Uhrgerät erforderte.

Im Vergleich zu den modernen digitalen Stoppuhren können die mechanischen Typen jedoch im Millisekundenbereich als wesentlich primitiv und ungenau angesehen werden.

Mit einem Arduino

Und heute, mit dem Aufkommen des Mikrocontrollers, sind diese Stoppuhren im Mikrosekundenbereich äußerst genau und zuverlässig geworden.

Die hier vorgestellte Arduino-Stoppuhrschaltung ist eines dieser modernen Designs mit Mikrocontroller-Antrieb, das am genauesten mit den kommerziellen modernen Stoppuhr-Geräten mithalten kann.

Lassen Sie uns lernen, wie die vorgeschlagene Arduino-Stoppuhr aufgebaut wird:

Für den Bau benötigen Sie folgende Stückliste:

Hardware erforderlich

Ein Arduino LCD KeyPad Shield (Artikelnummer: DFR0009)

Ein Arduino ONE Board

Ein Arduino USB-Kabel

Sobald Sie das oben genannte Material erworben und miteinander verbunden haben, müssen Sie lediglich den folgenden angegebenen Skizzencode in Ihrem Arduino-Board konfigurieren und die Magie der Stoppuhrfunktionen beobachten.

Der Code

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

Hinzufügen einer 7-Segment-Anzeige

Fahren wir nun mit den Details zum Aufbau einer Stoppuhrschaltung unter Verwendung einer 7-Segment-LED-Anzeige und Arduino fort. Wir werden die Konzepte für Interrupts und Display-Treiber-ICs untersuchen, die für das Verständnis dieses Projekts von entscheidender Bedeutung sind. Dieses Projekt wurde von Herrn Abu-Hafss vorgeschlagen, der einer der begeisterten Leser dieser Website ist.

Wie wir bereits wissen, handelt es sich bei der Stoppuhr um ein Gerät, mit dem (meistens) ein kurzer Zeitraum von Stunden bis Millisekunden verfolgt werden kann. Fast alle billigen digitalen Armbanduhren sind mit Stoppuhrfunktionen ausgestattet, aber keine der Uhren kann die Lust geben, eine für sich selbst herzustellen, und es ist außergewöhnlich, eine Stoppuhr mit 7-Segment-LED-Anzeige zu finden.

Herr Abu-Hafss schlug uns vor, eine Stoppuhr mit 4 Anzeigen zu entwerfen, zwei für Minuten und zwei für Sekunden (MM: SS). Für die meisten von uns ist dies jedoch möglicherweise kein realisierbares Design. Daher haben wir zwei weitere Anzeigen für den Millisekundenbereich hinzugefügt, sodass das vorgeschlagene Design jetzt in der Konfiguration MM: SS: mS vorliegt.

Wenn Sie aus irgendeinem Grund nur eine MM: SS-Konfiguration benötigen, müssen Sie die 7-Segment-Anzeigen im Millisekundenbereich und die Treiber-ICs nicht anschließen. Die gesamte Funktionalität der Schaltung bleibt davon unberührt.

Die Rennbahn:

Die vorgeschlagene Stoppuhr besteht aus sechs IC 4026, einem 7-Segment-Anzeigetreiber, sechs 7-Segment-LED-Anzeigen, einer Arduino-Karte, einigen Drucktasten und einigen 10K-Widerständen.

Lassen Sie uns nun verstehen, wie Sie den IC 4026 an die 7-Segment-Anzeige anschließen.

Die 7-Segment-Anzeige kann eine beliebige übliche Kathodenanzeige einer beliebigen Farbe sein. Die 7-Segment-Anzeige kann durch 5-V-Versorgung leicht zerstört werden, sodass für jedes Segment der Anzeige ein 330-Ohm-Widerstand erforderlich ist.

Sehen wir uns nun das Pin-Diagramm des IC 4026 an:

• Der Pin Nr. 1 ist ein Takteingang.
• Der Pin # 2 ist Clock Disable, er deaktiviert die Anzeige auf dem Display, wenn dieser Pin hoch ist.
• Der Pin Nr. 3 ist für die Anzeige aktiviert. Wenn dieser Pin niedrig ist, wird die Anzeige ausgeschaltet und umgekehrt.
• Der Pin Nr. 5 ist ausgeführt, was hoch wird, wenn der IC 10 zählt.
• Die Pins 6, 7, 9, 10, 11, 12, 13 sind Anzeigeausgänge.
• Der Pin # 8 ist GND.
• Der Pin # 16 ist Vcc.
• Der Pin Nr. 15 wird zurückgesetzt. Wenn wir diesen Pin hoch setzen, wird der Zähler auf Null gesetzt.
• Die Stifte Nr. 4 und Nr. 14 werden nicht verwendet.

Anschlussplan anzeigen:

Jeder der GND-Pins der 7-Segment-Anzeige kann mit Masse verbunden werden. Der IC muss über eine 5-V-Versorgung oder den 5-V-Ausgangspin von Arduino mit Strom versorgt werden.

Das obige Schema für nur eine Anzeige, wiederholen Sie das gleiche für fünf andere Anzeigen.

Hier ist der Rest des Schaltplans:

Der Stromkreis kann mit einer 9-V-Batterie betrieben werden. Hier sind zwei Tasten vorgesehen, eine zum Starten der Zeit und eine zum Stoppen. Durch Drücken der Reset-Taste auf Arduino wird die Zeitzählung auf dem Display auf Null zurückgesetzt.

Die beiden Drucktasten sind mit Pin 2 und 3 verbunden, die Hardware-Interrupts des Arduino / Atmega328P-Mikrocontrollers sind.

Lassen Sie uns verstehen, was Interrupt ist:

Es gibt zwei Arten von Interrupts: Hardware-Interrupt und Software-Interrupt. Hier verwenden wir nur den Hardware-Interrupt.

Ein Interrupt ist ein Signal an den Mikrocontroller, das den Mikrocontroller veranlasst, sofort auf ein Ereignis zu reagieren.

Es gibt nur zwei Hardware-Interrupt-Pins in Arduino-Boards mit den ATmega328P-Mikrocontroller-Pins Nr. 2 und Nr. 3. Arduino Mega hat mehr als zwei Hardware-Interrupt-Pins.

Die Mikrocontroller können nicht zwei Funktionen gleichzeitig ausführen. Zum Beispiel auf Tastendruck prüfen und Zahlen zählen.

Die Mikrocontroller können nicht zwei Ereignisse gleichzeitig ausführen. Wenn wir einen Code zum Überprüfen des Tastendrucks und zum Zählen von Zahlen schreiben, wird der Tastendruck nur erkannt, wenn der Mikrocontroller den Code zum Erkennen der Tastendruckerkennung liest. Der Rest der Zeit (zählt die Zahlen) Taste funktioniert nicht.

Es kommt also zu einer Verzögerung bei der Erkennung des Tastendrucks. Wenn der Code vorübergehend angehalten wird, wird der Tastendruck aus irgendeinem Grund möglicherweise nie erkannt. Um solche Probleme zu vermeiden, wird ein Interrupt eingeführt.

Das Interrupt-Signal hat immer die höchste Priorität, die Hauptfunktion (Hauptcodezeilen) wird angehalten und führt die für diesen bestimmten Interrupt zugewiesene Funktion (ein weiterer Code) aus.

Dies ist sehr wichtig für zeitkritische Anwendungen wie Stoppuhren oder Sicherheitssysteme usw., bei denen der Prozessor sofort auf ein Ereignis reagieren muss.

In Arduino weisen wir Hardware-Interrupts wie folgt zu:

attachInterrupt (0, start, RISING)

• '0' bedeutet die Interrupt-Nummer Null (bei Mikrocontrollern beginnt alles bei Null), die Pin 2 ist.
• 'Start' ist der Name der Interrupt-Funktion, hier können Sie alles benennen.
• 'RISING' Wenn der Pin # 2 (der Interrupt Null ist) hoch geht, wird die Interrupt-Funktion ausgeführt.

attachInterrupt (1, Stop, RISING)

• '1' bedeutet den Interrupt Nummer eins, der Pin # 3 ist.
• 'Stop' ist der Name des Interrupts.

Wir können auch 'RISING' durch 'FALLING' ersetzen. Wenn der Interrupt-Pin auf LOW geht, wird die Interrupt-Funktion ausgeführt.

Wir können 'RISING' auch durch 'CHANGE' ersetzen. Wenn der Interrupt-Pin von hoch nach niedrig oder von niedrig nach hoch wechselt, wird die Interrupt-Funktion ausgeführt.

Die Interrupt-Funktion kann wie folgt zugewiesen werden:

void start () // start ist der Name des Interrupts.

{

// hier programmieren

}}

Die Interrupt-Funktion muss so kurz wie möglich sein und die delay () -Funktion kann nicht verwendet werden.

Damit ist der Hardware-Interrupt-Software-Interrupt in Bezug auf Arduino in einem zukünftigen Artikel erläutert.

Jetzt wissen Sie, warum wir die Start- und Stopptasten angeschlossen haben, um die Pins zu unterbrechen.

Schließen Sie den Stromkreis gemäß dem Diagramm an. Der Rest des Stromkreises ist selbsterklärend.

Programm:

//----------------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---------------//
Damit ist der Code abgeschlossen.

Stoppuhr speziell für die Atheleten entwickelt

Lassen Sie uns abschließend lernen, wie die oben genannten Konzepte tatsächlich für Athleten verbessert werden, die ihre Lauffähigkeiten entwickeln möchten, ohne auf andere angewiesen zu sein, um den Timer / die Stoppuhr zu starten und zu stoppen. Es ist besser, den Timer automatisch zu starten, indem Sie Ihre Bewegung erkennen, als wenn jemand die Stoppuhr startet / stoppt, wodurch sich möglicherweise auch die Reaktionszeit erhöht.

HINWEIS: Dieses Projekt dient zum Messen der Zeit zwischen Punkt 'A' und Punkt 'B', die jeweils von EINEM Benutzer abgedeckt wird.

Der Aufbau besteht aus zwei Lasern, die am Start- und Endpunkt platziert sind. Zwei LDRs befinden sich ebenfalls gegenüber von zwei Lasermodulen. Wenn der Athlet den 'Start' -Laser unterbricht, beginnt die Zeit zu berechnen, und wenn der Athlet das Ende erreicht, unterbricht der 'End' -Laser und der Timer stoppt und zeigt die verstrichene Zeit zwischen zwei Punkten an. Dies ist die Methode, mit der die in der vorgeschlagenen Idee verstrichene Zeit gemessen wird.

Schauen wir uns jede einzelne Komponente der Schaltung im Detail an.

Arbeitsdetails der Komponenten

Die Schaltung ist recht einfach gehalten und besteht aus einem 16 x 2 LCD-Modul, wenigen Widerständen, zwei LDRs und einem Druckknopf.

Die Schnittstelle zwischen LCD und Arduino ist Standard. Eine ähnliche Verbindung finden wir in vielen anderen LCD-basierten Projekten.

Zwei analoge Pins A0 und A1 werden zur Erkennung von Laserunterbrechungen verwendet. Der analoge Pin A2 ist mit einem Druckknopf verbunden, mit dem die Stoppuhr scharfgeschaltet wird.

Drei Widerstände, zwei 4,7 K und ein 10 K sind Pulldown-Widerstände, die dazu beitragen, dass die Eingangspins niedrig bleiben.

Das 10K-Potentiometer dient zur Einstellung des Kontrasts im LCD-Modul für optimale Sichtbarkeit.

Die vorgeschlagene Schaltung wurde mit einem Fehlererkennungsmechanismus für Laser entworfen. Wenn einer der Laser fehlerhaft ist oder nicht richtig mit dem LDR ausgerichtet ist, wird auf dem LCD-Display eine Fehlermeldung angezeigt.

· Wenn der START-Laser nicht funktioniert, wird angezeigt, dass der Startlaser nicht funktioniert.

· Wenn der STOP-Laser nicht funktioniert, wird angezeigt, dass der Stopp-Laser nicht funktioniert.

· Wenn beide Laser nicht funktionieren, wird angezeigt, dass beide Laser nicht funktionieren.

· Wenn beide Laser ordnungsgemäß funktionieren, wird angezeigt, dass beide Laser einwandfrei funktionieren.

Die Fehlermeldung wird angezeigt, bis das Lasermodul repariert oder die Ausrichtung mit LDR ordnungsgemäß durchgeführt wurde.

Sobald dieser Schritt problemlos ist, wechselt das System in den Standby-Modus und zeigt „-system standby-“ an. Zu diesem Zeitpunkt kann der Benutzer das Setup jederzeit durch Drücken des Druckknopfs aktivieren.

Wenn der Druckknopf gedrückt wird, ist das System bereit, Bewegungen des Benutzers zu erkennen, und zeigt „System ist bereit“ an.

Der Läufer kann einige Zentimeter vom Startlaser entfernt sein.

Wenn der „Start“ -Laser unterbrochen wird, beginnt die Zeit zu zählen und die Anzeige „Zeit wird berechnet ……“ Die Zeit wird im Hintergrund berechnet.

Die verstrichene Zeit wird erst angezeigt, wenn der Läufer den Stopplaser erreicht / unterbricht. Dies liegt daran, dass für die Anzeige der verstrichenen Zeit auf dem LCD wie bei einer herkömmlichen Stoppuhr mehrere zusätzliche Anweisungen im Mikrocontroller ausgeführt werden müssen, was die Genauigkeit des Setups erheblich beeinträchtigt.

HINWEIS: Drücken Sie die Reset-Taste am Arduino, um die Messwerte zu löschen.

So stellen Sie die Rennstrecke auf Laufstrecke:

Bitte verwenden Sie dicke Drähte, um die LDRs und den Arduino-Schaltkreis zu verbinden, da der Abstand zwischen diesen beiden Metern mehrere Meter betragen kann und die Spannung nicht wesentlich abfallen darf. Der Abstand zwischen LDR1 und LDR2 kann maximal einige hundert Meter betragen.

So mounten Sie LDR:

Der LDR muss in einem hohlen undurchsichtigen Rohr montiert werden, und der vordere Teil muss ebenfalls abgedeckt sein, und es ist nur ein Loch mit einem Durchmesser von wenigen Millimetern vorgesehen, damit der Laserstrahl eintreten kann.

Der LDR muss vor direkter Sonneneinstrahlung geschützt werden, da er nicht vom Laserstrahl und anderen Lichtquellen unterscheiden kann und möglicherweise keine Bewegung des Benutzers registriert.

Programmcode:

//-------- 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 des Autors:

Upgrade mit einer Split-Timer-Funktion

Die vorgeschlagene automatische Stoppuhrschaltung mit geteiltem Timer ist eine Erweiterung der automatischen Stoppuhrschaltung, bei der die Stoppuhr die Zeit automatisch verfolgt, sobald der Solo-Läufer den Startpunkt verlässt und der Timer stoppt und die verstrichene Zeit anzeigt, wenn der Läufer den Endpunkt erreicht.

Einführung

Dieses Projekt wurde von einem der begeisterten Leser dieser Website, Herrn Andrew Walker, vorgeschlagen.

In diesem Projekt stellen wir 4 weitere LDRs vor, um die Zwischenzeit des Solo-Läufers zu messen. Insgesamt gibt es 6 LDRs, die alle in einem gleichmäßigen Abstand zwischen ihnen oder je nach den Umständen und der Wahl des Benutzers auf der Laufstrecke platziert werden können.

Der größte Teil der Hardware bleibt unverändert, mit Ausnahme von 4 LDRs, aber der Code wurde stark modifiziert.

Schematische Darstellung der Zwischenzeit:

Die obige Schaltung besteht aus wenigen Komponenten und ist anfängerfreundlich. Es ist keine weitere Erklärung erforderlich, nur Verdrahtung gemäß Schaltplan.

So verdrahten Sie LDRs:

Der LDR 2 ist im Hauptschaltplan dargestellt. Verbinden Sie 4 weitere LDRs parallel, wie im obigen Diagramm gezeigt.

Layoutdiagramm:

Das Obige ist die grundlegende Anordnung zum Platzieren des Lasers. Bitte beachten Sie, dass der Abstand zwischen LDRs je nach Länge des Tracks vom Benutzer gewählt werden kann.

Programm:

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

So bedienen Sie diese automatische Stoppuhr:

• Schalten Sie nach Abschluss der Einrichtung zuerst die Laser ein und dann die Arduino-Schaltung ein.
• Wenn alle Laser richtig auf LDRs ausgerichtet sind, werden auf dem Display keine Fehlermeldungen angezeigt. Falls vorhanden, richten Sie sie bitte richtig aus.
• Jetzt zeigt die Schaltung „System ist Standby“ an. Drücken Sie nun die Taste 'Start' und es wird 'System ist bereit' angezeigt.
• Zu diesem Zeitpunkt startet der Timer, wenn der Solospieler den Lichtstrahl LDR 1 unterbricht, und zeigt an, dass die Zeit berechnet wird.
• Sobald der Player den Endpunkt, d. H. LDR 6, erreicht, stoppt der Timer und zeigt die von der Schaltung aufgezeichnete Zwischenzeit an.
• Der Benutzer muss die Reset-Taste am Arduino drücken, um den Timer zurückzusetzen.
Warum kann diese automatische Stoppuhr nicht wie eine herkömmliche Stoppuhr das Live-Timing auf dem Display anzeigen (sondern zeigt einen statischen Text 'Zeit wird berechnet ...' an)?
Um das Timing in Echtzeit anzuzeigen, muss Arduino zusätzliche Anweisungen für die LCD-Anzeige ausführen. Dies fügt dem Hauptcode für die Zeiterfassung einige Mikrosekunden bis einige Millisekunden Verzögerung hinzu, was zu ungenauen Ergebnissen führt.

Wenn Sie weitere Fragen haben, wenden Sie sich bitte an den Kommentarbereich.