- Module de capteur de vitesse optique LM-393 à fente infrarouge
- Mesure de la vitesse et de la distance parcourue pour calculer le tarif
Aujourd'hui, les compteurs numériques remplacent les compteurs analogiques dans tous les secteurs, que ce soit son compteur électrique ou son compteur de taxi. La raison principale en est que les compteurs analogiques ont des pièces mécaniques qui ont tendance à s'user lorsqu'ils sont utilisés pendant une longue période et qui ne sont pas aussi précis que les compteurs numériques.
Un bon exemple pour cela est le compteur de vitesse et l'odomètre analogiques qui sont utilisés dans les anciennes motos pour mesurer la vitesse et la distance parcourue. Ils ont des pièces spéciales appelées pignon et crémaillère dans lesquelles un câble est utilisé pour faire tourner la broche du compteur de vitesse lorsque la roue est tournée. Cela s'usera lors d'une utilisation prolongée et nécessite également un remplacement et un entretien.
Dans le compteur numérique, au lieu d'utiliser des pièces mécaniques, certains capteurs tels que l'interrupteur optique ou le capteur à effet Hall sont utilisés pour calculer la vitesse et la distance. Ceci est plus précis que les compteurs analogiques et ne nécessite aucun entretien pendant une longue période. Nous avons déjà construit de nombreux projets de compteurs de vitesse numériques en utilisant différents capteurs:
- Compteur de vitesse bricolage utilisant Arduino et traitement de l'application Android
- Compteur de vitesse numérique et circuit d'odomètre utilisant le microcontrôleur PIC
- Mesure de la vitesse, de la distance et de l'angle pour les robots mobiles à l'aide du capteur LM393 (H206)
Aujourd'hui, dans ce tutoriel, nous allons créer un prototype de compteur de tarif de taxi numérique utilisant Arduino. Ce projet calcule la vitesse et la distance parcourue par la roue du taxi et l'affiche en continu sur un écran LCD 16x2. Et en fonction de la distance parcourue, il génère le montant du tarif lorsque nous appuyons sur le bouton-poussoir.
L'image ci-dessous montre la configuration complète du projet de compteur de taxi numérique
Ce prototype a un châssis de voiture RC avec un module de capteur de vitesse et une roue codeuse attachée au moteur. Une fois la vitesse mesurée, nous pouvons mesurer la distance parcourue et trouver la valeur du tarif en appuyant sur le bouton poussoir. Nous pouvons régler la vitesse de la roue à l'aide du potentiomètre. Pour en savoir plus sur l'utilisation du module de capteur de vitesse LM-393 avec Arduino, suivez le lien. Voyons une brève introduction du module de capteur de vitesse.
Module de capteur de vitesse optique LM-393 à fente infrarouge
Il s'agit d'un module de type slot qui peut être utilisé pour mesurer la vitesse de rotation des roues codeuses. Ce module de capteur de vitesse fonctionne sur la base d'un interrupteur optique de type à fente également appelé capteur de source optique. Ce module nécessite une tension de 3,3 V à 5 V et produit une sortie numérique. Il peut donc être interfacé avec n'importe quel microcontrôleur.
Le capteur de lumière infrarouge se compose d'une source lumineuse (IR-LED) et d'un capteur à phototransistor. Les deux sont placés avec un petit espace entre eux. Lorsqu'un objet est placé entre l'espace de la LED IR et du phototransistor, il interrompra le faisceau lumineux, ce qui empêchera le phototransistor de passer le courant.
Ainsi, avec ce capteur, un disque rainuré (roue codeuse) est utilisé qui peut être attaché à un moteur et lorsque la roue tourne avec le moteur, il interrompt le faisceau lumineux entre la LED IR et le phototransistor qui active et désactive la sortie (création d'impulsions).
Ainsi, il produit une sortie HIGH lorsqu'il y a une interruption entre la source et le capteur (lorsqu'un objet est placé entre les deux) et produit une sortie LOW lorsqu'il n'y a pas d'objet placé. Dans le module, nous avons une LED pour indiquer l'interruption optique provoquée.
Ce module est livré avec un IC comparateur LM393 qui est utilisé pour produire des signaux HAUT et BAS précis à la SORTIE. Ainsi, ce module est parfois appelé capteur de vitesse LM393.
Mesure de la vitesse et de la distance parcourue pour calculer le tarif
Pour mesurer la vitesse de rotation, nous avons besoin de connaître le nombre de fentes présentes dans la roue codeuse. J'ai une roue codeuse avec 20 emplacements. Quand ils tournent une rotation complète, nous avons 20 impulsions en sortie. Donc, pour calculer la vitesse, nous avons besoin du nombre d'impulsions produites par seconde.
Par exemple
S'il y a 40 impulsions en une seconde, alors
Vitesse = Noo. D'impulsions / Nombre de slots = 40/20 = 2RPS (Révolution par seconde)
Pour calculer la vitesse en tr / min (tours par minute), multipliez par 60.
Vitesse en tr / min = 2 X 60 = 120 tr / min (tours par minute)
Mesurer la distance
Mesurer la distance parcourue par la roue est si simple. Avant de calculer la distance, la circonférence de la roue doit être connue.
Circonférence de la roue = π * d
Où d est le diamètre de la roue.
La valeur de π est 3,14.
J'ai une roue (roue de voiture RC) de 6,60 cm de diamètre donc la circonférence est (20,7 cm).
Donc pour calculer la distance parcourue, il suffit de multiplier le nombre d'impulsions détectées par la circonférence.
Distance parcourue = circonférence de la roue x (nombre d'impulsions / nombre de fentes)
Ainsi, lorsqu'une roue de circonférence de 20,7 cm prend 20 impulsions soit une rotation de la roue codeuse, la distance parcourue par la roue est calculée par
Distance parcourue = 20,7 x (20/20) = 20,7 cm
Pour calculer la distance en mètre, divisez la valeur de la distance en cm par 100.
Remarque: il s'agit d'une petite roue de voiture RC, en temps réel, les voitures ont des roues plus grandes que celle-ci. Donc, je suppose que la circonférence de la roue à 230cm dans ce tutoriel.
Calcul du tarif en fonction de la distance parcourue
Pour obtenir le montant total du tarif, multipliez la distance parcourue par le tarif (montant / mètre).
Timer1.initialize (1000000); Timer1.attachInterrupt (timerIsr);
Ensuite, connectez deux interruptions externes. La première interruption fait de la broche Arduino 2 la broche d'interruption et appelle ISR (décompte) lorsqu'il y a RISING (LOW TO HIGH) détecté à la broche 2. Cette broche 2 est connectée à la sortie D0 du module de capteur de vitesse.
Et le second fait de la broche Arduino 3 comme broche d'interruption et appelle ISR (generatefare) lorsque HIGH est détecté à la broche3. Cette broche est connectée au bouton poussoir avec une résistance pull down.
attachInterrupt (digitalPinToInterrupt (2), count, RISING); attachInterrupt (digitalPinToInterrupt (3), generatefare , HIGH);
5. Voyons ensuite les ISR que nous avons utilisés ici:
ISR1- count () ISR est appelé quand une MONTÉE (BAS à HAUT) se produit sur la broche 2 (connectée au capteur de vitesse).
void count () // ISR pour les comptages du capteur de vitesse { counter ++; // augmente la valeur du compteur d'une rotation ++; // Augmente la valeur de rotation d'un délai (10); }
ISR2- timerIsr () ISR est appelé toutes les secondes et exécute les lignes présentes à l'intérieur de l'ISR.
void timerIsr () { detachInterrupt (digitalPinToInterrupt (2)); Timer1.detachInterrupt (); lcd.clear (); vitesse du flotteur = (compteur / 20,0) * 60,0; rotations du flotteur = 230 * (rotation / 20); rotationinm = rotations / 100; lcd.setCursor (0,0); lcd.print ("Dist (m):"); lcd.print (rotationinm); lcd.setCursor (0,1); lcd.print ("Vitesse (RPM):"); lcd.print (vitesse); compteur = 0; int analogip = analogRead (A0); int motorspeed = map (analogip, 0,1023,0,255); analogWrite (5, vitesse du moteur); Timer1.attachInterrupt (timerIsr); attachInterrupt (digitalPinToInterrupt (2), count, RISING); }
Cette fonction contient les lignes qui détachent en premier le Timer1 et Interrupt pin2 en premier parce que nous avons des instructions d'impression LCD à l'intérieur de l'ISR.
Pour calculer la VITESSE en RPM, nous utilisons le code ci-dessous où 20.0 est le nombre d'emplacements prédéfinis dans la roue codeuse.
vitesse du flotteur = (compteur / 20,0) * 60,0;
Et pour calculer la distance sous le code est utilisé:
rotations du flotteur = 230 * (rotation / 20);
Ici, la circonférence de la roue est supposée égale à 230 cm (comme c'est normal pour les voitures en temps réel)
Ensuite, convertissez la distance en m en divisant la distance par 100
rotationinm = rotations / 100;
Après cela, nous affichons la VITESSE et la DISTANCE sur l'écran LCD
lcd.setCursor (0,0); lcd.print ("Dist (m):"); lcd.print (rotationinm); lcd.setCursor (0,1); lcd.print ("Vitesse (RPM):"); lcd.print (vitesse);
IMPORTANT: Nous devons remettre le compteur à 0 car nous devons obtenir le nombre de plus détectés par seconde, nous utilisons donc cette ligne
compteur = 0;
Ensuite, lisez la broche analogique A0 et convertissez-la en valeur numérique (0 à 1023) et mappez ces valeurs à 0-255 pour la sortie PWM (réglage de la vitesse du moteur) et enfin écrivez ces valeurs PWM à l'aide de la fonction analogWrite connectée à l'ULN2003. Moteur IC.
int analogip = analogRead (A0); int motorspeed = map (analogip, 0,1023,0,255); analogWrite (5, vitesse du moteur);
ISR3: generatefare () ISR est utilisé pour générer le montant du tarif en fonction de la distance parcourue. Cet ISR est appelé lorsque la broche d'interruption 3 est détectée HIGH (lorsque le bouton-poussoir est enfoncé). Cette fonction détache l'interruption sur la broche 2 et l'interruption de la minuterie, puis efface l'écran LCD.
void generatefare () { detachInterrupt (digitalPinToInterrupt (2)); broche à 2 Timer1.detachInterrupt (); lcd.clear (); lcd.setCursor (0,0); lcd.print ("FARE Rs:"); float roupies = rotationinm * 5; lcd.print (roupies); lcd.setCursor (0,1); lcd.print ("Rs 5 par mètre"); }
Après cette distance parcourue est multipliée par 5 (j'ai utilisé 5 pour le taux 5 INR / mètre). Vous pouvez changer selon votre souhait.
float roupies = rotationinm * 5;
Après avoir calculé la valeur de la quantité, affichez-la sur l'écran LCD connecté à Arduino.
lcd.setCursor (0,0); lcd.print ("FARE Rs:"); lcd.print (roupies); lcd.setCursor (0,1); lcd.print ("Rs 5 par mètre");
Le code complet et la vidéo de démonstration sont donnés ci-dessous.
Vous pouvez encore améliorer ce prototype en augmentant la précision, la robustesse et en ajoutant plus de fonctionnalités telles que l'application Android, le paiement numérique, etc. et en le développant en tant que produit.