Atelier 2

2 Entrées Numériques
&
Interruption

objectifs:

Maitriser les modes et techniques d'interfaçages des entrées numériques.

Matériels utilisés :
 Siwtch
 Résistance 10K et 220
 Led
 4 fils MM

Le switch sera connecté en série avec une résistance au + 5 V comme sur le montage suivant :

Travail demandé :

1
Réaliser le montage suivant :

1. Le code qu’on souhaite réaliser doit permettre de faire :

Configuration de la broche 13 en sortie

Configuration de la broche 3 en entrée
répéter indéfiniment
Lire état du bouton (broche 3)
si état = BAS
allumer led
sinon
éteindre led

Traduire cet algorithme en code en utilisant les fonctions :digitalRead, digitalWrite,

pinMode
Remarque : la comparaison on utilise l’opérateur « == »

int state = 0 ;
constintledpin = 13 ;
constintinpin = 3 ;

void setup (){

pinMode(….,OUTPUT) ;
pinMode(….,INPUT) ;
}

voidloop(){
state=digitalRead(…….) ;
if(state==1)
digitalWrite(….,HIGH) ;
else
digitalWrite(…..,….) ;

2
 2. Compiler le code, téléverser et observer

Problème des rebonds :

Les boutons ne sont pas des systèmes mécaniques parfaits. Du coup,

lorsqu’un appui est fait dessus, le signal ne passe pas immédiatement
et proprement de 5V à 0V.
En l’espace de quelques millisecondes, le signal va “sauter” entre 5V
et 0V plusieurs fois avant de se stabiliser.

Il se passe le même phénomène lorsque l’utilisateur relâche le bouton. Ce genre d’effet n’est
pas désirable, car il peut engendrer des parasites au sein du programme (si vous voulez
détecter un appui, les rebonds vont vous en générer une dizaine en quelques millisecondes, ce
qui peut être très gênant dans le cas d’un compteur par exemple).

Solution 1 : Utilisation de condensateur

Pour atténuer ce phénomène, on utilise un condensateur en parallèle avec le bouton.

Ce composant servira ici “d’amortisseur” qui absorbera les rebonds. Le condensateur,

initialement charge, va se décharger lors de l’appui sur le bouton. S’il y a des rebonds, ils
seront encaisses par le condensateur durant cette décharge.

Il se passera le phénomène inverse (charge du condensateur) lors du relâchement du bouton.

Ce principe est illustre ci-contre :

Solution logicielle :

3
Ouvrir l’exemple « Debounce.ino »

1. Expliquer par quel moyen ce code permet-il d’éliminer le problème des rebonds.

2. Utilisation des interruptions

Une interruption, comme son nom l’indique, consiste à interrompre momentanément le

programme que l’Arduino exécute pour qu’il effectue un autre travail. Quand cet autre travail
est terminé, l’Arduino retourne à l’exécution du programme et reprend à l’endroit exact où il
l’avait laissé.

Cet autre travail s’appelle le programme d’interruption ou la routine d’interruption ou

encore une ISRpour Interrupt Service Routine en anglais.

Il est très important que les ISR aient un temps d’exécution le plus court possible. On ne
fera donc aucun calcul compliqué et aucun appel à des fonctions longues comme un affichage
sur un écran LCD.

Que se passe-t-il si plusieurs interruptions surviennent en même

temps ?
Les Interruptions ont chacune une priorité. Par exemple, les interruptions externes sont plus
prioritaires que les interruptions des Timers. L’Arduino exécutera les ISR dans leur ordre de
priorité. L’ordre de priorité est donné dans la table ci-dessous. La source d’interruption située la
plus en haut de la table est la plus prioritaire.

Source Rôle
INT0 Interruption externe sur la broche 2
INT1 Interruption externe sur la broche 3
PCINT0 Interruption externe sur les broches 8 à 13
PCINT1 Interruption externe sur les broches A0 à A5
PCINT3 Interruption externe sur les broches 0 à 7

4
 Les interruptions externes INT0 et INT1
Ces deux interruptions sont les plus faciles à utiliser. INT0 correspond à la broche 2 des Arduinoa
base d’AVR et INT1 correspond à la broche 3. Pour accrocher une routine d’interruption à un état
ou un changement d’état de l’une de ces broches on va utiliser la
fonction attachInterrupt(...).
Cette fonction prend 3 arguments : le numéro d’interruption externe, la fonction à appeler quand
l’interruption survient et enfin la condition selon laquelle l’interruption survient. Son prototype est
le suivant :
attachInterrupt(numéro, ISR, mode);

Détaillons ses arguments :

 numéro est le numéro d’interruption concernée. Il s’agira de 0 ou 1 sur un ArduinoUno, ce qui

correspond respectivement aux broches 2 et 3. Sur un ArduinoMega, les numéros 0 à 5 seront
possibles et correspondent, dans l’ordre, aux broches 21, 20, 19, 18, 2 et 3.

 ISR est la routine d’interruption qui sera appelée lorsque l’interruption surviendra. Cette
routine d’interruption est une fonction qui ne renvoit rien et qui ne prend aucun argument,
comme ceci :
voidmaRoutine() { ... }.
 mode indique ce qui va provoquer l’interruption. Les valeurs possibles pour mode sont :
o LOW : l’interruption est déclenchée quand la broche concernée est LOW. Comme il s’agit
d’un état et non d’un événement, l’interruption sera déclenchée tant que la broche est LOW.
Par conséquent, dès que l’ISR aura terminé son exécution, elle la recommencera. Pendant ce
temps, loop() ne sera pas exécuté.
o CHANGE : l’interruption est déclenchée quand la broche concernée change d’état, c’est à
dire passe de LOW à HIGH ou bien de HIGH à LOW. Il s’agit d’un événement.
o RISING : l’interruption est déclenchée quand la broche concernée passe de LOW à HIGH.
Il s’agit également d’un événement.
o FALLING : l’interruption est déclenchée quand la broche concernée passe de HIGH à
LOW. Il s’agit encore d’un événement.

Une seconde fonction, detachInterrupt(...) permet de déconnecter l’ISR de la source

d’interruption. Son prototype est le suivant :

1. detachInterrupt(numero);

Où numero est le numéro d’interruption, 0 ou 1 sur un ArduinoUno, 0 à 5 sur un ArduinoMega.

2. Tester le code suivant :

5
 3. Modifier le code pour valider le fonctionnement souhaitée

Application :
1.1. Montage à faire

1.2.
Deux boutons et quatre LED – SchémaDeux boutons et quatre LED - Montage

Pour cet exercice, nous allons utiliser deux boutons et quatre LED de n’importe quelles couleurs.

 Les deux boutons seront considérés actifs (appuyés) à l’état bas (0V) comme dans la partie
précédente. Ils seront connectés sur les broches 2 et 3 de l’Arduino.

 Ensuite, les quatre LED seront connectées sur les broches 10 à 13 de l’Arduino.

1.2.1. Cahier des charges

1.2.2. La réalisation prévue devra :

 posséder quatre LED (ou plus pour les plus téméraires)

 posséder deux boutons : un qui incrémentera le nombre de LED allumées, l’autre qui le
décrémentera

6
Vous devrez utiliser une variable qui voit sa valeur augmenter ou diminuer entre 0 et 4 selon l’appui du
bouton d’incrémentation ou de décrémentation.

Vous pouvez maintenant vous lancer dans l’aventure. Ceux qui se sentent encore un peu mal à l’aise avec
la programmation peuvent poursuivre la lecture, qui leur expliquera pas à pas comment procéder pour
arriver arésultat final.

1.3. Correction

1.3.1. Initialisation
Pour commencer, on crée et on initialise toutes les variables dont on a besoin dans notre programme :

/* déclaration des constantes pour les noms des broches ; ceci selon le
schéma */
constintbtn_minus = 2;
constintbtn_plus = 3;
constint led_0 = 10;
constint led_1 = 11;
constint led_2 = 12;
constint led_3 = 13;

/* déclaration des variables utilisées pour le comptage et le décomptage */

// le nombre qui sera incrémenté et décrémenté

intnombre_led = 0;
// lecture de l'état des boutons (un seul à la fois donc une variable
suffit)
intetat_bouton;

/* initilisation des broches en entrée/sortie */

voidsetup()
{
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INPUT);
pinMode(led_0, OUTPUT);
pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT);
pinMode(led_3, OUTPUT);
}

voidloop()
{
// les instructions de votre programme
}

7
 1.3.2. Détection des différences appuyé/relâché

Afin de détecter un appui sur un bouton, nous devons comparer son état courant avec son état précédent.
C’est-à-dire qu’avant qu’il soit appuyé ou relâché, on lit son état et on l’inscrit dans une variable. Ensuite,
on relit si son état a changé. Si c’est le cas alors on incrémente la variable nombre_led . Pour faire cela,
on va utiliser une variable de plus par bouton :

intmemoire_plus = HIGH; // état relâché par défaut

intmemoire_minus = HIGH;
1.3.3. Détection du changement d’état
Comme dit précédemment, nous devons détecter le changement de position du bouton, sinon on ne verra
rien car tout se passera trop vite. Voilà le programme de la boucle principale :

voidloop()
{
// lecture de l'état du bouton d'incrémentation
etat_bouton = digitalRead(btn_plus);

// Si le bouton a un état différent de celui enregistré ET

// que cet état est "appuyé"
if((etat_bouton != memoire_plus) && (etat_bouton == LOW))
{
// on incrémente la variable qui indique
// combien de LED devrons s'allumer
nombre_led++;
}

// on enregistre l'état du bouton pour le tour suivant

memoire_plus = etat_bouton;

// et maintenant pareil pour le bouton qui décrémente

etat_bouton = digitalRead(btn_minus); // lecture de son état

// Si le bouton a un état différent que celui enregistré ET

// que cet état est "appuyé"
if((etat_bouton != memoire_minus) && (etat_bouton == LOW))
{
nombre_led--; // on décrémente la valeur de nombre_led
}
// on enregistre l'état du bouton pour le tour suivant
memoire_minus = etat_bouton;

// on applique des limites au nombre pour ne pas dépasser 4 ou 0

if(nombre_led>4)
{
nombre_led = 4;
}
if(nombre_led<0)
{
nombre_led = 0;
}

// appel de la fonction affiche() que l'on aura créée

8
// on lui passe en paramètre la valeur du nombre de LED à éclairer
affiche(nombre_led);
}

Programme de détections d’évènements sur un bouton

Nous avons terminé de créer le squelette du programme et la détection d’évènements, il ne reste plus qu’à
afficher le résultat du nombre !

1.3.4. L’affichage

Pour éviter de se compliquer la vie et d’alourdir le code, on va créer une fonction d’affichage. Celle dont je
viens de vous parler : affiche(intle_parametre) . Cette fonction reçoit un paramètre représentant
le nombre à afficher. À présent, nous devons allumer les LED selon la valeur reçue. On sait que l’on doit
afficher une LED lorsque l’on reçoit le nombre 1, deux LED lorsqu’on reçoit le nombre 2, …

voidaffiche(intvaleur_recue)
{
// on éteint toutes les LED
digitalWrite(led_0, HIGH);
digitalWrite(led_1, HIGH);
digitalWrite(led_2, HIGH);
digitalWrite(led_3, HIGH);

// Puis on les allume une à une

if(valeur_recue>= 1)
{
digitalWrite(led_0, LOW);
}
if(valeur_recue>= 2)
{
digitalWrite(led_1, LOW);
}
if(valeur_recue>= 3)
{
digitalWrite(led_2, LOW);
}
if(valeur_recue>= 4)
{
digitalWrite(led_3, LOW);
}
}
Fonction d’affichage

Donc, si la fonction reçoit le nombre 1, on allume la LED 1. Si elle reçoit le nombre 2, elle allume la LED
et 2. Si elle reçoit 3, elle allume la LED 1, 2 et 3. Enfin, si elle reçoit 4, alors elle allume toutes les LED. Le
code au grand complet :