Construisez votre propre système de détection d'obstacles au stationnement

Ou comment résoudre vos problèmes concrets d'ingénierie ou d'électronique avec votre Raspberry Pi et l'aide d'un hacker et auteur renommé, Simon Monk

Simon Monk

Traducteur

f-leb

L'électronique pénètre tous les domaines de la vie moderne et il est aisé de prendre une telle technologie pour acquis sans même s'arrêter voir et comprendre comment ces choses fonctionnent. Les nano-ordinateurs à bas coûts tel le Raspberry Pi permettent aux amateurs passionnés de s'approprier des produits disponibles dans le commerce pour inventer eux aussi de nouveaux gadgets simplement pour le plaisir.

Dans cette série d'articles, nous allons explorer l'utilisation du Raspberry Pi pour fabriquer toutes sortes d'objets électroniques de la vie de tous les jours, à commencer par un système de détection d'obstacles à ultrason conçu pour vous avertir de la proximité d'obstacle à l'arrière de votre véhicule lors du stationnement.

Chacun de ces projets sera construit autour d'une plaquette de câblage sans soudure avec des composants aisément disponibles de façon à ce que même si vous ne souhaitez pas réellement mettre en œuvre ces dispositifs, vous puissiez au moins réaliser des prototypes pour en apprendre davantage en ingénierie et en invention électronique.

Commentez

- Titre : Construisez votre propre système de détection d'obstacles au stationnement

- Auteur : Simon Monk

- Traducteur : f-leb

- Parution : 11 octobre 2015

- Public visé :

- Licence : Le contenu de cet article est rédigé par Simon Monk et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.

Voir également :

- Raspberry Pi - Déballage et installation

- Raspberry Pi - Python et le port GPIO

- Utiliser des capteurs avec le port GPIO - Partie 3 - Télémètre à ultrasons

Sommaire

- I. Introduction

- II. Pourquoi utiliser quatre résistances électriques ?

- III. Construisez votre système de détection d'obstacles au stationnement

- IV. Comment fonctionne le code

- V. Interface graphique utilisateur

- VI. Utiliser votre système de détection d'obstacles au stationnement

- VII. Notes de la Rédaction de Developpez.com

I - Introduction

Ce dont vous avez besoin

- Une plaquette de câblage rapide

- 7 fils de câblage mâle-femelle

- 2 fils de câblage mâle-mâle

- 4 résistances de 470 Ω

- 2 capteurs ultrasons HC-SR04

- Le code Python, en fin d'article

Comme vous le verrez d'après la liste des composants requis, notre premier projet utilise deux télémètres ultrasons à bas coût pour mesurer la distance entre le capteur et tout obstacle dans son champ de détection. Tandis que vous pourriez fixer les télémètres au pare-choc de votre véhicule, avec un capteur à chacun des deux coins à l'arrière de la voiture et un dispositif d'affichage devant le conducteur, vous pourriez aussi placer les capteurs sur le mur de votre garage (en supposant que le vôtre n'est pas couvert d'ordures), de façon à ce qu'un affichage puisse vous guider et vous avertir quand il faut s'arrêter.

(*) Nous avons besoin d'abaisser la tension de 5 V délivrée en sortie du capteur, à 3,3 V au niveau des broches d'entrée GPIO du Raspberry Pi.(**) Les modules télémètres ultrasons à bas coûts mesurent des distances de quelques centimètres jusqu'à plusieurs mètres.

La distance de l'obstacle pour chacun des capteurs gauche et droite est indiquée par un rectangle qui s'étend vers le bas de l'écran au fur et à mesure que la distance de l'obstacle augmente. En complément, la distance actuelle de l'obstacle est affichée en centimètres puis un code de couleur est utilisé pour dessiner et colorier le rectangle : en rouge si la distance est inférieure à 30 cm, en vert si elle supérieure à 100 cm et en orange si elle est entre les deux.

Vous pouvez utiliser un écran abordable comme le HDMIPi dans votre garage.

Les télémètres ultrasons utilisés peuvent être achetés sur eBay, parfois pour moins de deux euros. Ces capteurs sont souvent utilisés en robotique pour détecter des obstacles. Ils utilisent les ondes sonores pour mesurer des distances à un obstacle variant entre quelques centimètres et plusieurs mètres. Il suffit de rechercher la référence HC-SR04 et se rappeler qu'il faut en acheter deux exemplaires.

Télémètre ultrason HC-SR04

L'écran HDMI est nécessaire seulement si vous projetez d'installer réellement le dispositif dans votre véhicule ou dans votre garage, autrement le moniteur que vous utilisez habituellement avec votre Raspberry Pi est suffisant. Le modèle que nous utilisons est un 7 pouces avec une carte de commande séparée. Recherchez un dispositif d'affichage qui fonctionne en 12 V si vous l'embarquez dans votre voiture.

Vous trouverez l'ensemble des autres composants en achetant un kit de composants électroniques pour débuter. Le Monk Makes Electronic Starter Kit pour Raspberry Pi inclut une plaquette de câblage, tous les composants et des fils de câblage excepté les télémètres. La plupart des kits pour Raspberry Pi incluent la plaquette, des fils de câblage et un jeu de résistances électriques.

II - Pourquoi utiliser quatre résistances électriques ?

Une broche GPIO de Raspberry Pi opère à une tension de 3,3 V, tandis que les broches du module télémètre opèrent à 5 V. Cela ne pose pas de problème lorsque vous connectez la sortie du Raspberry Pi à l'entrée du télémètre (par exemple, une broche GPIO du Raspberry Pi à l'entrée Trigger du télémètre) parce que même si le niveau de tension est un peu bas, à 3,3 V il est suffisamment élevé pour activer l'entrée Trigger.

Le problème surgit dans l'autre sens, quand vous allez connecter la sortie Echo 5 V du télémètre à une entrée GPIO du Raspberry Pi. Mettre une broche GPIO, conçue seulement pour supporter 3,3 V au maximum, à 5 V pourrait facilement endommager la broche. Donc, nous allons utiliser un montage avec deux résistances électriques pour abaisser la tension de 5 V à 2,5 V, où elle restera suffisamment élevée pour être vue comme une entrée à l'état haut, mais tout en restant bien en dessous des 3,3 V maximum. Les lecteurs confirmés préféreront sans doute utiliser différentes combinaisons de résistances pour s'approcher davantage des 3,3 V, mais l'avantage d'abaisser la tension d'un facteur deux est de pouvoir utiliser quatre résistances de mêmes valeurs.

5 V en entrée (Vin), 3 V en sortie (Vout) - protéger les broches GPIO du Raspberry Pi

III - Construisez votre système de détection d'obstacles au stationnement

Réalisation du prototype

Étape 1 : enfichez les télémètres sur la plaquette de câblage

Nous avons réalisé le prototype de ce projet en cinq étapes. Premièrement, enfichez les télémètres de part et d'autre de la plaquette, comme montré sur la photo.

Étape 2 : reliez les broches d'alimentation

Utilisez un fil rouge de câblage mâle-mâle pour relier entre elles les broches d'alimentation 5 V des télémètres (sérigraphiées « Vcc » sur le télémètre). Les extrémités des câbles doivent être branchées sur les mêmes rangées de trous que les broches « Vcc ».
Faites de même avec un fil de câblage noir ou bleu pour les broches « GND » (Ground).

Étape 3 : ajoutez les résistances

Enfoncez les pattes des quatre résistances dans la plaquette, comme montré sur la photo. Peu importe de quel côté vous les enfoncez, mais faites bien attention que les pattes ne se touchent pas entre elles.

Étape 4 : ajoutez les fils de câblage mâle-femelle

Enfichez les broches mâles des fils mâle-femelle qui permettront la connexion au Raspberry Pi sur la plaquette. Choisir les fils avec un code couleur vous aidera à identifier la connexion avec votre Raspberry Pi.

Étape 5 : reliez la plaquette de câblage au Raspberry Pi

Finalement, connectez toutes les parties femelles restantes des câbles aux broches GPIO de votre Pi.
La mise au point peut s'avérer délicate lorsqu'il s'agit de repérer l'emplacement des broches du Pi, mais vous pouvez utiliser un masque comme le Raspberry Leaf ou le GPIO Reference Board.

Même si vous envisagez de mettre réellement en œuvre le projet, c'est une bonne idée de démarrer avec les télémètres branchés directement sur la plaquette de câblage, avec les capteurs ultrasons dirigés vers l'extérieur. Cela vous permettra d'expérimenter sur le projet et de s'assurer que le tout fonctionne comme il le devrait avant de s'engager dans une configuration plus permanente.

Maintenant que nous en avons terminé côté matériel du projet, nous avons besoin de faire fonctionner le logiciel. Le programme est écrit en Python, avec la bibliothèque Pygame pour gérer les animations graphiques. Vous pouvez télécharger le programme sur Internet en entrant les commandes suivantes au prompt :

git clone https://github.com/simonmonk/
pi_magazine.git

Le programme a une interface utilisateur graphique, donc pour exécuter le programme vous devez quitter l'interface en ligne de commande et démarrer le système fenêtré. Si votre Pi n'est pas configuré pour démarrer en mode fenêtré, alors tapez les commandes suivantes après vous être logué :

startx

Ouvrez une fenêtre LXTerminal et tapez les commandes suivantes pour exécuter le programme :

cd pi_magazine
sudo python 01_parking_sensor.py

Après un court instant, la fenêtre Pygame apparaît. Mettez vos mains devant chaque capteur afin de vérifier qu'ils fonctionnent bien tous les deux. Si au moins l'un des deux ne semble pas fonctionner, vérifiez soigneusement vos branchements.

IV - Comment fonctionne le code

Le code Python de ce programme est largement commenté sur GitHub (bit.ly/1KutV7K) et vous trouverez sans doute plus pratique d'avoir le code visible dans un éditeur pendant que nous le parcourons.

01_parking_sensor.py

import RPi.GPIO as GPIO
import time, sys, pygame

trigger_pin_left = 8
echo_pin_left = 7
trigger_pin_right = 18
echo_pin_right = 23

green = (0, 255, 0)
orange = (255, 255, 0)
red = (255, 0, 0)
white = (255, 255, 255)
black = (0, 0, 0)

GPIO.setmode(GPIO.BCM)
GPIO.setup(trigger_pin_left, GPIO.OUT)
GPIO.setup(echo_pin_left, GPIO.IN)
GPIO.setup(trigger_pin_right, GPIO.OUT)
GPIO.setup(echo_pin_right, GPIO.IN)

def send_trigger_pulse(pin):
GPIO.output(pin, True)
time.sleep(0.0001)
GPIO.output(pin, False)

def wait_for_echo(pin, value, timeout):
count = timeout
while GPIO.input(pin) != value and count > 0:
count -= 1

def get_distance(trigger_pin, echo_pin):
send_trigger_pulse(trigger_pin)
wait_for_echo(echo_pin, True, 10000)
start = time.time()
wait_for_echo(echo_pin, False,10000)
finish = time.time()
pulse_len = finish - start
distance_cm = pulse_len / 0.000058
return int(distance_cm)

def colour_for_distance(distance):
if distance < 30:
return red
if distance < 100:
return orange
else:
return green

pygame.init()
size = width, height = 800, 600 # the variables alter window size
offset = width / 8

screen = pygame.display.set_mode(size)
myfont = pygame.font.SysFont("monospace", 50)

while True: # the main loop starts here
for event in pygame.event.get():
if event.type == pygame.QUIT:
GPIO.cleanup() # set GPIO pins to be inputs
sys.exit() # quit the program entirely

left_distance = get_distance(trigger_pin_left, echo_pin_left)
right_distance = get_distance(trigger_pin_right, echo_pin_right)

screen.fill(white)
pygame.draw.rect(screen, colour_for_distance(left_distance),
(offset, 0, width / 4, left_distance * 5))
pygame.draw.rect(screen, colour_for_distance(right_distance),
(width / 2 + offset, 0, width / 4, right_distance * 5))

left_label = myfont.render(str(left_distance) + " cm", 1, black)
screen.blit(left_label, (offset + 10, height / 2))

right_label = myfont.render(str(right_distance) + " cm", 1, black)
screen.blit(right_label, (width / 2 + offset + 10, height / 2))

pygame.display.update()
time.sleep(0.1)

Le programme commence par importer les bibliothèques Python nécessaires et déclarer quelques constantes pour les broches du port GPIO. Donc, si vous voulez permuter les branchements et utiliser d'autres broches, vous n'avez qu'à changer les numéros à droite du signe égal. Des variables sont également déclarées pour définir les couleurs qui seront affichées dans l'interface graphique avec Pygame.

Après cela, nous avons du code pour initialiser les quatre broches GPIO que nous voulons utiliser. Deux d'entre elles sont configurées en sorties de façon à ce qu'elles puissent envoyer une impulsion aux télémètres afin de déclencher un « ping » d'émission des ultrasons. Les deux autres broches (les broches « Echo ») sont configurées en entrées afin de pouvoir consulter leur état à la demande dans le programme et savoir quand l'écho est revenu, puis connaître la durée du signal afin de pouvoir calculer la distance.

Les trois fonctions qui suivent contiennent le code relatif à la mesure de la distance avec un télémètre ultrason. La première d'entre elles (send_trigger_pulse) permet de générer une impulsion de 0,0001 seconde sur la broche fournie en paramètre. Sous cette impulsion, le télémètre enverra un train d'ultrasons. La fonction qui suit (wait_for_echo) met en attente le programme jusqu'au retour de l'écho de ce train d'ultrasons après réflexion sur l'obstacle, de sorte que la distance puisse être calculée par le temps que met l'écho à aller et revenir.

La fonction get_distance rassemble le tout, envoie un signal de déclenchement du train d'ultrasons dans un premier temps puis mesure le temps que met l'écho à revenir. En fait, c'est un peu plus compliqué que cela, parce qu'on ne doit pas chercher à détecter le retour de l'écho tant que l'envoi du train d'ultrasons n'est pas terminé. Si nous lançons la détection trop tôt, nous aurons une fausse lecture.

C'est pourquoi il y a deux appels à la fonction wait_for_echo. La première fois, pour attendre jusqu'à la fin de l'émission du train d'ultrasons et la seconde fois pour attendre le retour de l'écho après réflexion sur l'obstacle.

V - Interface graphique utilisateur

Le reste du code concerne l'interface utilisateur du projet. La fonction colour_for_distance retourne la couleur à utiliser pour dessiner le rectangle, couleur qui dépend de la valeur de la distance mesurée par un capteur.

Les quelques lignes qui suivent permettent d'initialiser la fenêtre Pygame et de définir la fonte à utiliser pour l'affichage de la distance. Si Pygame est conçu à l'origine pour programmer des jeux, il s'avère excellent pour tout projet avec du graphisme et des animations, comme dans notre projet. Vous voudrez certainement modifier les valeurs des variables width et height afin d'adapter la taille de la fenêtre à la résolution de votre écran.

L'instruction while exécute la boucle principale. Le programme fera tourner en boucle les instructions à l'intérieur, à partir du while jusqu'à la fin du fichier, ceci jusqu'à la fermeture de la fenêtre du programme. Ce type de boucle est connu pour former une boucle infinie.

À chaque passage dans la boucle, les événements Pygame sont vérifiés, et si la fenêtre Pygame est fermée (en cliquant sur la petite croix dans le coin de la fenêtre), alors les broches GPIO sont configurées en entrée et en mode sécurisé grâce à la fonction GPIO.cleanup, puis le programme est quitté.

La plupart du temps la fenêtre n'a pas été fermée, donc le reste du code dans la boucle va lancer la mesure des deux distances et dessiner les rectangles à l'écran en utilisant la distance lue pour définir la hauteur du rectangle. La hauteur de chaque rectangle est la distance en centimètres multipliée par 5 pixels. Finalement, il y a un délai d'une fraction de seconde afin d'éviter un rafraîchissement trop rapide de l'animation.

VI - Utiliser votre système de détection d'obstacles au stationnement

Bien qu'il soit possible d'allonger jusqu'à peut-être environ un mètre de fil entre le Raspberry Pi et les télémètres ultrasons, aller au-delà risque de dégrader le signal.Donc si vous réalisez concrètement ce projet pour votre véhicule, il vaut mieux disposer le Raspberry Pi assez proche des capteurs et utiliser un long câble HDMI pour connecter le Raspberry Pi à l'écran.

Mais si vous réalisez concrètement ce projet, vous voudrez probablement faire en sorte que le programme soit lancé automatiquement. De cette façon, vous n'aurez plus besoin de relier un clavier et une souris au Raspberry Pi. Vous trouverez comment faire cela sur le forum Raspberry Pi : bit.ly/1DaEURv

Les télémètres ultrasons sont de super petits dispositifs. Vous pouvez prendre la partie télémétrie du programme de ce projet et la réutiliser dans beaucoup d'autres applications. Vous pouvez, par exemple, créer un mètre à mesurer, avec un affichage de la distance en pouces ou en centimètres. Vous pouvez aussi imaginer une sorte d'instrument de musique électronique, semblable au thérémine, qui modifie la hauteur de la note en fonction de la distance entre la main et le télémètre.

Le prototype complet

VII - Notes de la Rédaction de Developpez.com

Cet article est une traduction de l'article écrit par Simon Monk et paru dans le n° 31 du magazine TheMagPi, sous le titre Build your own parking sensors.

Retrouvez les projets de l'auteur publiés dans le magazine TheMagPi sur la plateforme GitHub.

Nous remercions les membres de la Rédaction de Developpez pour le travail de traduction et de relecture qu'ils ont effectué, en particulier :

- f-leb

- deusyss

Merci également à Claude Leloup pour sa relecture orthographique.