GPIO – Télémètre à ultrason SRF02

Parmi les capteurs les plus usités on trouve les télémètres : des senseurs capables de mesurer les distances. Plusieurs technologies peuvent être mises en oeuvre pour mesurer les distances par télémétrie. On trouve ainsi des télémètres optiques (utilisant la lumière, comme les télémètres laser, très précis), des radars (utilisant les ondes radio), des sonar (utilisant les ondes sonores), etc…

Le principe est toujours le même : Il s’agit d’envoyer un signal (lumineux, radio ou sonore) et de mesurer en combien de temps ce signal revient à son point d’origine après avoir « rebondit » sur un obstacle. Lorsqu’on connait la vitesse de propagation de la lumière ou des ondes sonores, on peut déterminer à quelle distance se trouve un objet grâce à la formule connue de tous : vitesse = distance / temps, soit distance = vitesse x temps.

telemetrie_calcul_distance

Dans cette article nous allons nous intéresser en particulier aux télémètres à ultrason. Nous allons voir quels modèles choisir et comment les utiliser avec nos Raspberry PI 🙂

La mesure du temps

Comme vu précédemment, mesurer une distance par télémétrie, consiste à mesurer le « temps » que met un signal pour aller et revenir. La précision du calcul de la distance dépend donc fortement de la précision de la mesure du « temps« .

Prenons un exemple : Un capteur à ultrason émet un signal sonore qui se propage (dans l’air) à une vitesse de 321 m/s, vers un objet se trouvant à 10 mètres. Le temps que va mettre le signal pour aller et revenir est donc de : 2 x 10 (m) / 321 (m/s) = 0,062 (s) = 62 millisecondes

Il s’agit de « temps » très courts, de l’ordre du millième de seconde. Pour les télémètres laser on parles de nanosecondes (un milliardième de seconde), c’est très rapide :).

Dans notre exemple, si on introduit une erreur de l’ordre de 5% dans la mesure du temps, on obtiendra une distance entre 9,5m et 10,5m, soit 1m d’erreur possible pour un objet positionné à 10m (l’erreur augmentant proportionnellement à la distance). Ce qui est énorme, vous en conviendrez 🙂 Il est donc impératif d’avoir une mesure du « temps » très précise entre l’émission et la réception du signal.

Temps réel et temps partagé

Dans le cas d’un circuit électronique dit « temps réel« , chaque opération ou calcul réalisé se fait dans un lapse de temps contrôlé et bien déterminé. Dans le cas d’un télémètre, cela signifie qu’entre le moment où le circuit envoie le signal, et le moment où il le reçoit, il est possible de mesurer très précisément le temps qui s’est écoulé en additionnant le temps « utilisé » par toutes les opérations réalisées par le circuit pendant ce lapse de temps.

Dans le cas du Raspberry Pi, qui fonctionne sous Linux (Rasbian par exemple) nous sommes sur un système dit « à temps partagé« . En effet, pour que votre Pi puisse exécuter plusieurs programmes en même temps (ou du moins pour que vous en ayez l’impression), le système d’exploitation « alloue » un certain temps processeur à chaque programme. Quelques microsecondes pour votre navigateur Internet, puis quelques microsecondes pour gérer la souris, puis quelques microsecondes pour votre lecteur de musique, puis à nouveaux quelques microsecondes pour votre navigateur Internet… et ainsi de suite… Ces opérations s’enchaînent tellement rapidement que vous avez l’impression que tout fonctionne en même temps, magique 🙂

Le problème avec la télémétrie sur un système à « temps partagé« , c’est qu’entre le moment où le système envoie le signal et le moment où il le reçoit, le système d’exploitation peut décider d’allouer des ressources à d’autres programmes. Le système ne traitera la réception du signal de retour, que lorsqu’il aura terminé toutes les opérations qu’il a entrepris de réaliser entre temps. Le problème, c’est que pendant ce temps, l’horloge continue de tourner, ce qui peut fausser la mesure du temps, et par conséquent, le calcul de la distance 🙂

Le choix du télémètre à ultrason

Grâce à l’essor des cartes Arduino, Raspberry Pi et autres BeagleBone, on peut trouver de nombreux télémètres à ultrason, permettant avec plus ou moins de précision, de mesurer des distances jusqu’à une dizaine de mètres. On trouve également des télémètres infrarouge qui fonctionnent sur le même principe, mais leur portée et leur précision son généralement moins bonnes. Ils sont généralement utilisés pour détecter objets très proches, voire détecter un contacte avec un objet.

Pour éviter les problèmes de précision des systèmes à « temps partagé » détaillés précédemment, il convient de choisir des modules dotés de circuits intégrés qui réalisent eux même les calculs de distances. Pour pouvoir l’utiliser directement sur votre Raspberry Pi, vous devrez également veillez à ce qu’il utilise un bus ou un protocole supporté par le GPIO du Pi (I2C, SPI, etc,…).

Le télémètre à ultrason SRF02 répond parfaitement à ce cahier des charges et est disponible pour une vingtaine d’Euros sur Amazon :

IMG_5770

SRF02

Ce module « autonome » est parfaitement adapté au Rapsberry Pi. Alimenté en 5V il ne consomme que 4mA et il dispose d’un bus I2C. Le SRF02 permet de mesurer des distances de 16cm à 6m avec une précision de l’ordre de 1 à 2 cm. L’ensemble est très petit (24x20x17 mm), et ne nécessite pas de calibration 🙂

Voici les spécifications techniques détaillées de ce module : SRF02_Technical_Specification.pdf

Le cône de détection est relativement large ce qui, selon l’usage, peut être un avantage ou un défaut. A noter qu’il existe des télémètres beaucoup plus directifs.

beam_SRF02

Branchement et configuration du GPIO du Raspberry Pi

Comme pour tous les périphériques I2C, le branchement se fait sur les broches SDA et SCL du GPIO du Pi :

SRF02_RaspberryPi_GPIOUne fois les branchements effectués, il convient d’activer le support de l’I2C sur le Raspberry Pi. Ceci se fait en deux étapes :

1 – Editez le fichier /etc/modules et ajoutez les deux lignes suivantes :

i2c-bcm2708
i2c-dev

2 – Editez ensuite le fichier /etc/modprobe.d/raspi-blacklist.conf et commentez les deux lignes suivantes (en ajoutant # au début de ces deux lignes) :

# blacklist spi-bcm2708
# blacklist i2c-bcm2708

Pour finir, installez l’outil i2c-tools et redémarrez le Pi :

apt-get install i2c-tools
shutdown -r now

Pour vérifer que la carte est bien reconnue par le Pi, lancez la commande suivante :

i2cdetect -y 1 # pour la révision 2 du Pi

ou

i2cdetect -y 0 # pour la première version du Pi

Vous devriez obtenir ce résultat :

root@raspberrypi:~# i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: 70 -- -- -- -- -- -- --

Le module SRF02 est ici détecté à l’adresse 0x70 🙂 Si vous utilisez plusieurs périphériques I2C, vous pouvez changer cette adresse en suivant la procédure décrite dans ce document : SRF02_Technical_Specification.pdf

Il ne reste plus qu’à installer les lib Python nécessaires :

apt-get install python-dev python-rpi.gpio python-smbus

Script en Python

Puisque le SRF02 se charge tout seul de prendre les mesures et de réaliser les calculs, le code est élémentaire, il suffit de lire la valeur retournée par le module dans l’unité de notre choix 🙂

Note : D’après le document SRF02_Technical_Specification.pdf, vous pouvez directement extraire la valeur en centimètres, en inches ou en microsecondes 🙂

Voici donc un petit script en Python, distance_SRF02.py, qui affiche la distance mesurée en centimètres, toutes les secondes :

#!/usr/bin/python

import smbus, time
i2c = smbus.SMBus(1)

adresse = 0x70
mode    = 81      # centimetres

while True:
  try:
    i2c.write_byte_data(adresse, 0, mode) # lance un "ping" en centimetre
    dst = i2c.read_word_data(adresse, 2) / 255 # lit le "mot" de données à partir du registre 2 et divise par 255 pour obtenir un entier (Cf doc technique)
    print(dst)
    time.sleep(1)
  except KeyboardInterrupt:
    quit()

Très simple d’utilisation, ce petit module trouvera sa place dans mon drone PiBOADrone en tant qu’altimètre sol basse altitude 🙂

Exemples d’utilisations

  • Altimètre sol basse altitude pour drone
  • Radar de recul pour voiture OU radar d’avancement pour parking/garage
  • Détection d’obstacle pour robot
  • Détection de passage/mouvement
  • Mesurer la taille des pièces d’une maison ^^

5 réflexions au sujet de « GPIO – Télémètre à ultrason SRF02 »

  1. matthieu

    bonjour,
    nous avons utiliser le telemetre à ultrason srf02 dans le but d’evaluer une distance.
    Les commandes on été tapées à la lettre mais lors de la commande :
    i2cdetect -y 1

    la raspberry nous renvoie le tableau suivant :

    0 1 2 3 4 5 6 7 8 9 a b c d e f
    00: — — — — — — — — — — — — —
    10: — — — — — — — — — — — UU — — — —
    20: — — — — — — — — — — — — — — — —
    30: — — — — — — — — — — — UU — — — —
    40: — — — — — — — — — — — — — — — —
    50: — — — — — — — — — — — — — — — —
    60: — — — — — — — — — — — — — — — —
    70: — — — — — — — —

    Nous avons alors essayé de remplacer la commande (issue du code python):
    adresse = 0x70

    par :
    adresse = bx30

    une erreur nous est retournée, nous avons alors essayé d’autre commande comme :
    adresse = bx10
    adresse = bxUU
    adresse = 0Bx10
    adresse = 0Bx30
    adresse = Bx10
    adresse = Bx30
    adresse = bx10, bx30

    l’erreur retourné est soit :
    SyntaxError : invalid syntax

    soit :
    IOError : [Errno 5] Input/output error

    soit :
    NameError: name ‘Bx30’ is not difined

    Merci d’avance pour votre aide !

    Répondre
    1. Olivier Auteur de l’article

      Bonjour,
      Avez vous bien branché le télémètre sur le port I2C du Pi ?
      Si oui, avez vous bien chargé les modules ?
      Vous pouvez également vérifier que l’I2C est bien activé en utilisant la commande raspi-config.
      Bonne continuation,

      Répondre
  2. Ping : Pi BOAt - Radar de surface - MagdiBlog

  3. spiralcb

    Bonjour,

    Tout d’abord bravo pour votre site et l’ensemble des articles.

    Je sors un peu du sujet mais je cherche une idée pour effectuer la détection dans les murs. L’idée est de réaliser un détecteur de câbles électriques ou autre dans les murs.

    Je sais que cela existe déjà mais je voulais le réaliser moi-même.

    Auriez-vous une idée du type de capteur à utiliser ?

    Merci d’avance pour vos suggestions et à très bientôt sur votre site.

    Répondre
    1. Olivier Auteur de l’article

      Hello,
      En principe, il « suffit » de détecter un champ magnétique en utilisant le principe d’induction. En gros, tu enroule quelques mètres de fils très fin pour former une boucle de quelques centimètres de diamètre et tu mesure, à l’aide d’un convertisseur analogique / numérique, le courant induit.
      Bon, ça, c’est la théorie. En pratique, il va falloir trouver les composants adéquats :/

      Répondre

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.