Comment faire du tracker de vitesse à l'aide de modules IR avec Arduino Uno

L'Arduino est une plate-forme très diversifiée qui offre à l'utilisateur une grande variété d'options lors de la conception d'un matériel pour tout type de projet. Sur le matériel potentiel, Arduino fournit une variété de cartes de microcontrôleur qui peuvent être sélectionnées sur la base du niveau des projets. Le plus populaire parmi les planches Arduino est la carte Arduino Uno en raison de sa simplicité et de sa compatibilité. De plus, en utilisant la plate-forme Arduino, nous pouvons interfacer différents appareils, y compris les capteurs et les modules avec les microcontrôleurs. Nous avons utilisé Arduino Uno pour créer un système de suivi de vitesse qui mesure la vitesse de tout objet en mouvement en utilisant le module de capteur infrarouge.

Comment faire du tracker de vitesse à l'aide du module IR avec Arduino Uno

Pour mesurer la vitesse d'un objet en mouvement, nous avons utilisé deux modules IR avec Arduino Uno. Ainsi, lorsque l'objet passe par les deux modules, nous pouvons mesurer la vitesse en prenant la différence du temps auquel l'objet a traversé chaque module. Nous avons publié l'image pour le schéma du circuit conçu pour le projet de suivi de la vitesse.

Assemblage matériel pour le tracker de vitesse Arduino Uno à l'aide du module IR

La liste des composants requis pour fabriquer un tracker de vitesse à l'aide du module IR avec Arduino Uno est donné ci-dessous

• Arduino Uno
• Fils de connexion
• Affichage en cristal liquide 16 × 2 (LCD)
• 1 potentiomètre
• 1 résistance de 220 ohms
• 1 LED
• 2 modules IR

Vous trouverez ci-dessous l'image de l'assemblage matériel qui donne une compréhension claire des connexions des composants énumérés ci-dessus:

Nous avons assemblé le matériel de telle manière que nous avons d'abord placé l'écran LCD, LED et potentiomètre sur la planche à pain, puis interfacé le LCD avec Arduino Uno en utilisant son 5,4,3,2 comme épingles de données de l'écran LCD en utilisant le fil blanc de couleur blanche. À côté pour ajuster la luminosité de l'écran LCD, nous avons connecté la broche V0 de l'écran LCD avec la sortie du potentiomètre à l'aide du fil de couleur jaune. De même après cela, nous avons connecté le registre SELECT et la broche d'activation de l'écran LCD avec Arduino et il est représenté par le fil gris dans l'image.

En venant aux modules IR, nous avons connecté la sortie des modules IR avec Arduino en utilisant ses broches 10 et 9 et les connexions sont effectuées en utilisant le fil de couleur brun et pour connecter la LED sur la broche 8 de l'Arduino, nous avons utilisé le fil de couleur orange.

Pour connecter les composants avec une alimentation en tension, nous avons utilisé la broche de 5 volts et la terre de l'Arduino Uno et l'avons connectée aux broches dédiées à la planche à pain pour l'alimentation et le sol.

Code Arduino pour Speed ​​Tracker à l'aide du module IR

Le code Arduino compilé pour mesurer la vitesse de tout objet en mouvement est donné ci-dessous:

#include // Définition de la bibliothèque pour l'écran LCD
LCD LiquidCrystal (12,11,5,4,3,2); // attribuant les épingles Arduino pour le LCD
const int int = 8; // broche arduino pour la LED
octet ir1 = 10; // broche arduino pour le premier module IR
octet ir2 = 9; // broche arduino pour le deuxième module IR
BYTE IRVAL1; // Variable pour stocker la valeur du premier module IR
BYTE IRVAL2; // Variable pour stocker la valeur du deuxième module IR
float diff; / * variable pour économiser la différence de temps entre les deux modules * /
vitesse flottante; // variable pour enregistrer la valeur de vitesse
variable non signée 1; / * pour stocker l'heure du premier module IR * /
Variable non signée 2; / * pour stocker l'heure du deuxième module IR * /
float speedconst = 453.6; // Distance entre deux modules IR en km / h
void displaylcd () // Création de la fonction pour afficher les données
LCD.setCursor (0, 0); / * Définition de la place pour que les données soient affichées * /
LCD.print ("Speed ​​Tracker"); // Données à afficher
LCD.setCursor (0,3); / * Définition de la place pour que les données soient affichées * /
LCD.Imprimer ("Speed:"); // Données à afficher

void setup()

/ * attribuer les modes aux modules IR et LED * /
PinMode (IR1, entrée);
PinMode (IR2, entrée);
PinMode (LED, sortie);
En série.commencer (9600); // initialisation de la communication série
LCD.commencer (16,2); // initialisation des dimensions de l'écran LCD
LCD.setCursor (0, 0); / * Définition de la place pour que les données soient affichées * /
LCD.print ("Speed ​​Tracker"); // Données à afficher
LCD.setCursor (0,3); / * Définition de la place pour que les données soient affichées * /
LCD.Imprimer ("Speed:"); // Données à afficher

VOID LOOP ()

irVal1 = DigitalRead (IR1); / * Lire la sortie du premier module IR * /
irVal2 = DigitalRead (IR2); / * Lire la sortie du deuxième module IR * /
if (irVal1 == high) / * Si la sortie est élevée, notez l'heure et activez la LED * /
Time1 = Millis (); // Sauver l'heure du premier module
DigitalWrite (LED, bas); // allumant la LED
retard (30);

if (irVal2 == Low) / * Si la sortie si le deuxième module est élevé, calculez la différence de temps et calculez la vitesse * /
Time2 = Millis (); // Sauver l'heure du deuxième module IR
diff = time2 - time1; / * Calcul de la différence de temps entre les deux modules IR * /
Velocity = SpeedConst / Diff; // Obtenez la vitesse convertie de mm / millis en km / h.
LCD.setCursor (6,3); / * Définition de la place pour que les données soient affichées * /
LCD.Imprimer (Velocity); // Données à afficher
LCD.imprimer ("km / h"); // données à afficher
retard (1000); // Temps pour lequel les données seront affichées sur l'écran LCD
LCD.clear (); // effacer le LCD
affichelcd (); / * appelant la fonction d'affichage pour afficher les données * /
DigitalWrite (LED, Low); // Donnant l'état bas LED

Le code Arduino pour le tracker de vitesse est compilé de telle manière que nous avons d'abord attribué les broches d'Arduino utilisées pour interfacer chaque composant avec Arduino Uno, puis les variables nécessaires sont déclarées. Ensuite, nous avons donné les modes de fonctionnement à chaque composant et nous avons créé une fonction d'affichage pour l'écran LCD pour afficher les données nécessaires sur l'écran LCD.

Pour calculer la vitesse de l'objet, nous avons d'abord mesuré la distance entre nos deux modules IR, dans notre cas, les deux modules sont à environ 126 mm d'intervalle. Étant donné que la vitesse est mesurée en km / h, nous avons converti la distance en km / h de mm en utilisant la formule suivante:

((distance) * 3600) / 1000; ((126) * 3600) / 1000 = 453.6;

À côté de calculer la vitesse de l'objet, nous avons utilisé la formule donnée ci-dessous.

vitesse = (distance / temps); vitesse = (453.6 / différence de temps des deux modules IR);

Dans la formule ci-dessus, le temps est la différence du temps des deux modules IR.

Pour résumer le fonctionnement du code Arduino, nous pouvons dire que lorsque la sortie du premier module IR est élevée, ce temps sera enregistré en utilisant la fonction Millis (), puis lorsque la sortie du deuxième module IR est élevée, son temps est également enregistré. Ensuite, la différence des deux heures sera calculée et la valeur sera placée dans la formule utilisée pour le calcul de la vitesse et la vitesse calculée sera affichée sur l'écran LCD.

Implémentation du matériel pour le suivi de la vitesse avec le module IR à l'aide d'Arduino Uno

Nous avons publié l'image ci-dessous pour afficher le matériel assemblé pour le projet Arduino Speed ​​Tracker.

Nous avons publié une animation pour démontrer le fonctionnement de la façon dont nous pouvons mesurer la vitesse d'un objet en mouvement:

Conclusion

Les modules infrarouges sont principalement utilisés pour la détection des obstacles, la mesure de la vitesse, la mesure de la température et de nombreuses autres applications. Ces modules sont faciles à interfacer avec les cartes Arduino et peuvent être utilisés dans un grand nombre de projets pour différentes applications. Nous avons également utilisé les modules infrarouges pour calculer la vitesse d'un objet en mouvement en utilisant l'Arduino Uno.