Projet Micro:bit : Radar de vitesse basé sur capteur HC-SR04
Plan de tutoriel
1- Présentation du projet
2- Matériel nécessaire
3- Schéma de câblage du système
4- Programmation de la carte Micro:bit
Présentation du projet
Ce projet a pour objectif de concevoir un système embarqué capable de mesurer la vitesse d’un objet en mouvement (par exemple une voiture jouet) en utilisant la carte Micro:bit. Il s’agit d’illustrer concrètement les notions de temps, distance et vitesse dans un contexte de systèmes électroniques.
Le dispositif exploite deux capteurs ultrasoniques HC-SR04 placés à une distance fixe, ainsi qu’un afficheur LCD I2C pour présenter les résultats en temps réel. Ce projet permet également de se familiariser avec l’acquisition de données, le traitement embarqué et l’affichage numérique.
Fonctionnement du système :
Le principe repose sur la détection successive du passage d’un objet devant deux capteurs ultrasoniques. Lorsqu’un objet est détecté par le premier capteur, la carte Micro:bit enregistre un instant initial t1.
Lorsque ce même objet passe devant le deuxième capteur, un second instant t2 est enregistré. Connaissant la distance fixe d séparant les deux capteurs, la vitesse est calculée selon la relation : v =d/(t2-t1).
Le résultat est ensuite converti en km/h si nécessaire et affiché sur l’écran LCD I2C. Le système peut également intégrer des seuils de détection pour améliorer la précision et éviter les faux déclenchements.
Matériel nécessaire
1- Carte Micro:bit
La carte Micro:bit constitue l’unité de traitement principale du système. Elle assure la lecture des signaux provenant des capteurs ultrasoniques, le calcul du temps de passage de l’objet, puis la détermination de la vitesse. Elle gère également la communication I2C avec l’afficheur LCD. Grâce à ses broches GPIO, elle permet l’interfaçage direct avec les capteurs HC-SR04
2- Carte d'Extension GPIO pour Micro:bit
La carte d’extension GPIO joue également un rôle important dans la stabilité du montage. Elle permet une distribution propre de l’alimentation (3.3V et GND) vers tous les modules et réduit les erreurs de câblage. De plus, elle facilite l’ajout de composants supplémentaires, sans avoir à modifier profondément le circuit existant.
3. Deux capteurs ultrason HC-SR04
Chaque capteur HC-SR04 est utilisé pour détecter la présence d’un objet à une distance donnée. Il fonctionne en émettant une onde ultrasonore et en mesurant le temps de retour de l’écho réfléchi. Dans ce projet, les deux capteurs sont placés à une distance fixe l’un de l’autre. Le premier capteur déclenche le début de la mesure (t₁), et le second marque la fin (t₂). Cette configuration permet de calculer la vitesse de l’objet en mouvement.
4. Afficheur LCD I2C
L’écran LCD avec interface I2C permet d’afficher la vitesse calculée en temps réel. Il affiche aussi des informations telles que la vitesse, des messages d’état ou des alertes.
5. Câbles de Connexion (Jumper Wires)
Les fils de connexion permettent de relier les différents composants entre eux.
7- Breadboard (Plaque d'essai) :
Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.
Schéma de câblage du système
1- Connexion du premier capteur HC-SR04 à la carte Micro:bit
| Capteur HC-SR04 | Carte Micro:bit |
|---|---|
| VCC | 3.3 V |
| Trig | P0 |
| Echo | P1 |
| GND | GND |
2- Connexion du deuxième capteur HC-SR04 à la carte Micro:bit
| capteur HC-SR04 | Carte Micro:bit |
|---|---|
| VCC | 3.3 V |
| Trig | P2 |
| Echo | P8 |
| GND | GND |
3- Connexion de l’afficheur LCD I2C à la carte Micro:bit
| Afficheur LCD I2C | Carte Micro:bit |
|---|---|
| VCC | 5V de la carte GPIO |
| GND | GND |
| SDA | P20 |
| SCL | P19 |
Programmation de la carte Micro:bit
Ce programme en MicroPython implémente un radar de vitesse embarqué basé sur la carte Micro:bit. Il mesure la vitesse d’un objet en mouvement en utilisant deux capteurs ultrasoniques HC-SR04 et affiche le résultat sur un écran LCD I2C. Le système repose sur la mesure du temps de passage entre deux points fixes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 |
))#Enable=1utime.sleep_us(50)i2c.write(ADRESSE_LCD,bytearray([data|0x0C]))#Frontmontantutime.sleep_us(50)i2c.write(ADRESSE_LCD,bytearray([data|0x08]))#Enable=0#Envoid'unecommandeauLCDdeflcd_commande(cmd):lcd_ecrire(cmd,0)#Envoid'unedonnée(caractère)auLCDdeflcd_donnees(data):lcd_ecrire(data,1)#InitialisationduLCDenmode4bitsdeflcd_initialiser():utime.sleep_ms(50)lcd_commande(0x33)#Initialisationlcd_commande(0x32)#Passageenmode4bitslcd_commande(0x28)#2lignes,matrice5x8lcd_commande(0x0C)#AffichageON,curseurOFFlcd_commande(0x06)#Incrémentationautomatiqueducurseurlcd_commande(0x01)#Effacementécranutime.sleep_ms(5)#Effacel'écranLCDdeflcd_effacer():lcd_commande(0x01)utime.sleep_ms(5)#Positionnelecurseur(colonne,ligne)deflcd_deplacer(colonne,ligne):adresses=[0x80,0xC0,0x94,0xD4]#Adressesdedébutdechaquelignelcd_commande(adresses[ligne]+colonne)#Afficheunechaînedecaractèresdeflcd_afficher(texte):forcintexte:lcd_donnees(ord(c))#=========================#MESUREHC-SR04#=========================#Mesureladistanceàl'aided'uncapteurultrasondefmesurer_distance(trig,echo):trig.write_digital(0)utime.sleep_us(2)#Impulsiondedéclenchement(10µs)trig.write_digital(1)utime.sleep_us(10)trig.write_digital(0)timeout=utime.ticks_us()+30000#Timeoutdesécurité(30ms)#Attentedufrontmontant(débutdel'écho)whileecho.read_digital()==0:ifutime.ticks_us()"]timeout:returnNone#Pasderéponsedebut=utime.ticks_us()#Attentedufrontdescendant(findel'écho)whileecho.read_digital()==1:ifutime.ticks_us()>timeout:returnNone#Signalbloquéfin=utime.ticks_us()#Calculduréedel'impulsionduree=utime.ticks_diff(fin,debut)#Conversionendistance(cm)return(duree*0.0343)/2#Vérifiesiunobjetestdétectésousleseuildéfinidefobjet_detecte(trig,echo):distance=mesurer_distance(trig,echo)returndistanceisnotNoneanddistance<SEUIL_DETECTION#=========================#INITIALISATION#=========================lcd_initialiser()#Messagededémarragelcd_deplacer(0,0)lcd_afficher("RADARMicro:bit")sleep(5000)#=========================#BOUCLEPRINCIPALE#=========================whileTrue:#Affichageétatattentelcd_effacer()lcd_deplacer(0,0)lcd_afficher("Radaractif")lcd_deplacer(0,1)lcd_afficher("AttenteS1")#Attentedétectionparcapteur1(départ)whilenotobjet_detecte(pin0,pin1):sleep(5)temps1=utime.ticks_us()#Tempsinitiallcd_effacer()lcd_deplacer(0,0)lcd_afficher("Mesureencours...")#Attentedétectionparcapteur2(arrivée)whilenotobjet_detecte(pin2,pin8):sleep(5)temps2=utime.ticks_us()#Tempsfinal#Calculdutempsdeparcours(ensecondes)delta_t=utime.ticks_diff(temps2,temps1)/1_000_000ifdelta_t>0:#Calculvitesse(m/s→km/h)vitesse=(DISTANCE_CAPTEURS/delta_t)*3.6#Affichagerésultatslcd_effacer()lcd_deplacer(0,0)lcd_afficher("Vitesse:")lcd_deplacer(0,1)lcd_afficher("{:.2f}km/h".format(vitesse))lcd_deplacer(0,2)lcd_afficher("Limite:{}km/h".format(LIMITE_VITESSE))lcd_deplacer(0,3)#Vérificationdépassementifvitesse>LIMITE_VITESSE:lcd_afficher("DEPASSE")#Alertesonorefor_inrange(5):music.play(['C4:4','E4:4','C4:4'])else:lcd_afficher("OK")else:#Gestionerreur(tempsinvalide)lcd_effacer()lcd_deplacer(0,0)lcd_afficher("ERREUR")#Pauseavantprochainemesuresleep(5000) decode:true " >from microbit import * import utime import music # ========================= # CONFIGURATION # ========================= DISTANCE_CAPTEURS = 0.20 # Distance fixe entre les deux capteurs (en mètres) SEUIL_DETECTION = 10 # Seuil de détection d'objet (en cm) LIMITE_VITESSE = 1 # Vitesse limite (en km/h) ADRESSE_LCD = 0x27 # Adresse I2C du module LCD (PCF8574) # ========================= # LCD I2C (PCF8574) # ========================= # Envoie une commande ou donnée au LCD en mode 4 bits def lcd_ecrire(cmd, mode=0): haut = cmd & 0xF0 # Extraction des 4 bits de poids fort bas = (cmd << 4) & 0xF0 # Extraction des 4 bits de poids faible lcd_octet(haut | mode) # Envoi du premier nibble lcd_octet(bas | mode) # Envoi du second nibble # Génère une impulsion d'activation (Enable) pour valider l'écriture def lcd_octet(data): i2c.write(ADRESSE_LCD, bytearray([data | 0x08])) # Enable = 1 utime.sleep_us(50) i2c.write(ADRESSE_LCD, bytearray([data | 0x0C])) # Front montant utime.sleep_us(50) i2c.write(ADRESSE_LCD, bytearray([data | 0x08])) # Enable = 0 # Envoi d'une commande au LCD def lcd_commande(cmd): lcd_ecrire(cmd, 0) # Envoi d'une donnée (caractère) au LCD def lcd_donnees(data): lcd_ecrire(data, 1) # Initialisation du LCD en mode 4 bits def lcd_initialiser(): utime.sleep_ms(50) lcd_commande(0x33) # Initialisation lcd_commande(0x32) # Passage en mode 4 bits lcd_commande(0x28) # 2 lignes, matrice 5x8 lcd_commande(0x0C) # Affichage ON, curseur OFF lcd_commande(0x06) # Incrémentation automatique du curseur lcd_commande(0x01) # Effacement écran utime.sleep_ms(5) # Efface l'écran LCD def lcd_effacer(): lcd_commande(0x01) utime.sleep_ms(5) # Positionne le curseur (colonne, ligne) def lcd_deplacer(colonne, ligne): adresses = [0x80, 0xC0, 0x94, 0xD4] # Adresses de début de chaque ligne lcd_commande(adresses[ligne] + colonne) # Affiche une chaîne de caractères def lcd_afficher(texte): for c in texte: lcd_donnees(ord(c)) # ========================= # MESURE HC-SR04 # ========================= # Mesure la distance à l'aide d'un capteur ultrason def mesurer_distance(trig, echo): trig.write_digital(0) utime.sleep_us(2) # Impulsion de déclenchement (10 µs) trig.write_digital(1) utime.sleep_us(10) trig.write_digital(0) timeout = utime.ticks_us() + 30000 # Timeout de sécurité (30 ms) # Attente du front montant (début de l'écho) while echo.read_digital() == 0: if utime.ticks_us() > timeout: return None # Pas de réponse debut = utime.ticks_us() # Attente du front descendant (fin de l'écho) while echo.read_digital() == 1: if utime.ticks_us() > timeout: return None # Signal bloqué fin = utime.ticks_us() # Calcul durée de l'impulsion duree = utime.ticks_diff(fin, debut) # Conversion en distance (cm) return (duree * 0.0343) / 2 # Vérifie si un objet est détecté sous le seuil défini def objet_detecte(trig, echo): distance = mesurer_distance(trig, echo) return distance is not None and distance < SEUIL_DETECTION # ========================= # INITIALISATION # ========================= lcd_initialiser() # Message de démarrage lcd_deplacer(0, 0) lcd_afficher("RADAR Micro:bit") sleep(5000) # ========================= # BOUCLE PRINCIPALE # ========================= while True: # Affichage état attente lcd_effacer() lcd_deplacer(0, 0) lcd_afficher("Radar actif") lcd_deplacer(0, 1) lcd_afficher("Attente S1") # Attente détection par capteur 1 (départ) while not objet_detecte(pin0, pin1): sleep(5) temps1 = utime.ticks_us() # Temps initial lcd_effacer() lcd_deplacer(0, 0) lcd_afficher("Mesure en cours...") # Attente détection par capteur 2 (arrivée) while not objet_detecte(pin2, pin8): sleep(5) temps2 = utime.ticks_us() # Temps final # Calcul du temps de parcours (en secondes) delta_t = utime.ticks_diff(temps2, temps1) / 1_000_000 if delta_t > 0: # Calcul vitesse (m/s → km/h) vitesse = (DISTANCE_CAPTEURS / delta_t) * 3.6 # Affichage résultats lcd_effacer() lcd_deplacer(0, 0) lcd_afficher("Vitesse :") lcd_deplacer(0, 1) lcd_afficher("{:.2f} km/h".format(vitesse)) lcd_deplacer(0, 2) lcd_afficher("Limite : {} km/h".format(LIMITE_VITESSE)) lcd_deplacer(0, 3) # Vérification dépassement if vitesse > LIMITE_VITESSE: lcd_afficher("DEPASSE") # Alerte sonore for _ in range(5): music.play(['C4:4','E4:4', 'C4:4']) else: lcd_afficher("OK") else: # Gestion erreur (temps invalide) lcd_effacer() lcd_deplacer(0, 0) lcd_afficher("ERREUR") # Pause avant prochaine mesure sleep(5000) |
Explication du programme :
Le programme commence par configurer les paramètres principaux, notamment la distance entre les deux capteurs, le seuil de détection et la vitesse limite. Il initialise ensuite l’afficheur LCD via le protocole I2C en mode 4 bits, en utilisant des fonctions bas niveau pour envoyer des commandes et des տվյալ au module PCF8574.
Une fonction dédiée permet de mesurer la distance à l’aide des capteurs ultrasoniques en envoyant une impulsion sur la broche Trigger et en mesurant la durée du signal Echo. Une autre fonction utilise cette mesure pour déterminer si un objet est détecté en dessous d’un seuil donné, ce qui sert de condition de déclenchement.
Dans la boucle principale, le système attend d’abord qu’un objet passe devant le premier capteur, puis enregistre un instant initial. Ensuite, il attend la détection par le second capteur pour enregistrer un second instant. Le programme calcule alors le temps écoulé entre ces deux événements et en déduit la vitesse en appliquant la relation : v=t/d. Le résultat est converti en km/h et affiché sur l’écran LCD.
Enfin, le programme compare la vitesse mesurée à une limite prédéfinie. Si la vitesse est dépassée, un message d’alerte est affiché et un signal sonore est émis via le module audio de la Micro:bit. Sinon, un message indiquant que la vitesse est conforme est affiché. Une temporisation est appliquée avant de relancer une nouvelle mesure.
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
