Annonce 1

2nde Générale SNT

Annonce 2

1ère Générale NSI

Annonce 3

TS : Spécialité ISN

Annonce 4

Terminale STI2D SIN

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 :
  • 1 potentiomètres rotatif – entrées analogiques A0.
  • 1 capteur de température - entrée analogique A4
  • 3 boutons poussoirs – entrées numériques (TOR) D15, D16, and D17.

Et d’afficheurs :
  • 4 LEDs  - sortie logique D10, D11, D12 et D13.
  • 4 afficheurs 7 segments.
  • 1 buzzer - sortie logique D3.



                          
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 :

  • vous pouvez vérifier si votre constante est juste en calculant avec la valeur intermédiaire de 512 qui correspond à 2,5V.
  • vous pouvez aussi vous aider de la documentation arduino:
    
     

Extrait de la documentation Arduino:

analogRead()

Description

Reads the value from the specified analog pin. The Arduino board contains a 6 channel (8 channels on the Mini and Nano, 16 on the Mega), 10-bit analog to digital converter. This means that it will map input voltages between 0 and 5 volts into integer values between 0 and 1023. This yields a resolution between readings of: 5 volts / 1024 units or, .0049 volts (4.9 mV) per unit. The input range and resolution can be changed using analogReference().

It takes about 100 microseconds (0.0001 s) to read an analog input, so the maximum reading rate is about 10,000 times a second.

Syntax
analogRead(pin)

Parameters
pin: the number of the analog input pin to read from (0 to 5 on most boards, 0 to 7 on the Mini and Nano, 0 to 15 on the Mega)

Returns
int (0 to 1023)

....

   

 


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
 

 

    
     

Voici un extrait de la documentation Arduino:

while loops

Description
while loops will loop continuously, and infinitely, until the expression inside the parenthesis, () becomes false. Something must change the tested variable, or the while loop will never exit. This could be in your code, such as an incremented variable, or an external condition, such as testing a sensor.

Syntax
while (expression) {
  // statement(s)
}

Parameters
expression - a (boolean) C statement that evaluates to true or false

....

   

 

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.

 


Logo Lycée Paul Sérusier

J'enseigne au
Lycée Paul SERUSIER
Avenue de Waldkappel
29270 CARHAIX PLOUGUER
Tél : 02 98 99 29 29
Site : www.lycee-serusier.fr

footer2

Richard GAUTHIER
Professeur de Physique Appliquée
Certification ISN
Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.

 

 


Mentions légales


Plan du site

  Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.