Arduino Interface de Communication [PDF]

Zitiervorschau

Arduino

Le chapitre sur la programmation entre un peu plus spécifiquement dans le langage Arduino, il décrit notamment en détail les fonctionnalités propres à ce langage. Les chapitres sur les entrées-sorties 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échargement sur le site www.editions-eni.fr (bibliothèques de fonctions, quelques applications simples liées à l’emploi des fonctionnalités Téléchargement de base de l’Arduino). Ils peuvent être utilisés immédiatement ou www.editions-eni.fr .fr adaptés pour répondre aux besoins du lecteur.

Le module Arduino • Environnement de développement • Les bases de l’électronique • Les bases de la programmation • La programmation sur Arduino • Les entrées/sorties • Les interfaces de communication • Les cartes Arduino • Les shields • Les accessoires de l’Arduino • Vers l’Internet des objets et la robotique

Pour plus d’informations :

29,90 €

sur www.editions-eni.fr : b Bibliothèques de fonctions. b Exemples de code.

Les chapitres du livre

Arduino

Les premiers chapitres décrivent l’univers Arduino, de l’introduction 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 électronicien, ou respectivement à un informaticien, d’acquérir les compétences nécessaires pour être autonome dans cet univers.

Nicolas GOILAV est Ingénieur informatique, spécialisé dans le management de projets. Geoffrey LOI est étudiant en informatique, spécialité Sciences de l’électronique. Nicolas et Geoffrey sont tous les deux passionné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 formation, ils transmettent au lecteur un livre réellement opérationnel pour lui apprendre à développer des objets intelligents.

ISBN : 978-2-7460-9602-8

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.

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

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

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

Nicolas GOILAV Geoffrey LOI

Table des matières

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

1

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 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

3

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 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

5

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 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

7

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, principalement dans la structure d’un programme. Un programme Arduino se décompose en deux parties principales : une premiè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écuter 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.

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 fonctions 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 fonctions pourront s’insérer à tout endroit du programme, du moment que la syntaxe 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. 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-

© Editions ENI - All rights reserved

142

La programmation sur Arduino 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 également 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 programmation 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 tensions comprises dans ces marges pour que la lecture de ces broches soit comprise.

143

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 microcontrô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 jusqu’à 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

144

La programmation sur Arduino Chapitre 5

3. Fonctions propres à l’Arduino Il existe également un certain nombre de fonctions qui sont spécifiques à l’utilisation sur Arduino. Ces fonctions sont directement accessibles dans l’environnement 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éalement 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 enfin 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 souhaite utiliser une broche en lecture, mais il est fortement conseillé tout de même d’effectuer systématiquement ce travail de configuration pour faciliter la lisibilité du programme.

145

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 utiliser. digitalWrite(numéro de la broche, valeur à envoyer);

Le numéro de la broche, comme dans la fonction précédente, doit être indiqué dans les paramètres sous la forme d’un nombre. La valeur à envoyer ensuite 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, 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.

© Editions ENI - All rights reserved

146