Dans cet article, je vous propose de voir (assez simplement) comment faire pour mesurer une distance avec un capteur à ultrason HY-SRF05.

Tout cela avec un raspberry pi et un peu de Python. Objectif du script est d'être en mesure de détecter l'ouverture d'une porte.

L'usage qui m'intéresse particuliérement est de savoir si, avec ce petit joujou, je peux détecter l'ouverture de la porte de mon garage. C'est une porte sectionnelle avec un moteur d'ouverture électrique. Et ma fille qui dispose d'une clé RF a plusieurs fois ouvert accidentellement la porte donnant ainsi un accés direct à la rue... Il faut dire que la clé est assez puissante et sensible ce qui occasionne ces ouvertures intempestives.

Bref, l'idée est de réaliser un sonar directif afin de déterminer réguliérement (toutes les minutes par exemple) la distance capteur/porte. Si la porte est ouverte, le sonar indiquera un valeur différente ce qui permettra de se douter que la porte est ouverte.

J'aurais pu utiliser un détecteur à effet hall, mais je n'ai rien trouvé de réaliste et mon idée de sonar me semble intéressante à creuser. Donc j'ai commandé le capteur chez www.kubii.fr et reçu quelques jours aprés mon petit colis parfaitement emballé dans une pochette antistatique.

Alors, comment fonctionne le capteur HY-SRF05? Il émet un ultrason à 8470khz, pour cela il faut que le capteur recoive un front montant de 10 microsecondes sur sa patte trigger. Une fois émis, il bascule le port ECHO à +VCC. Lorsque le capteur détecte la fin de réception de l'utrason émis, il passe la patte ECHO à 0. Sachant que la vittesse du son est connu, et en mesurant le temps de réception de l'ECHO, on peut connaitre la distance par la formule : Distance=temps_echo x vitesse_son
La vitesse du son est de 330m/s environ. S'agissant d'un ECHO, le son a donc réalisé deux fois la distance avec l'obstacle. Et donc, il suffit de diviser par deux notre distance pour connaitre la distance entre le capteur et l'obstacle.



Le raccordement est assez simple. Vous le trouverez sur le schèma ci-dessous, les PIN GPIO du Raspberry sont précisées sur la droite.
A noter que l'entrée sur le GPIO (numéro 24) du Raspberry pi sur la patte ECHO du HY-SRF05 doit être à 3V environ. Donc il est nécessaire de faire un pont diviseur de tension avec deux résistances (330 et 470 ohms) pour protèger la sortie +5V du HY-SRF05. Cela est vital à réaliser, sinon vous risquez d'endommager gravement votre Raspberry, il n'est pas protégé contre les surtensions.

Voici mon montage avec les deux résistances. (Vous noterez la présence d'un capteur thermique ds18b20, j'ai eu la flemme de le retirer...).


La mesure se fait par un script en Python avec l'utilisation de la librairie RPI.GPIO :

#*****************************************************************************************************
#
#                  Robert DORIGNY - www.doritique.fr le 25 mars 2018
#
#                 Ce script pour construire un sonar avec un HY-SRF05
#
#*****************************************************************************************************

from __future__ import print_function
import os
import sys
#import pexpect
import time
import urllib2
import urllib
import threading	
import RPi.GPIO as GPIO

GPIO_TRIGGER = 23
GPIO_ECHO    = 24
speedSound   = 33112

#Cette fonction mesure la distance  
def measure():
  #On lance un front pour lancer la mesure
  GPIO.output(GPIO_TRIGGER, True)
  # Attend 10us
  time.sleep(0.00001)
  GPIO.output(GPIO_TRIGGER, False)
  start = time.time() #heure de debut
  
  while GPIO.input(GPIO_ECHO)==0:
    start = time.time()

  while GPIO.input(GPIO_ECHO)==1:
    stop = time.time()

  elapsed = stop-start
  distance = (elapsed * speedSound)/2
  return distance

#Cette fonction effectue 3 mesures et retoune la valeur moyenne  
def measure_average():
  distance1=measure()
  time.sleep(0.1)
  distance2=measure()
  time.sleep(0.1)
  distance3=measure()
  distance = distance1 + distance2 + distance3
  distance = distance / 3
  return distance

class myThread (threading.Thread):
  def __init__(self,name):
	threading.Thread.__init__(self)
	self.name=name
		
  def run(self):
    #Recuperation des donnees
	distance=measure_average()
	print("Distance : {0:5.1f}".format(distance))
	sys.exit() 

#*******************************************Fonction principale************************************ 
def main(): 
  #Mise en daemon
  fpid = os.fork()
  if fpid!=0:
    # Fonctionne en daemon desormais. Le PID est fpid
    sys.exit(0)

  # Utilise le mode BCM des GPIO references
  GPIO.setmode(GPIO.BCM)
  # Setup des pins output et input
  GPIO.setup(GPIO_TRIGGER,GPIO.OUT)  # Trigger
  GPIO.setup(GPIO_ECHO,GPIO.IN)      # Echo
  # Setup trigger pour False (niveau Low)
  GPIO.output(GPIO_TRIGGER, False)
  # Laisse du temps pour la prise en compte du setup
  time.sleep(0.5)
  
  try :
    while True:
      thread1 = myThread("HYSRF05")
      thread1.start()
      thread1.join()	
      time.sleep(10)

  except KeyboardInterrupt:
    # User pressed CTRL-C
    # Reset GPIO settings
    GPIO.cleanup()
	
if __name__ == "__main__":
    main()

Donc on retrouve la même philosophie que pour les autres scripts que je vous avais présenté. Je créé en premier un daemon (tâche de fond) qui va éxécuter le programme principal. Celui ci va crééer des Threads toutes les 10s. Chaque thread réalise 3 mesures, fait la moyenne et affiche le résultat.

Ce qui donne: (Le capteur est positionné sur une table, l'echo se fait sur le plafond. Les valeurs sont en centimètres.)

Conclusion

Le capteur à ultrason HY-SRF05 est parfaitement fonctionnel et vraiment simple d'utilisation avec un Rasperry pi. Il ne me reste plus qu'à l'installer dans mon garage pour détecter l'ouverture de la porte sectionnelle.