# Tuto pas-à-pas C++ : utiliser un capteur ultrason HC-SR04 sur la Gamebuino Meta

**URL:** <https://community.gamebuino.com/t/tuto-pas-a-pas-c-utiliser-un-capteur-ultrason-hc-sr04-sur-la-gamebuino-meta/219>\
**Category:** \[FR\] Programmation en C/C++\
**Created:** [7 June 2021 15:11 UTC](https://community.gamebuino.com/t/tuto-pas-a-pas-c-utiliser-un-capteur-ultrason-hc-sr04-sur-la-gamebuino-meta/219 "2021-06-07T15:11:43Z")\
**Posts on this page:** 3\
**Page:** 1

<div class="post-metadata">

**Author:** ![Tombuino](https://community.gamebuino.com/user_avatar/community.gamebuino.com/tombuino/32/64_2.png) [@Tombuino](https://community.gamebuino.com/u/Tombuino)\
**Post date:** [7 June 2021 15:11 UTC](https://community.gamebuino.com/t/tuto-pas-a-pas-c-utiliser-un-capteur-ultrason-hc-sr04-sur-la-gamebuino-meta/219/1 "2021-06-07T15:11:43Z")

</div>

Voici un tutoriel étape par étape qui vous permettra de réaliser un programme simple afin d’utiliser un capteur US (ultrason) avec votre console.

 ![Ultrasonic detector HC-SR04](https://community.gamebuino.com/uploads/default/original/1X/b55a1c6c1e0aebd75ae0dd3271192b0a7fa7758e.jpeg)

Le tuto est destiné à être réalisé avec le matériel fourni dans le [pack d’accessoires Gamebuino](https://shop.gamebuino.com/fr/accessories/73-gamebuino-accessories-pack.html). Toutefois vous pouvez bien entendu utiliser un autre capteur tant que celui-ci est compatible Arduino.

 ![00002](https://community.gamebuino.com/uploads/default/original/1X/66d5d919cb3b1e6a0176dc253bd80d6ee652c9fe.png)

Pour ce tutoriel, il vous faut :

- une console [Gamebuino META](https://shop.gamebuino.com/fr/accueil/65-gamebuino-meta.html)
- Un capteur US compatible Arduino
- un ordinateur avec l’environnement de développement l’IDE Aduino installé

Si ce n’est pas encore fait, reportez vous à la fiche  
[https://gamebuino.com/fr/academy/workshop/start-with-your-gamebuino/quick-software-setup](https://gamebuino.com/fr/academy/workshop/start-with-your-gamebuino/quick-software-setup) pour installer l’IDE Arduino.

![hline_orange](https://community.gamebuino.com/uploads/default/original/1X/c338b375ef4f0c5b6fd0ee77e3b4da6b90ef4e26.png)

Si vous avez déjà les bases en programmation vous pouvez trouver le code complet du programme réalisé ici dans le Mini-code : ultrason

![hline_orange](https://community.gamebuino.com/uploads/default/original/1X/c338b375ef4f0c5b6fd0ee77e3b4da6b90ef4e26.png)

### Les branchements

En parallèle de notre code il faut brancher le capteur à la console, si possible avec le backpack.  
On branche l’ alimentation (VCC) sur un pin 3V3, la masse (GND) sur une masse. Les pins “echo” et “trig” sont à brancher sur des pins digitals, ici echo sera branché sur D3 et trig sur D4.

 ![dessin_ultrason](https://community.gamebuino.com/uploads/default/original/1X/ea84cd77c4e22677b64605d25eebe575a5598232.png)

| Capteur | Backpack | Couleur | Description |
| --- | --- | --- | --- |
| TRIG | 4 | VERT | Sortie de signal |
| ECHO | 3 | JAUNE | Entrée de signal |
| VCC | 3V3 | ROUGE | Alimentation |
| GND | GND | BRUN | Masse |

 ![IMG_0853.HEIC](https://community.gamebuino.com/uploads/default/original/1X/f23e6fd7c1dcb40e4c5e64a327157482f3fca598.jpeg)  
 ![IMG_0854.HEIC](https://community.gamebuino.com/uploads/default/original/1X/9171c1ee521f51452993f8b368c86adcefb92358.jpeg)  
 ![IMG_0855.HEIC](https://community.gamebuino.com/uploads/default/original/1X/a7c815659c34b90753634fd1ada1a269b9f55026.jpeg)

![hline_orange](https://community.gamebuino.com/uploads/default/original/1X/c338b375ef4f0c5b6fd0ee77e3b4da6b90ef4e26.png)

# Etape 1 : Bien commencer

#### Cette étape est identique sur la plupart des tutos car elle constitue la base indispensable de n’ilmporte quel programme pour Gamebuino.

Pour commencer, ouvrez l’éditeur Arduino préconfiguré pour la Gamebuino

-Vous devriez avoir ceci sur votre écran :

```cpp
void setup() {
  // put your setup code here, to run once:
}

void loop() {
  // put your main code here, to run repeatedly:
}

```

Pour l’instant, le code est un peu vide, mais on va le compléter.

- En premier lieu on a besoin d’ajouter au tout début du fichier la ligne suivante :

```cpp
#include <Gamebuino-Meta.h>

```

C’est ce qu’on appelle une “librairie”, elle va nous permettre d’utiliser tout un tas de fonctions sans avoir à les programmer à la main. Cette librairie contient toutes les fonctions de la Gamebuino et est très utile pour la suite.  
On va ajouter deux fonctions pour que notre programme puisse fonctionner :

- Dans la fonction setup() on ajoute un appel à la fonction [gb.begin()](https://gamebuino.com/fr/academy/reference/gb-begin) comme suit :

```cpp
void setup() {
  // put your setup code here, to run once:
  gb.begin();
}

```

La fonction gb.begin() permet d’initialiser la console : **sans cela rien ne fonctionnera !**

- Ensuite, on ajoute la fonction waitForUpdate() dans la fonction loop :

```cpp
void loop() {
  // put your main code here, to run repeatedly:
  gb.waitForUpdate();
}

```

La fonction [waitForUpdate()](https://gamebuino.com/fr/academy/reference/gb-waitforupdate) permet de rafraichir le contenu de l’écran (c’est à dire dessiner dessus), gère la lecture des sons, les appuis sur les touches, bref tout ce qui donne vie à votre Gamebuino.

On a à présent une structure de programme fonctionnelle, même si elle ne fait encore rien de concret.

![hline_orange](https://community.gamebuino.com/uploads/default/original/1X/c338b375ef4f0c5b6fd0ee77e3b4da6b90ef4e26.png)

# Etape 2 : Lire les données du capteur

Avant d’obtenir une mesure de distance plus ou moins précise avec notre capteur il faut commencer par récupérer les données brutes, et pour cela il faut de petits réglages pour permettre à la console de communiquer avec le capteur.

- En premier on doit configurer les entrées/sorties de notre capteur dans le programme comme suit :

```cpp
#include <Gamebuino-Meta.h> 

#define US_PIN_INPUT_ECHO 3 // Attache le pin D3 au pin Echo du capteur US
#define US_PIN_OUTPUT_TRIG 4 // Attache le pin D4 au pin Trig du capteur US

```

Ici on utlise les define pour assigner des “noms” à nos pins D3 et D4 afin de les différencier et d’y faire référence plus facilement dans la suite de notre programme.

- Ensuite on doit configurer le mode d’interaction de ces pins dans notre fonction setup() :

```cpp
void setup() {
  gb.begin();
  
  pinMode( US_PIN_OUTPUT_TRIG, OUTPUT); // Définit le pin TRIG comme sortie (OUTPUT)
  pinMode( US_PIN_INPUT_ECHO, INPUT); // Définit le pin ECHO comme entrée (INPUT)
  digitalWrite(US_PIN_OUTPUT_TRIG, LOW); // Démarrage du pin TRIG en mode sortie faible
}

```

C’est une étape cruciale car si l’on ne définit pas ces modes correctement il est impossible de communiquer avec notre capteur.

Maintenant nous allons pouvoir effectuer la mesure proprement dite.

Pour cela on commence par déclarer une fonction ultrasonic\_measure() avec un retour en float.

- La déclaration se fait donc ainsi :

```cpp
float ultrasonic_measure() {

}

```

Jusque-là tout va bien.

- On ajoute ensuite l’activation de l’émetteur ultrason TRIG sur 10ms :

```cpp
float ultrasonic_measure() {

 digitalWrite(US_PIN_OUTPUT_TRIG, HIGH); 
 delayMicroseconds(10); // Active le pin TRIG en mode HIGH pendant 10ms
 digitalWrite(US_PIN_OUTPUT_TRIG, LOW);
}

```

Cela nous permet d’émettre une vague d’ultrason dont on va pouvoir mesurer le temps de retour avec notre pin ECHO

- Cette mesure là est effectuée ainsi :

```cpp
float ultrasonic_measure() {

  digitalWrite(US_PIN_OUTPUT_TRIG, HIGH); 
  delayMicroseconds(10); // Active le pin TRIG en mode HIGH pendant 10ms
  digitalWrite(US_PIN_OUTPUT_TRIG, LOW);
  
  long duration = pulseIn(US_PIN_INPUT_ECHO, HIGH, 20000); // Lecture du pin ECHO, retourne la temps de trajet de l'ultrason en microsecondes
  duration = duration * 144 / 100; // On doit ajuster la mesure en ajoutent 44% à la valeur renvoyée par pulseIn()
  
  // Calcul de la distance
  long distance = duration * 0.034 / 2; // Vitesse du son divisée par 2 (car aller et retour)

  f32_distance = f32_distance*.9 + 0.1 * distance;
  return f32_distance;
}

```

On mesure l’écart de temps entre l’activation du pin TRIG et la détection de l’onde retour par le pin ECHO. On ajuste de 44% la valeur obtenue et on obtient la durée en microsecondes. Cet ajustement tient au capteur lui-même. Ensuite on peut simplement diviser ce temps par 1/2 de la vitesse du son pour obtenir une distance en vertu de la formule D = T \* V (1/2 car l’onde fait un aller et retour et parcourt donc deux fois la distance).  
En fin de fonction on retourne notre valeur distance.

Enfin on va ajouter un appel à notre fonction ultrasonic\_measure() dans notre loop()

- On en profite pour ajuster notre valeur tel que :

```cpp
void loop() {
  gb.waitForUpdate();
  
  float d = ultrasonic_measure();
  if ( d > 50 ) d = 50;
  if ( d < 5 ) d = 5;
}

```

Ainsi on ne mesure “que” la plage entre 5 et 50 cm. Vous pouvez bien entendu ajuster ces valeurs si vous le souhaitez, le capteur est précis jusqu’à 3-4 mètres environ.

![hline_orange](https://community.gamebuino.com/uploads/default/original/1X/c338b375ef4f0c5b6fd0ee77e3b4da6b90ef4e26.png)

# Etape 3 : Ajouter un visuel

Dans cette partie nous allons afficher les valeurs obtenues pendant notre mesure puis les transformer en une jauge dynamique pour représenter une distance.

- On commence par déclarer une fonction display\_bar(float) que l’on appelle bien entendu dans notre loop() :

```cpp
void display_bar(float distance) {

  gb.display.clear();
}

```

```cpp
void loop() {
  gb.waitForUpdate();
  
  float d = ultrasonic_measure();
  if ( d > 50 ) d = 50;
  if ( d < 5 ) d = 5;
  
  display_bar(d);
}

```

Ici on a juste une fonction prenant un float en paramètre qui efface l’écran à chaque cycle.

- On y ajoute donc l’affichage de nos valeurs de temps et de distance :

```cpp
void display_bar(float distance) {

  gb.display.clear();

  gb.display.print( "Duration : ");
  gb.display.println(duration);

  gb.display.print( "Distance : ");
  gb.display.println(f32_distance);
}

```

 ![00001](https://community.gamebuino.com/uploads/default/original/1X/146253ab5466c4670184f23a5d3732729865c3a6.png)  
Rien de bien compliqué, on utilise simplement des fonctions d’affichage standard pour afficher du texte et des valeurs numériques.

On peut maintenant commencer à créer notre jauge de distance.

- Tout d’abord on affiche un rectangle vide avec la fonction [drawRect()](https://gamebuino.com/fr/academy/reference/graphics-drawrect) :

```cpp
void display_bar(float distance) {

  gb.display.clear();

  // Affichage des valeurs

  //Affichage de la jauge
  gb.display.drawRect(5, gb.display.height() - 15, gb.display.width() - 10, 10);
}

```

 ![00004](https://community.gamebuino.com/uploads/default/original/1X/f7607a4b4f0a37fe81b7bd92cf037d4083329ee5.png)

- Ensuite on remplit cette jauge avec la fonction [fillRect()](https://gamebuino.com/fr/academy/reference/graphics-fillrect) ET on ajuste la couleur de remplissage en fonction de la distance :

```cpp
void display_bar(float distance) {

  gb.display.clear();

  // Affichage des valeurs

  //Affichage de la jauge
  gb.display.drawRect(5, gb.display.height() - 15, gb.display.width() - 10, 10);

  //Remplissage de la jauge
  int32_t i32_bar_len = (((distance + 0.5) * 100) / 50) * (gb.display.width()- 12) / 100;
  gb.display.setColor(GREEN);
  if(distance < 35){
    gb.display.setColor(ORANGE);
  }
  if(distance < 15){
    gb.display.setColor(RED);
  }
  gb.display.fillRect(6, gb.display.height() - 14, i32_bar_len, 8);
}

```

 ![00002](https://community.gamebuino.com/uploads/default/original/1X/66d5d919cb3b1e6a0176dc253bd80d6ee652c9fe.png) ![00003](https://community.gamebuino.com/uploads/default/original/1X/efe9c1df69c4af2e5f772ea5df41deb959f42f50.png) ![00005](https://community.gamebuino.com/uploads/default/original/1X/31d6113b7e692dfe13c3d7be1aa293a7a53a0f07.png)  
On remplit par défaut en vert, si la distance est inférieure à 35cm on passe en orange et en rouge si elle est en dessous de 15cm. Vous pouvez bien entendu changer ces valeurs si vous le souhaitez. Pensez à modifier le “padding” de notre valeur distance dans la fonction loop() si c’est le cas.

![hline_orange](https://community.gamebuino.com/uploads/default/original/1X/c338b375ef4f0c5b6fd0ee77e3b4da6b90ef4e26.png)

Et voilà, vous avez survécu à un nouveau tutoriel Gamebuino. Félicitations !

---

<div class="post-metadata">

**Author:** ![JMP](https://community.gamebuino.com/user_avatar/community.gamebuino.com/jmp/32/5_2.png) [@JMP](https://community.gamebuino.com/u/JMP)\
**Post date:** [17 June 2021 11:37 UTC](https://community.gamebuino.com/t/tuto-pas-a-pas-c-utiliser-un-capteur-ultrason-hc-sr04-sur-la-gamebuino-meta/219/2 "2021-06-17T11:37:45Z")

</div>

> [@Tombuino](#):
>
> On ajuste de 44% la valeur obtenue et on obtient la durée en microsecondes. Cet ajustement tient au capteur lui-même.

Petite précision : les 44% ne proviennent pas du capteur, mais de la librairie de mesure de temps du SAM21.

Cette mesure de temps est effectuée par une boucle mal calibrée.

Le temps mesuré en microsecondes est sous estimé, ce qui nécessite de multiplier le résultat par 1.44 pour obtenir la valeur correcte.

---

<div class="post-metadata">

**Author:** ![Steph](https://community.gamebuino.com/user_avatar/community.gamebuino.com/steph/32/395_2.png) [@Steph](https://community.gamebuino.com/u/Steph)\
**Post date:** [17 June 2021 12:04 UTC](https://community.gamebuino.com/t/tuto-pas-a-pas-c-utiliser-un-capteur-ultrason-hc-sr04-sur-la-gamebuino-meta/219/3 "2021-06-17T12:04:08Z")

</div>

Ha ! Merci pour cette précision !.. Je ne comprenais pas du tout d’où venait cette bizarrerie ! 😂
