Projet 4 - Ondes ultrasonores : Vitesse & Distances

Nous avons vu qu'il était possible, avec un Arduino, de produire des ondes sonores,
caractérisées par leur fréquence. Nous allons maintenant, nous intéresser à la vitesse de
propagation des ondes sonores.

- Liste des composants :

. 1 capteur ultrasonique (par exemple, le

HC-SR04)
. 1 DEL Rouge
. 1 résistance de 220 Ω
. 1 résistance de 10 kΩ
. 1 bouton poussoir
. 1 haut-parleur (ou piezzo)
. 1 plaque d’essai
. Fils de connexion

- Protocole de communication:

. Firmata Express
 Le circuit sur un ”shield” pour Arduino Uno

Rappels :
Le son est une onde mécanique qui se propage dans un milieu matériel fluide (air, eau) ou
solide et les ondes sonores sont caractérisées par leur fréquence.
Les sons audibles par l'Homme ont des fréquences comprises entre 20 et 20 000 Hz, les
infrasons ont une fréquence inférieure à 20 Hz, et les ultrasons sont situés au-delà de 20 kHz.
La vitesse de propagation, ou célérité, du son est indépendante de sa fréquence mais dépend
du milieu de propagation : plus le milieu matériel est dense plus la vitesse est grande.
Par exemple : c (air) = 340 m.s-1 ; c (eau de mer) = 1 500 m.s-1 ; c (acier) = 5 000 m.s-1

La célérité du son dépend de la température, c'est-à-dire de l'agitation des particules qui

constituent le milieu de propagation : plus la température est élevée plus le son se propage
vite.
Par exemple : c (air à 0°C) = 331 m.s-1 ; c (air à 15°C) = 340 m.s-1

La relation entre la vitesse du son dans l'air en m/s et la température en kelvins est:
(T en kelvins = T en °C + 273,15)

La célérité dans l’air, en m.s-1, peut être déterminée expérimentalement en mesurant la

durée de propagation Dt, en s, de l'onde sonore, entre un émetteur et un récepteur situés à
une distance d, en m, grâce à la relation :
 𝒅𝒅
Cair =
𝑫𝑫𝑫𝑫

On peut également utiliser un ensemble émetteur - récepteur d’onde ultrasonores placé

devant un obstacle. C’est le principe de la mesure par écho ou du Sonar :

Dans ce cas, la distance parcourue par l’onde sonore, pendant la durée Dt, est 2 d, et alors :
𝟐𝟐𝟐𝟐
Cair =
𝑫𝑫𝑫𝑫

Principe de fonctionnement des émetteurs et récepteurs à ultrasons :

Les émetteurs et récepteurs à ultrasons sont aussi appelés transducteurs piézoélectriques,
car ils convertissent une énergie électrique en énergie mécanique et réciproquement. Le
principe de fonctionnement est donc identique à celui des buzzer.
Extérieurement les transducteurs d’émission (généralement, repérés par un « T » gravé)
sont très semblables à ceux de réception (généralement, repérés par un « R » gravé) :

Un schéma de principe de ces transducteurs est donné ci-dessous :

 . Fonctionnement d’un émetteur US :
Le transducteur est alimenté par une tension alternative à une fréquence nominale de
fonctionnement (souvent 40 KHz). Cette tension, est appliquée sur les lamelles métalliques
ce qui génère une déformation mécanique des céramiques qui est transformée en
pression acoustique appliquée à l’air ambiant, via le cornet acoustique.

. Fonctionnement d’un récepteur US :

La pression acoustique (due à l’onde ultrasonore) reçue à travers l’air ambiant, via le
cornet acoustique du récepteur US, est transformée en contrainte mécanique dans les
céramiques qui génèrent des charges électriques sur les lamelles métalliques et donc une
tension alternative à ses bornes.

Avec un Arduino, l’ensemble émetteur - récepteur d’onde ultrasonores ou le capteur

ultrasonique le plus couramment utilisé est le HC-SR04.
Capteur ultrasonique HC-SR04

Caractéristiques
Le capteur est composé d’un émetteur d’ultrasons, d’un récepteur et du circuit de
commande. Il est généralement utilisé pour mesurer des distances entre le capteur et un
obstacle.
• Dimensions : 45 mm x 20 mm x 15 mm
• Plage de mesure : 2 cm à 400 cm
• Résolution de la mesure annoncée : 0,3 cm (en pratique : 1 cm)
• Angle de mesure efficace : 15 °

Broches de connexion
• Vcc = Alimentation +5 V DC
• Trig = Entrée émetteur d’impulsion d’ultrasons (Trigger input)
• Echo = Sortie récepteur d’impulsion d’ultrasons (Echo output)
• GND = Masse 0V

Spécifications et limites
• Tension d'alimentation : 5.0 V à ± 0.5 V
• Courant de repos : 2.0 mA à ± 0.5 mA
• Courant de fonctionnement : 15 ± 5 mA
• Fréquence des ultrasons : 40 kHz

Le principe de fonctionnement :
1. Envoyer un signal numérique à l’état haut sur l’émetteur pendant 10 µs,

2. Le capteur envoie automatiquement 8 impulsions d’ultrasons à 40 kHz,

3. A la fin des 8 impulsions, la sortie Echo du capteur passe à l’état haut,
4. Si le signal revient et est détecté par le récepteur, la sortie Echo du capteur passe à
l’état bas. La durée de l’état haut du signal Echo correspond au temps entre l’émission
des ultrasons et leur réception.

Le principe de fonctionnement est résumé sur le schéma suivant :

La formule couramment utilisée dans les programmes Arduino permettant de calculée la
distance entre le capteur et un obstacle est :
Distance capteur- obstacle (en cm) = durée propagation (en μs) / 58

En effet, pour cela, on suppose que la vitesse des ultrasons dans l’air est de V = 340 m.s-1, la
distance parcourue, d (en m), par l’onde sonore pendant la durée, Dt (en s), est alors :

dparcours onde sonore = Vultrasons x Dt

Soit : Distance capteur- obstacle (en m) = d parcours onde sonore /2 = Vultrasons x Dt / 2

Distance capteur- obstacle (en m) = 340 x Dt / 2
Distance capteur- obstacle (en cm) = 34000 x Dt (en μs) /2000000 = 17x Dt (en μs) / 1000
Distance capteur- obstacle (en cm) = Dt (en μs) / 58,82

Le capteur ultrasonique HC-SR04 dispose de 2 broches différentes pour l’émission et la

réception des ultrasons.
Il existe également des capteurs ultrasoniques à une seule broche, comme le Grove
101020010
Capteur ultrasonique Grove 101020010

Caractéristiques
Le capteur est composé d’un émetteur d’ultrasons, d’un récepteur et du circuit de
commande. Il est généralement utilisé pour mesurer des distances entre le capteur et un
obstacle.
• Dimensions : 50 mm x 25 mm x 16 mm
• Plage de mesure : 2 cm à 350 cm
• Résolution de la mesure : 1 cm
• Angle de mesure efficace : 15 °

Broches de connexion
• Vcc = Alimentation +5 V DC
• SIG = Entrée émetteur et sortie récepteur d’impulsion d’ultrasons
• GND = Masse 0V
• NC = Non connectée

Spécifications et limites
• Tension d'alimentation : 3,2 V à 5,2 V
• Courant de fonctionnement : 8 mA
• Fréquence des ultrasons : 40 kHz

• Température de fonctionnement : 10 - 60 °C

Le principe de fonctionnement :

1. Déclarer la broche de l’Arduino sur laquelle est connectée la broche SIG du capteur
en sortie numérique et la maintenir à l’état bas pendant 2 µs,
2. Envoyer un signal numérique à l’état haut sur l’émetteur (sur la broche SIG) pendant
5 µs,

3. Le capteur envoie automatiquement des impulsions d’ultrasons à 40 kHz,

 4. Déclarer la broche de l’Arduino sur laquelle est connectée la broche SIG du capteur
en entrée numérique, afin de pouvoir recevoir le signal du récepteur d’ultrasons.
5. A la fin des impulsions, la broche SIG du capteur passe à l’état haut,
6. Si le signal revient et est détecté par le récepteur, la broche SIG du capteur passe à
l’état bas. La durée de l’état haut du signal SIG correspond au temps entre l’émission
des ultrasons et leur réception.

Le principe de fonctionnement est résumé sur le schéma suivant :

Le principe de calcul de la distance entre ce capteur et un obstacle reste le même.

Par défaut, les programmes sont conçus pour un capteur ultrasonique disposant de deux
broches différentes pour l'émission et la réception des ultrasons. Pour utiliser un capteur
ultrasonique à une broche commune pour l'émission et la réception, il suffit de modifier le
programme et de donner la même valeur aux variables TRIGGER_PIN et ECHO_PIN.

Capteur à 2 broches différentes Trigg et Echo Capteur à 1 broche commune pour Trigg et Echo
La prise en charge des capteurs ultrasoniques par le protocole de communication "Firmata
Express"

Avec "pymata-express", pour utiliser un capteur ultrasonique, il faut déclarer les broches
servant à l’émission et à la réception des ultrasons avec la commande :
loop.run_until_complete(board.set_pin_mode_sonar(trigger_pin, echo_pin,
Get_Distance))
où :
- "board" est l’objet créé lors de l’appel de la méthode "PymataExpress" du module
"pymata-express",
- "trigger_pin" est le numéro de la broche du microcontrôleur sur laquelle est connecté
l’émetteur d’ultrasons,
- "echo_pin" est le numéro de la broche du microcontrôleur sur laquelle est connecté le
récepteur d’ultrasons,
- loop" est la boucle des tâches "asyncio" déclarée ainsi :
loop = asyncio.get_event_loop(),
- "Get_Distance" est une fonction "asyncio" pour récupérer la valeur de la distance en cm
entre le capteur et un obstacle :

async def Get_Distance(data):

global Distance
Distance = data[1]

Remarque : "data" est une liste de 2 éléments (nombres décimaux entiers) générée lors de
la déclaration des broches du capteur dont le premier élément (data[0]) est la valeur de
"trigger_pin" et le deuxième élément (data[1]) est la distance mesurée en cm.

Dans le cas d’un capteur ultrasonique à une broche commune pour l’émission et la réception
des ultrasons, il suffit de déclarer la même broche pour "trigger_pin" et "echo_pin".

On peut définir une fonction déclarant plus facilement les broches d’un capteur
ultrasonique :

def Set_Sonar_Pins(board, trigger_pin, echo_pin):

loop.run_until_complete(board.set_pin_mode_sonar(trigger_pin, echo_pin, Get_Distance))
Ainsi, dans le cas d’un capteur ultrasonique à 2 broches différentes pour l’émission (broche
8) et la réception (broche 9) des ultrasons, l’instruction de déclaration est :
Set_Sonar_Pins(board, 8, 9)

Pour obtenir la valeur de la distance en cm entre le capteur et l’obstacle, on utilise la fonction

"sonar_read" qui fait appel à la fonction "Get_Distance" définie lors de la déclaration des
broches du capteur :
loop.run_until_complete(board.sonar_read(trigger_pin))
où :
- "board" est l’objet créé lors de l’appel de la méthode "PymataExpress" du module
"pymata-express",
- "trigger_pin" est le numéro de la broche du microcontrôleur sur laquelle est connecté
l’émetteur ultrasons.

Si on définit une fonction, comme ci-dessous :

def Sonar_Read(board, trigger_pin):

loop.run_until_complete(board.sonar_read(trigger_pin))

Pour obtenir la valeur de la distance en cm entre le capteur (connecté aux broches 8 et 9) et

l’obstacle, on appelle la fonction :
Sonar_Read(board,8)
La variable globale "Distance" est alors mise à jour via la fonction "Get_Distance", celle-ci
étant appelée lors de l’appel de la fonction " Sonar_Read ".
- Activité 1 : Détermination de la vitesse du son dans l'air

Dans cette activité, nous allons déterminer expérimentalement la vitesse de propagation des
ondes sonores en mesurant, à l'aide d'un capteur à ultrasons (par exemple, le HC-SR04), la
durée de propagation, Dt, de l'onde sonore entre l'émetteur et le récepteur situés à une
distance, d, connue d'un obstacle.

Le programme ci-dessous est adapté pour un capteur ultrasonique à deux broches

différentes pour l’émission et la réception des ultrasons.

Dans le cas d’un capteur ultrasonique à une broche commune pour l’émission et la réception
des ultrasons, il suffit de déclarer la même broche pour ”trigger_pin” (émetteur US) et
”echo_pin” (récepteur US).

. Programme en Python (Projet4\Activity1\PY\Activity1.py)

Déroulement du programme :

- Importation des librairies et définition de fonctions :

. Le module ”ConnectToArduino.py”, contenant les fonctions de connexion à l’Arduino via le protocole

”Firmata Express”,

. Le module "PymataExpressDef.Py" regroupant toutes les fonctions utiles à l’utilisation de " Pymata-
express " (fonction de déclaration des entrées et sorties, de lectures, d’écritures…) ,
. La bibliothèque "time" pour la gestion des temps de pause,

. La fonction ”Get_Dt” pour obtenir la durée de propagation dans l’air de l’onde sonore,

. La fonction ”Set_Sonar_Pins” pour déclarer les broches du capteur ultrasonique,

. La fonction ”Sonar_Read” qui appelle la fonction ”Get_Dt”.

- Déclaration des constantes et variables :

. TRIGGER_PIN = 8 (cst correspondant au n° de la broche sur laquelle l’émetteur US est connecté)

. ECHO_PIN = 9 (cst correspondant au n° de la broche sur laquelle le récepteur US est connecté)
. PinButton = 7 (cst correspondant au n° de la broche sur laquelle le bouton poussoir est connecté)
. ValButton = 0 (variable pour stocker la valeur de l’état logique de la broche du bouton poussoir)
. OldValButton = 0 (variable pour stocker la valeur précédente de l’état logique de la broche du
bouton poussoir)
. State=0 (variable correspondant à l’action à effectuer)
. OldState = 0 (variable pour stocker la valeur précédente de la variable state)
. Distance = 0 (variable correspondant à la distance en cm entre le capteur et l’obstacle)
 . Vitesse = 0 (variable correspondant à la vitesse des ondes ultrasonores dans l’air en m/s)
. Dt = 0 (variable correspondant à la durée de propagation des ondes ultrasonores en µs entre le
capteur et l’obstacle)
. DtMesure = 0 (variable correspondant à la durée de propagation des ondes ultrasonores en µs
précédente)
. Distancechoisie = False (variable booléenne indiquant si la distance entre le capteur et l’obstacle a
été saisie)
. PortComArduino (port COM sur lequel l’Arduino est connecté)

- Connexion à l'Arduino :
. Détection du port COM, tentative d’ouverture du port COM sélectionné et connexion à l’Arduino :

PortComArduino = SelectPortCOM()
board = OpenPortCom(PortComArduino)

. Si la connexion à l’Arduino est réussie :

- Déclaration des broches du capteur ultrasonique :

Set_Sonar_Pins(board, TRIGGER_PIN, ECHO_PIN)

- Déclaration de la broche du bouton poussoir en entrée digitale :

Set_DigitalInput_Pin(board, PinButton)
- Boucle principale du programme (boucle "while True") :
Résultats dans la fenêtre Python Shell :
. Programme en langage Arduino (Projet4\Activity1\INO\Activity1.ino)
Déroulement du programme :
Résultats dans le moniteur série :
- Activité 2 : Mesure de distances

Maintenant que nous avons déterminer la célérité des ondes sonores dans l’air, dans cette
activité, nous allons utiliser le capteur à ultrasons pour mesurer des distances, selon le même
principe que l'activité précédente, en mesurant la durée de propagation, Dt, de l'onde sonore
entre l'émetteur et le récepteur situés à une distance, d, inconnue d'un obstacle. C'est le
principe du Sonar.

Dans les codes en langage Arduino ou en Python, la température de l’air est une variable qu’il
est possible de modifier. La vitesse théorique du son dans l’air en fonction de la température
indiquée est alors calculée et utilisée pour déterminer la distance entre le capteur et
l’obstacle.
Comme pour l’activité précédente, le programme ci-dessous est adapté pour un capteur
ultrasonique à deux broches différentes pour l’émission et la réception des ultrasons.

Dans le cas d’un capteur ultrasonique à une broche commune pour l’émission et la réception
des ultrasons, il suffit de déclarer la même broche pour ”trigger_pin” (émetteur US) et
”echo_pin” (récepteur US).

. Programme en Python (Projet4\Activity2\PY\Activity2.py)

Déroulement du programme :

- Importation des librairies et définition de fonctions :

. Le module ”ConnectToArduino.py”, contenant les fonctions de connexion à l’Arduino via le protocole

”Firmata Express”,

. Le module "PymataExpressDef.Py" regroupant toutes les fonctions utiles à l’utilisation de " Pymata-
express " (fonction de déclaration des entrées et sorties, de lectures, d’écritures…) ,
. La bibliothèque "time" pour la gestion des temps de pause,

. La bibliothèque "math" pour le calcul de la vitesse théorique du son dans l’air,

. La fonction ”Get_Dt” pour obtenir la durée de propagation dans l’air de l’onde sonore,

. La fonction ”Set_Sonar_Pins” pour déclarer les broches du capteur ultrasonique,

. La fonction ”Sonar_Read” qui appelle la fonction ”Get_Dt”.

- Déclaration des constantes et variables :

. TRIGGER_PIN = 8 (cst correspondant au n° de la broche sur laquelle l’émetteur US est connecté)

. ECHO_PIN = 9 (cst correspondant au n° de la broche sur laquelle le récepteur US est connecté)
. PinButton = 7 (cst correspondant au n° de la broche sur laquelle le bouton poussoir est connecté)
. ValButton = 0 (variable pour stocker la valeur de l’état logique de la broche du bouton poussoir)
. OldValButton = 0 (variable pour stocker la valeur précédente de l’état logique de la broche du
bouton poussoir)
. State=0 (variable correspondant à l’action à effectuer)
. OldState = 0 (variable pour stocker la valeur précédente de la variable state)
. Distance = 0 (variable correspondant à la distance en cm entre le capteur et l’obstacle)
. DistanceMesure = 0 (variable correspondant à la distance en cm entre le capteur et l’obstacle
mesurée précédemment)
. Dt = 0 (variable correspondant à la durée de propagation des ondes ultrasonores en µs entre le
capteur et l’obstacle)
. Temp = 20 (variable correspondant à la température de l’air en °C)
. VitTheoUS = 20.05*(sqrt(Temp+273.15)) (constante correspondant à la vitesse théorique du son dans
l’air en m/s)
. PortComArduino (port COM sur lequel l’Arduino est connecté)

- Connexion à l'Arduino :
. Détection du port COM, tentative d’ouverture du port COM sélectionné et connexion à l’Arduino :

PortComArduino = SelectPortCOM()
board = OpenPortCom(PortComArduino)

. Si la connexion à l’Arduino est réussie :

- Déclaration des broches du capteur ultrasonique :

Set_Sonar_Pins(board, TRIGGER_PIN, ECHO_PIN)

- Déclaration de la broche du bouton poussoir en entrée digitale :

Set_DigitalInput_Pin(board, PinButton)
- Boucle principale du programme (boucle "while True") :
Résultats dans la fenêtre Python Shell :
. Programme en langage Arduino (Projet4\Activity2\INO\Activity2.ino)
Déroulement du programme :
Résultats dans le moniteur série :
- Activité 3 : Détecteur d'obstacles

Comme il est possible de mesurer une distance avec un Arduino et un capteur à ultrasons,
nous allons dans cette activité, réaliser un détecteur d'obstacles qui déclenchera une alarme
lumineuse et sonore quand le capteur est situé en dessous d'une distance, d, fixée.

Dans les codes en langage Arduino ou en Python, la température de l’air est une variable qu’il
est possible de modifier. La vitesse théorique du son dans l’air en fonction de la température
indiquée est alors calculée et utilisée pour déterminée la distance entre le capteur et
l’obstacle.

On pourra également modifier la distance minimale de déclenchement de l’alarme.

Comme pour l’activité précédente, le programme ci-dessous est adapté pour un capteur
ultrasonique à deux broches différentes pour l’émission et la réception des ultrasons.

Dans le cas d’un capteur ultrasonique à une broche commune pour l’émission et la réception
des ultrasons, il suffit de déclarer la même broche pour ”trigger_pin” (émetteur US) et
”echo_pin” (récepteur US).
. Programme en Python (Projet4\Activity3\PY\Activity3.py)
Déroulement du programme :

- Importation des librairies et définition de fonctions :

. Le module ”ConnectToArduino.py”, contenant les fonctions de connexion à l’Arduino via le protocole

”Firmata Express”,

. Le module "PymataExpressDef.Py" regroupant toutes les fonctions utiles à l’utilisation de " Pymata-
express " (fonction de déclaration des entrées et sorties, de lectures, d’écritures…) ,
. La bibliothèque "time" pour la gestion des temps de pause,

. La bibliothèque "math" pour le calcul de la vitesse théorique du son dans l’air,

. La fonction ”Get_Dt” pour obtenir la durée de propagation dans l’air de l’onde sonore,

. La fonction ”Set_Sonar_Pins” pour déclarer les broches du capteur ultrasonique,

. La fonction ”Sonar_Read” qui appelle la fonction ”Get_Dt”.

- Déclaration des constantes et variables :

. TRIGGER_PIN = 8 (cst correspondant au n° de la broche sur laquelle l’émetteur US est connecté)

. ECHO_PIN = 9 (cst correspondant au n° de la broche sur laquelle le récepteur US est connecté)
 . PinButton = 7 (cst correspondant au n° de la broche sur laquelle le bouton poussoir est connecté)
. PinTone = 3 (cst correspondant au n° de la broche sur laquelle le buzzer est connecté)
. PinLed = 4 (cst correspondant au n° de la broche sur laquelle la DEL est connectée)
. ValButton = 0 (variable pour stocker la valeur de l’état logique de la broche du bouton poussoir)
. OldValButton = 0 (variable pour stocker la valeur précédente de l’état logique de la broche du
bouton poussoir)
. State=0 (variable correspondant à l’action à effectuer)
. OldState = 0 (variable pour stocker la valeur précédente de la variable state)
. Distance = 0 (variable correspondant à la distance en cm entre le capteur et l’obstacle)
. DistanceMesure = 0 (variable correspondant à la distance en cm entre le capteur et l’obstacle
mesurée précédemment)
. DistanceAlarme = 10 (constante correspondant à la distance en cm en dessous de laquelle l’alarme
est déclenchée)
. Dt = 0 (variable correspondant à la durée de propagation des ondes ultrasonores en µs entre le
capteur et l’obstacle)
. Temp = 20 (variable correspondant à la température de l’air en °C)
. VitTheoUS = 20.05*(sqrt(Temp+273.15)) (constante correspondant à la vitesse théorique du son dans
l’air en m/s)
. PortComArduino (port COM sur lequel l’Arduino est connecté)

- Connexion à l'Arduino :
. Détection du port COM, tentative d’ouverture du port COM sélectionné et connexion à l’Arduino :

PortComArduino = SelectPortCOM()
board = OpenPortCom(PortComArduino)

. Si la connexion à l’Arduino est réussie :

- Déclaration des broches du capteur ultrasonique :

Set_Sonar_Pins(board, TRIGGER_PIN, ECHO_PIN)

- Déclaration de la broche du bouton poussoir en entrée digitale :

Set_DigitalInput_Pin(board, PinButton)

- Déclaration de la broche du buzzer en mode ”Tone” :

Set_Tone_Pin(board, PinTone)

- Déclaration de la broche de la DEL en sortie digitale :

Set_DigitalOutput_Pin(board, PinLED)
- Boucle principale du programme (boucle "while True") :
Résultats dans la fenêtre Python Shell :
. Programme en langage Arduino (Projet4\Activity3\INO\Activity3.ino)
Déroulement du programme :
Résultats dans le moniteur série :