Vous êtes sur la page 1sur 15

Arduino

Apprendre à développer pour créer des objets intelligents


Ce livre s’adresse à toute personne intéressée par la création Nicolas GOILAV est Ingénieur infor-

Arduino

pour créer des objets intelligents


d’objets intelligents et pose les bases de l’utilisation des cartes matique, spécialisé dans le manage-
électroniques Arduino. La simplicité d’utilisation de ce type de ment de projets. Geoffrey LOI est
carte rend l’électronique accessible à tous et la création d’objets étudiant en informatique, spécialité
intelligents à la portée de toute personne passionnée par le sujet. Sciences de l’électronique. Nicolas et
Les premiers chapitres décrivent l’univers Arduino, de l’introduc- Geoffrey sont tous les deux passion-

Apprendre à développer
tion des microcontrôleurs à la présentation de l’environnement de nés par les « objets intelligents » et
développement. Les deux chapitres suivants présentent les bases ont tout de suite été séduits par le
de l’électronique puis de l’informatique, ce qui permet à un élec- potentiel des cartes Arduino dans ce
tronicien, ou respectivement à un informaticien, d’acquérir les com- domaine. Grâce à la complémentarité
pétences nécessaires pour être autonome dans cet univers. de leur expérience et de leur forma-
tion, ils transmettent au lecteur un
Le chapitre sur la programmation entre un peu plus spécifiquement
livre réellement opérationnel pour lui
dans le langage Arduino, il décrit notamment en détail les fonc-
apprendre à développer des objets

Apprendre à développer
tionnalités propres à ce langage. Les chapitres sur les entrées-sor-
intelligents.
ties et les interfaces de communication mettent en valeur l’inté-
grabilité de la carte Arduino dans son environnement, en relation
avec d’autres composants électriques un peu plus complexes. Cette

pour créer
intégration peut être d’autant plus simplifiée en utilisant des cartes
prévues à cet effet, les Shields. Compatibles avec Arduino, ces
cartes proposent des caractéristiques plus avancées. Les capacités Les chapitres du livre

Arduino
des Shields ainsi que certaines applications pratiques constituent Le module Arduino • Environnement

des objets intelligents


les dernières parties de cet ouvrage. Enfin, l’intégration de divers de développement • Les bases de
capteurs et composants permet d’ouvrir le champ des possibilités l’électronique • Les bases de la pro-
vers l’internet des objets ou la robotique. grammation • La programmation sur
Certains des exemples du livre sont disponibles en télécharge- Arduino • Les entrées/sorties • Les
ment sur le site www.editions-eni.fr (bibliothèques de fonctions, interfaces de communication • Les
quelques applications simples liées à l’emploi des fonctionnalités cartes Arduino • Les shields • Les
Téléchargement
de base de l’Arduino).
www.editions-eni.fr
.fr Ils peuvent être utilisés immédiatement ou accessoires de l’Arduino • Vers l’In-
adaptés pour répondre aux besoins du lecteur. ternet des objets et la robotique

sur www.editions-eni.fr :
b Bibliothèques de fonctions. Pour plus
ISBN : 978-2-7460-9602-8

d’informations :
b Exemples de code.
29,90 €

Nicolas GOILAV
Geoffrey LOI
Table des matières 1

Les éléments à télécharger sont disponibles à l'adresse suivante :


http://www.editions-eni.fr
Saisissez la référence ENI de l'ouvrage RIARD dans la zone de recherche
et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

Chapitre 1
Le module Arduino
1. Introduction au microcontrôleur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.1 Principales notions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2. Présentation générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3. Description technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1 Alimentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2 Horloge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3 Reset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.4 Entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.5 Mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4. Historique de l’Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5. Matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.1 Fer à souder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.2 Breadboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.3 Multimètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.4 Câble d’alimentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

Chapitre 2
Environnement de développement
1. Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2. Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.1 Sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.2 Sous Linux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2 Arduino
Apprendre à développer pour créer des objets intelligents

2.3 Sous Mac OS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33


3. Interface de développement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.1 Démarrer sur l’environnement . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2 Créer un nouveau projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3 Ouvrir un projet existant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4 Fonctionnalités utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.5 Communiquer avec la carte Arduino . . . . . . . . . . . . . . . . . . . . . 42
4. Première application : faire clignoter une LED . . . . . . . . . . . . . . . . . . 46

Chapitre 3
Les bases de l'électronique
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2. Quelques notions d’électricité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.1 Intensité, tension et puissance . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.1.1 Intensité d’un courant électrique . . . . . . . . . . . . . . . . . . . 52
2.1.2 Tension d’un courant électrique . . . . . . . . . . . . . . . . . . . . 54
2.1.3 Puissance d'un courant électrique . . . . . . . . . . . . . . . . . . . 55
2.2 Courant continu et courant alternatif . . . . . . . . . . . . . . . . . . . . 55
2.2.1 Courant continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.2.2 Courant alternatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.3 Fil de terre, fil neutre et fil de phase . . . . . . . . . . . . . . . . . . . . . . 57
3. Composants de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.1 Diodes/LED. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.2 Résistances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.3 Transistors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.3.1 Introduction aux transistors . . . . . . . . . . . . . . . . . . . . . . . 62
3.3.2 Transistors bipolaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.3.3 Transistors à effet de champ . . . . . . . . . . . . . . . . . . . . . . . 65
3.4 Condensateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.5 Bobines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Table des matières 3

4. Principes fondamentaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.1 Loi d’Ohm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.2 Loi des nœuds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.3 Loi des mailles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5. Lecture et compréhension des schémas électriques . . . . . . . . . . . . . . 76
5.1 Montages en série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.2 Montages en dérivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
6. Découverte d’autres composants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.1 Découverte de nouveaux composants. . . . . . . . . . . . . . . . . . . . . 80
6.1.1 Multiplexeurs et démultiplexeurs . . . . . . . . . . . . . . . . . . . 80
6.1.2 Relais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.1.3 Photocoupleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2 Lecture de datasheets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.3 Exemple de datasheet : le transistor . . . . . . . . . . . . . . . . . . . . . . 85
7. Premier branchement : relier la carte à une diode . . . . . . . . . . . . . . . 90

Chapitre 4
Les bases de la programmation
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2. Quelques notions d’informatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
3. Langage de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
3.1 Syntaxe de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
3.2 Inclusions et définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
4. Variables et constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
4.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
4.2 Types de variables et constantes . . . . . . . . . . . . . . . . . . . . . . . . 103
4.3 Portée des variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
5. Opérations basiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
5.1 Opérations mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
5.2 Opérations logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
5.3 Opérations trigonométriques . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4 Arduino
Apprendre à développer pour créer des objets intelligents

6. Structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116


6.1 Structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.2 Boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7. Structures de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7.1 Définitions générales et introduction à la complexité . . . . . . . 121
7.2 Structures linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
7.3 Choix d'une structure de données . . . . . . . . . . . . . . . . . . . . . . . 129
8. Fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
8.1 Définition d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
8.2 Création d'une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
8.3 Appel d'une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
9. Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
9.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
9.2 Lecture des erreurs de compilation . . . . . . . . . . . . . . . . . . . . . . 139

Chapitre 5
La programmation sur Arduino
1. Structure d’un programme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
2. Variables et constantes spécifiques . . . . . . . . . . . . . . . . . . . . . . . . . . 143
3. Fonctions propres à l’Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
3.1 Entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
3.2 Gestion du temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
3.2.1 Fonctions de pause . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
3.2.2 Fonctions de décompte . . . . . . . . . . . . . . . . . . . . . . . . . . 150
3.3 Génération de nombres aléatoires . . . . . . . . . . . . . . . . . . . . . . . 152
3.4 Manipulation de bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
3.5 Gestion des interruptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
4. Bibliothèques et objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
4.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
4.2 Création d'une bibliothèque. . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
4.2.1 Bibliothèque en C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Table des matières 5

4.2.2 Bibliothèque en C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . 167


4.3 Ajout de bibliothèques à son projet. . . . . . . . . . . . . . . . . . . . . . 173

Chapitre 6
Les entrées/sorties
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
2. Les types d’entrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
2.1 Les entrées digitales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
2.2 Les entrées analogiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
2.3 Les entrées PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
3. Les types de sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
3.1 Les sorties digitales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
3.2 Les sorties PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

Chapitre 7
Les interfaces de communication
1. Présentation des interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
1.1 Liaison asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
1.2 Liaison synchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
2. Communication Serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
2.1 Principe de communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
2.2 Bibliothèque Serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
2.3 Exemple d’utilisation de Serial. . . . . . . . . . . . . . . . . . . . . . . . . . 200
3. Communication I2C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
3.1 Principe de communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
3.2 Bibliothèque Wire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
3.2.1 Fonctions maîtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
3.2.2 Fonctions esclaves. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
3.2.3 Fonctions de lecture et d’écriture . . . . . . . . . . . . . . . . . . 206
3.3 Exemple d’utilisation de l’I2C . . . . . . . . . . . . . . . . . . . . . . . . . . 208
6 Arduino
Apprendre à développer pour créer des objets intelligents

4. Communication SPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210


4.1 Principe de communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
4.2 Bibliothèque SPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

Chapitre 8
Les cartes Arduino
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
2. Arduino Uno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
2.1 Présentation de l’Arduino Uno . . . . . . . . . . . . . . . . . . . . . . . . . 216
2.2 Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
3. Arduino Mega . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
3.1 Présentation de l’Arduino Mega . . . . . . . . . . . . . . . . . . . . . . . . 223
3.2 Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
4. Arduino Nano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
4.1 Présentation de l’Arduino Nano . . . . . . . . . . . . . . . . . . . . . . . . 227
4.2 Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
5. LilyPad Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
5.1 Présentation de la LilyPad Arduino . . . . . . . . . . . . . . . . . . . . . . 231
5.2 Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
6. Adapter la carte Arduino à son projet . . . . . . . . . . . . . . . . . . . . . . . . 236

Chapitre 9
Les shields
1. Définitions et utilisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
2. Le protoshield : construire vos propres shields . . . . . . . . . . . . . . . . . 238
2.1 Définition générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
2.2 Utilisation d'un protoshield . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
3. Le module XBee : communiquer avec l’extérieur . . . . . . . . . . . . . . . 240
3.1 Définition générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
3.2 Intérêts et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Table des matières 7

3.3 Utilisation d’un module XBee . . . . . . . . . . . . . . . . . . . . . . . . . . 242


4. Les shields Ethernet/Wi-Fi : relier son Arduino à Internet . . . . . . . 251
4.1 Définition générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
4.2 Le shield Ethernet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
4.3 Le shield Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
4.4 Le shield GSM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

Chapitre 10
Les accessoires de l'Arduino
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
2. L’écran LCD : communiquer avec l’environnement. . . . . . . . . . . . . 267
2.1 Brancher un écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
2.2 Utilisation d’un écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
2.3 Réalisation d'une interface graphique . . . . . . . . . . . . . . . . . . . . 274
2.4 Utilisation de l’écran pour exécuter des commandes . . . . . . . . 275
3. Les capteurs : connaître son environnement . . . . . . . . . . . . . . . . . . 278
3.1 Capteurs de distance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
3.2 Capteurs de température . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
3.3 Capteurs de lumière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
3.4 Capteurs d’orientation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
3.5 Capteurs de déplacement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
4. Les moteurs : se déplacer dans son environnement . . . . . . . . . . . . . 299
4.1 Définition générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
4.2 Types de moteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
4.2.1 Servomoteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
4.2.2 Moteurs pas à pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
4.2.3 Moteurs à courant continu . . . . . . . . . . . . . . . . . . . . . . . 303
4.3 Mise en marche et arrêt d'un moteur . . . . . . . . . . . . . . . . . . . . 304
4.3.1 La bibliothèque Servo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
4.3.2 La bibliothèque Stepper . . . . . . . . . . . . . . . . . . . . . . . . . . 306
5. Savoir s’adapter à son environnement automatiquement. . . . . . . . 307
8 Arduino
Apprendre à développer pour créer des objets intelligents

Chapitre 11
Vers l'Internet des objets et la robotique
1. Internet des objets, objets connectés et objets intelligents . . . . . . . 309
1.1 Définition générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
1.2 Intérêts, avantages et inconvénients. . . . . . . . . . . . . . . . . . . . . 310
1.3 Réalisation d'objets intelligents avec Arduino . . . . . . . . . . . . . 311
1.4 Cas particulier de la domotique. . . . . . . . . . . . . . . . . . . . . . . . . 311
1.5 Application domotique : relier une lampe
à une carte Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
2. Robotique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
2.1 Définition générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
2.2 Réalisation de robots avec Arduino . . . . . . . . . . . . . . . . . . . . . . 315
2.3 Applications robotiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
141

Chapitre 5
La programmation sur Arduino

1. Structure d’un programme


La programmation s ur Arduino

Comme vu dans le chapitre précédent, le langage utilisé avec Arduino est très
proche du langage C ou C++. C’est notamment le cas pour la syntaxe et les
types de variables. Cependant, ce langage présente quelques différences, prin-
cipalement dans la structure d’un programme.
Un programme Arduino se décompose en deux parties principales : une pre-
mière partie appelée setup, et une seconde appelée loop. Ces deux parties
sont représentatives de la manière de fonctionner d’un microcontrôleur et
sont appelées dans cet ordre. En effet, un microcontrôleur est destiné à exécu-
ter les instructions contenues dans sa mémoire de manière cyclique et infinie.
Avant de s’exécuter, le microcontrôleur a besoin d’une phase de
« configuration » de son environnement, notamment pour paramétrer des
broches d’entrées/sorties ou tout simplement pour fixer des variables globales.
Cette phase correspond à la fonction setup.
La fonction setup se présente de la manière suivante :
void setup(){
[Instructions] ;
}

Les instructions contenues dans cette fonction ne sont exécutées qu’une seule
fois, et ce, lors de la mise sous tension de la carte.
142 Arduino
Apprendre à développer pour créer des objets intelligents

Remarque
Une réinitialisation de la carte est considérée également comme une mise
sous tension. La fonction setup est donc également exécutée après un reset.

Une fois la configuration effectuée, le microcontrôleur débute l’exécution des


instructions contenues dans sa mémoire. Cette phase correspond à la fonction
loop.
La fonction loop se présente de la manière suivante :
void loop(){
[Instructions] ;
}

Cette fonction s’apparente à une boucle ne possédant aucune condition


d’arrêt. Le seul moyen de l’arrêter est de couper l’alimentation de la carte ou
de réinitialiser la carte. Les instructions contenues dans cette fonction sont
donc répétées aussi longtemps que la carte sera alimentée.
Il est impératif que ces deux fonctions soient présentes dans le programme
principal. L’ordre d’apparition de ces fonctions dans le programme n’a pas
d’importance. Cependant, il est conseillé de garder la déclaration de ces fonc-
tions dans cet ordre et d’éviter de les séparer. Cela permet de rendre plus lisible
le code, et surtout cela permet à un autre lecteur de repérer plus rapidement le
début de la fonction principale.
Il est également possible de déclarer des fonctions dans le même fichier que
celui dans lequel est présent le programme Arduino. Ces déclarations de fonc-
tions pourront s’insérer à tout endroit du programme, du moment que la syn-
taxe est respectée. Enfin, il est possible, tout comme dans les programmes en
C ou C++, d’inclure des bibliothèques de fonctions dans son programme.
Cette inclusion devra s’effectuer, si nécessaire, avant la déclaration de toute
fonction.

© Editions ENI - All rights reserved


Il est important de structurer efficacement son programme, afin de permettre
une meilleure relecture et surtout de repérer rapidement d’éventuelles erreurs.
Un programme Arduino « efficace » pourrait se composer de la manière
suivante :
-Inclusion ou non des bibliothèques utilisées-

-Déclaration des fonctions utilisées-


La programmation sur Arduino 143
Chapitre 5

void setup(){
[Instructions exécutées une seule fois lors de la mise
sous tension de la carte] ;
}

void loop(){
[Instructions exécutées en boucle par le microcontrôleur] ;
}

2. Variables et constantes spécifiques


Les variables et constantes utilisées par le langage Arduino partagent égale-
ment cette similarité avec le langage C et C++. Les variables présentées lors
du chapitre précédent sont donc toutes applicables pour la programmation sur
Arduino. Il en va de même pour les constantes. Le langage Arduino présente
cependant quelques constantes qui lui sont propres. Ces dernières ne se
retrouvent pas dans les autres langages et ne sont applicables qu’à la program-
mation sur Arduino.
Ces constantes spécifiques sont surtout utilisées pour contrôler les broches
d’entrées/sorties de la carte Arduino. Plus spécifiquement, il s’agit de
constantes permettant de paramétrer leurs modes de fonctionnement.

HIGH et LOW

Ces deux constantes sont employées avec les broches digitales. Comme vu
précédemment (cf. chapitre Le module Arduino, section Entrées/sorties), les
broches digitales manipulent des données digitales sous forme de signaux
logiques. Les deux valeurs représentables sont donc définies par ces
constantes. Elles correspondent dans la pratique à des valeurs de tension qui
seront utilisées par les broches de l’Arduino. Ces constantes ont des propriétés
particulières qui dépendent du mode de fonctionnement que l’on a attribué
aux broches digitales.
Lorsque ces broches sont en lecture, la constante HIGH correspond à une
valeur de tension supérieure à 3V. La constante LOW correspond à une valeur
de tension inférieure à 1,5V. Cela signifie qu’il faut fournir des valeurs de ten-
sions comprises dans ces marges pour que la lecture de ces broches soit com-
prise.
144 Arduino
Apprendre à développer pour créer des objets intelligents

Toutes les valeurs de tension comprises entre ces deux valeurs ne peuvent être
interprétées par le microcontrôleur. Il est donc impératif que la tension ne soit
pas comprise entre ces deux valeurs si l’on souhaite qu’il n’y ait pas d’erreur
dans le programme.
Lorsque les broches sont en écriture, la constante HIGH indique au microcon-
trôleur de fournir aux broches concernées une tension de 5V. Le microcontrô-
leur fournit à l’inverse une tension de 0V lorsque la constante LOW est
employée.

OUTPUT et INPUT

Ces deux constantes servent à déterminer si les broches auxquelles elles sont
appliquées fonctionnent en lecture ou en écriture. Comme seules les broches
digitales peuvent fonctionner dans ces deux modes (cf. chapitre Le module
Arduino, section Entrées/sorties), ces deux constantes ne s’appliquent donc
que pour celles-ci.
Lorsqu’une broche est déclarée en INPUT, elle est placée dans un état dit de
haute impédance. Dans cet état, les broches ne consomment quasiment pas
de courant sur les circuits auxquels elles sont raccordées. Cet état correspond
au mode entrée. C’est également le mode de fonctionnement par défaut de
toutes les broches digitales.
Lorsqu’une broche est déclarée en OUTPUT, elle peut fournir ou absorber jus-
qu’à 40 mA de courant. Il s’agit du mode de sortie des broches digitales. Dans
ce mode, les broches génèrent suffisamment de courant pour alimenter des
LED ou de petits capteurs. Rappelons néanmoins que même si toutes les
broches peuvent fournir 40 mA de courant, il existe une limite totale cumulée
de courant de 200 mA environ à ce qu’une carte Arduino peut fournir.

© Editions ENI - All rights reserved


La programmation sur Arduino 145
Chapitre 5

3. Fonctions propres à l’Arduino


Il existe également un certain nombre de fonctions qui sont spécifiques à l’uti-
lisation sur Arduino. Ces fonctions sont directement accessibles dans l’envi-
ronnement de développement Arduino sans avoir à utiliser de nouvelles
bibliothèques.

3.1 Entrées/sorties

Les fonctions d’entrées/sorties permettent d'utiliser les broches présentes sur


les cartes Arduino. On peut distinguer deux types de fonctions, vu qu'il existe
deux types de broches. En effet, les broches analogiques et digitales ne se
contrôlent pas de la même manière et il existe des fonctions spécifiques pour
ces deux cas.

Broches digitales
Les fonctions suivantes permettent de manipuler les broches digitales des
cartes Arduino.
– pinMode()
Les broches digitales peuvent fonctionner en lecture ou en écriture. Cette
fonction permet de préciser ce mode de fonctionnement. Elle doit être idéa-
lement appelée lors de la fonction setup() du programme principal.
pinMode(numéro de la broche, mode de fonctionnement);
La broche à configurer doit être précisée dans les paramètres de la fonction
sous la forme d’un nombre. Ce dernier est représenté par le numéro qui est
gravé sur la carte. Sur les cartes Arduino Uno, ce numéro va de 0 à 13. Il est
important de noter que les broches analogiques peuvent également servir
d’entrée/sortie digitale. Les numéros à utiliser dans ce cas, pour une carte
Arduino Uno par exemple, vont de A0 à A5. Le mode de fonctionnement en-
fin est déclaré en utilisant les deux constantes INPUT et OUTPUT définies
dans la partie précédente. Par défaut, toutes les broches sont configurées en
mode INPUT. Il n’est techniquement pas nécessaire de le faire si l’on sou-
haite utiliser une broche en lecture, mais il est fortement conseillé tout de
même d’effectuer systématiquement ce travail de configuration pour facili-
ter la lisibilité du programme.
146 Arduino
Apprendre à développer pour créer des objets intelligents

– digitalWrite()
L’écriture sur les broches digitales est maintenant la prochaine étape. Pour
cela, la fonction digitalWrite() entre en jeu. Une broche configurée en
écriture doit envoyer une valeur et cette fonction indique quelle valeur uti-
liser.
digitalWrite(numéro de la broche, valeur à envoyer);
Le numéro de la broche, comme dans la fonction précédente, doit être indi-
qué dans les paramètres sous la forme d’un nombre. La valeur à envoyer en-
suite correspond aux deux constantes HIGH et LOW introduites dans la
partie précédente.
– digitalRead()
La lecture est effectuée par la fonction digitalRead(). Cette fonction ne
prend en paramètre que le numéro de la broche sur laquelle la lecture est
souhaitée. La valeur retournée ne peut être qu'une des deux constantes
HIGH et LOW. Cette constante renvoyée, même si cela n'est précisé nulle
part, est d’un type numérique. Il est ainsi possible de stocker cette valeur
dans une variable locale dans son programme pour peu que cette variable
soit du bon type.
byte valeur;
valeur = digitalRead(numéro de la broche);

Broches analogiques

Les broches analogiques ont un fonctionnement différent de celui de leur


contrepartie digitale. De par leur nature, elles doivent pouvoir manipuler plus
que deux valeurs. Ainsi, les microcontrôleurs équipant les Arduino disposent
d’un certain nombre de convertisseurs analogique/numérique (6 pour les
Arduino Uno et 16 pour les Arduino Mega). La fonction de ces convertisseurs
est de traduire une grandeur analogique, dans notre cas une tension électrique,

© Editions ENI - All rights reserved


en une valeur numérique qu'il sera possible de manipuler dans un programme
Arduino. Le convertisseur présent dans les microcontrôleurs utilisés par les
cartes Arduino peut manipuler des valeurs allant jusqu’à 10 bits, soit des
nombres compris entre 0 et 1023. Ainsi, le nombre 0 correspond à une valeur
de tension nulle ou 0V, et le nombre 1023 correspond à une valeur maximale.

Vous aimerez peut-être aussi