des objets intelligents

ISBN : 978-2-7460-9602-8
29,90 €
Ce livre s’adresse à toute personne intéressée par la création
d’objets intelligents et pose les bases de l’utilisation des cartes
électroniques Arduino. La simplicité d’utilisation de ce type de
carte rend l’électronique accessible à tous et la création d’objets
intelligents à la portée de toute personne passionnée par le sujet.
Les premiers chapitres décrivent l’univers Arduino, de l’introduc-
tion des microcontrôleurs à la présentation de l’environnement de
développement. Les deux chapitres suivants présentent les bases
de l’électronique puis de l’informatique, ce qui permet à un élec-
tronicien, ou respectivement à un informaticien, d’acquérir les com-
pétences nécessaires pour être autonome dans cet univers.
Le chapitre sur la programmation entre un peu plus spécifiquement
dans le langage Arduino, il décrit notamment en détail les fonc-
tionnalités propres à ce langage. Les chapitres sur les entrées-sor-
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
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
des Shields ainsi que certaines applications pratiques constituent
les dernières parties de cet ouvrage. Enfin, l’intégration de divers
capteurs et composants permet d’ouvrir le champ des possibilités
vers l’internet des objets ou la robotique.
Certains des exemples du livre sont disponibles en télécharge-
ment sur le site www.editions-eni.fr (bibliothèques de fonctions,
quelques applications simples liées à l’emploi des fonctionnalités
de base de l’Arduino). Ils peuvent être utilisés immédiatement ou
adaptés pour répondre aux besoins du lecteur.
Arduino
Apprendre à développer pour créer des objets intelligents
Pour plus
d’informations :
Nicolas GOILAV est Ingénieur infor-
matique, spécialisé dans le manage-
ment de projets. Geoffrey LOI est
étudiant en informatique, spécialité
Sciences de l’électronique. Nicolas et
Geoffrey sont tous les deux passion-
nés par les « objets intelligents » et
ont tout de suite été séduits par le
potentiel des cartes Arduino dans ce
domaine. Grâce à la complémentarité
de leur expérience et de leur forma-
tion, ils transmettent au lecteur un
livre réellement opérationnel pour lui
apprendre à développer des objets
intelligents.
Le module Arduino • Environnement
de développement • Les bases de
l’électronique • Les bases de la pro-
grammation • La programmation sur
Arduino • Les entrées/sorties • Les
interfaces de communication • Les
cartes Arduino • Les shields • Les
accessoires de l’Arduino • Vers l’In-
ternet des objets et la robotique
Téléchargement
www.editions-eni.fr
.fr
sur www.editions-eni.fr :
b Bibliothèques de fonctions.
b Exemples de code.
Nicolas GOILAV
Geoffrey LOI
Arduino
Apprendre à développer
pour créer
des objets intelligents
Arduino Apprendre à développer
pour créer des objets intelligents
Les chapitres du livre

1
Table des matières
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
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.

2
Apprendre à développer pour créer des objets intelligents
Arduino
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

3
Table des matières
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
Apprendre à développer pour créer des objets intelligents
Arduino
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