VIII. Gestion d'une entrée analogique
Lecture d'un potentiomètre et calcul de la valeur de la tension correspondante.
Lecture de la valeur d'un capteur analogique (température)
8.1. Quelques notions sur le Shield Multifonctions et le moniteur série
Nous allons utiliser le Shield Multifonctions (ci-dessous, à gauche)
![]() |
Demandez au professeur de mettre la carte DangerShield sur la carte Arduino. |
Cette carte se compose de capteurs : | En gras les entrées/sorties Arduino utilisées : |
Et d’afficheurs :
|
![]() |
Le moniteur série
Arduino possède un outil très pratique pour déboguer un programme (déboguer = trouver les erreurs ou contrôler un programme). Il s'agit d'une liaison série qui peut envoyer les informations que l'on veut et que l'on peut lire ensuite à l'aide du logiciel Arduino sur notre ordinateur.
Comment ça fonctionne :
Paramétrage dans un programme arduino :
Dans le setup il faut mettre:
Serial.begin(9600); // mise en route de la liaison série à 9600 bauds//
9600 correspond à la vitesse de communication. 9600 bauds est une vitesse rapide fiable
Dans le void loop :
Pour afficher le texte "le contenu de ma variable est : "
Serial.print("le contenu de ma variable est : ");
Pour afficher le contenu d'une variable (par exemple ici elle s'appelle var1)
Serial.print(var1);
Pour aller à la ligne (sinon chaque "Serial.print" affiche les données les unes à côté des autres) :
Serial.println(var1);
Pour ouvrir le moniteur série (il faut une carte arduino raccordée bien sûr!) :
soit on clique sur l’icône:
soit sur le menu Outils :
Si le contenu de la variable var1 est 26, on obtiendra dans le moniteur série :
II. Lecture d'un signal analogique (potentiomètres)
Copier le programme ci-dessous et testez le.
//**** début du programme *********//
// adressage du potentiomètre (PIN)
int pinPot = A0;
int potentiom = 0; //définition de la variable entière (integer) potentiom
void setup() {
Serial.begin(9600); // mise en route de la liaison série
}
void loop() {
potentiom = analogRead(pinPot); // lecture potentiomètre
Serial.print("potentiometres: "); // affichage liaison série
Serial.print(" ");
Serial.println(potentiom);
delay(300); // brève attente
}//**** fin du programme *********//
1. Relever les valeurs minimum et maximum. Combien cela fait-il de valeurs différentes ?
2. A partir du programme Arduino, donner le nom de la fonction qui permet de « lire » une entrée analogique.
3. A l'aide de la documentation Arduino, trouver sur combien de bit les variables de type « entier » (int) sont-elles codées ?
4. En déduire le nombre de valeurs différentes disponibles pour ce type de variable.
5. A partir des valeurs minimum et maximum relevées précédemment, dire sur combien de bits travaille le convertisseur analogique/numérique de la carte Arduino ?
III. Modification du programme
Objectif : on va essayer d'afficher non plus le nombre entier issu du convertisseur mais la valeur réelle de la tension (pour le curseur 1 seulement).
Comme on va faire des calculs on va utiliser une variable permettant d'avoir des chiffres avec virgule. On va choisir le type « float ».
1. A l'aide de la documentation Arduino, donner les caractéristiques des variables de type « float »
2. Calculer la constante du convertisseur de telle sorte que la valeur issue du convertisseur multipliée par cette constante nous donne la tension présente sur l'entrée (la tension peut varier entre 0V et 5V) : const_can * entrée analogique = tension.
![]() |
Remarques :
|
Modifiez le programme :
- définissez 2 variables flottantes (tension1 et const_cna et en même temps affecter 0 à tension1 et la valeur calculée précédemment à const_can)
- ajouter la ligne du calcul de la tension (du genre : variable 1 = variable 2 * variable 3).
- envoyer le résultat sur la liaison série à la place de la valeur « potentiom1 »
- Ne pas oublier le point virgule à la fin des lignes
3. Essayer le programme. Faites valider par le professeur
IV. Lecture de la température (capteur LM35 du Shield Multifonctions)
Sur le Shield Multifonctions il y a un capteur de température LM35. Ce capteur rentre sur la broche A4 (PIN 4) de la carte Arduino (entrée analogique au fonctionnement identique à celle utilisée par le programme précédent).
1. En vous inspirant du programme précédent, faire le programme permettant d'envoyer sur la liaison série la valeur analogique reçue par la carte arduino (sur un nombre de type « entier »). Le programme doit être clair et bien commenté. Faites valider par le professeur
2. Modifier maintenant le programme pour afficher dans le « moniteur série » la valeur en °C. (la température en °C est donnée par la formule suivante : Temp = ( mesure en mV /1023.0)* 125.
Faites valider par le professeur.
IX. La boucle « While »
Utilisation du buzzer du Shield Multifonctions à l'aide d'une boucle WHILE
I. Fonctionnement de la boucle « While »
Le principe de fonctionnement de la boucle WHILE (tant que) :
TANTQUE condition vraie exécution d'instructions (traitement) FIN TANTQUE suite du programme |
![]() |
|
|||
En résumé cela donne (exemple):
toto=0 ;
while (toto < 5 ) // on fait la boucle While tant que la variable toto est inférieure à 5
{
digitalWrite(LED_PIN,HIGH) ; // allumage d'une LED
toto=toto+1 ; incrément de la variable toto
}
II. Application avec le Buzzer le carte DangerShield
![]() |
Remarque : pour faire fonctionner ce buzzer (CET 12A3.5), il faut le faire vibrer (on l'alimente, on arrête, on l'alimente, on arrête, …. le son émis va dépendre de la fréquence de cette alternance marche/arrêt). |
1. Copier le programme ci-dessous et testez le (il faut appuyer sur le 1er bouton poussoir) et essayer de comprendre comment il fonctionne.
//**** dƩbut du programme *********//
int BUZZER_PIN = 3; // adresse du Buzzer (PIN) //
int Bp1 = 15; // adresse du BP1 (bouton poussoir 1) (PIN) //
int appui_bp1 = 0; // variable de l'Ć©tat de l'appui sur le BP1//
float demi_periode = (2.27e-3)*1000000; // variable pour son//
float temps=2000; //temps du son en milliseconde//
float duree = 0; //variable de calcul du temps de fonctionnement du buzzer//
void setup()
{
pinMode(BUZZER_PIN, OUTPUT); // adressage du Buzzer//
pinMode(Bp1,INPUT); // adressage BP1 (bouton poussoir 1) //
digitalWrite(Bp1,HIGH); // Simule la resistance de tirage du BP1//
}
void loop()
{
appui_bp1= digitalRead(Bp1); // lecture de l'Ć©tat du BP1//
if (appui_bp1 == LOW) // test si appui sur BP//
{
duree = 0;
while(duree < temps*1000)
{
digitalWrite(BUZZER_PIN,HIGH); //
delayMicroseconds(demi_periode);
digitalWrite(BUZZER_PIN,LOW);
delayMicroseconds(demi_periode);
duree = duree + 2*demi_periode;
}
}
}
//**** fin du programme *********//
2. Compléter l'algorigramme correspondant au programme :
3. A partir du programme, en déduire la fréquence du son émis
4. Pourquoi la variable "temps" est-elle multipliée par 1 000 ?
III. 1ère modification du programme (changement de variable)
Vous allez modifier le programme précédent pour que la variable réglée soit directement la fréquence (en Hertz). Vous devrez faire le calcul de la demi période (avant la boucle « While »).
Ainsi en tête de programme (dans la partie déclaration de variables) vous allez écrire :
float frequence = 220; // frequence en Hertz //
float demi_periode; // calcul de la demi période de la fréquence //
Faites la modification du programme. Testez là et faites valider par le professeur.
IV. 2ème modification du programme (ajout d'une fonction ou sous-programme)
On va maintenant créer une fonction (sous programme) que l'on va appeler allu_buzzer. Pour rappel les fonctions ont été vues dans la Fiche 3: les fonctions ou « sous programmes »
La fonction allu_buzzer va posséder 3 paramètres :
- le numéro de la broche (PIN en anglais) de branchement du buzzer
- la fréquence
- la durée de fonctionnement (en millisecondes)
Ces trois paramètres auront comme nom de variable à l'intérieur de la fonction (variables locales):
- adress_buzzer
- freq
- temps_buz
La fonction sera donc de la forme: void allu_buzzer ( ……. , …….. , ……….)
et utilisée de la manière suivante (dans la boucle Loop): allu_buzzer ( ……. , …….. , ………. );
Cette fonction allu_buzzer va contenir la partie qui gère le Buzzer que l'on enlèvera de la boucle Loop pour la mettre dans la fonction. Grosso modo ceci (il faudra bien sûr changer le nom des variables et mettre les variables locales propres à la fonction:
partie issue du Loop et à mettre dans la fonction (après modifications): |
|
duree = 0; while(duree < temps*1000) { digitalWrite(BUZZER_PIN,HIGH); // delayMicroseconds(demi_periode); digitalWrite(BUZZER_PIN,LOW); delayMicroseconds(demi_periode); duree = duree + 2*demi_periode; } |
1. Faire la modification du programme. Essayer. Quand cela fonctionne faire valider par le professeur.
V. Un peu de musique maintenant
rajouter dans la déclaration des variables les notes de musique (norme anglo-saxonne):
const float c = 261;
const float d = 294;
const float e = 329;
const float f = 349;
const float g = 391;
const float gS = 415;
const float a = 440;
const float aS = 455;
const float b = 466;
const float cH = 523;
const float cSH = 554;
const float dH = 587;
const float dSH = 622;
const float eH = 659;
const float fH = 698;
const float fSH = 740;
const float gH = 784;
const float gSH = 830;
const float aH = 880;
et dans la boucle du programme (void loop) :
appui_bp1= digitalRead(Bp1); // lecture de l'état du BP1//
if (appui_bp1 == LOW) // test si appui sur BP//
{
allu_buzzer(BUZZER_PIN, a, 500);
allu_buzzer(BUZZER_PIN, a, 500);
allu_buzzer(BUZZER_PIN, a, 500);
allu_buzzer(BUZZER_PIN, f, 350);
allu_buzzer(BUZZER_PIN, cH, 150);
allu_buzzer(BUZZER_PIN, a, 500);
allu_buzzer(BUZZER_PIN, f, 350);
allu_buzzer(BUZZER_PIN, cH, 150);
allu_buzzer(BUZZER_PIN, a, 650);
delay (500);
allu_buzzer(BUZZER_PIN,eH, 500);
allu_buzzer(BUZZER_PIN,eH, 500);
allu_buzzer(BUZZER_PIN,eH, 500);
allu_buzzer(BUZZER_PIN,fH, 350);
allu_buzzer(BUZZER_PIN,cH, 150);
allu_buzzer(BUZZER_PIN,gS, 500);
allu_buzzer(BUZZER_PIN,f, 350);
allu_buzzer(BUZZER_PIN,cH, 150);
allu_buzzer(BUZZER_PIN,a, 650);
}
Essayer.