Barrière ultrason

Il fut un temps je voulais monter un empire industriel.

Et qui dit industriel dit industrie ! Et je voulais particulièrement créer des systèmes robotisés.

Et petit à petit je me suis rendu compte qu’il y avait beaucoup plus d’opportunités dans le secteur tertiaire.

Ayant obtenu mon diplôme en 2013, les effets de la crise économique de 2008 se faisait encore ressentir, et trouver un travail n’était pas très simple. Donc quand j’ai eu des opportunités dans l’informatique de gestion, je n’ai pas dit non.

Mais aujourd’hui rien ne m’empêche de faire un peu d’électronique durant mon temps libre, surtout que depuis les années 2010, Arduino a grandement facilité la programmation de microcontrôleur.

Pour faire simple Arduino est un ensemble de cartes électroniques muni chacune d’un microcontrôleur et un logiciel permettant de facilité la programmation d’un microcontrôleur.

Et pour ceux qui ne savent pas ce qu’est un microcontrôleur, et bien c’est une puce qu’on peut programmer pour gérer des entrées et des sorties.

Par exemple si une température atteint un certain seuil, on lance une action de refroidissement.

Bien qu’on puisse réaliser quelques calculs avec un microcontrôleur, son rôle se destine à les gestion d’entrées / sorties. Pour les calculs plus lourd il est préférable d’utiliser un microprocesseur (qu’on retrouve par exemple sur un Raspberry Pi).

J’ai donc réalisé une barrière ultrason.

Tout d’abord parlons du composant, le : hc sr04

On retrouve ce capteur sur de nombreux systèmes robotisés, et savoir l’utiliser peut alors être très utile :

Un robot lambda avec des capteurs ultrason hc-sr04

Voici une vision globale de ma barrière ultrason :

Si le rubik cube est à moins de 18 cm du capteur, alors le haut parleur sonne.

Biiiiip !!!
Pas bip.

Et voici un angle pour mieux voir les branchements sur la carte Arduino Mega :

La résistance entre le haut parleur et la masse est de 470 Ohms.

Au niveau des fils c’est un peu le dawa, donc voici le schéma pour y voir un peu plus clair.

Dans le code que je vais présenter, il y a l’usage de fonction de l’API Arduino. Donc si vous ne voyez pas d’où vient une fonction c’est qu’elle vient de l’API Arduino.

/***************************************************** 
Auteur : Rémi Matthieu RODRIGUES
** Date : 13 aoüt 2020
** Description du programme : Génère un signale sonore
** si un objet approche à x cm du capteur ultrason 
*****************************************************/

#define TRIG 11
#define ECHO 10
#define HP 9

#define TrigUp digitalWrite(TRIG,HIGH)
#define TrigDown digitalWrite(TRIG,LOW)
#define HPToggle digitalWrite(HP,!digitalRead(HP))

void setup()
{
  pinMode(TRIG,OUTPUT);
  digitalWrite(TRIG,LOW);
  pinMode(HP,OUTPUT);
  pinMode(ECHO,INPUT);
}

long lecture_echo;
long cm;

void loop()
{
  //Génération de l’impultion émétrice
  TrigUp;
  delayMicroseconds(10);
  TrigDown;
      
  //Traitement du rebond de l’impultion
  lecture_echo = pulseIn(ECHO,HIGH);
  //Traduction en cm
  cm = lecture_echo / 58;
      
  //Si la distance est inférieure à 18 cm on buzz
  if(cm < 18) {
    for(int i; i < 1500; i++) { 
      HPToggle;
      delay(1.2);
    } 
  }
  delay(200);
}

Bon je vais détailler partie par partie car ça fait beaucoup de code d’un seul coup.

Tout d’abord je crée des constantes de variables et de méthode, car je veux que le corps de mon code soit le plus compréhensible possible. Et c’est ce que je peux faire avec #define.

#define TRIG 11
#define ECHO 10
#define HP 9

#define TrigUp digitalWrite(TRIG,HIGH)
#define TrigDown digitalWrite(TRIG,LOW)
#define HPToggle digitalWrite(HP,!digitalRead(HP))

Ensuite il y a l’initialisation où défini que nos broches nommées TRIG et HP seront des sorties, et que la broche ECHO sera une entrée. On voit tout de suite l’intérêt d’utiliser les constantes !

En plus on force la sortie TRIG à l’état bas, puis on initialise deux variables au type long (nombre réel).

void setup()
{
  pinMode(TRIG,OUTPUT);
  digitalWrite(TRIG,LOW);
  pinMode(HP,OUTPUT);
  pinMode(ECHO,INPUT);
}

long lecture_echo;
long cm;

Etant donné qu’on est en informatique embarqué, il faut que le programme agisse en continu. C’est pour cela qu’on a une fonction appelé loop(), c’est là que le cœur du programme se situe !

J’ai mis beaucoup de commentaires qui expliquent le fonctionnement.

Sauf peut être au niveau de la boucle for. Si le rubik cube est à une distance inférieur à 18 cm, alors on veut pouvoir entendre le bip ! Pour cela il tout d’abord générer le bip, et cela passe par de multiples passages à l’état haut et à l’état bas (avec une pause de 1,2 ms, on est environ à une fréquence de 417 Hz, à priori un Ré) et suffisamment longtemps pour qu’on puisse l’entendre (d’où la valeur de 1500 dans la boucle for).

void loop()
{
  //Génération de l’impultion émétrice
  TrigUp;
  delayMicroseconds(10);
  TrigDown;
      
  //Traitement du rebond de l’impultion
  lecture_echo = pulseIn(ECHO,HIGH);
  //Traduction en cm
  cm = lecture_echo / 58;
      
  //Si la distance est inférieure à 18 cm on buzz
  if(cm < 18) {
    for(int i; i < 1500; i++) { 
      HPToggle;
      delay(1.2);
    } 
  }
  delay(200);
}

Voilà !

J’espère que je vous ai donné envie de vous intéressé à l’informatique embarquée, ou qu’au moins vous avez apprécié la lecture de cet article. Idéalement j’aurais dû faire une vidéo, car la vous devez me croire sur parole vis à vis du fonctionnement, j’en suis désolé et ça viendra peut-être. Mais je préférais passer du temps sur les explications.

Pour marque-pages : Permaliens.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *