Partie I: Compléments de cours

1. Les interruptions matérielles

a) Principe

Dans les parties précédentes , la lecture d'un changement d'état se faisait en comparant
régulièrement l'état du bouton à un moment avec son état précédent. Cette méthode
fonctionne bien, mais pose un problème : l'appui ne peut pas être détecté s'il est trop
court. Autre situation, si l'utilisateur fait un appui très long, mais que vous êtes déjà dans
un traitement très long , le temps de réponse à l'appui ne sera pas du tout optimal. Pour
pallier ce genre de problème, les constructeurs de microcontrôleurs ont mis en place des
systèmes qui permettent de détecter des évènements et d’exécuter des fonctions dès la
détection de ces derniers. Par exemple, lorsqu'un pilote d'avion de chasse demande au
siège de s'éjecter, le siège doit réagir au moment de l'appui, pas une minute plus tard
(trop tard).

Qu'est-ce qu'une interruption ?

une interruption du programme est générée lors d'un événement attendu. Ceci
dans le but d'effectuer une tâche, puis de reprendre l'exécution du programme.
Arduino propose aussi ce genre de gestion d’évènements. On les retrouvera sur certaines
broches, sur des timers, des liaisons de communication, etc.

b) Mise en place

Nous allons illustrer ce mécanisme avec ce qui nous concerne ici, les boutons. Dans le cas
d'une carte Arduino UNO, on trouve deux broches pour gérer des interruptions externes
(qui ne sont pas dues au programme lui-même), la 2 et la 3. Pour déclencher une
interruption, plusieurs cas de figure sont possibles :

•LOW : Passage à l'état bas de la broche

•FALLING : Détection d'un front descendant (passage de l'état haut à l'état bas)
•RISING : Détection d'un front montant (pareil qu'avant, mais dans l'autre sens)
•CHANGE : Changement d'état de la broche

Autrement dit, s'il y a un changement d'un type énuméré au-dessus, alors le programme

1/10
sera interrompu pour effectuer une action.

Créer une nouvelle interruption

Comme d'habitude, nous allons commencer par faire des réglages dans la fonction
setup(). La fonction importante à utiliser est attachInterrupt(interrupt, function, mode) .
Elle accepte trois paramètres :

1)interrupt : qui est le numéro de la broche utilisée pour l'interruption (0 pour la

broche 2 et 1 pour la broche 3)
2)function : qui est le nom de la fonction à appeler lorsque l'interruption est
déclenchée
3)mode : qui est le type de déclenchement (cf. ci-dessus)

Si l'on veut appeler une fonction nommée Reagir() lorsque l'utilisateur appuie sur un
bouton branché sur la broche 2 on fera :
attachInterrupt(0, Reagir, FALLING);

Ensuite, il vous suffit de coder votre fonction Reagir() un peu plus loin.

Attention, cette fonction ne peut pas prendre d'argument et ne retournera aucun résultat.

Lorsque quelque chose déclenchera l'interruption, le programme principal sera mis en

pause. Ensuite, lorsque l'interruption aura été exécutée et traitée, il reprendra comme si
rien ne s'était produit (avec peut-être des variables mises à jour).

Mise en garde
Tout d'abord, les interruptions ne sont pas une solution miracle. En effet, gardez
bien en tête que leur utilisation répond à un besoin justifié. Elles mettent tout votre
programme en pause, et une mauvaise programmation peut entraîner une altération de
l'état de vos variables. De plus, les fonctions delay() et millis() n'auront pas un
comportement correct. En effet, pendant ce temps le programme principal est
complètement stoppé, donc les fonctions gérant le temps ne fonctionneront plus, elles
seront aussi en pause et laisseront la priorité à la fonction d'interruption.

La fonction delay() est donc désactivée et la valeur retournée par millis() ne changera
pas. Justifiez donc votre choix avant d'utiliser les interruptions.

2) Afficheur 7 segments

2/10
Ces 7 led sont toutes reliées soit par leur anode, soit par leur cathode. Voici les 2 schémas de
principe

L'électrode libre peut être reliée à des broches d'Arduino par une résistance mais généralement on
utilise un circuit spécialisé (décodeur) qui sélectionne les led en fonction du chiffre souhaité.

3. Capteur DHT22
Le capteur DHT22 est une des sondes les plus classiques lorsque l’on souhaite mesurer une
température avec un minimum de fiabilité. Évitez d’utiliser la DHT11 qui ne vaut pas le coup même
si elle est moins chère. Elle est moins précise, et ne prend pas les températures négative. A éviter
donc !
DHT22 a elle les spécifications suivantes :
•Entre 3 et 5V en entrée

•Lecture de l’humidité entre 0 et 100% avec une précision allant de 2% à 5%

•Lecture de la température de -40°C à 80°C avec une précision d’environ 0.5°C

3/10
 Montage
La sonde possède 4 pattes, mais la 3 ème ne nous sert pas. On relie donc les pattes de la manière
suivante :
1.Vers l’alimentation 3,3 Volts
2.Vers un pin de donnée
3.On laisse vide
4.Vers un pin GRD
il faut mettre une résistance de 4700 Ohm à la broche 2 et la relier ensuite à l’alimentation. Voila,
montage terminé, c’est on ne peut plus simple.

Le code
Il faut installer la bibliothèque dans votre IDE arduino, en utilisant le fichier zip fourni par
l'enseignant et modifier l'exemple fourni avec la bibliothèque , pour préciser le numéro de pin sur
lequel est connecté le capteur. Voici le programme exemple contenu dans la bibliotheque dht
#include "DHT.h"

 #define DHTPIN 2     // what pin we're connected to

 // Uncomment whatever type you're using!

//#define DHTTYPE DHT11   // DHT 11 

#define DHTTYPE DHT22   // DHT 22  (AM2302)

//#define DHTTYPE DHT21   // DHT 21 (AM2301)

DHT dht(DHTPIN, DHTTYPE);

void setup() {

  Serial.begin(9600); 

  Serial.println("DHTxx test!");

  dht.begin();

 void loop() {

  // Reading temperature or humidity takes about 250 milliseconds!

  // Sensor readings may also be up to 2 seconds 'old' (its a very slow 
sensor)

  float h = dht.readHumidity();

4/10
  float t = dht.readTemperature();

  // check if returns are valid, if they are NaN (not a number) then 
something went wrong!

  if (isnan(t) || isnan(h)) {

    Serial.println("Failed to read from DHT");

  } else {

    Serial.print("Humidity: "); 

    Serial.print(h);

    Serial.print(" %\t");

    Serial.print("Temperature: "); 

    Serial.print(t);

    Serial.println(" *C");

  }

Partie 2: Rappels : quelques programmes arduino

simples

1. Sorties/Entrees numériques
On appelle numériques des bornes de la plaquette qui fonctionnent en "tout ou rien", c'est à dire 0
ou 5 volts.
en entrée : il faut leur fournir
- soit une tension comprise entre 2,5 et 5 volts et elle est alors reconnue comme niveau 1
- soit moins de 0,8 volt et elle est alors reconnu comme niveau 0
sinon le résultat est incertain
en sortie : pas de problème, Arduino fournit 0 ou 5 volts.
Application : faire un montage en 2 étapes
- d'abord une Led qui clignote
- ensuite on ajoutera une autre qui s'allume quand on appuie sur un bouton.

5/10
Rappel: repérages d'une led, La cathode (borne moins) d'une diode est la plus courte.
exemple de leds
Arduino est sécurisé : chaque sortie est limitée à 20 mA. Ce n'est pas une raison pour faire n'importe
quoi. Nous ne brancherons pas les leds directement sur les broches mais par l'intermédiaire d'une
résistance.

a) 1er montage : utilisation d'une sortie digitale

Nous mettons l'anode d'une led sur la borne digitale 2. la cathode est reliée à la masse par une
résistance.
Programme blink
void setup() { 

pinMode(13, OUTPUT); 

} 

void loop() { 

digitalWrite(13, HIGH);    // éclaire la LED 

delay(1000);                   // attend 1 seconde 

digitalWrite(13, LOW);     // éteint la LED 

delay(1000);                   // attend 1 seconde 

b) 2ème montage : utilisation d'une entrée digitale

Sur le même montage, on ajoute :
- une led sur la borne 3, branchée comme la première
- un bouton-poussoir entre la borne 4 et le 5Volts.
- une résistance entre la borne 4 et la masse
Cette seconde led s'éclairera quand on appuyera sur le bouton.
Il suffit d'ajouter dans la loop
- la lecture de l'état du bouton
- l'éclairage ou non de la LED

6/10
voici le programme

void setup() { 
    pinMode(13, OUTPUT); 
} 

void loop() { 
    digitalWrite(13, HIGH);    // éclaire la LED 
    delay(1000);                   // attend 1 seconde 
    digitalWrite(13, LOW);     // éteint la LED 
    delay(1000);                   // attend 1 seconde 
    // 2ème partie du programme (led 3 et bouton) 
    etatBouton = digitalRead(4); 
    // Serial.print(etatBouton); // pendant les essais 
    digitalWrite(3, etatBouton); 
}

2) Entrées analogiques
Nous connaissons les entrées digitales qui valent soit 0 (0 volt) soit 1 (5 volts). Nous allons voir
l'autre type d'entrées, celles qui varient progressivent entre 0 et 5 volts. La tension présente sur une
broche analogique est lue par Arduino avec une précision sur 10 bits. Puisque 2 à la puissance 10
vaut 1024, on lit un nombre entre 0 et 1023.

Montage
On relie le curseur d'un potentiomètre à la borne analogique A0 d'Arduino. Les 2 autres broches du
potentiomètre sont reliées au +5 et à la masse.
Lorsqu'on varie la position du curseur, la chutte de tension entre la borne c et la masse varie, c'est
cette tension qui doit être lue par arduino et affichée dans le moniteur série

Programme
on écrit un programme arduino qui affiche sur le moniteur série la valeur lue sur l'entree analogique
A0 et la tension correspondante à cette valeur.
// le potentiomètre, branché sur la broche analogique 0, il n'est pas 
//nécssaire de la configurer en entree

const int entreeAna = 0;

int valeurLue;

//on convertit cette valeur en une tension

float tension;

7/10
void setup(){

    Serial.begin(9600);

void loop() {

    //on convertit en nombre binaire la tension lue en sortie du 
potentiomètre

    valeurLue = analogRead(entreeAna);

    //on traduit la valeur brute en tension 

    tension = valeurLue * 5.0 / 1023;

    //on affiche la valeur lue sur la liaison série

    Serial.print("valeurLue = ");  Serial.println(valeurLue);

    //on affiche la tension calculée

    Serial.print("Tension = ");  Serial.print(tension,2);

    Serial.println(" V");

    //on saute une ligne entre deux affichages

    Serial.println();

    //on attend une demi­seconde pour que l'affichage ne soit pas rapide

    delay(500);

Rq:
Pour convertir une valeur lue sur une entree analogique en une tension, on peut utiliser la fonction
arduino map
int valeurLue=analogRead(A0); //lit la valeur de l'entree analogique A0

int  tension = map(valeurLue, 0, 1023, 0, 5000); //conversion de la valeur 
lue en tension en mV

La fonction map prend 5 parametres tous entiers et qui : valeur_d_entree, valeur_min_d_entree,

valeur_max_d_entree, valeur_min_de_sortie, valeur_max_de_sortie

8/10
 3) Sorties Analogiques ou PWM
On veut une sortie analogique, c'est-à-dire pouvant prendre des valeurs intermédiaires entre 0 et
5V.
Arduino ne délivre que 0 ou +5, mais peut aussi envoyer des créneaux 0V/5V dont on peut choisir
le rapport cyclique
exemple : si le niveau est haut 80% du temps, on aura une moyenne de 4 volts.

Le programme écrit sur une sortie PWM une valeur comprise entre 0 et 255 (rappel : 255 est le plus
grand nombre qu'on peut écrire dans un octet).
Ce nombre va être transformé par le compilateur Arduino en un rapport cyclique de 0% à 100% . La
commande est analogWrite( pin, valeur)

Le montage
On met une LED sur la sortie PWM n°2, avec cathode reliée à la masse par une résistance. Le
programme va faire varier progressivement le rapport cyclique de la sortie 2. On verra encore mieux
si on ajoute un voltmètre entre la sortie 2 et la masse.
On fera varier de 0 à 255 la valeur envoyée à la LED, en s'arrêtant 20 ms sur chaque valeur. Et on
variera ensuite en sens inverse

Le code
 /*            variations de l'intensité d'éclairage d'une led          */ 

int sortie;       

void setup()      { 

     pinMode(2, OUTPUT); 

9/10
} 

void loop()      { 

     for ( sortie = 0 ; sortie < 256 ; sortie++) { 

         analogWrite(2, sortie); 

         delay(20); 

     } 

     delay (500); 

     for ( sortie = 255 ; sortie >= 0 ; sortie­­) { 

         analogWrite(2, sortie); 

         delay(20); 

     } 

     delay (500); 

 } 

10/10