Résumer

1. Apprentissage des bases
Le cours est composé de façon à ce que les bases essentielles soient regroupées dans les premières
parties. C’est-à-dire, pour commencer la lecture, vous devrez lire les parties 1 et 2. Ensuite, les parties 3 et 4 sont également essentielles et sont à lire dans l’ordre.
Après cela, vous aurez acquis toutes les bases nécessaires pour poursuivre la lecture sereinement.
C’est seulement alors que vous pourrez sélectionner les chapitres selon les connaissances que vous souhaitez acquérir.

Le cours est ponctué de vidéos réalisés lors de sessions lives sur ma chaîne Twitch
https://twitch.tv/eskimon . L’ensemble de ces extraits ainsi que des vidéos complètes
originales peuvent être trouvées sur la playlist YouTube suivante : https://www.youtube.com/playlist ?list=PLNBsspAtBwlL7lw9HI50YE3WJKY5us-cn

I. Découverte de l’Arduino
Dans cette première partie, nous ferrons nos premiers pas avec Arduino. Nous allons avant tout voir de quoi il s’agit exactement, essayer de comprendre comment cela fonctionne, puis installerons le matériel et le logiciel pour ensuite enchaîner sur l’apprentissage du langage de programmation nécessaire au bon fonctionnement de la carte Arduino. Soyez donc attentif afin de bien comprendre tout ce que je vais vous expliquer. Sans les bases, vous n’irez pas bien loin...

Table des matières
.1. Apprentissage des bases 12
I. Découverte de l’Arduino 13
I.1.Présentation d’Arduino 15
I.1.1. Qu’est-ce que c’est ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
I.1.1.1. Une carte électronique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
I.1.1.2. Programmable ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
I.1.1.3. Et un logiciel ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
I.1.2. Pourquoi choisir Arduino ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
I.1.2.1. Que va-t-on faire avec ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
I.1.2.2. Arduino à l’école . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
I.1.3. Les cartes Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
I.1.3.1. Les fabricants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
I.1.3.2. Les différentes cartes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
I.1.3.3. Où acheter ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
I.1.4. Liste d’achat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
I.1.4.1. Liste Globale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
I.1.4.2. Les revendeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
I.1.4.3. Les kits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
I.2.Quelques bases élémentaires 31
I.2.1. Le courant, la tension et la masse . . . . . . . . . . . . . . . . . . . . . . . . . . 31
I.2.1.1. Le courant électrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
I.2.1.2. Tension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
I.2.1.3. La masse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
I.2.2. La résistance et sa loi ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
I.2.3. Le microcontrôleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
I.2.3.1. La programmation en électronique . . . . . . . . . . . . . . . . . . . . . 37
I.2.4. Les bases de comptage (2,10 et 16) . . . . . . . . . . . . . . . . . . . . . . . . . 39
I.2.4.1. Les bases du de comptage . . . . . . . . . . . . . . . . . . . . . . . . . . 39
I.2.4.2. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
I.3.Le logiciel 45
I.3.1. Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
I.3.1.1. Téléchargement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
I.3.2. Interface du logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
I.3.2.1. Lancement du logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
I.3.2.2. Présentation du logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
I.3.3. Approche et utilisation du logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . 52
I.3.3.1. Le menu File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
I.3.3.2. Les boutons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
I.4.Le matériel 55
I.4.1. Présentation de la carte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
I.4.1.1. Constitution de la carte . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
I.4.2. Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
I.4.2.1. Sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
I.4.2.2. Tester son matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
I.4.3. Fonctionnement global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
I.4.3.1. Partons du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
I.4.3.2. Réception du programme . . . . . . . . . . . . . . . . . . . . . . . . . . 69
I.4.3.3. À l’intérieur du microcontrôleur . . . . . . . . . . . . . . . . . . . . . . . 70
I.5.Le langage Arduino (1/2) 72
I.5.1. La syntaxe du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
I.5.1.1. Le code minimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
I.5.2. Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
I.5.2.1. Une variable, qu’est ce que c’est ? . . . . . . . . . . . . . . . . . . . . . . 75
I.5.2.2. Définir une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
I.5.2.3. Les variables booléennes . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
I.5.2.4. Les opérations ”simples” . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
I.5.2.5. Quelques opérations bien pratiques . . . . . . . . . . . . . . . . . . . . . 82
I.5.2.6. L’opération de bascule (ou ”inversion d’état”) . . . . . . . . . . . . . . . 83
I.5.3. Les conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
I.5.3.1. Qu’est-ce qu’une condition ? . . . . . . . . . . . . . . . . . . . . . . . . . 84
I.5.3.2. Quelques symboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
I.5.3.3. If...else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
I.5.3.4. Les opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
I.5.3.5. Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
I.5.3.6. La condition ternaire ou condensée . . . . . . . . . . . . . . . . . . . . . 92
I.6.Le langage Arduino (2/2) 94
I.6.1. Les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
I.6.1.1. La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
I.6.1.2. La boucle do...while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
I.6.1.3. La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
I.6.1.4. La boucle infinie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
I.6.2. Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
I.6.2.1. Qu’est-ce qu’une fonction ? . . . . . . . . . . . . . . . . . . . . . . . . . 99
I.6.2.2. Fabriquer une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
I.6.2.3. Le type void . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
I.6.2.4. Les fonctions ”typées” . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
I.6.2.5. Les fonctions avec paramètres . . . . . . . . . . . . . . . . . . . . . . . . 103
I.6.3. Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
I.6.3.1. Un tableau en programmation . . . . . . . . . . . . . . . . . . . . . . . . 106
I.6.3.2. Déclarer un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
I.6.3.3. Accéder et modifier une case du tableau . . . . . . . . . . . . . . . . . . 107

I.6.3.4. Initialiser un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
I.6.3.5. Exemple de traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
II. Gestion des entrées / sorties 112
II.1.Notre premier programme ! 114
II.1.1.La diode électroluminescente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
II.1.1.1.DEL / LED ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
II.1.1.2.Fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
II.1.2.Par quoi on commence ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
II.1.2.1.Un outil formidable : la breadboard ! . . . . . . . . . . . . . . . . . . . . 119
II.1.2.2.Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
II.1.2.3.Créer un nouveau projet . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
II.1.3.Créer le programme : les bons outils ! . . . . . . . . . . . . . . . . . . . . . . . . 128
II.1.3.1.La référence Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
II.1.3.2.Allumer notre LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
II.1.4.Comment tout cela fonctionne ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
II.1.4.1.Le démarrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
II.1.4.2.Et l’exécution du programme . . . . . . . . . . . . . . . . . . . . . . . . 135
II.1.4.3.La vitesse d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
II.2.Introduire le temps 138
II.2.1.Comment faire ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
II.2.2.Faire clignoter un groupe de LED . . . . . . . . . . . . . . . . . . . . . . . . . . 142
II.2.3.Réaliser un chenillard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
II.2.4.Fonction millis() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
II.2.4.1.Les limites de la fonction delay() . . . . . . . . . . . . . . . . . . . . . . 151
II.2.4.2.Découvrons et utilisons millis() . . . . . . . . . . . . . . . . . . . . . . . 152
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
II.3.[TP] Feux de signalisation routière 156
II.3.1.Préparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
II.3.2.Énoncé de l’exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
II.3.3.Correction ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
II.3.3.1.La correction, enfin ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
II.4.Un simple bouton 163
II.4.1.Qu’est-ce qu’un bouton ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
II.4.1.1.Mécanique du bouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
II.4.1.2.L’électronique du bouton . . . . . . . . . . . . . . . . . . . . . . . . . . 164
II.4.1.3.Contrainte pour les montages . . . . . . . . . . . . . . . . . . . . . . . . 165
II.4.1.4.Les pull-ups internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
II.4.2.Récupérer l’appui du bouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
II.4.2.1.Montage de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
II.4.2.2.Paramétrer la carte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
II.4.2.3.Récupérer l’état du bouton . . . . . . . . . . . . . . . . . . . . . . . . . 175
II.4.2.4.Test simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
II.4.3.Interagir avec les LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
II.4.3.1.Montage à faire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
II.4.3.2.Objectif : Barregraphe à LED . . . . . . . . . . . . . . . . . . . . . . . . 179
II.4.3.3.Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
II.4.4.Les interruptions matérielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
II.4.4.1.Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
II.4.4.2.Mise en place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
II.4.4.3.Mise en garde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
II.5.Afficheurs 7 segments 189
II.5.0.1.Matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
II.5.1.Première approche : côté électronique . . . . . . . . . . . . . . . . . . . . . . . . 189
II.5.1.1.Un peu (beaucoup) d’électronique . . . . . . . . . . . . . . . . . . . . . . 189
II.5.1.2.Branchement ”complet” de l’afficheur . . . . . . . . . . . . . . . . . . . . 191
II.5.2.Afficher son premier chiffre ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
II.5.2.1.Schéma de connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
II.5.2.2.Le programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
II.5.3.Techniques d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
II.5.3.1.Les décodeurs ”4 bits -> 7 segments” . . . . . . . . . . . . . . . . . . . . 199
II.5.3.2.L’affichage par alternance . . . . . . . . . . . . . . . . . . . . . . . . . . 201
II.5.4.Utilisation du décodeur BCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
II.5.4.1.Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
II.5.4.2.Programme principal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
II.5.4.3.Fonction d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
II.5.5.Utiliser plusieurs afficheurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
II.5.5.1.Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
II.5.5.2.Un peu d’électronique... . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
II.5.5.3.Quelques détails techniques . . . . . . . . . . . . . . . . . . . . . . . . . 212
II.5.5.4....et de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
II.5.6.Contraintes des évènements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
II.6.[TP] Parking 224
II.6.1.Consigne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
II.6.2.Correction ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
II.6.2.1.Montage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
II.6.2.2.Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
II.6.2.3.Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
III. La communication avec Arduino 237
III.1.Généralités sur la voie série 238
III.1.1.Communiquer, pourquoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
III.1.1.1.Transmettre des informations . . . . . . . . . . . . . . . . . . . . . . . . 238
III.1.1.2.Le récepteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
III.1.2.La norme RS232 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
III.1.2.1.La mécanique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
III.1.2.2.Le signal électrique et le protocole . . . . . . . . . . . . . . . . . . . . . 241
III.1.3.Connexion série entre Arduino et … . . . . . . . . . . . . . . . . . . . . . . . . . 247
III.1.3.1.Émulation du port série . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
III.1.3.2.Arduino et un autre microcontrôleur . . . . . . . . . . . . . . . . . . . . 247
III.1.3.3.Arduino au PC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
III.1.4.Au delà d’Arduino avec la connexion série . . . . . . . . . . . . . . . . . . . . . 252
III.1.4.1.Le connecteur série (ou sortie DB9) . . . . . . . . . . . . . . . . . . . . . 252
III.1.4.2.Désolé, je suis occupé... . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
III.1.4.3.Avec ou sans horloge ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
III.2.Envoyer et recevoir des données sur la voie série 256
III.2.1.Préparer la voie série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
III.2.1.1.Du côté de l’ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
III.2.1.2.Du côté du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
III.2.2.Envoyer des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
III.2.2.1.Appréhender l’objet Serial . . . . . . . . . . . . . . . . . . . . . . . . . . 260
III.2.2.2.La fonction print() en détail . . . . . . . . . . . . . . . . . . . . . . . . 262
III.2.2.3.Exercice : Envoyer l’alphabet . . . . . . . . . . . . . . . . . . . . . . . . 266
III.2.3.Recevoir des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
III.2.3.1.Réception de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
III.2.3.2.Exemple de code complet . . . . . . . . . . . . . . . . . . . . . . . . . . 269
III.2.4.[Exercice] Attention à la casse ! . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
III.2.4.1.Consigne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
III.2.4.2.Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
III.3.[TP] Baignade interdite ! 274
III.3.1.Sujet du TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
III.3.1.1.Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
III.3.1.2.Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
III.3.1.3.Conseil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
III.3.1.4.Résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
III.3.2.Correction ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
III.3.2.1.Le schéma électronique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
III.3.2.2.Les variables globales et la fonction setup() . . . . . . . . . . . . . . . 279
III.3.2.3.La fonction principale et les autres . . . . . . . . . . . . . . . . . . . . . 281
III.3.2.4.Code complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
III.3.3.Améliorations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
III.4.[Annexe] Ordinateur et voie série dans un autre langage de programmation 292
III.4.1.En C++ avec Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
III.4.1.1.Installer QextSerialPort . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
III.4.1.2.Les trucs utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
III.4.1.3.Émettre et recevoir des données . . . . . . . . . . . . . . . . . . . . . . . 299
III.4.2.En C# (.Net) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
III.4.2.1.Les trucs utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
III.4.2.2.Émettre et recevoir des données . . . . . . . . . . . . . . . . . . . . . . . 304
III.4.3.En Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
III.4.3.1.Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
III.4.3.2.Utiliser la librairie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
III.4.3.3.Code exemple complet et commenté . . . . . . . . . . . . . . . . . . . . 309
IV. Les grandeurs analogiques 310
IV.1.Les entrées analogiques de l’Arduino 312
IV.1.1.Un signal analogique : petits rappels . . . . . . . . . . . . . . . . . . . . . . . . 312
IV.1.2.Les convertisseurs analogiques –> numérique ou CAN . . . . . . . . . . . . . . . 314
IV.1.2.1.Arduino dispose d’un CAN . . . . . . . . . . . . . . . . . . . . . . . . . 314
IV.1.2.2.Le CAN à approximations successives . . . . . . . . . . . . . . . . . . . 315
IV.1.3.Lecture analogique, on y vient… . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
IV.1.3.1.Lire la tension sur une broche analogique . . . . . . . . . . . . . . . . . . 323
IV.1.3.2.Convertir la valeur lue . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
IV.1.4.Exemple d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
IV.1.4.1.Le potentiomètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
IV.1.4.2.Utilisation avec Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
IV.1.5.Une meilleure précision ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
IV.1.5.1.Solution 1 : modifier la plage d’entrée du convertisseur . . . . . . . . . . 331
IV.1.5.2.Solution 2 : utiliser un pont diviseur de tension . . . . . . . . . . . . . . 333
IV.1.5.3.Solution 3 : utiliser un CAN externe . . . . . . . . . . . . . . . . . . . . 333
IV.1.5.4.Solution 4 : Modifier la fréquence de fonctionnement de l’ADC . . . . . . 334
IV.2.[TP] Vu-mètre à LED 335
IV.2.1.Consigne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
IV.2.2.Correction ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
IV.2.2.1.Schéma électronique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
IV.2.2.2.Le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
IV.2.3.Amélioration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
IV.3.Et les sorties “analogiques”, enfin… presque ! 344
IV.3.1.Convertir des données binaires en signal analogique . . . . . . . . . . . . . . . . 344
IV.3.1.1.Convertisseur Numérique->Analogique . . . . . . . . . . . . . . . . . . . 344
IV.3.1.2.PWM ou MLI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
IV.3.2.La PWM de l’Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
IV.3.2.1.Avant de commencer à programmer . . . . . . . . . . . . . . . . . . . . . 348
IV.3.2.2.Quelques outils essentiels . . . . . . . . . . . . . . . . . . . . . . . . . . 349
IV.3.2.3.À vos claviers, prêt... programmez ! . . . . . . . . . . . . . . . . . . . . . 355
IV.3.3.Transformation PWM -> signal analogique . . . . . . . . . . . . . . . . . . . . . 358
IV.3.3.1.La valeur moyenne d’un signal . . . . . . . . . . . . . . . . . . . . . . . 359
IV.3.3.2.Extraire cette valeur moyenne . . . . . . . . . . . . . . . . . . . . . . . . 360
IV.3.3.3.Calibrer correctement la constante RC . . . . . . . . . . . . . . . . . . . 365
IV.3.4.Modifier la fréquence de la PWM . . . . . . . . . . . . . . . . . . . . . . . . . . 366
IV.4.[Exercice] Une animation “YouTube” 372
IV.4.1.Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
IV.4.2.Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
IV.4.2.1.Le schéma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
IV.4.2.2.Le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
V. Les capteurs et l’environnement autour d’Arduino 380
V.1.Généralités sur les capteurs 382
V.1.1.Capteur et Transducteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
V.1.1.1.Capteurs Transducteurs passifs . . . . . . . . . . . . . . . . . . . . . . . 383
V.1.1.2.Capteurs actifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
V.1.1.3.Les autres capteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
V.1.2.Un capteur, ça capte ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
V.1.2.1.Mesure, le rôle du transducteur . . . . . . . . . . . . . . . . . . . . . . . 385
V.1.2.2.L’intérêt d’adapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
V.1.2.3.L’électronique d’adaptation . . . . . . . . . . . . . . . . . . . . . . . . . 388
V.1.3.Les caractéristiques d’un capteur . . . . . . . . . . . . . . . . . . . . . . . . . . 389
V.1.3.1.Les critères à ne pas négliger . . . . . . . . . . . . . . . . . . . . . . . . 389
V.1.3.2.D’autres caractéristiques à connaitre . . . . . . . . . . . . . . . . . . . . 390
V.2.Différents types de mesures 392
V.2.1.Tout Ou Rien, un capteur qui sait ce qu’il veut . . . . . . . . . . . . . . . . . . 392
V.2.1.1.Deux états . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
V.2.1.2.Le capteur ILS ou Interrupteur à Lames Souples . . . . . . . . . . . . . 393
V.2.1.3.Capteur logique prêt à l’emploi . . . . . . . . . . . . . . . . . . . . . . . 396
V.2.2.Capteurs à résistance de sortie variable . . . . . . . . . . . . . . . . . . . . . . . 397
V.2.2.1.La photo-résistance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
V.2.2.2.Un peu de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . 404
V.2.2.3.Un programme plus évolué . . . . . . . . . . . . . . . . . . . . . . . . . . 405
V.2.2.4.Un autre petit robot mobile . . . . . . . . . . . . . . . . . . . . . . . . . 408
V.2.3.Capteurs à tension de sortie variable . . . . . . . . . . . . . . . . . . . . . . . . 409
V.2.3.1.L’élément piézoélectrique . . . . . . . . . . . . . . . . . . . . . . . . . . 409
V.2.3.2.Montage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
V.2.3.3.Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
V.2.3.4.La réversibilité de l’élément piézoélectrique . . . . . . . . . . . . . . . . 415
V.2.3.5.La tension comme image du courant avec les photodiodes et phototransistors416
V.2.4.Étalonner son capteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
V.2.4.1.La méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
V.3.Des capteurs plus évolués 426
V.3.1.Capteur à sortie en modulation de largeur d’impulsion (PWM) . . . . . . . . . . 426
V.3.1.1.Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
V.3.1.2.Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
V.3.1.3.Étude de cas : le capteur de distance SRF05 . . . . . . . . . . . . . . . . 428
V.3.2.Capteur à signal de sortie de fréquence variable . . . . . . . . . . . . . . . . . . 430
V.3.2.1.Exemple / Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
V.3.3.Capteur utilisant un protocole de communication . . . . . . . . . . . . . . . . . 433
V.3.3.1.Quelques protocoles de communication . . . . . . . . . . . . . . . . . . . 433
VI. Le mouvement grâce aux moteurs 435
VI.1.Le moteur à courant continu 437
VI.1.1.Un moteur, ça fait quoi au juste ? . . . . . . . . . . . . . . . . . . . . . . . . . . 437
VI.1.1.1.Principe de fonctionnement du moteur à courant continu . . . . . . . . . 438
VI.1.1.2.La mécanique liée au moteur . . . . . . . . . . . . . . . . . . . . . . . . 448
VI.1.1.3.Quelques relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
VI.1.2.Alimenter un moteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458
VI.1.2.1.Connecter un moteur sur une source d’énergie : la pile . . . . . . . . . . 458
VI.1.2.2.Avec la carte Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
VI.1.2.3.Une question de puissance : le transistor . . . . . . . . . . . . . . . . . . 461
VI.1.2.4.Protégeons l’ensemble : la diode de roue libre . . . . . . . . . . . . . . . 463
VI.1.3.Piloter un moteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
VI.1.3.1.Faire varier la vitesse : la PWM . . . . . . . . . . . . . . . . . . . . . . . 468
VI.1.3.2.Tourner dans les deux sens : le pont en H . . . . . . . . . . . . . . . . . 470
VI.1.3.3.Les protections nécessaires . . . . . . . . . . . . . . . . . . . . . . . . . . 474
VI.1.3.4.Des solutions intégrées : L293, L298... . . . . . . . . . . . . . . . . . . . 476
VI.1.4.Et Arduino dans tout ça ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
VI.1.4.1.Bref rappel sur les PWM . . . . . . . . . . . . . . . . . . . . . . . . . . 481
VI.1.4.2.Utiliser un shield moteur . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
VI.1.4.3.Petit programme de test . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
VI.1.4.4.Programme plus élaboré . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
VI.2.Un moteur qui a de la tête : le Servomoteur 492
VI.2.1.Principe du servomoteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
VI.2.1.1.Vue générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
VI.2.1.2.Composition d’un servomoteur . . . . . . . . . . . . . . . . . . . . . . . 495
VI.2.2.La commande d’un servomoteur . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
VI.2.2.1.Le signal de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
VI.2.3.Arduino et les servomoteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
VI.2.3.1.Câblage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
VI.2.3.2.La librairie Servo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
VI.2.4.L’électronique d’asservissement . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
VI.2.4.1.Principe de fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . 507
VI.2.4.2.Électronique à consigne manuelle . . . . . . . . . . . . . . . . . . . . . . 508
VI.2.4.3.Électronique à consigne PWM . . . . . . . . . . . . . . . . . . . . . . . . 510
VI.2.5.Un peu d’exercice ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
VI.2.5.1.Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
VI.2.6.Tester un servomoteur “non-standard” . . . . . . . . . . . . . . . . . . . . . . . 516
VI.2.6.1.Programme de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
VI.3.A petits pas, le moteur pas-à-pas 520
VI.3.1.Les différents moteurs pas-à-pas et leur fonctionnement . . . . . . . . . . . . . . 520
VI.3.1.1.Fonctionnement des moteurs . . . . . . . . . . . . . . . . . . . . . . . . . 521
VI.3.2.Se servir du moteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
VI.3.2.1.Le moteur unipolaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
VI.3.2.2.Le moteur bipolaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
VI.3.2.3.Piloter le moteur bipolaire . . . . . . . . . . . . . . . . . . . . . . . . . . 533
VI.3.3.Utilisation avec Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
VI.3.3.1.Câbler les moteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
VI.3.3.2.Piloter les moteurs avec Arduino . . . . . . . . . . . . . . . . . . . . . . 542
VI.3.3.3.Aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
VII. L’affichage, une autre manière d’interagir 547
VII.1.Les écrans LCD 549
VII.1.1.Un écran LCD c’est quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
VII.1.1.1.Fonctionnement de l’écran . . . . . . . . . . . . . . . . . . . . . . . . . . 549
VII.1.1.2.Commande du LCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
VII.1.2.Quel écran choisir ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
VII.1.2.1.Les caractéristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
VII.1.2.2.Communication avec l’écran . . . . . . . . . . . . . . . . . . . . . . . . . 553
VII.1.3.Comment on s’en sert ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
VII.1.3.1.Le branchement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
VII.1.3.2.Le démarrage de l’écran avec Arduino . . . . . . . . . . . . . . . . . . . 559
VII.2.Votre premier texte sur le LCD! 561
VII.2.1.Ecrire du texte sur le LCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
VII.2.1.1.Afficher du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
VII.2.1.2.Afficher une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
VII.2.1.3.Combo ! Afficher du texte ET une variable . . . . . . . . . . . . . . . . . 562
VII.2.1.4.Exercice, faire une horloge . . . . . . . . . . . . . . . . . . . . . . . . . . 564
VII.2.2.Se déplacer sur l’écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
VII.2.2.1.Gérer l’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
VII.2.2.2.Gérer le curseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
VII.2.2.3.Jouer avec le texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568
VII.2.3.Créer un caractère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
VII.3.[TP] Supervision avec un LCD 575
VII.3.1.Consigne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
VII.3.2.Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576
VII.3.2.1.Le montage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576
VII.3.2.2.Le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579
VIII.Internet of Things : Arduino sur Internet 589
VIII.1.Découverte de l’Ethernet sur Arduino 590
VIII.1.1.Un réseau informatique c’est quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . 590
VIII.1.2.Le shield Ethernet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
VIII.1.2.1.Le cœur du traitement : Le Wiznet 510 . . . . . . . . . . . . . . . . . . . 591
VIII.1.2.2.De la communication à droite à gauche... . . . . . . . . . . . . . . . . . . 592
VIII.1.3.Un peu de vocabulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
VIII.1.3.1.Architecture Serveur/Client . . . . . . . . . . . . . . . . . . . . . . . . . 592
VIII.1.3.2.Des adresses pour tout ! . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
VIII.1.3.3.D’autres notions utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
VIII.2.Arduino et Ethernet : client 595
VIII.2.1.Client et requêtes HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
VIII.2.1.1.Un client, ça fait quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
VIII.2.1.2.Une requête HTTP, c’est quoi ? . . . . . . . . . . . . . . . . . . . . . . . 595
VIII.2.2.Utilisation du shield comme client . . . . . . . . . . . . . . . . . . . . . . . . . . 596
VIII.2.2.1.Préparation minimale . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
VIII.2.2.2.Démarrer le shield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
VIII.2.2.3.Envoyer une requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598
VIII.2.2.4.Lire une réponse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
VIII.2.2.5.Faire des requêtes en continu . . . . . . . . . . . . . . . . . . . . . . . . 604
VIII.2.2.6.L’intérêt d’un client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
VIII.2.3.Exercice, lire l’uptime de Eskimon.fr . . . . . . . . . . . . . . . . . . . . . . . . 610
VIII.2.3.1.Consigne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
VIII.3.Arduino et Ethernet : serveur 611
VIII.3.1.Préparer l’Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
VIII.3.2.Répondre et servir des données . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
VIII.3.3.Agir sur une requête plus précise . . . . . . . . . . . . . . . . . . . . . . . . . . 616
VIII.3.3.1.Répondre à la requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
VIII.3.3.2.Lire la requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
VIII.3.3.3.Code complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
VIII.3.4.Sortir de son réseau privé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
VIII.3.4.1.Le souci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
VIII.3.4.2.La solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
VIII.3.5.Faire une interface pour dialoguer avec son Arduino . . . . . . . . . . . . . . . . 626
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630
VIII.4.Aller plus loin 635
VIII.5.Remerciements 636

• Télécharger
• Voir Plus

Resultats du Test [Arduino : premiers pas en informatique embarquée ]