La mesure de distance est une fonctionnalité très utile dans de nombreuses applications. Dans cet article, nous allons voir comment mesurer la distance à l’aide d’un capteur GP2D12 et afficher le résultat sur un moniteur série. Nous verrons comment le capteur fonctionne, comment le connecter à un microcontrôleur et comment afficher les données sur un moniteur série. Nous verrons également comment le code peut être adapté pour mesurer des distances plus grandes ou plus petites. Enfin, nous verrons comment le code peut être modifié pour afficher les données sur un autre type de moniteur.
Mesure de distance à l’aide d’un capteur GP2D12 et affichage dans moniteur série
1. Présentation
Ce programme affiche la distance d’un objet comprise entre 10 et 80 cm
à l’aide d’un capteur GP2D12
Ce programme utilise les fonctionnalités suivantes :
- la connexion série vers le PC
- la conversion analogique numérique 10bits sur les voies analogiques analog 0,
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
2.2 Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,
- des straps,
- un capteur de distance analogique GP2D12
3. Instructions de montage
- Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
- Broche Analog 0 (=broche 14) en entrée Analogique : connecter broche Vo d’un capteur GP2D12
4. Le schéma théorique du montage
Le schéma théorique du montage
5. Le circuit du montage
Le schéma du montage à réaliser
6. Explication du programme
6.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
6.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.
Le déroulement du programme
7. Au niveau de la partie déclarative :
Inclusion des librairies utilisées
- On inclut les librairies des fonctionnalités utilisées :
Déclaration de constantes utiles
- On déclare les constantes utiles dans le programme :
Déclaration des constantes de broches
- Déclaration des constantes pour les broches utilisées dans le programme :
Déclaration des variables globales
- Déclaration des variables globales du programmes : on déclare un tableau contenant les valeurs empiriques de la tension de sortie du capteur en fonction de la distance.
// 1ère valeur a l’index 0
int calibrage[]={
2370, // 10 cm – index 0
1700, // 15 cm – index 1
1300, // 20 cm – index 2
1100, // 25 cm – index 3
950, // 30 cm – index 4
830, // 35 cm – index 5
720, // 40 cm – index 6
650, // 45 cm – index 7
580, // 50 cm – index 8
540, // 55 cm – index 9
500, // 60 cm – index 10
480, // 65 cm – index 11
450, // 70 cm – index 12
430, // 75 cm – index 13
410, // 80 cm – index 14
400, // au delà 80cm – index 15
}; // fin du tableau
-
- Déclaration des variables globales utilisées pour la conversion analogique-numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique
int nombre_mesure=30; // nombre de mesure à réaliser pour le moyennage
int cumul=0; // variable pour cumul des mesures
int moyenne; // variable calcul de la moyenne
int distance; // distance référence
Déclarations des objets utiles pour les fonctionnalités utilisées
- Déclaration des objets utiles pour les fonctionnalités utilisées :
8. Au niveau de la fonction d’initialisation setup( ) :
Initialisation des fonctionnalités utilisées :
- On initialise les différentes fonctionnalités utilisées :
- Initialisation de la communication série avec le PC
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
9. Au niveau de la boucle principale, la fonction loop ( ) :
- On commence par réaliser une moyenne de plusieurs mesures pour s’affranchir des variations de la tension de sortie du capteur :
for (int i=0; i<nombre_mesure; i++) // répète la mesure
{
mesure_brute=analogRead(GP2D12);
cumul=cumul+mesure_brute;
}
Serial.print(« cumul= »), Serial.println(cumul);
// calcul moyenne
moyenne=cumul/nombre_mesure;
cumul=0; //RAZ cumul…
Serial.print(« moyenne= »), Serial.println(moyenne);
// mesure tension correspondante en mV
mesuref=float(moyenne);
mesuref=mesuref*5000.0;
mesuref=mesuref/1023.0;
Serial.print(« tension= »), Serial.println(mesuref);
- Ensuite, on compare la valeur obtenue avec les valeurs du tableau de calibrage afin d’obtenir la distance :
distance=0; // RAZ distance
for (int j=0; j<=14; j++) { // teste les valeurs de calibrage
if ((int(mesuref)<=calibrage[j]) && (int(mesuref)>calibrage[j+1])) { // si la mesure comprise entre 2 valeurs
distance=10+(j*5); // calcule de la distance en cm à partir de l’index courant
}
} // fin boucle test calibrage
- On affiche le résultat. Une pause de 1 seconde est prévue entre chaque affichage :
if (distance==0) {// si valeur ne correspond pas au calibrage
Serial.println(« Distance hors plage de mesure »);
}
else { // si valeur distance calculée
Serial.print(« Distance comprise entre »), Serial.print(distance), Serial.print( » cm et « );
Serial.print(distance+5),Serial.println( » cm. »);
}
delay (1000);
- Le programme recommence en boucle les instructions de la fonction loop( ).
Se reporter aux commentaires présents dans le programme pour plus de détails.
10. Mise en oeuvre du programme
10.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
10.2 Préparation du Terminal côté PC dans le logiciel Arduino
- Côté PC, il faut ouvrir la fenêtre terminal de l’IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
- La fenêtre « Terminal » s’ouvre alors :
- Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :
10.3 Fonctionnement
- Les valeurs mesurées et calculées ainsi que le résultat de la distance calculée s’affiche dans la fenêtre terminal.
11. Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// Copyright X. HINAULT – Créé le 01/05/2010
// www.mon-club-elec.fr
// Code sous licence GNU GPL :
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// — Que fait ce programme ? —
/* affiche la distance d’un objet comprise entre 10 et 80 cm
à l’aide d’un capteur GP2D12*/
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise la conversion analogique numérique 10bits sur les voies analogiques analog 0,
// — Circuit à réaliser —
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
// Broche Analog 0 (=broche 14) en entrée Analogique : connecter broche Vo d’un capteur GP2D12
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables…
// — Inclusion des librairies utilisées —
// — Déclaration des constantes —
// — constantes des broches —
const int GP2D12=0; //declaration constante de broche analogique
// — Déclaration des variables globales —
int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique
int nombre_mesure=30; // nombre de mesure à réaliser pour le moyennage
int cumul=0; // variable pour cumul des mesures
int moyenne; // variable calcul de la moyenne
int distance; // distance référence
//— tableau de valeurs en millivolts pour distance de 5 en 5cm de 10 à 80 cm pour le capteur GP2D12
// 1ère valeur a l’index 0
int calibrage[]={
2370, // 10 cm – index 0
1700, // 15 cm – index 1
1300, // 20 cm – index 2
1100, // 25 cm – index 3
950, // 30 cm – index 4
830, // 35 cm – index 5
720, // 40 cm – index 6
650, // 45 cm – index 7
580, // 50 cm – index 8
540, // 55 cm – index 9
500, // 60 cm – index 10
480, // 65 cm – index 11
450, // 70 cm – index 12
430, // 75 cm – index 13
410, // 80 cm – index 14
400, // au delà 80cm – index 15
}; // fin du tableau
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter au démarrage —
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// ——- Broches en sortie ——-
// ——- Broches en entrée ——-
// ——- Activation du rappel au + interne des broches en entrée si nécessaire ——-
} // fin de la fonction setup()
// ********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
//—– calcul d’une moyenne de plusieurs mesures ——-
for (int i=0; i<nombre_mesure; i++) // répète la mesure
{
mesure_brute=analogRead(GP2D12);
cumul=cumul+mesure_brute;
}
Serial.print(« cumul= »), Serial.println(cumul);
// calcul moyenne
moyenne=cumul/nombre_mesure;
cumul=0; //RAZ cumul…
Serial.print(« moyenne= »), Serial.println(moyenne);
// mesure tension correspondante en mV
mesuref=float(moyenne);
mesuref=mesuref*5000.0;
mesuref=mesuref/1023.0;
Serial.print(« tension= »), Serial.println(mesuref);
// ——- détermination de la distance à partir du tableau de reference
distance=0; // RAZ distance
for (int j=0; j<=14; j++) { // teste les valeurs de calibrage
if ((int(mesuref)<=calibrage[j]) && (int(mesuref)>calibrage[j+1])) { // si la mesure comprise entre 2 valeurs
distance=10+(j*5); // calcule de la distance en cm à partir de l’index courant
}
} // fin boucle test calibrage
//—– affichage du résultat ——–
if (distance==0) {// si valeur ne correspond pas au calibrage
Serial.println(« Distance hors plage de mesure »);
}
else { // si valeur distance calculée
Serial.print(« Distance comprise entre »), Serial.print(distance), Serial.print( » cm et « );
Serial.print(distance+5),Serial.println( » cm. »);
}
delay (1000);
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
//*************** Autres Fonctions du programme *************
// — Fin programme —
