SOMMAIRE

Chapitre1 : Les enregistrements

1.1 Présentation ..................................................................................................................... 1
1.1.1 Historique ................................................................................................................. 1
1.1.2 Plateforme Arduino .................................................................................................. 1
1.2 Le logiciel Arduino ......................................................................................................... 2
1.2.1 Description ............................................................................................................... 2
1.2.2 Principe général d'utilisation .................................................................................... 3
1.2.3 Description de la barre des boutons ......................................................................... 4
1.2.4 Transfert des programmes vers la carte Arduino ..................................................... 4
1.2.5 Librairies .................................................................................................................. 6
1.3 La carte Arduino.............................................................................................................. 7
1.4 Le langage Arduino ......................................................................................................... 8
1.4.1 La syntaxe du langage .............................................................................................. 8
1.4.1.1 Le code minimal ................................................................................................... 8
1.4.1.2 La fonction ........................................................................................................... 9
1.4.2 Les variables ............................................................................................................ 9
1.4.3 Reference : ............................................................................................................. 10
1.5 Exercices d’application ................................................................................................. 12
Chapitre 2 : Gestion des Entrées/Sorties
2.1 Capteurs et Actionneurs ................................................................................................ 17
2.1.1 Les capteurs ........................................................................................................... 17
2.1.2 Les actionneurs ...................................................................................................... 17
2.1.3 Entrées/sorties ........................................................................................................ 18
2.1.4 CIRCUITS ADDITIONNELS ............................................................................... 19
2.2 Electronique Interactive ................................................................................................ 20
2.3 Exercices d’application ................................................................................................. 22
Chapitre3 : Communication Série
3.1 Principe de la communication série .............................................................................. 27
3.2 Fonctionnement de la liaison série ................................................................................ 27
3.3 Programmation Série ..................................................................................................... 28

I
 3.3.1 Envoyer des données .............................................................................................. 28
3.3.2 Recevoir des données ............................................................................................. 30
3.4 Application .................................................................................................................... 31
Chapitre4 : Les grandeurs analogiques
4.1 Les entrées analogiques ................................................................................................. 37
4.1.1 Présentation ............................................................................................................ 37
4.1.2 Les convertisseurs analogiques -> numérique ou CAN ......................................... 37
4.2 Exercice d’application ................................................................................................... 38
Chapitre5 : L'affichage
5.1 Les ecrans LCD ............................................................................................................. 42
5.2 Exercice d’application ................................................................................................... 44

II
 Chapitre 1 :
Découverte de l’Arduino

Vue d’ensemble
Cette leçon présente l’historique et l’utilisation des cartes Arduino.

Objectifs
Ce chapitre a pour objectifs de permettre aux étudiants d’acquérir les connaissances de
base de la carte arduino et de ses nombreux avantages.
Pré-requis
• Systèmes logiques
• Electronique numérique
• Programmation structurée
Durée
• 3H

Eléments de contenu
1. Présentation
2. Base élémentaires
3. Logiciel Arduino
4. Carte Arduino
5. Langage Arduino
6. Exercices d’application
 Chapitre1 : Présentation

1.1 Présentation
1.1.1 Historique

Le projet Arduino est né en hiver 2005. Massimo Banzi enseigne dans une école de Design à
Ivrea en Italie, et souvent ses étudiants se plaignent de ne pas avoir accès à des solutions bas
prix pour accomplir leurs projets de robotique. Banzi en discute avec David Cuartielles, un
ingénieur Espagnol spécialisé sur les microcontrôleurs…

Ils décident de créer leur propre carte en embarquant dans leur histoire un des étudiants de
Banzi, David Mellis qui sera chargé de créer le langage de programmation allant avec la carte.

Figure 1: Prototype Arduino

1.1.2 Plateforme Arduino

Arduino est un projet en source ouverte : la communauté importante d'utilisateurs et de

concepteurs permet à chacun de trouver les réponses à ses questions.

Le système Arduino permet à l’utilisateur de réaliser un grand nombre de projets puisque

l'étendue de l'utilisation de l'Arduino est gigantesque. Voici quelques exemples:

• contrôler les appareils domestiques

• fabriquer l’ propre robot
• faire un jeu de lumières
• communiquer avec l'ordinateur
• télécommander un appareil mobile
• etc.

La plateforme Arduino est constituée de deux choses :

• Le logiciel : gratuit et open source, développé en Java, dont la simplicité d'utilisation

relève du savoir cliquer sur la souris.

1
 Chapitre1 : Présentation

• Le matériel : cartes électroniques dont les schémas sont en libre circulation sur
internet.

Cette liberté a une condition : le nom « Arduino » ne doit être employé que pour les cartes «
officielles ». En somme, les concepteurs ne pouvant pas fabriquer ses propres cartes sur le
modèle Arduino et lui assigner le nom « Arduino ».

1.2 Le logiciel Arduino

1.2.1 Description

Le logiciel Arduino a pour fonctions principales :

• de pouvoir écrire et compiler des programmes pour la carte Arduino

• de se connecter avec la carte Arduino pour y transférer les programmes
• de communiquer avec la carte Arduino

Cet espace de développement intégré (EDI) dédié au langage Arduino et à la programmation

des cartes Arduino comporte :

• une BARRE DE MENUS comme pour tout logiciel une interface graphique (GUI),
• une BARRE DE BOUTONS qui donne un accès direct aux fonctions essentielles du
logiciel et fait toute sa simplicité d'utilisation,
• un EDITEUR (à coloration syntaxique) pour écrire le code de programme, avec
onglets de navigation,
• une ZONE DE MESSAGES qui affiche indique l'état des actions en cours,
• une CONSOLE TEXTE qui affiche les messages concernant le résultat de la
compilation du programme

2
 Chapitre1 : Présentation

Le logiciel Arduino intègre également :

• un TERMINAL SERIE (fenêtre séparée) qui permet d'afficher des messages textes
reçus de la carte Arduino et d'envoyer des caractères vers la carte Arduino. Cette
fonctionnalité permet une mise au point facilitée des programmes, permettant
d'afficher sur l'ordinateur l'état de variables, de résultats de calculs ou de conversions
analogique-numérique : un élément essentiel pour améliorer, tester et corriger ses
programmes.

1.2.2 Principe général d'utilisation

Le code écrit avec le logiciel Arduino est appelé un programme (ou une séquence - sketch en
anglais) :

• Ces programmes sont écrits dans l'éditeur de texte. Celui-ci a les fonctionnalités
usuelles de copier/coller et de rechercher/remplacer le texte.

• la zone de messages donne l'état de l'opération en cours lors des sauvegardes, des
exportation et affiche également les erreurs.

• La console texte affiche les messages produits par le logiciel Arduino incluant des
messages d'erreur détaillés et autres informations utiles.

• la barre de boutons permette de vérifier la syntaxe et de transférer les programmes,

créer, ouvrir et sauver le code, et ouvrir le moniteur série.

• la barre des menus permet d'accéder à toutes les fonctionnalités du logiciel Arduino.

3
 Chapitre1 : Présentation

1.2.3 Description de la barre des boutons

Vérifier/compiler : Vérifie le code à la recherche d'erreur.

Stop : Stoppe le moniteur série ou les autres boutons activés.

Nouveau : Crée un nouveau code (ouvre une fenêtre d'édition vide)

Ouvrir : Ouvre la liste de tous les programmes dans la "livre de programmes".

Cliquer sur l'un des programmes l'ouvre dans la fenêtre courante.
Note: en raison d'un bug dans Java, ce menu ne défile pas.

Sauver : Enregistre le programme.

Transférer vers la carte : Compile le code et le transfert vers la carte Arduino.

Voir ci-dessous "Transférer les programmes" pour les détails.

Moniteur Série : Ouvre la fenêtre du moniteur (ou terminal) série.

1.2.4 Transfert des programmes vers la carte Arduino

On suppose ici qu'un programme correctement écrit se trouve dans la fenêtre éditeur. Pour
première programmation de la carte, aller dans le menuFile>Examples>Digital>Blink : un
programme s'ouvre avec du code dans la fenêtre éditeur.

4
 Chapitre1 : Présentation

Appuyez alors sur le bouton Verify de la barre d'outils pour lancer la vérification du code :

Si tout va bien, aucun message d'erreur ne doit apparaître dans la console et la zone de
message doit afficher Done Compiling attestant que la vérification s'est bien déroulée.

Avant de transférer la programme vers la carte Arduino, l’utilisateur devez vérifier que il a
bien sélectionné la bonne carte Arduino depuis le menu Tools>Board (Outils>Carte).

5
 Chapitre1 : Présentation

Une fois le transfert terminé, le logiciel Arduino doit afficher un message indiquant que le
transfert est bien réalisé.

1.2.5 Librairies

Les librairies fournissent des fonctions nouvelles à utiliser dans les programmes, par exemple
pour utiliser un matériel précis (un afficheur LCD...) ou manipuler des données. Pour utiliser
une librairie, la sélectionner depuis le menu Sketch > Import Library (Programme > Importer
Librairie). Cela insèrera une ou plusieurs instructions #include au début de le programme et
compilera la librairie avec le programme.

6
 Chapitre1 : Présentation

1.3 La carte Arduino

La déclaration d’un enregistrement se fait comme étant un nouveau type définit par
l’utilisateur dans l’algorithme, il doit être déclaré dans la partie Type avant d’être utilisé
comme type de variable dans la partie Var.

Le microcontrôleur : C’est le cerveau de la carte. Il va recevoir le programme que nous allons

créer et va le stocker dans sa mémoire avant de l’exécuter. Grâce à ce programme, il va savoir
faire des choses, qui peuvent être : faire clignoter une LED, afficher des caractères sur un
écran, envoyer des données à un ordinateur...

Il existe deux modèles d’Arduino Uno: l’un avec un microcontrôleur de grande taille (DIP), et
un autre avec un microcontrôleur dit SMD (SMD: Surface Mounted Device, soit composants
montés en surface, en opposition aux composants qui traversent la carte électronique et qui
sont soudés du côté opposé). D’un point de vue utilisation, il n’y a pas de différence entre les
deux types de microcontrôleurs.

L’alimentation : Pour fonctionner, la carte a besoin d'une alimentation. Le microcontrôleur

fonctionnant sous 5V, la carte peut être alimentée en 5V par le port USB ou bien par une
alimentation externe qui est comprise entre 7V et 12V. Cette tension doit être continue et peut
par exemple être fournie par une pile 9V. Un régulateur se charge ensuite de réduire la tension
à 5V pour le bon fonctionnement de la carte.

Visualisation : Les trois LED de l’Arduino UNO servent à deux choses :

7
 Chapitre1 : Présentation

• La LED jaune en haut: elle est connectée à une broche du microcontrôleur et va servir
pour tester le matériel.
• Les deux LED (orange): servent à visualiser l'activité sur la voie série (une pour
l'émission et l'autre pour la réception). Le téléchargement du programme dans le
microcontrôleur se faisant par cette voie, on peut les voir clignoter lors du chargement.

La connectique : La carte Arduino ne possédant pas de composants (résistances, diodes,

moteurs...) qui peuvent être utilisés pour un programme, il est nécessaire de les rajouter. Mais
pour ce faire, il faut les connecter à la carte. C'est là qu'interviennent les connecteurs de la
carte. Sur les Arduino et sur beaucoup de cartes compatibles Arduino, les connecteurs se
trouvent au même endroit. Cela permet de fixer des cartes d’extension, appelée shields en les
empilant.

Nomenclature des connecteurs Arduino :

• 0 à 13 : Entrées/sorties numériques
• A0 à A5 : Entrées/sorties analogiques
• GND : Terre ou bien masse (0V)
• 5V : Alimentation +5V
• 3.3V : Alimentation +3.3V
• Vin : Alimentation non stabilisée (= le même voltage que celui à l’entrée de la carte)

1.4 Le langage Arduino

Pour pouvoir programmer notre carte, il nous faut trois choses :
• Un ordinateur
• Une carte Arduino
• Et connaitre le langage Arduino

1.4.1 La syntaxe du langage

Le langage Arduino est très proche du C et du C++. La syntaxe d'un langage de

programmation est l'ensemble des règles d'écritures liées à ce langage. On va donc voir dans
ce sous-chapitre les règles qui régissent l'écriture du langage Arduino.

1.4.1.1 Le code minimal

Avec Arduino, nous devons utiliser un code minimal lorsque l'on crée un programme. Ce code
permet de diviser le programme que nous allons créer en deux grosses parties.

void setup() //fonction d'initialisation de la carte

{
//contenu de l'initialisation
}
void loop() //fonction principale, elle se répète (s’exécute) à 1
//'infini

8
 Chapitre1 : Présentation

{
//contenu de votre programme
}

1.4.1.2 La fonction

Dans ce code se trouvent deux fonctions. Les fonctions sont en fait des portions de code.

void setup() //fonction d'initialisation de la carte

{
//contenu de l'initialisation
//on écrit le code à l'intérieur
}

Cette fonction setup() est appelée une seule fois lorsque le programme commence. C'est
pourquoi c'est dans cette fonction que l'on va écrire le code qui n'a besoin d'être exécuté une
seule fois. On appelle cette fonction : "fonction d'initialisation". On y retrouvera la mise en
place des différentes sorties et quelques autres réglages. C'est un peu le check-up de
démarrage. Une fois que l'on a initialisé le programme il faut ensuite créer son "cœur",
autrement dit le programme en lui-même.

void loop() //fonction principale, elle se répète (s’exécute) à l

//'infini
{
//contenu de votre programme
}

C'est donc dans cette fonction Loop() où l'on va écrire le contenu du programme. Il faut
savoir que cette fonction est appelée en permanence, c'est-à-dire qu'elle est exécutée une fois,
puis lorsque son exécution est terminée, on le ré-exécute et encore et encore. On parle de
boucle infinie.

1.4.2 Les variables

Les variables booléennes sont des variables qui ne peuvent prendre que deux valeurs : VRAI
ou FAUX. Elles sont utilisées notamment dans les boucles et les conditions.

Une variable booléenne peut être définie de plusieurs manières :

boolean variable = FALSE; //variable est fausse car elle vaut FALSE, du te
rme anglais "faux"
boolean variable = TRUE; //variable est vraie car elle vaut TRUE, du term
e anglais "vrai"

Quand une variable vaut "0", on peut considérer cette variable comme une variable
booléenne, elle est donc fausse. En revanche, lorsqu'elle vaut "1" ou n'importe quelle valeurs
différente de zéro, on peut aussi la considérer comme une variable booléenne, elle est donc
vraie. Voilà un exemple :

int variable = 0; //variable est fausse car elle vaut 0

int variable = 1; //variable est vraie car elle vaut 1

9
 Chapitre1 : Présentation

int variable = 42; //variable est vraie car sa valeur est différente d
e 0

Le langage Arduino accepte aussi une troisième forme d'écriture (qui lui sert pour utiliser les
broches de sorties du microcontrôleur) :

int variable = LOW; //variable est à l'état logique bas (= traduction

de "low"), donc 0
int variable = HIGH; //variable est à l'état logique haut (= traductio
n de "high"), donc 1

Nous nous servirons de cette troisième écriture pour allumer et éteindre des lumières...

1.4.3 Reference :

Structure
Fonctions de base Structures de contrôle Syntaxe de base
Ces deux fonctions sont •if • ; (point virgule)
obligatoires dans tout
• if...else • {} (accolades)
programme en langage
Arduino: • for • / / (commentaire sur une
• void setup() • switch case ligne)
• void loop() • while • /* * / (commentaire sur
• do... while plusieurs lignes)
• break • #define
• continue • #include
• return
• goto
Opérateurs Opérateurs de Opérateurs
arithmétiques comparaison booléens
• = (égalité) • == (égal à) • && (ET booléen)
• + (addition) • != (différent de) • | | (OU booléen)
• - (soustraction) • < (inférieur à) • ! (NON booléen)
• * (multiplication) • > (supérieur à)
• / (division) • <= (inférieur ou égal à)
• % (modulo) • >= (supérieur ou égal à)
Pointeurs Opérateurs bit à bit Opérateurs composés
• * pointeur • & (ET bit à bit) • ++ (incrémentation)
• & pointeur • | (OU bit à bit) • -- (décrémentation) (à revoir)
Voir également : • ^(OU EXCLUSIF bit à bit) • += (addition composée)
• Manipulation des Ports • ˜ (NON bit à bit) • -= (soustraction composée)
• << (décalage à gauche) • *= (multiplication composée)

10
 Chapitre1 : Présentation

• >> (décalage à droite) • /= (division composée)

• &= (ET bit à bit composé)
• |= (OU bit à bit composé)

Variables et constantes
Les variables sont des expressions que l’apprenant peut utiliser dans les programmes pour stocker
des valeurs, telles que la tension de sortie d'un capteur présente sur une broche analogique.
Constantes prédéfinies Types des données Conversion des types
Les constantes prédéfinies du Les variables peuvent être de de données
langage Arduino sont des type variés qui sont décrits ci-
• char()
valeurs particulières ayant une dessous.
signification spécifique. • byte()
• boolean
• int()
• char
• HIGH | LOW • long()
• byte
• INPUT | OUTPUT • float()
• in t
• true | false • word()
• unsigned in t
• long
• unsigned long
• float (nombres à
virgules)
• double (nombres à
virgules)
• Les chaînes de
caractères
• objet String NEW
• Les tableaux de
variables
• le mot-clé void
(fonctions)

Fonctions
Entrées/Sorties Numériques Temps Trigonométrie
• pinMode (broche, mode) • unsigned long millis() • sin (rad)
• digitalWrite (broche, valeur) • unsigned long micros() • cos (rad)
• int digitalRead(broche) • delay (ms) • tan (rad)
Entrées analogiques • delayMicroseconds (us) Bits et Octets

11
 Chapitre1 : Présentation

• int analogRead(broche) Math • lowByte ()

• analogReference (type) • min (x, y) • highByte ()
Sorties "analogiques" • max (x, y) • bitRead ()
(génération d'impulsion)
• abs (x) • bitWrite ()
• analogWrite (broche, valeur) -
• constrain (x, a, b) • bitSet()
PWM
• map (valeur, toLow, • bitClear ()
Entrées/Sorties Avancées
fromHigh, toLow, toHigh)
• bit()
• tone ()
• pow (base, exposant)
Interruptions Externes
• noTone ()
• sq (x)
• attachInterrupt(interruption,
• shiftOu t(broche,
• sqr t(x) fonction, mode)
BrocheHorloge, OrdreBit,
valeur) Nombres randomisés (hasard) • detachInterrupt(interruption)
• unsigned long pulseIn(broche, • randomSeed (seed) Interruptions
valeur) • long random(max) • interrupts ()
Communication • long random(min, max) • noInterrupts ()
• Serial

1.5 Exercices d’application

Exercice 1 : Lire un bouton poussoir

Un bouton poussoir peut comme la LED être branché

électriquement de deux façons, suivant que l'on veut que le
processeur lise HIGH (5V) ou LOW (0V) quand on pèse.
Ne documentons que la plus usuelle.
Si on ne pèse pas, il faut que la tension d'entrée sur le
processeur soit définie, donc on rajoute une résistance
"pull-up" vers le 5V, donc un HIGH tant que l'on ne pèse
pas (22 kOhm – rouge-rouge-orange convient bien). Si on
pèse, on envoie le courant de la résistance dans le 0V
(Gnd) et le processeur lit un LOW. Le poussoir est branché
sur un pin qui doit être nommée et déclarée en entrée.
#define Pous9 9
void setup ()
{
pinMode (Pous9, INPUT);
}
Pour lire l'état du poussoir, on utilise
l'opération
digitalRead(Pous9)

Exercice 2 : Faire clignoter une LED

Nous allons maintenant réaliser le schéma suivant:

12
 Chapitre1 : Présentation

Ecrire un programme qui permet de faire clignoter un LED à la PIN 10.

void setup() {
// Initialise la broche 10 comme sortie
pinMode(10, OUTPUT);
// Ouvre le port série à 9600 bauds
Serial.begin(9600);
}
void loop() {
digitalWrite(10, HIGH); // allume la LED
delay(500); // attend 500ms
digitalWrite(10, LOW); // éteint la LED
delay(500); // attend 500ms
}

Télécharger le code: http://www.sharedamine.ovh/code/code2.txt

Ce qui a changé par rapport au code précédent, c’est que la valeur de la broche est passée de
13 à 10. En effet, nous avons choisi (arbitrairement) de connecter la LED sur la broche 10.

Exercice 3 : faire clignoter deux LEDs

- Modifie le code 2 pour faire clignoter les deux LEDs en même temps.

Corrigé: http:// www.sharedamine.ovh /code/code2-1.txt

- Modifie ton code pour faire clignoter les LEDs en alternance.

Corrigé: http:// www.sharedamine.ovh /code/code2-2.txt

En observant le code ci-dessous, seras-tu capable de prédire ce qui va se passer?

void setup()

13
 Chapitre1 : Présentation

{
pinMode(10, OUTPUT);
pinMode(12, OUTPUT);
Serial.begin(9600);
}
void loop()
{
digitalWrite(10, LOW);
digitalWrite(12, HIGH);
delay(500);
digitalWrite(10, HIGH);
digitalWrite(12, HIGH);
delay(2000);
}

Exercice 4 : Code 3: faire clignoter une LED 10 fois

L’objectif est de faire clignoter une LED 10 fois. Le montage est toujours le même:

/*
Code 3 - Edurobot.ch, destiné au Arduino
Objectif: faire clignoter 10 fois la LED montée sur le port 10
*/
//***** EN-TETE DECLARATIVE *****
// On déclare les variables, les constantes,...
byte compteur; //On définit la variable "compteur"
//***** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et une seule fois, au
démarrage
du programme
void setup()
{
pinMode(10, OUTPUT); // Initialise la broche 10 comme sortie
Serial.begin(9600); // Ouvre le port série à 9600 bauds
// Exécute le programme entre accolades en partant de zéro et en
incrémentant à
chaque fois la valeur de +1: 0+1/2+1/3+1... jusqu’à ce que la variable
“compteur“ soit égale à 9 (plus petit que 10).
for(compteur=0 ; compteur<10 ; compteur++)
{ // début du programme exécuté 10 fois
digitalWrite(10, HIGH); // allume la LED
delay(500); // attend 500ms
digitalWrite(10, LOW); // éteint la LED
delay(500); // attend 500ms

14
 Chapitre1 : Présentation

}
} // fin du programme exécuté 10 fois
void loop() { // vide, car programme déjà exécuté dans setup
}

Télécharger le code: http://sharedamine.ovh/code/code3.txt

Exercice 5 : Faire clignoter deux LED 20 fois

Réalise le montage suivant:

- Modifier le code pour que les deux LED clignotent en même temps vingt fois.

Le corrigé se trouve à l’adresse : http://sharedamine.ovh/code/code4-1.txt

- Modifier le programme pour que les LED clignotent en alternance vingt fois.

Le corrigé se trouve à l’adresse: http://sharedamine.ovh/code/code4-2.txt

15
 Chapitre 2 : Gestion des
Entrées/Sorties

Vue d’ensemble
Cette leçon présente la gestion des entrées/sorties.

Objectifs
Ce chapitre a pour objectifs de permettre aux étudiants d’acquérir les connaissances de
base se rapportant aux objectifs spécifiques suivants:
• Etre capable d’utiliser les capteurs et les actionneurs.
• Voir le résultat de programme en temps réel.
• Gérer un ensemble fini d’éléments dont le nombre varie au cours de l’exécution du
programme.
• Réalisation des prototypes.

Prérequis
• Systèmes logiques
• Electronique numérique
• Programmation
Durée
• 1,5 H

Eléments de contenu
1. Capteurs et Actionneurs
2. Electronique Interactive
3. Exercices d’applications
 Chapitre2 : Gestion Entrées/Sorties

2.1 Capteurs et Actionneurs

L'électronique est une branche de la physique appliquée qui traite les signaux
électriques. La carte Arduino est un circuit électronique qui peut être programmé et qui
permet de faire le pont entre le monde virtuel de la programmation informatique (concepts
formels et logiques) et le monde physique (interaction électromécanique des objets). Nous
abordons ci-après les notions de capteurs et actionneurs ainsi que quelques sous catégories de
ces deux grandes familles.

2.1.1 Les capteurs

Les capteurs sont des composants matériels qui peuvent fournir des informations sur le
monde extérieur. Ceux-ci ont comme rôle de saisir une grandeur physique et de la convertir
en information numérique. Il est ainsi possible de capter la plupart des phénomènes physiques
comme le vent, la pression, la température, la lumière, la torsion, la distance, etc. On peut
classifier l'ensemble des capteurs en trois familles suivant le type d'informations qu'ils
renvoient.

- Les capteurs logiques ou TOR

Ce type de capteur renvoie une information de type logique c'est-à-dire 0 ou 1. En d’autres

termes, la sortie peut prendre uniquement deux états. Par exemple, un clavier est une matrice
de capteurs logiques car chaque touche est un interrupteur (ou un contact) qui peut être soit «
ouvert » soit « fermé ».

- Les capteurs analogiques

Ce type de capteur renvoie une valeur proportionnelle à la grandeur physique mesurée. Par
exemple une photorésistance (capteur de lumière) est un capteur qui convertit la luminosité en
valeur électrique. Il existe des capteurs analogiques qui renvoient une information linéaire et
d'autres dont la réponse suit une courbe différente.

Pour un capteur, une courbe linéaire signifie que la progression de sa valeur suit une
progression constante et régulière. Une courbe non linéaire appartient à une fonction plus
complexe dont la valeur ne progresse pas également dans le temps.

2.1.2 Les actionneurs

Les actionneurs sont des composants matériels qui permettent d'agir sur le monde extérieur.
Ceux-ci ont comme rôle de convertir une valeur électrique en action physique. Il existe une
infinité de types d'actionneurs différents et certains sont plus ou moins faciles à utiliser avec
Arduino. Comme pour les capteurs, il existe une multitude de phénomènes physiques sur

17
 Chapitre2 : Gestion Entrées/Sorties

lesquels il est possible d'agir par le biais d'actionneurs comme les moteurs électriques,
électroaimants, lumières, LEDs, éléments chauffants utilisés pour concevoir une multitude
d'objets et applications comme des hautparleurs, valves hydrauliques et pneumatiques,
ventilateurs, pompes, ….

Beaucoup de machines et objets qui nous entourent comportent à la fois des capteurs et des
actionneurs. Ils sont tous basés sur les principes de base de l'électronique que nous avons vus
dans le chapitre précédent.

2.1.3 Entrées/sorties

Une carte Arduino standard est dotée de :

• 6 entrées analogiques.
• 14 entrées/sorties numériques dont 6 peuvent assurer une sortie PWM (voir
explication en bas dans la section « Les sorties numériques »).

Les entrées analogiques lui permettent de mesurer une tension variable (entre 0 et 5 V) qui
peut provenir de capteurs 6 ou d'interfaces divers (potentiomètres, etc.).

Les entrées/sorties numériques reçoivent ou envoient des signaux « 0 » ou « 1 » traduits par

0 ou 5 V. On décide du comportement de ces connecteurs (entrée ou sortie) en général dans
l'initialisation du programme (voir chapitre « Langage Arduino ») mais il peut être aussi
changé dans le corps du programme.

Lorsqu'on utilise une entrée numérique, il est important de s'assurer que le potentiel de l'entrée
« au repos » est bien celui auquel on s'attend. En effet, si on laisse l'entrée « libre », c'est-à-
dire non câblée, le potentiel qu'elle prendra ne sera pas nécessairement 0 V. On parle alors de
potentiel flottant car l'électricité statique ambiante ou les perturbations électromagnétiques
peuvent faire apparaitre des valeurs très fluctuantes. Pour s'assurer du bon fonctionnement,
l'on utilise une liaison protégée par une résistance qui va « tirer vers le haut » (5 V) ou « tirer
vers le bas » (0 V) le potentiel au repos, comme une sorte d'élastique. On utilise en général
une résistance de 10 kOhms.

dans un montage « tiré vers le haut » ou « dans un montage « tiré vers le bas » ou «

18
 Chapitre2 : Gestion Entrées/Sorties

pull-up », le potentiel de l'entrée au repos est pull-down », le potentiel de l'entrée au repos

5 V. est 0 V.
Les sorties numériques peuvent actionner de nombreux composants (LED, transistor, etc.)
mais elles ne peuvent pas fournir beaucoup de courant (40 mA pour une carte Arduino UNO).
Pour piloter des circuits de plus forte puissance, il faut passer par des transistors ou des relais.

La puce AT MEGA n'est pas capable de sortir des tensions variables. Heureusement, 6 des
sorties numériques (N° 3, 5, 6, 9, 10, 11) peuvent produire un signal PWM. Ce sigle signifie «
Pulse Width modulation » en anglais ; en français l'on parle de MLI : "« Modulation de
largeur d'impulsion ». Il s'agit d'un artifice permettant de produire une tension variable à partir
d'une tension fixe.

La technique s'apparente approximativement à du morse : le signal de sortie est modulé sous

forme d'un signal carré dont la largeur des créneaux varie pour faire varier la tension
moyenne:

Figure 2: modulation de largeur d'impulsion ou PWM

2.1.4 CIRCUITS ADDITIONNELS

Il est possible de spécialiser la carte Arduino en l’associant avec des circuits. Lorsqu'ils se
branchent directement sur la carte, ces circuits s'appellent des « shields » ou cartes
d'extension. Ces circuits spécialisés apportent au système des fonctionnalités diverses et
étendues dont voici quelques exemples :

• ethernet : communication réseau ;

• Bluetooth ou zigbee : communication sans fil ;
• pilotage de moteurs (pas à pas ou à courant continu) ;
• pilotage de matrices de LEDs : pour piloter de nombreuses LEDs avec peu de sorties ;
• écran LCD : pour afficher des informations ;
• lecteur de carte mémoire : lire ou stocker des données ;
• lecteur de MP3 ;
• GPS : pour avoir une information de position géographique ;

19
 Chapitre2 : Gestion Entrées/Sorties

• joystick ;
• etc.

Figure 3: une carte Arduino équipée de plusieurs cartes d'extension

2.2 Electronique Interactive

Savoir reconnaitre quelques composants électroniques, savoir reconnaitre leur symbole,
connaitre leur usage, l’utilisateur permettra de concevoir son propres expériences et de
progresser à partir de données trouvées sur le web. L’apprenant saurez ainsi fabriquer
quelques capteurs, et actionner quelques matériels.

La résistance s’oppose au passage du

courant, proportionnellement à sa “
résistance” exprimée en Ohm. Un code de
couleurs, ci-dessous permet de reconnaître
cette valeur.
Les condensateurs peuvent stocker un peu de
courant si on les charge, mais comme un
tonneau percé, ils renvoient ce courant
instantanément s’ils sont branchés à un
organe consommateur de courant.
Le transistor est généralement utilisé comme
une sorte de multiplicateur de puissance:
lorsqu’on lui fait passer un courant faible,
mais variable dans un de ses 3 pattes, il
autorise proportionnellement le passage d’un
gros courant dans une autre des 3 pattes.

20
 Chapitre2 : Gestion Entrées/Sorties

L’interrupteur ouvre ou ferme un circuit. Il y

a toutes sortes d’interrupteurs. Sur l’Arduino,
utiliser un interrupteur pour déclencher un
événement nécessite d’utiliser un composant
supplémentaire: une résistance de 10K ohms.

La cellule photo-électrique (LDR)

C’est une résistance variable, en fonction de
la luminosité qu’elle reçoit. Sa résistance
diminue quand elle reçoit de la lumière. On
s’en sert donc de capteur de luminosité. Non
polarisée. Pour lire sa valeur avec une
Arduino, il faut également l’associer avec
une résistance équivalente à sa résistance
maxi (dans le noir).
Le transducteur piézo-électrique est un
composant réversible: il peut aussi bien être
utilisé en capteur de chocs ou de vibrations
qu’en actionneur pouvant émettre des sons
stridents parfois modulables.

Le servomoteur est un moteur (rotatif) qui

peut effectuer des rotations très précises
(dans une portion de tour seulement) et en un
certain nombre de pas (de micro-
déplacements). Il y a toutes sortes de
servomoteurs. Un des avantages des
servomoteurs est sa possibilité de maintenir
avec force une position donnée. On peut
piloter des rotations avec l’Arduino, quelques
fois directement avec la carte si le moteur
n’est pas trop puissant, sinon en passant par
un montage associé.
Le potentiomètre, rotatif comme ici, ou à
glissière, est une résistance variable. Entre
les extrémités, il y a la résistance maximale.
La patte centrale est le curseur. C’est la
résistance entre cette patte centrale et une
extrémité que l’on peut faire varier en
tournant le bouton. Le potentiomètre est donc
un capteur. Il se branche sur les entrées
analogiques de l’Arduino. De très nombreux
capteurs sont basés sur le principe de
résistance variable et se cablent presque de la
même façon: la cellule photo-électrique, le
capteur de pression, le fil résistif, etc

21
 Chapitre2 : Gestion Entrées/Sorties

Le relais est un composant à 4 broches

minimum. C’est un interrupteur que l’on peut
commander en envoyant un petit courant. Au
repos, il est normalement fermé, ou
normalement ouvert, selon le modèle. On
peut s’en servir avec l’Arduino pour
commander des machines en haute tension (
230V par exemple), ou pour déclencher toute
machine ou lumière.

2.3 Exercices d’application

Exercice 1 : Les feux de circulation
L’objectif est de créer deux feux de circulation et de les faire fonctionner de manière
synchrone.

Voici les phases de deux feux de circulation à recréer:

Il faut mettre un délai de 3 secondes entre le feu vert et le feu orange. Un délai de 1 seconde
entre le feu orange et le feu rouge. Et un délai de 3 secondes entre le feu rouge et le feu vert.
1. Définir les broches du microcontrôleur à utiliser.
2. Définir si les broches sont des entrées, des sorties, ou E/S.
3. Faire le programme complet dans la fonction qui réalise une boucle.
Correction :
Organigramme
• DEBUT
• //première partie du programme, on s'occupe principalement du deuxième feu
• Allumer led_rouge_feux_1
• Allumer led_verte_feux_2

22
 Chapitre2 : Gestion Entrées/Sorties

• Attendre 3 secondes
• Éteindre led_verte_feux_2
• Allumer led_jaune_feux_2
• Attendre 1 seconde
• Éteindre led_jaune_feux_2
• Allumer led_rouge_feux_2
• /*deuxième partie du programme, pour l'instant : led_rouge_feux_1 et
led_rouge_feux_2 sont allumées; on éteint donc la led_rouge_feux_1 pour allumer la
led_verte_feux_1*/
• Attendre 3 secondes
• Éteindre led_rouge_feux_1
• Allumer led_verte_feux_1
• Attendre 3 secondes
• Éteindre led_verte_feux_1
• Allumer led_jaune_feux_1
• Attendre 1 seconde
• Éteindre led_jaune_feux_1
• Allumer led_rouge_feux_1
• FIN
La fonction setup : on va nommer les broches, puis les placer en sortie et les mettre dans leur
état de départ.
//définition des broches
const int led_rouge_feux_1 = 2;
const int led_jaune_feux_1 = 3;
const int led_verte_feux_1 = 4;
const int led_rouge_feux_2 = 5;
const int led_jaune_feux_2 = 6;
const int led_verte_feux_2 = 7;
void setup()
{
//initialisation en sortie de toutes les broches
pinMode(led_rouge_feux_1, OUTPUT);
pinMode(led_jaune_feux_1, OUTPUT);
pinMode(led_verte_feux_1, OUTPUT);
pinMode(led_rouge_feux_2, OUTPUT);
pinMode(led_jaune_feux_2, OUTPUT);
pinMode(led_verte_feux_2, OUTPUT);
//on initialise toutes les LED éteintes au début du programme (sauf les
deux feux rouges)
digitalWrite(led_rouge_feux_1, LOW);
digitalWrite(led_jaune_feux_1, HIGH);
digitalWrite(led_verte_feux_1, HIGH);
digitalWrite(led_rouge_feux_2, LOW);

23
 Chapitre2 : Gestion Entrées/Sorties

digitalWrite(led_jaune_feux_2, HIGH);
digitalWrite(led_verte_feux_2, HIGH);
}

Le code principal :
void loop()
{
// première séquence
digitalWrite(led_rouge_feux_1, HIGH);
digitalWrite(led_verte_feux_1, LOW);
delay(3000);
// deuxième séquence
digitalWrite(led_verte_feux_1, HIGH);
digitalWrite(led_jaune_feux_1, LOW);

delay(1000);
// troisième séquence
digitalWrite(led_jaune_feux_1, HIGH);
digitalWrite(led_rouge_feux_1, LOW);
delay(1000);
/* ---------- deuxième partie du programme, on s'occupe du feux numéro 2 --
-------- */

// première séquence
digitalWrite(led_rouge_feux_2, HIGH);
digitalWrite(led_verte_feux_2, LOW);
delay(3000);
// deuxième séquence
digitalWrite(led_verte_feux_2, HIGH);
digitalWrite(led_jaune_feux_2, LOW);

delay(1000);
// deuxième séquence
digitalWrite(led_jaune_feux_2, HIGH);
digitalWrite(led_rouge_feux_2, LOW);

delay(1000);
/* --------------- le programme va reboucler et revenir au début ----------
-------- */
}

Tu trouveras le corrigé à l’adresse suivante: http://sharedamine.ovh/code/code5.txt

Exercice 2 : Le bouton poussoir
Le BP et l'interrupteur ne possèdent pas le même symbole pour les schémas électroniques.
Pour le premier, il est représenté par une barre qui doit venir faire contact pour fermer le
circuit ou défaire le contact pour ouvrir le circuit. Le second est représenté par un fil qui ouvre
un circuit et qui peut bouger pour le fermer.
Voici leurs symboles, il est important de s'en rappeler :

24
 Chapitre2 : Gestion Entrées/Sorties

Bouton Poussoir NO Bouton Poussoir NF Interrupteur

- Montage avec résistance pull-down

Réalisons maintenant le circuit suivant:

Lorsqu’on appuie sur le bouton poussoir, La LED doit s’allumer. Et naturellement, lorsqu’on
relâche le bouton poussoir, la LED s’éteint.
Nous allons utiliser une nouvelle instruction: if ... else (si ... sinon). C’est donc une condition.
Voici ce qui va se passer:
Si le bouton poussoir est pressé (digitalRead(4) == 1), allumer la LED (digitalWrite(12,
HIGH)), sinon
éteindre la LED (digitalWrite(12, LOW)).
L’instruction == vérifie si deux expressions sont égales. Si elles le sont, alors le résultat sera
vrai (true) sinon le résultat sera faux (false).
Télécharger le code: http://www.sharedamine.ovh/code/code7.txt

25
 Chapitre 3 : Communication
par la liaison série

Vue d’ensemble
Ce Chapitre présente la communication par la liaison série.

Objectifs
Dans ce chapitre, nous allons apprendre à utiliser la liaison série, a travers le câble USB.
Grâce à elle, l’utilisateur pourra faire communiquer entre eux, l’ ordinateur et la carte
Arduino.

Prérequis
• Systèmes logiques
• Electronique numérique
• Programmation
Durée
• 3H

Eléments de contenu
1. Introduction « communication série »
2. Fonctionnement
3. Programmation
4. Application
 Chapitre3 : Communication série

3.1 Principe de la communication série

Pour faire des communications entre différents supports, il existe différents moyens. On
retrouve les bus CAN, le bus I²C, l'Ethernet, etc. et la liste est longue. Dans notre cas, nous
allons étudier la communication série, aussi appelée RS232, puisqu'elle est intégrée par défaut
dans la carte Arduino.

La voie série permet de communiquer de manière directe et unique entre deux supports.
Ici, elle se fera entre un ordinateur et la platine Arduino, mais elle pourrait aussi se faire par
exemple entre deux cartes Arduino. Dans sa forme la plus simple, elle ne nécessite que 3 fils :
2 pour l'émission/réception et 1 pour la masse afin d'avoir un référentiel électrique commun.

3.2 Fonctionnement de la liaison série

Il y a quelques années, l'USB n'était pas si véloce et surtout pas tant répandu. Beaucoup de
matériels (surtout d'un point de vue industriel) utilisaient la voie série. A l'époque, les
équipements se branchaient sur ce qu'on appelle une prise DB9 (9 car 9 broches). Sachez
simplement que ce nom est attribué à un connecteur qui permet de relier divers matériels
informatiques entre eux.

• DCD : Détection d'un signal sur la ligne. Utilisée uniquement pour la connexion de
l'ordinateur à un modem ; détecte la porteuse
• RXD : Broche de réception des données
• TXD : Broche de transmission des données
• DTR : Le support qui veut recevoir des données se déclare prêt à "écouter" l'autre
• GND : Le référentiel électrique commun ; la masse
• DSR : Le support voulant transmettre déclare avoir des choses à dire
• RTS : Le support voulant transmettre des données indique qu'il voudrait
communiquer
• CTS : Invitation à émettre. Le support de réception attend des données
• RI : Très peu utilisé, indiquait la sonnerie dans le cas des modems RS232

Selon les cartes Arduino utilisé, l’utilisateur pourra utiliser une seule ou plusieurs liaisons
séries. Par exemple, la carte Arduino Mega propose 4 voies séries différentes. La carte
Arduino ADK (interfacer avec Android) propose elle aussi 4 voies séries. Lorsque l’étudiant
utilise les voies séries, l’utilisateur faites appel à un objet Serial (nous verrons ça plus loin
dans le cours). Ainsi, lorsqu'il n'y a qu'une seule voie série, l'objet utilisé est "Serial". Ensuite,
s'il y a d'autres voies séries on aura les objets "Serial1", "Serial2" puis "Serial3".

La voie série n'est pas le seul moyen de communication existant sur Arduino. En effet, il
existe une multitude de types de connexion, natives ou non et plus ou moins difficiles à mettre
en place. On citera par exemple l'I²C, qui est une communication de type "Maître/Esclave" et
est intégré nativement à Arduino grâce à la librairie "Wire".

27
 Chapitre3 : Communication série

La liaison série est un moyen de communication utilisé pour faire communiquer entre eux
plusieurs dispositifs. On retrouve cette liaison sur les ordinateurs, par exemple, ou sur des
appareils électroniques (onduleurs, ...). Cette liaison est aussi utilisée dans le milieu industriel.

3.3 Programmation Série

Pour utiliser la liaison série et communiquer avec notre ordinateur (par exemple), nous
allons utiliser un objet (une sorte de variable mais plus évoluée) qui est intégré nativement
dans l'ensemble Arduino : l'objet Serial.

Cet objet rassemble des informations (vitesse, bits de données, etc.) et des fonctions (envoi,
lecture de réception,...) sur ce qu'est une voie série pour Arduino. Ainsi, pas besoin pour le
programmeur de recréer tous le protocole.

Pour commencer, nous allons donc initialiser l'objet Serial. Ce code sera à copier à chaque
fois que l’utilisateur doit créer un programme qui utilise la liaison série.
Le logiciel Arduino à prévu, dans sa bibliothèque Serial, tout un tas de fonctions qui vont
nous êtres très utiles, voir même indispensables afin de bien utiliser la liaison série.
void setup()
{
Serial.begin(9600); //on démarre la liaison en la réglant à une vitesse
de 9600 bits par seconde.
}

3.3.1 Envoyer des données

Dans un premier temps, nous allons utiliser l'objet Serial pour tester quelques envois de
données.

On va commencer par envoyer un caractère et une chaine de caractères.

• Un caractère seul s'écrit entre guillemets simples : 'A', 'a', '2', '!', ...
• Une phrase est une suite de caractère et s'écrit entre guillemets doubles : "Salut tout
le monde", "Bonjour SEM31", "Vive la Tunisie !"

Les fonctions que l'on va utiliser pour débuter, s'agit de print() et println

• print() : cette fonction permet d'envoyer des données sur la liaison série. On peut par
exemple envoyer un caractère, une chaine de caractère ou d'autres données
• println() : c'est la même fonction que la précédente, elle permet simplement un
retour à la ligne à la fin du message envoyé.

Pour utiliser ces fonctions, rien de plus simple :

Serial.print("Welcome ISETKR !");

28
 Chapitre3 : Communication série

Bien sûr, au préalable, l’utilisateur devrez avoir "déclaré/créé" l’ objet Serial et définis une
valeur de vitesse de communication :

void setup()
{
Serial.begin(9600); //création de l'objet Serial (=établissement d'une n
ouvelle communication série)
Serial.print("Welcome ISETKKR !"); //envoie de la chaine "Welcome
ISETKR!" sur la liaison série
}

Exercice : Envoyer l'alphabet

Objectif

Le but est d'envoyer l'ensemble des lettres de l'alphabet. La fonction setup restera la même
que celle vue précédemment. Un délai de 250 ms est attendu entre chaque envoi de lettre et un
delay de 5 secondes est attendu entre l'envoi de deux alphabets.

Correction

void loop()
{
char i = 0;
char lettre = 'a'; // ou 'A' pour envoyer en majuscule
Serial.println("------ Bonjour ISETKR ---"); //petit message d'accueil

29
 Chapitre3 : Communication série

//on commence les envois

for(i=0; i<26; i++)
{
Serial.print(lettre); //on envoie la lettre
lettre = lettre + 1; //on passe à la lettre suivante
delay(250); //on attend 250ms avant de réenvoyer
}
Serial.println(""); //on fait un retour à la ligne
delay(5000); //on attend 5 secondes avant de renvoyer l'alphabet
}

3.3.2 Recevoir des données

Pour vérifier si on a reçu des données, on va régulièrement interroger la carte pour lui
demander si des données sont disponibles dans son buffer de réception. Un buffer est une
zone mémoire permettant de stocker des données sur un cours instant. Dans notre situation,
cette mémoire est dédiée à la réception sur la voie série. Il en existe un aussi pour l'envoi de
donnée, qui met à la queue leu leu les données à envoyer et les envoie dès que possible. En
résumé, un buffer est une sorte de salle d'attente pour les données. Je disais donc, nous allons
régulièrement vérifier si des données sont arrivées. Pour cela, on utilise la fonction
available() (de l'anglais "disponible") de l'objet Serial. Cette fonction renvoie le nombre de
caractères dans le buffer de réception de la liaison série.

Voici un exemple de traitement :

void loop()
{
int donneesALire = Serial.available(); //lecture du nombre de caractère
s disponibles dans le buffer
if(donneesALire > 0) //si le buffer n'est pas vide
{
//Il y a des données, on les lit et on fait du traitement
}
//on a fini de traiter la réception ou il n'y a rien à lire
}

Si l’utilisateur veut éviter de mettre le test de présence de données sur la voie série dans le
code, Arduino à rajouter une fonction qui s'exécute de manière régulière. Cette dernière se
lance régulièrement avant chaque redémarrage de la loop. Ainsi, si l’utilisateur n'avait pas
besoin de traiter les données de la communication série à un moment précis, il suffit de
rajouter cette fonction. Pour l'implémenter c'est très simple, il suffit de mettre du code dans
une fonction nommé "serialEvent()" qui sera a rajouté en dehors du setup et du loop. Le reste
du traitement de texte se fait normalement, avec Serial.read par exemple.
Voici un exemple de squelette possible :
const int maLed = 11; //on met une LED sur la broche 11
void setup()
{
pinMode(maLed, OUTPUT); //la LED est une sortie
digitalWrite(maLed, HIGH); //on éteint la LED
Serial.begin(9600); //on démarre la voie série
}
void loop()

30
 Chapitre3 : Communication série

{
delay(500); //fait une tite pause
//on ne fait rien dans la loop
digitalWrite(maLed, HIGH); //on éteint la LED

}
void serialEvent() //déclaration de la fonction d'interruption sur la voie
série
{
while(Serial.read() != -
1); //lit toutes les données (vide le buffer de réception)
digitalWrite(maLed, LOW); //on allume la LED
}

3.4 Application
Pour ce montage, nous allons utiliser un afficheur numérique à LED.

La référence utilisée ici est un afficheur à anode commune.

31
 Chapitre3 : Communication série

Dans le cas d’une anode commune, cette dernière est branchée sur le +5V. Les cathodes sont
branchées sur les broches. Au niveau du code, cela implique que les LEDs sont allumée en
position LOW et éteintes en position HIGH. Avec un composant à cathode commune, c’est le
contraire. Dans notre exemple, nous allons commencer par allumer toutes les diodes, puis
l’une après l’autre, pour les identifier. On peut ensuite écrire des chiffres.

Le code est disponible ici: http://www.sharedamine.ovh/code/code15.txt

L’objectif est d’identifier chaque LED sur le schéma ci-dessous:

Voici donc, dans notre cas, les LEDs qui doivent être allumées pour écrire les chiffres
suivants:

# LED1 LED2 LED3 LED4 LED5 LED6 LED7

32
 Chapitre3 : Communication série

1 X X

2 X X X X X

3 X X X X X

4 X X X X

5 X X X X X

6 X X X X X X

7 X X X

8 X X X X X X X

9 X X X X X X

0 X X X X X X

Le schéma suivant représente le montage voulu

33
 Chapitre3 : Communication série

L’utilisateur voit que chaque LED de l'afficheur va être commandée séparément les unes des
autres.

Solution :

/* On assigne chaque LED à une broche de l'arduino */

const int A = 2;
const int B = 3;
const int C = 4;
const int D = 5;
const int E = 6;
const int F = 7;
const int G = 8;
//notez que l'on ne gère pas l'affichage du point, mais l’utilisateur pouve
le rajouter ^^
void setup()
{
//définition des broches en sortie
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
pinMode(G, OUTPUT);
//mise à l'état HAUT de ces sorties pour éteindre les LED de l'afficheur
digitalWrite(A, HIGH);
digitalWrite(B, HIGH);
digitalWrite(C, HIGH);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
}
void loop()
{
//affichage du chiffre 5, d'après le tableau précédent
digitalWrite(A, LOW);
digitalWrite(B, HIGH);

34
 Chapitre3 : Communication série

digitalWrite(C, LOW);
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
}

35
 Chapitre 4 : Les grandeurs
Analogiques
Vue d’ensemble
Ce Chapitre présente l’utilisation des grandeurs analogiques.

Objectifs
Ce premier chapitre va faire découvrir chez l’apprenant comment gérer des tensions
analogiques avec la carte Arduino. L’apprenant doit tout d'abord prendre en main le
fonctionnement d'un certain composant essentiel à la mise en forme d'un signal
analogique, et d’expliquer comment l’etudiant doit en servir avec la Arduino.

Pré-requis
• Systèmes logiques
• Electronique numérique
• Programmation
Durée
• 3H

Eléments de contenu
1. Introduction
2. Les convertisseurs
3. Exercice d’application
 Chapitre4 : Les grandeurs Analogiques

4.1 Les entrées analogiques

4.1.1 Présentation

D'abord, jusqu'à présent nous n'avons fait qu'utiliser des grandeurs numériques binaires.
Autrement dit, nous n'avons utilisé que des états logiques HAUT et BAS. Ces deux niveaux
correspondent respectivement aux tensions de 5V et 0V.

Cependant, une valeur analogique ne se contentera pas d'être exprimée par 0 ou 1. Elle peut
prendre une infinité de valeurs dans un intervalle donné. Dans notre cas, par exemple, la
grandeur analogique pourra varier aisément de 0 à 5V en passant par 1.45V, 2V, 4.99V, etc.

Voici un exemple de signal analogique, le très connu signal sinusoïdal :

Tout d'abord, nous allons devoir être capables de convertir cette valeur analogique en une
valeur numérique, que l'on pourra ensuite manipuler à l'intérieur de notre programme. Par
exemple, lorsque l'on mesurera une tension de 2,5V nous aurons dans notre programme une
variable nommée "tension" qui prendra la valeur 250 lorsque l'on fera la conversion.

4.1.2 Les convertisseurs analogiques -> numérique ou CAN

C'est un dispositif qui va convertir des grandeurs analogiques en grandeurs numériques. La
valeur numérique obtenue sera proportionnelle à la valeur analogique fournie en entrée, bien
évidemment. Il existe différentes façons de convertir une grandeur analogique, plus ou moins
faciles à mettre en œuvre, plus ou moins précises et plus ou moins onéreuses.

Convertisseur à simple rampe : ce convertisseur "fabrique" une tension qui varie

proportionnellement en un cours laps de temps entre deux valeurs extrêmes. En même temps
qu'il produit cette tension, il compte. Lorsque la tension d'entrée du convertisseur devient
égale à la tension générée par ce dernier, alors le convertisseur arrête de compter. Et pour
terminer, avec la valeur du compteur, il détermine la valeur de la grandeur d'entrée. Malgré sa
bonne précision, sa conversion reste assez lente et dépend de la grandeur à mesurer. Il est, de
ce fait, peu utilisé.

37
 Chapitre4 : Les grandeurs Analogiques

Convertisseur flash : ce type de convertisseur génère lui aussi des tensions analogiques.
Pour être précis, il en génère plusieurs, chacune ayant une valeur plus grande que la
précédente (par exemple 2V, 2.1V, 2.2V, 2.3V, etc.) et compare la grandeur d'entrée à chacun
de ces paliers de tension. Ainsi, il sait entre quelle et quelle valeur se trouve la tension
mesurée.

4.2 Exercice d’application

Pour l'exercice, nous allons réaliser la visualisation d'une tension. Cette dernière sera donnée
par un potentiomètre et sera affichée sur 10 LED. Lorsque le potentiomètre sera à 0V, on
allumera 0 LED, puis lorsqu'il sera au maximum on les allumera toutes. Pour les valeurs
comprises entre 0 et 5V, elles devront allumer les LED proportionnellement.

Le schéma n'est pas très difficile. Nous allons retrouver 10 LEDs et leurs résistances de
limitations de courant branchées sur 10 broches de l'Arduino (histoire d'être original nous
utiliserons 2 à 11). Ensuite, nous brancherons un potentiomètre entre le +5V et la masse. Sa
broche centrale, qui donne la tension variable sera connectée à l'entrée analogique 0 de
l'Arduino.
Voici le schéma obtenu :

38
 Chapitre4 : Les grandeurs Analogiques

Dans cette application nous utilisons 10 LEDs, ce qui représente autant de sorties sur la carte
Arduino, nous allons déclarer un tableau de "const int. Ensuite, nous allons déclarer la broche
analogique sur laquelle sera branché le potentiomètre. Enfin, nous déclarons une variable pour
stocker la tension mesurée sur le potentiomètre.

// Déclaration et remplissage du tableau...

// ...représentant les broches des LEDs
const int leds[10] = {2,3,4,5,6,7,8,9,10,11};
const int potar = 0; //le potentiomètre sera branché sur la broche analogiq
ue 0
int tension; //variable stockant la tension mesurée

Une fois que l'on à fait ces déclarations, il ne nous reste plus qu'à déclarer les broches en
sortie et à les mettre à l'état HAUT pour éteindre les LEDs. Pour faire cela de manière simple,
nous allons utiliser une boucle for pour effectuer l’opération 10 fois.

void setup()
{
int i = 0;
for(i=0; i<10; i++)
{
pinMode(leds[i], OUTPUT); //déclaration de la broche en sortie
digitalWrite(leds[i], HIGH); //mise à l'état haut
}
}

En effet, elle ne va effectuer que deux opérations : Mesurer la tension du potentiomètre, puis
appeler une fonction d'affichage pour faire le rendu visuel de cette tension.
Voici ces deux lignes de code :

39
 Chapitre4 : Les grandeurs Analogiques

void loop()
{
tension = analogRead(potar); //on récupère la valeur de la tension du p
otentiomètre
afficher(tension); //et on affiche sur les LEDs cette tension
}

Alors certes la fonction principale est très légère, mais ce n'est pas une raison pour ne pas
avoir un peu de code autre part. En effet, le gros du traitement va se faire dans la fonction
d'affichage, qui, comme son nom et ses arguments l'indiquent, va servir à afficher sur les
LEDs la tension mesurée.

Le but de cette dernière sera d'allumer les LEDs de manière proportionnelle à la tension
mesuré. Par exemple, si la tension mesurée vaut 2,5V (sur 5V max) on allumera 5 LEDs (sur
10). Si la tension vaut 5V, on les allumera toutes les LEDs.

Tout d'abord, mettons-nous d'accord. Lorsque l'on fait une mesure analogique, la valeur
retournée est comprise entre 0 et 1023. donc d'allumer une LED par tranche de 100 unités. Par
exemple, si la valeur est comprise entre 0 et 100, une seule LED est allumée. Ensuite, entre
100 et 200, on allume une LED supplémentaire, etc

void afficher(int valeur)

{
int i;
for(i=0; i<10; i++)
{
if(valeur < (i*100))
digitalWrite(leds[i], LOW); //on allume la LED
else
digitalWrite(leds[i], HIGH); //ou on éteint la LED
}
}

40
 Chapitre 5 : L’affichage

Vue d’ensemble
Cette leçon présente la définition et l’utilité de la récursivité.

Objectifs
L’apprenant doit appris plus tôt comment interagir avec l'ordinateur, lui envoyer de
l'information. Mais maintenant, il faut pouvoir afficher de l'information sans avoir besoin d'un
ordinateur donc avec les écrans .

Pré-requis
• Electronique
• Programmation
• Système logique

Durée
• 3H

Eléments de contenu
1. Les Ecrans LCD
2. Exercice d’application
 Chapitre5 : L’affichage

5.1 Les ecrans LCD

Mettons tout de suite au clair les termes : LCD signifie "Liquid Crystal Display" et se
traduit, en français, par "Écran à Cristaux Liquides". Ces écrans sont dans plein d'appareils
électroniques disposant d'afficheur : les montres, le tableau de bord de du voiture, les
calculatrices, etc

Normalement, pour pouvoir afficher des caractères sur l'écran il nous faudrait activer
individuellement chaque pixel de l'écran. Un caractère est représenté par un bloc de 7*5
pixels. Ce qui fait qu'un écran de 16 colonnes et 2 lignes représente un total de 16*2*7*5 =
1120 pixels.

Tout comme il existe un driver vidéo pour la carte graphique d'ordinateur, il existe un
driver "LCD" pour l’afficheur. Ce composant va servir à décoder un ensemble "simple" de
bits pour afficher un caractère à une position précise ou exécuter des commandes comme
déplacer le curseur par exemple. Ce composant est fabriqué principalement par Hitachi et se
nomme le HC44780. Il sert de décodeur de caractères. Ainsi, plutôt que de devoir multiplier
les signaux pour commander les pixels un à un, il nous suffira d'envoyer des octets de
commandes pour lui dire "écris moi 'welcome ISET' à partir de la colonne 3 sur la ligne 1".

Ce composant possède 16 broches que je vais brièvement décrire :

N° Nom Rôle
1 VSS Masse
2 Vdd +5V
3 V0 Réglage du contraste
4 RS Sélection du registre (commande ou donnée)
5 R/W Lecture ou écriture
6 E Entrée de validation
7 à 14 D0 à D7 Bits de données
15 A Anode du rétroéclairage (+5V)
16 K Cathode du rétroéclairage (masse)

Afficheur alphanumérique Afficheur graphique Afficheur graphique

(monochrome) (couleur)

Les afficheurs existent dans de nombreuses tailles. Pour les afficheurs de type textes, on
retrouve le plus fréquemment le format 2 lignes par 16 colonnes. Il en existe cependant de

42
 Chapitre5 : L’affichage

nombreux autres avec une seule ligne, ou 4 (ou plus) et 8 colonnes, ou 16, ou 20 ou encore
plus.

L'afficheur LCD utilise 6 à 10 broches de données ((D0 à D7) ou (D4 à D7) + RS + E) et

deux d'alimentations (+5V et masse). La plupart des écrans possèdent aussi une entrée
analogique pour régler le contraste des caractères. Nous brancherons dessus un potentiomètre
de 10 kOhms.

Le montage à 4 broches de données

43
 Chapitre5 : L’affichage

Nous allons utiliser la librairie "LiquidCrystal". Nous allons donc commencer par déclarer un
objet (c'est en fait une variable évoluée, plus de détails dans la prochaine partie) lcd, de type
LiquidCrystal et qui sera global à notre projet. La déclaration de cette variable possède
plusieurs formes:

• LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7) où rs est le
numéro de la broche où est branché "RS", "enable" est la broche "E" et ainsi de suite
pour les données.
• LiquidCrystal(rs, enable, d4, d5, d6, d7) (même commentaires que
précédemment

Ensuite, dans le setup() il nous faut démarrer l'écran en spécifiant son nombre de colonnes
puis de lignes. Cela se fait grâce à la fonction begin(cols,rows).

Voici un exemple complet de code correspondant au branchement précédent :

#include "LiquidCrystal.h" //ajout de la librairie

//Vérifier les broches !
LiquidCrystal lcd(11,10,9,8,7,6,5,4,3,2); //liaison 8 bits de données
LiquidCrystal lcd(11,10,5,4,3,2); //liaison 4 bits de données
void setup()
{
lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes
lcd.write("Welcome ISET"); //petit test pour vérifier que tout marche
}
void loop() {}

5.2 Exercice d’application

En effet, une fois que l’écran LCD est bien paramétré, il nous suffira d'utiliser qu'une seule
fonction pour afficher du texte.

En effet, une fois de plus nous retrouvons une fonction print(), comme pour l'objet Serial,
pour envoyer du texte.

lcd.print("Welcome ISET");

et pour code complet avec les déclarations on obtient :

#include <LiquidCrystal.h> //on inclut la librairie

// initialise l'écran avec les bonnes broches
LiquidCrystal lcd(8,9,4,5,6,7);
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
lcd.print("Bonjour SEM 3 1!");
}
void loop() {
}

44
 Chapitre5 : L’affichage

Dans cet exercice, je vous propose de réaliser une petite horloge. L'objectif sera donc
d'afficher le message suivant :
"Il est hh:mm:ss" avec 'hh' pour les heures, 'mm' pour les minutes et 'ss' pour les secondes.

Solution :

#include <LiquidCrystal.h> //on inclut la librairie

// initialise l'écran avec les bonnes broches
// ATTENTION, REMPLACER LES NOMBRES PAR VOS BRANCHEMENTS À VOUS !
LiquidCrystal lcd(8,9,4,5,6,7);
int heures,minutes,secondes;
char message[16] = "";
void setup()
{
lcd.begin(16, 2); // règle la taille du LCD : 16 colonnes et 2 lignes
//changer les valeurs pour démarrer à l'heure souhaitée !
heures = 0;
minutes = 0;
secondes = 0;
}
void loop()
{
//on commence par gérer le temps qui passe...
if(secondes == 60) //une minutes est atteinte ?
{
secondes = 0; //on recompte à partir de 0
minutes++;
}
if(minutes == 60) //une heure est atteinte ?
{
minutes = 0;
heures++;
}
if(heures == 24) //une journée est atteinte ?
{
heures = 0;
}

//met le message dans la chaine à transmettre

sprintf(message,"Il est %2d:%2d:%2d",heures,minutes,secondes);
lcd.home(); //met le curseur en position (0;0) sur l'écran

lcd.write(message); //envoi le message sur l'écran

delay(1000); //attend une seconde

//une seconde s'écoule...
secondes++;
}

45