Fabriquer un chronomètre automatique pour les coureurs, les athlètes et les sportifs

Dans cet article, nous allons construire un chronomètre qui démarre automatiquement le chronomètre lorsque le coureur commence à courir et le chronomètre s'arrête lorsque le coureur atteint la fin. Le temps écoulé entre le point de départ et le point de fin est affiché sur un écran LCD 16 x 2.

Commençons par apprendre à configurer un circuit de chronomètre Arduino simple et extrêmement précis.

Un chronomètre est un dispositif d'horloge à commande manuelle conçu pour mesurer la durée qui peut s'être écoulée à partir d'un moment particulier où il a été activé et au moment où il a finalement été désactivé.Une variante plus grande du même appareil est appelée le chronomètre qui est utilisé pour surveiller l'action à distance et se trouve normalement dans un stade de sport, etc.

Chronomètre mécanique vs électronique

Auparavant, les chronomètres mécaniques traditionnels étaient plus courants et utilisés par tous à cette fin.

Dans le système mécanique, nous avions deux boutons-poussoirs pour exécuter les fonctions du chronomètre. Un pour démarrer le chronomètre en appuyant une fois, et pour arrêter le temps en appuyant à nouveau sur le même bouton pour enregistrer le temps écoulé .... le deuxième bouton a été utilisé pour remettre l'horloge à zéro.

L'horloge d'arrêt mécanique fonctionnait essentiellement grâce à la puissance du ressort, ce qui nécessitait un remontage manuel de la période en tournant le bouton moleté donné en haut du dispositif d'horloge.

Cependant, par rapport aux chronomètres numériques modernes, les types mécaniques peuvent être considérés comme significativement primitifs et imprécis dans la plage de millisecondes.

Utiliser un Arduino

Et aujourd'hui, avec l'avènement du microcontrôleur, ces chronomètres sont devenus extrêmement précis et fiables à la microseconde.

Le circuit de chronomètre Arduino présenté ici est l'un de ces modèles modernes alimentés par microcontrôleur qui est le plus précis et qui est à égalité avec les gadgets de chronomètre modernes commerciaux.

Apprenons à construire le circuit d'horloge d'arrêt Arduino proposé:

Vous aurez besoin de la nomenclature suivante pour la construction:

Matériel requis

Un blindage de clavier LCD Arduino (SKU: DFR0009)

Une carte Arduino ONE

Un câble USB Arduino

Une fois que vous avez acquis le matériel ci-dessus et que vous les avez connectés les uns aux autres, il s'agit simplement de configurer le code d'esquisse suivant dans votre carte Arduino et de regarder la magie des fonctions de chronomètre.

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

Ajout d'un affichage à 7 segments

Passons maintenant aux détails concernant la construction d'un circuit de chronomètre utilisant un affichage LED à 7 segments et Arduino. Nous explorerons les concepts liés aux interruptions et aux circuits intégrés de pilote d'affichage qui sont cruciaux pour comprendre ce projet. Ce projet a été suggéré par M. Abu-Hafss qui est l'un des lecteurs avides de ce site.

Comme nous le savons déjà, Chronomètre est un appareil qui permet de suivre une brève période allant de quelques heures à quelques millisecondes (principalement). Presque toutes les montres-bracelets numériques bon marché équipées de la fonctionnalité de chronomètre, mais aucune des montres ne peut donner le goût d'en fabriquer une pour nous-mêmes et trouver un chronomètre avec un affichage LED à 7 segments est exceptionnel.

M. Abu-Hafss nous a suggéré de concevoir un chronomètre avec 4 affichages, deux pour les minutes et deux pour les secondes (MM: SS). Mais pour la plupart d'entre nous, ce n'est peut-être pas une conception réalisable, nous avons donc ajouté deux autres écrans pour une plage de millisecondes, donc maintenant la conception proposée sera en configuration MM: SS: mS.

Si vous avez juste besoin d'une configuration MM: SS pour une raison quelconque, vous n'avez pas besoin de connecter les affichages à 7 segments de la plage de millisecondes et ses circuits intégrés de pilote, toutes les fonctionnalités du circuit ne sont toujours pas affectées.

Le circuit:

Le chronomètre proposé se compose de six IC 4026 qui est un pilote d'affichage à sept segments, six écrans LED à 7 segments, une carte Arduino, deux boutons poussoirs et deux résistances 10K.

Voyons maintenant comment connecter l'IC 4026 à un affichage à 7 segments.

L'affichage à 7 segments peut être n'importe quel affichage cathodique commun de n'importe quelle couleur. L'affichage à 7 segments peut être facilement tué par une alimentation 5V, donc une résistance de 330 ohms est obligatoire sur chaque segment de l'affichage.

Voyons maintenant le diagramme des broches de l'IC 4026:

• La broche n ° 1 est l'entrée d'horloge.
• La broche n ° 2 est désactivée de l'horloge, elle désactive le compte à l'écran si cette broche est haute.
• La broche n ° 3 est activée pour l'affichage si cette broche est basse, l'affichage sera désactivé et vice versa.
• La broche n ° 5 est effectuée, ce qui devient haut lorsque IC compte 10.
• Les broches 6, 7, 9, 10, 11, 12, 13 sont des sorties d'affichage.
• La broche n ° 8 est GND.
• La broche n ° 16 est Vcc.
• La broche n ° 15 est réinitialisée, si nous augmentons cette broche, le compte devient zéro.
• Les broches # 4 et # 14 ne sont pas utilisées.

Afficher le schéma de connexion:

N'importe laquelle des broches GND de l'affichage à 7 segments peut être connectée à la terre. Le circuit intégré doit être alimenté par une alimentation 5V ou la broche de sortie 5V d'Arduino.

Le schéma ci-dessus pour un seul écran, répétez la même chose pour cinq autres écrans.

Voici le reste du schéma:

Le circuit peut être alimenté par une pile 9V. Les deux boutons sont fournis ici un pour démarrer l'heure et un autre pour l'arrêt. En appuyant sur le bouton de réinitialisation sur Arduino, le compte de temps sera remis à zéro sur l'affichage.

Les deux boutons poussoirs sont connectés aux broches n ° 2 et n ° 3 qui sont une interruption matérielle du microcontrôleur Arduino / Atmega328P.

Voyons ce qu'est une interruption:

Il existe deux types d'interruptions: interruption matérielle et interruption logicielle. Ici, nous n'utilisons que l'interruption matérielle.

Une interruption est un signal adressé au microcontrôleur, ce qui obligera le microcontrôleur à répondre immédiatement à un événement.

Il n'y a que deux broches d'interruption matérielle dans les cartes Arduino avec les broches de microcontrôleur ATmega328P # 2 et # 3. Arduino mega a plus de deux broches d'interruption matérielle.

Les microcontrôleurs ne peuvent pas faire deux fonctions en même temps. Par exemple, vérifier la pression des boutons et compter les nombres.

Les microcontrôleurs ne peuvent pas exécuter deux événements simultanément, si nous écrivons un code pour vérifier la pression sur le bouton et compter les nombres, la pression sur le bouton ne sera détectée que lorsque le microcontrôleur lit le morceau de code de détection de pression de bouton, le reste du temps (compte les nombres) le le bouton ne fonctionne pas.

Il y aura donc un retard dans la détection de la pression sur le bouton et pour une raison quelconque, si le code est temporairement arrêté, la pression sur le bouton peut ne jamais être détectée. Pour éviter ce genre de problèmes, une interruption est introduite.

Le signal d'interruption a toujours la priorité la plus élevée, la fonction principale (lignes principales de code) sera arrêtée et exécutera la fonction (un autre morceau de code) affectée à cette interruption particulière.

Ceci est très important pour les applications à temps critique comme le chronomètre ou les systèmes de sécurité, etc. où le processeur doit prendre des mesures immédiates en réponse à un événement.

Dans Arduino, nous attribuons une interruption matérielle comme:

attachInterrupt (0, start, RISING)

• «0» signifie le numéro d'interruption zéro (dans les microcontrôleurs, tout commence à zéro) qui est la broche # 2.
• «Start» est le nom de la fonction d'interruption, vous pouvez tout nommer ici.
• «RISING» si la broche n ° 2 (qui est l'interruption zéro) passe à l'état haut, la fonction d'interruption s'exécute.

attachInterrupt (1, Stop, RISING)

• «1» signifie l'interruption numéro un qui est la broche # 3.
• «Stop» est le nom de l'interruption.

Nous pouvons également remplacer «RISING» par «FALLING», maintenant lorsque la broche d'interruption passe à BAS, la fonction d'interruption s'exécute.

Nous pouvons également remplacer «RISING» par «CHANGE». Désormais, chaque fois que la broche d'interruption passe de haut en bas ou de bas en haut, la fonction d'interruption s'exécute.

La fonction d'interruption peut être affectée comme suit:

void start () // start est le nom de l'interruption.

{

// programmez ici

}

La fonction d'interruption doit être aussi courte que possible et la fonction delay () ne peut pas être utilisée.

Cela conclut que l'interruption logicielle d'interruption matérielle liée à Arduino sera expliquée dans un prochain article.

Vous savez maintenant pourquoi nous avons connecté les boutons poussoirs de démarrage et d'arrêt pour interrompre les broches.

Connectez le circuit selon le schéma, le reste du circuit est explicite.

Programme:

//----------------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---------------//
Maintenant, cela conclut le code.

Chronomètre spécialement développé pour les Atheletes

Enfin, apprenons comment les concepts ci-dessus peuvent être améliorés pour les athlètes qui souhaitent développer leurs compétences de course sans dépendre des autres pour le démarrage et l'arrêt nécessaires du chronomètre / chronomètre. Il est préférable de démarrer automatiquement le chronomètre en détectant votre mouvement que quelqu'un qui démarre / arrête le chronomètre, ce qui peut également ajouter son temps de réaction.

REMARQUE: Ce projet est conçu pour mesurer le temps entre le point «A» et le point «B» couvert par UN utilisateur à la fois.

La configuration se compose de deux lasers placés au point de départ et au point d'arrivée, deux LDR sont également placés en face de deux modules laser. Lorsque l'athlète interrompt le laser de «départ», le temps commence à se calculer et lorsque l'athlète atteint la fin, interrompt le laser de «fin» et le chronomètre s'arrête et affiche le temps écoulé entre deux points. C'est la méthode utilisée pour mesurer le temps écoulé dans l'idée proposée.

Examinons en détail chaque composant du circuit.

Détails de fonctionnement des composants

Le circuit est assez simple, il se compose d'un module LCD 16 x 2, de quelques résistances, de deux LDR et d'un bouton poussoir.

L'interface entre LCD et arduino est standard, nous pouvons trouver une connexion similaire dans de nombreux autres projets LCD.

Deux broches analogiques A0 et A1 sont utilisées pour détecter les interruptions laser. La broche analogique A2 est connectée au bouton poussoir qui sert à armer le chronomètre.

Trois résistances, deux 4,7K et une 10K sont des résistances de tirage vers le bas qui aident les broches d'entrée à rester au niveau bas.

Un potentiomètre 10K est fourni pour régler le contraste dans le module LCD pour une visibilité optimale.

Le circuit proposé a été conçu avec un mécanisme de détection de défaut pour les lasers. Si l'un des lasers est défectueux ou n'est pas correctement aligné avec le LDR, il affiche un message d'erreur sur l'écran LCD.

· Si le laser START ne fonctionne pas, il affiche «Le laser de démarrage ne fonctionne pas»

· Si le laser STOP ne fonctionne pas, il affiche «le laser« stop »ne fonctionne pas»

· Si les deux lasers ne fonctionnent pas, le message «Les deux lasers ne fonctionnent pas» s'affiche.

· Si les deux lasers fonctionnent correctement, le message «Les deux lasers fonctionnent correctement» s'affiche.

Le message d'erreur apparaît jusqu'à ce que le module laser soit fixé ou que l'alignement soit effectué correctement avec LDR.

Une fois cette étape sans problème, le système passe en mode veille et affiche «-system standby-». À ce stade, l'utilisateur peut armer l'installation en appuyant à tout moment sur le bouton-poussoir.

Une fois le bouton poussoir enfoncé, le système est prêt à détecter les mouvements de l'utilisateur et affiche «Le système est prêt».

Le coureur peut être à quelques centimètres du laser «de départ».

Si le laser «de démarrage» est interrompu, le temps commence à compter et les affichages «Le temps est en cours de calcul ……» Le temps est calculé en arrière-plan.

Le temps écoulé ne sera pas affiché jusqu'à ce que le coureur atteigne / interrompt le laser «stop». En effet, l'affichage du temps écoulé sur l'écran LCD comme le fait le chronomètre traditionnel nécessite l'exécution de plusieurs instructions supplémentaires dans le microcontrôleur, ce qui détériore considérablement la précision de la configuration.

REMARQUE: Appuyez sur le bouton de réinitialisation sur arduino pour effacer les lectures.

Comment régler le circuit sur piste de course:

Veuillez utiliser des fils épais pour vous connecter entre les LDR et le circuit arduino car la distance entre ces deux peut être distante de plusieurs mètres et la tension ne doit pas chuter de manière significative. La distance entre LDR1 et LDR2 peut être de quelques centaines de mètres maximum.

Comment monter LDR:

Le LDR doit être monté à l'intérieur du tube creux opaque et la partie avant doit également être recouverte et seul un trou de quelques millimètres de diamètre est fait pour permettre au faisceau laser d'entrer.

Le LDR doit être protégé de la lumière directe du soleil car il ne peut pas se différencier du faisceau laser et d'autres sources de lumière et peut ne pas enregistrer le mouvement de l'utilisateur.

Code de programme:

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

Prototype de l'auteur:

Mise à niveau avec une fonction de minuterie fractionnée

Le circuit du chronomètre automatique proposé avec minuterie fractionnée est une extension du circuit du chronomètre automatique, où le chronomètre suit automatiquement le temps dès que le coureur solo quitte le point de départ et que le chronomètre s'arrête et montre le temps écoulé lorsque le coureur atteint le point final.

introduction

Ce projet a été suggéré par l'un des lecteurs avides de ce site, M. Andrew Walker.

Dans ce projet, nous introduisons 4 LDR supplémentaires pour mesurer le temps intermédiaire du coureur solo. Il y a 6 LDR au total, tous peuvent être placés sur la piste de course avec une distance uniforme entre eux ou selon les circonstances et le choix de l'utilisateur.

La plupart du matériel reste inchangé, sauf l'ajout de 4 LDR, mais le code a subi d'énormes modifications.

Diagramme schématique montrant le temps intermédiaire:

Le circuit ci-dessus se compose de quelques composants et est adapté aux débutants. Aucune autre explication n'est requise, il suffit de câbler selon le schéma de circuit.

Comment câbler les LDR:

Le LDR 2 est montré sur le schéma du circuit principal, connectez 4 LDR supplémentaires en parallèle comme indiqué dans le schéma ci-dessus.

Schéma de disposition:

Ce qui précède est la disposition de base sur la façon de placer le laser. Veuillez noter que la distance entre les LDR peut être choisie par l'utilisateur en fonction de la longueur de la piste.

Programme:

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

Comment utiliser ce chronomètre automatique:

• Une fois la configuration terminée, allumez d'abord les lasers, puis allumez ensuite le circuit Arduino.
• Si tous les lasers sont correctement alignés avec les LDR, l'écran ne présentera pas de messages d'erreur. Le cas échéant, veuillez les aligner correctement.
• Le circuit affiche maintenant «Le système est en veille». Appuyez maintenant sur le bouton «Démarrer» et il affichera «Le système est prêt».
• À ce stade, lorsque le joueur solo interrompt le faisceau lumineux du LDR 1, la minuterie démarre et affiche «Le temps est en cours de calcul…».
• Dès que le joueur atteint le point final, c'est-à-dire LDR 6, le chronomètre s'arrête et il affiche le temps intermédiaire 5 enregistré par le circuit.
• L'utilisateur doit appuyer sur le bouton de réinitialisation de l'arduino pour réinitialiser la minuterie.
Pourquoi ce chronomètre automatique ne peut-il pas afficher le chronométrage en direct sur l'écran comme le fait le chronomètre traditionnel (mais il affiche plutôt un texte statique «Le temps est en cours de calcul…»)?
Pour afficher la synchronisation en temps réel, Arduino doit exécuter des instructions supplémentaires sur l'écran LCD. Cela ajoutera un délai de quelques microsecondes à quelques millisecondes au morceau de code de suivi du temps principal, ce qui entraînera des résultats inexacts.

Si vous avez d'autres questions, veuillez les exprimer via la section des commentaires.