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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.