- Matériaux nécessaires
- Calcul de la vitesse et affichage sur le compteur de vitesse analogique
- Schéma de circuit et connexions
- Explication de la programmation
Mesurer la vitesse / tr / min d'un véhicule ou d'un moteur a toujours été un projet fascinant à essayer. Dans ce projet, nous allons construire un compteur de vitesse analogique en utilisant l'Arduino. Nous utiliserons le module de capteur IR pour mesurer la vitesse. Il existe d'autres moyens / capteurs pour cela, comme le capteur à effet Hall pour mesurer la vitesse, mais l'utilisation d'un capteur IR est facile car le module de capteur IR est un appareil très courant et nous pouvons l'obtenir facilement sur le marché et il peut également être utilisé sur n'importe quel type de véhicule à moteur.
Dans ce projet, nous allons montrer la vitesse sous forme analogique et numérique. En faisant ce projet, nous améliorerons également nos compétences dans l'apprentissage de l' Arduino et du moteur pas à pas puisque ce projet implique l'utilisation d'interruptions et de minuteries. A la fin de ce projet vous pourrez calculer la vitesse et les distances parcourues par tout objet en rotation et les afficher sur un écran LCD 16x2 au format numérique et également sur compteur analogique. Commençons donc par ce circuit de compteur de vitesse et d'odomètre avec Arduino
Matériaux nécessaires
- Arduino
- Un moteur pas à pas bipolaire (4 fils)
- Pilote de moteur pas à pas (module L298n)
- Module capteur IR
- Écran LCD 16 * 2
- Résistance 2.2k
- Fils de connexion
- Planche à pain.
- Source de courant
- Impression d'image du compteur de vitesse
Calcul de la vitesse et affichage sur le compteur de vitesse analogique
Un capteur infrarouge est un appareil capable de détecter la présence d'un objet devant lui. Nous avons utilisé un rotor à deux pales (ventilateur) et placé le capteur IR à proximité de telle sorte que chaque fois que les pales tournent, le capteur IR le détecte. Nous utilisons ensuite l'aide des minuteries et des interruptions dans Arduino pour calculer le temps nécessaire pour une rotation complète du moteur.
Ici, dans ce projet, nous avons utilisé l'interruption de priorité la plus élevée pour détecter le régime et nous l'avons configuré en mode ascendant. Ainsi, chaque fois que la sortie du capteur passe de LOW à High, la fonction RPMCount () sera exécutée. Et comme nous avons utilisé un rotor à deux pales, cela signifie que la fonction sera appelée 4 fois en un tour.
Une fois que le temps pris est connu, nous pouvons calculer le RPM en utilisant les formules ci-dessous, Où 1000 / temps pris nous donnera le RPS (tour par seconde) et le multiplier encore par 60 vous donnera le RPM (tour par minute)
rpm = (60/2) * (1000 / (millis () - temps)) * REV / lamesInFan;
Après avoir obtenu le régime, la vitesse peut être calculée par une formule donnée:
Vitesse = tr / min * (2 * Pi * rayon) / 1000
Nous savons que Pi = 3,14 et le rayon est de 4,7 pouces
Mais d'abord, nous devons convertir le rayon en mètres à partir de pouces:
rayon = ((rayon * 2,54) /100,0) mètres Vitesse = tr / min * 60,0 * (2,0 * 3,14 * rayon) / 1000,0) en kilomètres par heure
Ici, nous avons multiplié le régime par 60 pour convertir le régime en tr / min (tour par heure) et divisé par 1000 pour convertir les mètres / heure en kilomètres / heure.
Après avoir eu la vitesse en kmh, nous pouvons afficher ces valeurs directement sur l'écran LCD sous forme numérique, mais pour afficher la vitesse sous forme analogique, nous devons faire un calcul supplémentaire pour savoir non. d'étapes, le moteur pas à pas doit se déplacer pour afficher la vitesse sur un compteur analogique.
Ici, nous avons utilisé un moteur pas à pas bipolaire à 4 fils pour compteur analogique, qui a 1,8 degré signifie 200 pas par révolution.
Maintenant, nous devons afficher 280 Kmh sur le compteur de vitesse. Donc, pour montrer que le moteur pas à pas de 280 Kmh doit se déplacer de 280 degrés
Nous avons donc maxSpeed = 280
Et maxSteps sera
maxSteps = 280 / 1,8 = 155 étapes
Nous avons maintenant une fonction dans notre code Arduino, à savoir la fonction de carte qui est utilisée ici pour mapper la vitesse en étapes.
Steps = map (vitesse, 0, maxSpeed , 0, maxSteps);
Alors maintenant nous avons
étapes = carte (vitesse, 0,280,0,155);
Après avoir calculé les étapes, nous pouvons directement appliquer ces étapes dans la fonction de moteur pas à pas pour déplacer le moteur pas à pas. Nous devons également prendre soin des pas de courant ou de l'angle du moteur pas à pas en utilisant des calculs donnés
currSteps = étapes étapes = currSteps-preSteps preSteps = currSteps
ici currSteps correspond aux étapes actuelles issues du dernier calcul et preSteps correspond aux dernières étapes effectuées.
Schéma de circuit et connexions
Le schéma de circuit de ce compteur de vitesse analogique est simple, ici nous avons utilisé un écran LCD 16x2 pour afficher la vitesse sous forme numérique et un moteur pas à pas pour faire tourner l'aiguille du compteur de vitesse analogique.
L'écran LCD 16x2 est connecté aux broches analogiques suivantes d'Arduino.
RS - A5
RW - GND
EN - A4
D4 - A3
D5 - A2
D6 - A1
D7 - A0
Une résistance de 2,2 k est utilisée pour régler la luminosité de l'écran LCD. Un module de capteur IR, qui est utilisé pour détecter la lame du ventilateur pour calculer le régime, est connecté pour interrompre la broche 0 signifie D2 d'Arduino.
Ici, nous avons utilisé un pilote de moteur pas à pas, à savoir le module L293N. Les broches IN1, IN2, IN3 et IN4 du pilote de moteur pas à pas sont directement connectées à D8, D9, D10 et D11 d'Arduino. Le reste des connexions est indiqué dans le schéma de circuit.
Explication de la programmation
Le code complet pour Arduino Speedomete r est donné à la fin, nous en expliquons ici quelques parties importantes.
Dans la partie programmation, nous avons inclus toutes les bibliothèques nécessaires comme la bibliothèque de moteurs pas à pas, la bibliothèque LCD LiquidCrystal et les broches déclarées pour elles.
#comprendre
Après cela, nous avons pris quelques variables et macros pour effectuer les calculs. Les calculs sont déjà expliqués dans la section précédente.
octet volatil REV; RPM int long non signé, RPM; non signé long st = 0; non signé depuis longtemps; int ledPin = 13; int led = 0, RPMlen, prevRPM; indicateur int = 0; int flag1 = 1; #define bladeInFan 2 float radius = 4.7; // pouce int preSteps = 0; float stepAngle = 360.0 / (float) stepsPerRevolution; float minSpeed = 0; float maxSpeed = 280,0; float minSteps = 0; float maxSteps = maxSpeed / stepAngle;
Après cela, nous initialisons l'écran LCD, série, interruption et moteur pas à pas dans la fonction de configuration
void setup () { myStepper.setSpeed (60); Serial.begin (9600); pinMode (ledPin, OUTPUT); lcd.begin (16,2); lcd.print ("Compteur de vitesse"); retard (2000); attachInterrupt (0, RPMCount, RISING); }
Après cela, nous lisons le régime en boucle et effectuons un calcul pour obtenir la vitesse et la convertissons en étapes pour faire fonctionner le moteur pas à pas pour afficher la vitesse sous forme analogique.
boucle void () { readRPM (); rayon = ((rayon * 2,54) / 100,0); // convergeant en mètre int Speed = ((float) RPM * 60.0 * (2.0 * 3.14 * radius) /1000.0); // RPM en 60 minutes, le diamètre du pneu (2pi r) r est le rayon, 1000 à convertir en km int Steps = map (Speed, minSpeed, maxSpeed, minSteps, maxSteps); if (flag1) { Serial.print (Speed); Serial.println ("Kmh"); lcd.setCursor (0,0); lcd.print ("RPM:"); lcd.print (RPM); lcd.print (""); lcd.setCursor (0,1); lcd.print ("Vitesse:"); lcd.print (vitesse); lcd.print ("Km / h"); flag1 = 0; } int currSteps = Étapes;int étapes = currSteps-preSteps; preSteps = currSteps; myStepper.step (étapes); }
Ici, nous avons la fonction reapRPM () pour calculer le RPM.
int readRPM () { if (REV> = 10 ou millis ()> = st + 1000) // IL MISE À JOUR APRÈS TOUTES LES 10 LECTURES ou 1 seconde au repos { if (flag == 0) flag = 1; rpm = (60/2) * (1000 / (millis () - temps)) * REV / lamesInFan; temps = millis (); REV = 0; int x = rpm; tandis que (x! = 0) { x = x / 10; RPMlen ++; } Serial.println (rpm, DEC); RPM = rpm; retard (500); st = millis (); flag1 = 1; } }
Enfin, nous avons une routine d'interruption qui est chargée de mesurer la révolution de l'objet
void RPMCount () { REV ++; if (led == LOW) { led = HIGH; } else { led = LOW; } digitalWrite (ledPin, led); }
C'est ainsi que vous pouvez simplement créer un compteur de vitesse analogique en utilisant Arduino. Cela peut également être construit à l'aide du capteur Hall et la vitesse peut être affichée sur un téléphone intelligent, suivez ce tutoriel sur le compteur de vitesse Arduino pour la même chose.