Chapitre.

3 Arduino

Elaboré par : Mohamed HADJ SAID

Avril 2O22

1
 Plan
1) Arduino: A quoi ça sert ?
2) Diverses Cartes microcontrôleurs Arduino
3) Périphérique de La carte Arduino Uno
4) « Shields » Arduino
5) Matériels nécessaire
6) Programmation graphique (Scratch)
7) Programmation sur IDE
8) Structure d'un programme
9) Gérer les entrées/sorties
10) Types de variables
11) Déclaration d'une fonction
12) Les structures de contrôle 2
 1) Arduino: A quoi ça sert ?

 Construire des dispositifs qui interagissent

avec l’environnement qui les entoure

Capteurs Actionneurs

Températures Moteurs

Humidité Servos

Pression Electrovannes

Présence Pompes

Distance Verins

Position Résistances chauffantes

Luminosité Eclairages
Système
... Arduino ...

3
 Exemple d’Architecture AVR

4
2) Diverses Cartes microcontrôleurs Arduino

Plus évoluée
 Plus d’entrées et sorties (54 contre 14 ),
 Plus de mémoire (programmes plus complexes)
 Processeur, plus puissant.
 Adaptée pour les projets collège
 Mise à disposition de nombreux tutoriels
 Limitée en nombre de périphériques externes
 Arduino équivalent Mega mais
plus puissante pour des calculs
plus rapides.

Lilipad

 Permet la miniaturisation,
 Incrustation dans des espaces
 caractéristiques l’Arduino Mega)
réduits (vêtement).
 Interagir avec un smartphone Android grâce à
un port USB.
5
3) Périphérique de La carte Arduino Uno

6
4) Shields Arduino
 Rajouter des fonctionnalités nouvelles à votre
carte Arduino

GSM
Ethernet WIFI

LCD
Relais Commande moteurs

➢ Shield + Uno

7
5) Matériels nécessaire
Interface :
Carte Arduino uno
Câbles USB

Montage des circuits :

Plaque test de Montage
Fils de pontage
Résistances
Potentiomètres ….

Outillage électronique

Capteurs (logiques et analogiques)

Actionneurs
 Cellule photo-résistive
 LED
 Capteur IR
 Servomoteur
 Capteur température
 Transducteur Piezo électrique
 Capteur humidité
 Haut-parleur
 Microphone 8
 Relais
 Interrupteurs …..
6) Programmation graphique (Scratch)

- Langage sous forme de blocs

- Approche ludique de l‟algorithmique
- Compilation et « résultat » instantanée
Permet de :
 Créer des animations,
 Créer des logiciels, 99
 Transformer le programme en exe.
6) Programmation graphique (Exemple de code
sur Scratch)

10
7) Programmation sur IDE

11
 7) Programmation sur IDE
7.a) Charger un programme dans la carte

Etape 1 : lancer le logiciel.

Etape 2 : ouvrir et modifier le programme.
Etape 3 : vérifier le programme.
Etape 4 : connecter la carte à l‟ordinateur avec le cordon USB.
Etape 5 : transférer le programme vers la carte.
Si un message d’erreur apparaît :
faire Outil/Port série/Com …
et choisir le bon port USB.
Etape 6 : vérifier le fonctionnement.

12
7.b) Selection du Port et du type de la carte
8) Structure d'un programme
Un programme Arduino comporte 3parties :
1. la partie déclaration des variables (optionnelle)
2. la partie initialisation et configuration des entrées/sorties : la
fonction setup ()
3. la partie principale qui s'exécute en boucle : la fonction loop ()
Dans chaque partie d'un programme sont utilisées différentes
instructions issues de la syntaxe du langage Arduino.

COLORATION SYNTAXIQUE
Lorsque du code est écrit dans l'interface de programmation,
certains mots apparaissent en différentes couleurs qui clarifient le
statut des différents éléments :
En orange, apparaissent les mots-clés reconnus par le langage
Arduino comme des fonctions existantes. Lorsqu'on sélectionne
un mot coloré en orange et qu'on effectue un clic avec le bouton
droit de la souris, l'on a la possibilité de choisir « Find in reference
» : cette commande ouvre directement la documentation de la
fonction sélectionnée.
En bleu, apparaissent les mots-clés reconnus par le langage
Arduino comme des constantes.
En gris, apparaissent les commentaires qui ne seront pas exécutés
dans le programme.

On peut déclarer un commentaire de deux manières différentes

:dans une ligne de code, tout ce qui se trouve après « // » sera un
commentaire. On peut encadrer des commentaires sur plusieurs
lignes entre « /* » et « */ ».
14
9) Gérer les entrées/sorties

9.a) Initialiser les E/S

Les cartes Arduino sont faites pour nous donner des possibilités d’interaction avec
le monde réel.

Pour que ce soit possible il faut initialiser les ports d’entrée/sortie en utilisant la
fonction pinMode(pinNb, mode ).

mode peut avoir les valeurs INPUT, OUTPUT ou INPUT_PULLUP

 Se fait en général dans la fonction setup()

 6 entrées analogiques qu’il n’est pas nécessaire d’initialiser (ou

entrées/sorties numériques qu’il faudra initialiser)

 14 Entrées/Sorties numériques qu’il est nécessaire d’initialiser

15
9.b) Lecture et écriture sur les E/S

Utilisation des fonctions :

 digitalRead(pinNb ) (retourne HIGH ou LOW) ;

 digitalWrite(pinNb, level ) avec level valant HIGH ou LOW ;

 analogRead(pinNb ) (retourne un entier compris entre 0 et 1023) ;

 analogWrite(pinNb, value ) (PWM).

 Se fait généralement dans la fonction loop() ou dans toute fonction

perso ;

 Possibilité également de faire dans la fonction setup() pour :

- mettre un dispositif connecté dans un état particulier ;

- (dés)activer la résistance interne de pull-up sur les lignes de sortie.

16
9.c) Sortie TOR

Exemple 1
//There is a LED connected to pin 13 on the //RedBoard

void setup(){
pinMode(13, OUTPUT); // sets pin 13 as output
}

void loop(){
digitalWrite(13, HIGH); // sets the LED on
delay(1000); // waits for a second
digitalWrite(13, LOW); // sets the LED off
delay(1000); // waits for a second
}

17
 9.d) E/S TOR
Exemple 2
int ledPin = 13; // LED connected to digital pin 13
int inPin = 7; // pushbutton connected to digital pin 7
boolean val = 0; // variable to store the read value
void setup(){
Digital input pins can be HIGH
pinMode(ledPin, OUTPUT); // sets pin 13 as output
(2.7V-5V) or LOW (1.2V-0V).
Before you use a digital input you pinMode (inPin, INPUT); // sets the pin 7 as input
need to set the “pinMode” }
void loop(){
val = digitalRead(inPin); // read the input pin
digitalWrite(ledPin, val); // sets the LED to the button's value}

Remarque : Pins Configured as

INPUT_PULLUP
The Atmega chip on the Arduino has internal
pull-up resistors (resistors that connect to
power internally) that you can access. If you
prefer to use these instead of external pull-
down resistors, you can use the INPUT_PULLUP
argument in pinMode().

18
 9.e) Entrée analogique

Exemple 3

int analogPin = 3;
int val = 0;

void setup(){
Serial.begin(9600); // setup serial
}

void loop(){
val = analogRead(analogPin);
// read the input pin
Serial.println(val); // debug value
}

19
int analogPin = 3;
int val = 0;
int ledPin = 11;

void setup(){
pinMode(analogPin, INPUT);
pinMode(ledPin, OUTPUT);
Serial.begin(9600); // setup serial
}

void loop(){
val = analogRead(analogPin); // read the input pin
analogWrite(ledPin, val/4);
Serial.println(val); // debug value
delay(1000);
}

20
9.f) Sortie MLI (analogWrite)

La modulation de largeur d’impulsions (MLI ; en anglais :

Pulse Width Modulation, soit PWM), est une technique
couramment utilisée pour synthétiser des signaux
continus à l’aide de circuits à fonctionnement tout ou rien,
ou plus généralement à états discrets.
Le principe général est qu’en appliquant une succession
d’états discrets pendant des durées bien choisies, on peut
obtenir en moyenne sur une certaine durée n’importe
quelle valeur intermédiaire.

Exemple 4

21
 9.f) Sortie MLI (PWM)

Exemple 5 : variation de vitesse

d’un moteur à courant continu
par un potentiomètre

int ledPin = 7; // LED connected to digital pin 9

int analogPin = 3; // pot connected to analog pin 3
int val = 0; // variable to store the read value
void setup(){
pinMode(ledPin, OUTPUT); // sets the pin as output
}
void loop(){
val = analogRead(analogPin); // read the input pin
analogWrite(ledPin, val / 4);
}

22
10) Types de variables
10.a) Déclaration d'un scalaire
boolean single bit FALSE/TRUE
(really uses a whole byte of memory)
Unsigned Integers
byte eight bits 0 to 255
word two bytes 0 to 65535
unsigned long 4 bytes 0 to 4,294,967,295

Signed Integers
char eight bits -128 to 127
Exp : char A;
A='B'; //'B' is encoded with ASCII and the resulting value of 66 is stored in A.
int (short) two bytes -32,768 to 32,767
long 4 bytes -2,147,483,648 to 2,147,483,647.

Real Numbers
Float Floating point number uses 4 bytes. Used for non-integers has 6-7 decimal point precision.
-3.4028235E+38 to 3.4028235E+38

N.B : Before using a variable it must be declared.

Exp : int a=34; // creates an integer with the name „a‟ and assigns it the value 34.

23
Exercice : Testons nos connaissances
int hi; //global variables
int there=0; //all functions have access

void setup(){
int this=10; //only exists within “setup()”
hi=1; //changing value of “hi”
}
void loop(){
println(“hi”); //prints “….”
println(hi); //prints “….”
println(there); //prints “….”
println(this); // prints “….”
}

24
Exercice : Testons nos connaissances (Réponse)

int hi; //global variables

int there=0; //all functions have access

void setup(){
int this=10; //only exists within “setup()”
hi=1; //changing value of “hi”
}
void loop(){
println(“hi”); //prints “hi”
println(hi); //prints “1”
println(there); //prints “0”
println(this); //variable not defined…error program
//won‟t compile (verify)
}

25
10.b) Declaration d'un tableau
A single variable can store an array of values.
The index is contained in square brackets. Arrays are zero indexed (start at zero).

int threeints[3]; // „threeints‟ is an array (0-2)

threeints[0]=15;
threeints[1]=10;
threeints[2]=threeints[0]-threeints[1];

An array of characters is called a string

char examplestring[8];
examplestring=“arduino”;
The last element of a sting is always the „null string‟ which has an ASCII value of zero

Stings can also be stored as objects using the String class.

Using String objects rather than character arrays uses more memory but adds functionality.
Character arrays are referred to as strings with a small s, and instances of the String class are
referred to as Strings with a capital S.
Constant strings, specified in "double quotes" are treated as char arrays, not instances of the
String class.

26
11) Declaration d'une fonction

Une fonction (également désignée sous le nom de procédure ou de sous-routine) est un bloc d'instructions
que l'on peut appeler à tout endroit du programme.Le langage Arduino est constitué d'un certain nombre
de fonctions, par exemple analogRead(),digitalWrite() ou delay().Il est possible de déclarer ses propres
fonctions par exemple :
….
Void clignote(){
digitalWrite (brocheLED, HIGH) ;delay (1000) ;
digitalWrite (brocheLED, LOW) ;delay (1000) ;
}
…
Pour exécuter cette fonction, il suffit de taper la commande :clignote();

La fonction peut aussi retourner une valeur après leur exécution. Exemple :

27
12) Les structures de contrôle

Les structures de contrôle sont des blocs d'instructions qui s'exécutent en fonction du
respect d'un certain nombre de conditions.

Il existe quatre types de structure :

1) Structure if...else:
exécute un code si certaines conditions sont remplies
et éventuellement exécutera un autre code avec sinon.
exemple :
//si la valeur du capteur depasse le seuil
if(valeurCapteur>seuil){
clignote();
}//appel de la fonction clignote

2) Structure while:
exécute un code tant que certaines conditions sont remplies.
exemple :
while(valeurCapteur>250) { //tant que la valeur du capteur est supérieure à 250
digitalWrite(5,HIGH); //allume la sortie 5
Serial.println(1); //envoi le message "0" au port serie en boucle tant que valeurCapteur est supérieue à 250
}
Serial.println(0);
digitalWrite(5,LOW);
28
12) Les structures de contrôle

3) Structure For :
exécute un code pour un certain nombre de fois.

exemple :
//pour i de 0 à 255, par pas de 1
for (inti=0; i<= 255; i++){
analogWrite(PWM pin, i);
delay(10);
}

4) Structure switch/case :

fait un choix entre plusieurs codes parmi une liste de possibilités.

exemple :
// fait un choix parmi plusieurs messages reçus
switch (message) {
case 0: //si le message est "0"allume que la sortie 3
digitalWrite(3,HIG H);digitalWrite(4,LOW);digitalWrite(5,LOW);break;
case 1: //si le message est "1"//allume que la sortie 4
digitalWrite(3,HIG H);digitalWrite(4,LO W);digitalWrite(5,LOW);break;
case 2: //si le message est "2"//allume que la sortie 5
digitalWrite(3,LO W);digitalWrite(4,LO W);digitalWrite(5,HIGH);break;
} 29

:
12) Les structures de contrôle

Example: What is the final value of x?

int x=1;
void setup(){
x=10;

}
void loop(){
if (x<20){
for(int i=1;i<3;i++){
x=x+x;
}
}
}

30
 12) Les structures de contrôle

Exemple 6 :
/*Dans ce programme, un signal analogique provenant d'un capteur (potentiomètre) fait varier la vitesse de clignotement d'une LED, à
partir d'un certain seuil
*/
////declaration des variables
Int brocheCapteur = 0; // sélection de la broche sur laquelle est connectée le capteur
Int brocheLED = 13; // sélection de la broche sur laquelle est connectée la LED
Int valeurCapteur = 0; // variable stockant la valeur du signal reçu du capteur
int seuil= 200; //seuil de déclenchement
///////////Initialisation
void setup () {
pinMode (brocheCapteur, OUTPUT) ; // broche du capteur configurée en sortie
pinMode (brocheLED, OUTPUT) ; // broche de la LED configurée en sortie
}
////////////boucle principale
Void loop () {
valeurCapteur = analogRead (brocheCapteur) ;// lecture du signal du capteur
if(valeurCapteur>seuil){ //condition de déclenchement
clignote(); //appel de la fonction clignote
}}
/////fonction personnalisée de clignotement
Void clignote(){
digitalWrite (brocheLED, HIGH) ; // allume la LED
delay (valeurCapteur) ; // délai de «valeurCapteur" millisecondes
digitalWrite (brocheLED, LO W) ; // éteint la LED
delay (valeurCapteur) ; // delai de «valeurCapteur" millisecondes 31
}
13) Interface série sur ATMega328P

Il existe une interface série (USART) sur les ATMega328P.

- Utilisée pour les communications inter-modules ou entre le module et l’ordinateur

(au travers de l’USB) ;

-Pris en charge par la bibliothèque Serial ;

-La ligne série (broches 0 et 1) est exclusive,

-son utilisation empêche de se servir de ces
-broches pour autre chose.

Il est donc possible de recevoir des données depuis un module Arduino, mais
également de lui en envoyer pour, par exemple, modifier son comportement.

32
13) Interface série sur ATMega328P

•First you need to setup serial communication

•Serial.begin(9600); //typically in setup()
•9600 is the default speed but different values can be used.
•Two main functions for printing information on the computer.
•Serial.print(“Hi”); //Prints the word “Hi” on the screen. The next print
//command will result in printing right after the “i”
•Serial.println(“Hi”); //will pass a linebreak after “Hi”. The next print
//command will result in printing on a new line.
•What is printed depends on the data type of the variable being passed to the
function.
Information can be read from the computer (serial monitor)
Bytes are stored in a buffer automatically
•Serial.read(); //reads first byte from buffer
•Serial.available();// returns the number of bytes in the buffer
•Serial.flush();// clears the buffer
33
.
13) Interface série sur ATMega328P
Exemple 7 : Allumer et éteindre les LEDs à partir du clavier
int pinLed2 = 6; //Déclaration des pin sur lesquelles sont connectées les LED // LED Verte
int pinLed1 = 4; // LED Jaune
int pinLed0 = 2; // LED Rouge
int octetRecu; //Déclaration de la variable contenant la valeur de //la touche saisi au
clavier
void setup() {
Serial.begin(9600); // Configuration des pin en sortie
pinMode(pinLed0, OUTPUT); pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT); pinMode(pinLed3, OUTPUT);
}
void loop() {
if (Serial.available() > 0) { // Verfie si il y a une donnée sérielle disponible
octetRecu = Serial.read(); // Lecture de l'octet présent dans la mémoire tampon (buffer)
if (octetRecu == 'R' || octetRecu == 'r') { //Si l'octet recu est égal à R ou r
digitalWrite(pinLed0, HIGH); //Allumer la LED connectée à pinLed0
Serial.println("LED Rouge allumee");} //Afficher "LED Rouge allumee" dans le moniteur
if (octetRecu == 'J' || octetRecu == 'j') { //Si l'octet recu est égal à J ou j
digitalWrite(pinLed1, HIGH); //Allumer la LED connectée à pinLed1
Serial.println("LED Jaune allumee"); } //Afficher "LED Jaune allumee" dans le moniteur
if (octetRecu == ‘V' || octetRecu == ‘v') { //Si l'octet recu est égal à V ou v
digitalWrite(pinLed1, HIGH); //Allumer la LED connectée à pinLed2
Serial.println("LED Jaune allumee"); } //Afficher "LED verte allumee" dans le moniteur
if (octetRecu == 'E' || octetRecu == 'e') { //Si l'octet recu est égal à E ou e
//Eteindre les LED connectées aux pinLed0,…Led2
digitalWrite(pinLed0, LOW);digitalWrite(pinLed1, LOW);digitalWrite(pinLed2, LOW);digitalWrite(pinLed3, LOW);
Serial.println("LED eteinte"); //Afficher "LED eteinte" dans le moniteur série. 34
}
}
13) Interface série sur ATMega328P
13.a) Bus série – SPI
SPI : Serial Peripheral Interface
- Principe de fonctionnement en maître/esclaves : une ligne SS par périphérique ;
- Communications synchrones : une ligne SCK commune à tous les périphériques ;
- Deux lignes pour la communications entre maître et esclaves : lignes MOSI et MISO
communes à tous les périphériques.

Il y a une bibliothèque dédiée à ce mode de communication : SPI Library qui gère le

transfert des données et l’horloge série. Chaque constructeur de périphérique SPI
défini ses propres modes de communication.

35
13) Interface série sur ATMega328P
13-b) Bus Série – I2C
I2C : Inter Integrated Circuits
I2C, également connu sous le nom de bus TWI (Two Wire Interface) nécessite, comme
son nom l’indique presque, trois fils pour fonctionner :
1. signal de données : SDA ;
2. signal d’horloge : SCL ;
3. une référence (masse).
Chaque périphérique a une adresse (7 bits) sur le bus et c’est un fonctionnement en
maître/esclaves. La bibliothèque permettant de gérer ce bus est Wire Library. Elle
simplifie grandement la gestion des différents états sur les lignes.

36
14) Interruptions sur les ATMega328P

Définition de l’Interruption : Signal permettant d’interrompre temporairement le

fonctionnement normal d’un programme pour exécuter une routine spécifique.

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 ISR : Interrupt Service Routine.

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.

Attention : A l'intérieur de la fonction attachée à l'interruption, la fonction delay ne

fonctionne pas et la valeur renvoyée par millis ne s'incrémente pas. Les données séries
reçues pendant l'exécution de la fonction sont perdues.

37
14) Interruptions sur les ATMega328P

Il existe plusieurs sources d’interruption, on dit également vecteur d’interruption,

sur l’AVR 328 qui équipe l’Arduino Uno, 26 au total.

 5 interruptions externes
Il s’agit des 5 interruptions liées au changement de la tension présente sur une
broche numérique qui sont donc ce que l’on appelle des interruptions externes:
- 2 programmables via l’API Arduino, INT0 et INT1 (pins 2 et 3)
- 3 sur changement d’état des pins

 18 interruptions internes
- RESET
- Timers
- ADC
- Watchdog
- Comparateur
- ...

38
14) Interruptions sur les ATMega328P

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

39
14) Interruptions sur les ATMega328P
14.a) Les interruptions externes INT0 et INT1
-Correspond en respectivement à la broche 2 et à la broche 3.
-On utilise la fonction attachInterrupt (numéro, ISR, mode);
- numéro est le numéro d’interruption concernée. Il s’agira de 0 ou 1 sur un
Arduino Uno (broches 2 et 3). Sur un Arduino Mega, les numéros 0 à 5
seront possibles (broches 21, 20, 19, 18, 2 et 3). //digitalPinToInterrupt(broche)
- ISR est la routine d’interruption qui sera appelée lorsque l’interruption
surviendra. Cette routine d’interruption est une fonction qui ne renvoi
rien et qui ne prend aucun argument, comme ceci : void maRoutine(){ ... }.
- Mode indique ce qui va provoquer l’interruption. Les valeurs possibles
pour mode sont :
*LOW l’interruption sera déclenchée tant que la broche est L.
Pendant ce temps, loop() ne sera pas exécuté.
* CHANGE : : L à H ou H à L(événement).
* RISING : L à H (événement).
* FALLING : H à L. (événement).

-On utilise detachInterrupt(numéro) ;qui permet de déconnecter l’ISR de la source

d’interruption.
40
14) Interruptions sur les ATMega328P
14.b) Les interruptions externes PCINT0, PCINT1 et PCINT2
PCINT0 correspond aux interruptions externes sur les broches 8 à 13,
PCINT1 aux interruptions externes sur les broches A0 à A5 et
PCINT2 aux interruptions externes sur les broches 0 à 7.

-On peut noter que les broches 2 et 3 sont donc partagées entre PCINT2 et INT0 et INT1.
- On ne peut donc à la fois bénéficier de INT0 et INT1 et des interruptions PCINT2 sur les
broches 2 et 3
-La richesse des modes de déclenchement de INT0 et INT1 n’existent pas pour les sources
PCINTx. Le seul mode est l’interruption sur changement d’état, L à H et H à L.
Il existe une bibliothèque qui masque la complexité du matériel :PinChangeInt. La
bibliothèque fournit les fonctions :
PCintPort::attachInterrupt(pin, ISR, mode);
PCintPort::detachInterrupt(pin);
NB: Le premier argument est le numéro NB : le 1er argument est le Num de la broche (au
lieu de N° de l’interruption). Les autres arguments sont identiques.

41
14) Interruptions sur les ATMega328P
14.c) Exemple 1

Lorsque vous utilisez une interruption, tout le programme se met en « pause » et la fonction
appelée dans l’interruption prend le relais. Ainsi, les fonctions de temps « delay() »,
« millis() » seront également stoppée. Veillez à bien faire attention dans vos programmes
pour ne pas avoir de mauvaise surprise !

Code Arduino IDE

int pin = 13; volatile int state = LOW; //déclaration d'une variable volatile
void Setup(){
pinMode(pin, OUTPUT); attachInterrupt(0, blink, CHANGE); //attache l'int ext 0 à "blink«
}
void Loop(){
digitalWrite(pin, state); //la LED reflète d'état de la variable
}
void blink(){
state = !state; //inverse l'état de la variable
}

42
14) Interruptions sur les ATMega328P
14.c) Exemple 2
- les ISR sont attachées à A1, A2, A3 et A4.
- L’objectif est la surveillance d’un grand nombre de pédales (entrées numériques externes).
- Les entrées A1 à A4 programmées en entrées numériques avec pull-up.

- Le programme installe 4 fonctions qui seront appelées par les ISR des vecteurs PCINTx, une
pour chaque entrée.
- Les pédales mettent l’entrée à 0V quand ils sont actionnées, le mode de déclenchement
choisi est FALLING. Chaque fonction incrémente une variable.
-Les péales engendrent des rebonds quand ils sont actionnés. C’est à dire que, au lieu de
géner un seul FALLING, ils vont en générer plusieurs. Un delay de 1ms permet d’éliminer
les rebonds tout en conservant une bonne réactivité.
- Afin de visualiser l’activation des ILS, un LCDKeypad shield est employé.
On demande d’afficher, toutes les 20 ms, la valeur des 4 variables mémorisant le nombre43
de déclenchements sur chaque pédale
 14) Interruptions sur les ATMega328P
14.c) Exemple
#include <LiquidCrystal.h> void interruptI2(){ void setup(){
#include <LCDKeypad.h> static unsigned long dateDernCh = 0;
#include <PinChangeInt.h> lcd.begin(16, 2);
unsigned long date = millis(); lcd.clear();
LCDKeypad lcd; if ((date - dateDernCh) > dureeAntiRebd) lcd.print("Test PCINT");
const byte pinI1 = A1; comptageI2++;
const byte pinI2 = A2; dateDernCh= date; } pinMode(pinILS1, INPUT_PULLUP);
const byte pinI3 = A3; } pinMode(pinILS2, INPUT_PULLUP);
const byte pinI4 = A4; void interruptI3(){ pinMode(pinILS3, INPUT_PULLUP);
static unsigned long dateDernCh = 0; pinMode(pinILS4, INPUT_PULLUP);
byte comptageI1 = 0;
byte comptageI2 = 0; unsigned long date = millis(); PCintPort::attachInterrupt(pinI1, intI1, FALLING);
byte comptageI3 = 0; if ((date - dateDernCh) > dureeAntiRebd) PCintPort::attachInterrupt(pinI2, intI2, FALLING);
byte comptageI4 = 0; comptageI3++; PCintPort::attachInterrupt(pinI3, intI3, FALLING);
const unsigned long dureeAntiRebd = 1; dateDernCh= date; PCintPort::attachInterrupt(pinI4, intI4, FALLING);
} }
void interI1(){ }
static unsigned long dateDernCh = 0; void interruptI4(){ void loop(){
static unsigned long dateDernCh = 0; lcd.setCursor(0,1); lcd.print(comptageI1);
unsigned long date = millis(); lcd.setCursor(4,1); lcd.print(comptageI2);
if ((date - dateDernCh) > dureeAntiRebd) unsigned long date = millis(); lcd.setCursor(8,1); lcd.print(comptageI3);
{ if ((date - dateDernCh) > dureeAntiRebd) lcd.setCursor(12,1); lcd.print(comptageI4);
comptageI1++; { delay(20);
dateDernCh= date; comptageI4++; }
} dateDernCh= date;
} }
}
44
16) Les conditions et le opérateurs
Les conditions
Condition Dans le programme

Egale à ==

Supérieur >

Inférieur <

Supérieur ou égal >=

Inférieur ou égal <=

Non égal !=
16) Les conditions et le opérateurs
Opérateurs logiques
Dans le
Opérateur logique Exemple
programme

ET logique
Vraie si les deux
&& if(condition 1 && conditions 2)
conditions sont
remplies

OU logique
Vrai si l’une ou l’autre des !! if(condition 1 !! conditions 2)
conditions est remplie

NON logique
Vrai si la condition est ! if( ! condition)
fausse
Merci pour Votre Attention

47