1ère PC : Déterminer une distance à l’aide d’un microcontrôleur.

Ressource proposée par : P. ROBERT

Démarche pédagogique choisie :

Les élèves réalisent différentes étapes pour construire, à l’aide du microcontrôleur, un télémètre.

1ère étape : Mesure de la célérité des ondes ultrasonores par une mesure de retard.
  • Les élèves utilisent le microcontrôleur.
2ème étape : Utilisation du microcontrôleur comme télémètre.
  • Exploitation de la relation entre célérité, retard et distance.
  • Modification du programme pour afficher la distance capteur-écran plutôt que le retard.
3ème étape : Amélioration du dispositif (prise en compte de la température, affichage sur écran LCD, déclenchement de la mesure via un bouton poussoir).

Matériel nécessaire (1ère et 2ème étape)

Carte Arduino

         Module ultrason Grove

                 Fil de connexion                Microcontrôleur (carte ArduinoTM)

 

 

 


Étape n°1 : Utilisation du logiciel Arduino IDE (avec affichage dans son moniteur série)

On utilise le logiciel Arduino IDE pour charger les programmes dans la carte et on observe les valeurs mesurées retard (durée d’un aller-retour) dans le moniteur série du logiciel.

Programme permettant la mesure et l’affichage du retard.

//variables :
int ER = 4;             // broche où est l'ER ultrasons
int chrono; 

void setup()
{
Serial.begin(9600);     // vitesse de communication 
}

void loop()
{
//émission d'un pulse de 10 µs
pinMode(ER, OUTPUT);    // paramétrage du module en sortie (émission)
digitalWrite(ER, HIGH); //broche niveau haut : émission
delayMicroseconds(10);  //délai de 10 µs     
digitalWrite(ER, LOW);  //broche niveau bas : fin d'émission
pinMode(ER, INPUT);     // paramétrage du module en entrée (réception)

//mesure de la durée
chrono = pulseIn(ER, HIGH); // arrêt chronométrage quand on reçoit un signal
Serial.print("durée de l'aller-retour :");// écriture Durée :
Serial.print(chrono);// écriture valeur du chronométrage
Serial.println(" µs");// écriture µs
delay(1000);// délai de 1000 ms avant la mesure suivante
}

Étape n°2 : Réalisation du télémètre

On exploite la relation entre retard, célérité et distance pour modifier l’affichage et obtenir la distance

Modification du programme précédent

distance = celerite*chrono/1000000/2;
Serial.print("Distance :");// écriture Distance :
Serial.print(distance);// écriture valeur distance
Serial.println(" m");// écriture m

Étape n°3 : Affichage du résultat sur un écran LCD

L’écran utilisé dans cette activité est l’écran LCD en couleur utilisant la connectique Grove :

On fait appel aux bibliothèques permettant de paramétrer l’affichage sur l’écran LCD Grove : #include <Wire.h> et #include <rgb_lcd.h>. Une fois cette étape réalisée, on crée objet afficheur grâce à la commande rgb_lcd EcranRGB;.

On introduit dans le programme de l’étape n°2, la boucle void setup() devient :

void setup()
{
EcranRGB.begin(16, 2);           //configure l'afficheur 16 lig 2 col
EcranRGB.clear();
EcranRGB.print("Distance :");     //affichage 1ere ligne
}

Dans la boucle du programme principal void loop() on ajoute les instructions pour l’affichage sur l’écran :

//affichage
EcranRGB.setRGB(255, 255, 255);    //couleur de fond (Rouge, vert, bleu)
EcranRGB.setCursor(5, 1);          //placement curseur 2e ligne
EcranRGB.print(distance);           //affichage de la distance
EcranRGB.print(" mm   ");
delay(500);// délai de 500 ms avant la mesure suivante
}

Étape n°3bis : Prise en compte de la température de l’air

On exploite dans cette partie la dépendance de la célérité des ondes ultrasonores avec la température. Cette partie utilise un capteur de température et peut faire office de réinvestissement d’un TP de 2nde sur les capteurs résistifs.

Le capteur utilisé ici est le capteur de température Grove :

Programme permettant de mesurer et d’afficher la température dans l’IDE.

// programme pour utiliser le capteur de température grove (sur entrée A0)

#include <math.h>           // pour avoir le log

const int B = 4250;         // constante B
const int R0 = 100000;      // R0 = 100k résistance à 25°C
const int pinCapteur = A0;  // broche de connexion du capteur

void setup()
{
    Serial.begin(9600);     //vitesse de communication
}

void loop()
{
// lecture puis conversion de l'entrée en valeur de résistance de la CTN
    int valeur = analogRead(pinCapteur); 
    float R = R0*(1023.0/valeur - 1.0);

// passage de la valeur de R à celle de T en °C 
    float temperature = 1.0/(log(R/R0)/B+1/298.15)-273.15;

//affichage dans le moniteur série
    Serial.print("temperature = ");
    Serial.print(temperature);
    Serial.println("°C");
    delay(1000);
}

Programme permettant de mesurer la célérité des ondes ultrasonores corrigée avec la température.

#include <Wire.h>                //biblioteque I2C
#include <rgb_lcd.h>             //pour l'afficheur
#include <math.h>                // pour avoir le log

rgb_lcd EcranRGB;                //creation de l'objet afficheur

//variables :
    int ER = 4;                  // broche où est l'ER ultrasons
    float distance;
    int chrono; 
    const int B = 4250;          // constante B
    const int R0 = 100000;       // R0 = 100k résistance à 25°C
    const int pinCapteur = A0;   // broche de connexion du capteur

void setup()
{
EcranRGB.begin(16, 2);           //configure l'afficheur 16 lignes 2 colonnes
EcranRGB.clear();
EcranRGB.print("Distance :");    //affichage 1ere ligne
}

void loop()
{
  // lecture puis conversion de l'entrée en valeur de résistance de la CTN
    int valeur = analogRead(pinCapteur); 
    float R = R0*(1023.0/valeur - 1.0);

// passage de la valeur de R à celle de T en °C 
    float temperature = 1.0/(log(R/R0)/B+1/298.15)-273.15;

// calcul de la célérité des US
    float celerite = 331.5+0.607*temperature;      
    
//émission d'un pulse de 10 µs
    pinMode(ER, OUTPUT);    // paramétrage du module en sortie (émission)
    digitalWrite(ER, HIGH); //broche niveau haut : émission
    delayMicroseconds(10);  //délai de 10 µs     
    digitalWrite(ER, LOW);  //broche niveau bas : fin d'émission
    pinMode(ER, INPUT);     // paramétrage du module en entrée (réception)

//calculs
    chrono = pulseIn(ER, HIGH); // arrêt chronométrage quand on reçoit un signal
    distance = celerite*chrono/1000000/2;

//affichage
if (distance <0.2)
{
    EcranRGB.setRGB(255, 0, 0);    //couleur de fond (Rouge, vert, bleu)
    EcranRGB.setCursor(5, 1);          //placement curseur 2e ligne
    EcranRGB.print(distance);           //affichage de la distance
    EcranRGB.print(" m   ");
}

else
{
    EcranRGB.setRGB(0, 255, 0);    //couleur de fond (Rouge, vert, bleu)
    EcranRGB.setCursor(5, 1);          //placement curseur 2e ligne
    EcranRGB.print(distance);           //affichage de la distance
    EcranRGB.print(" m   ");
}
    delay(1000);// délai de 1000 ms avant la mesure suivante
}

Propositions d’activité expérimentale :

TP réalisation d’un télémètre.