Le grand livre d'Arduino pdf


Télécharger Le grand livre d'Arduino pdf

★★★★★★★★★★2.9 étoiles sur 5 basé sur 12 votes.
Votez ce document:

Télécharger aussi :


LE GRAND LIVRE D’ARDUINO

Erik Bartmann


25 montages à réaliser avec Arduino

Avec son petit microcontrôleur hautement performant et facilement programmable, la carte Arduino a révolutionné le mouvement Do It Yourself. Se couplant aisément avec d’autres composants (écrans LCD, capteurs, moteurs…), elle est devenue aujourd’hui un élément indispensable dans de nombreux dispositifs électroniques. Sa simplicité d’utilisation, l’étendue de ses applications et son prix modique ont conquis un large public d’amateurs et de professionnels : passionnés d’électronique, designers, ingénieurs, musiciens…

Remarquable par son approche pédagogique, cet ouvrage de référence vous fera découvrir le formidable potentiel d’Arduino, en vous délivrant un peu de théorie et surtout beaucoup de pratique avec ses 25 montages à réaliser. Mise à jour avec les dernières évolutions d’Arduino, cette troisième édition entièrement refondue s’est enrichie de nouveaux projets à monter, qui font appel à une liaison Bluetooth, à Scratch, ou encore au module WI-FI ESP8266.

À qui s’adresse ce livre ?

Aux électroniciens, bricoleurs, bidouilleurs, hobbyistes, ingénieurs, designers, artistes, makers…

Dans ce livre, vous apprendrez notamment à :

? créer un séquenceur de lumière

? fabriquer un afficheur LCD

? commander un moteur pas-à-pas ? concevoir un jeu de ping pong

Sur

Téléchargez le code source des sketches Arduino présentés dans cet ouvrage.

Électronicien de formation, Erik Bartmann est aujourd’hui développeur pour le principal fournisseur européen d’infrastructures informatiques. Passionné d’électronique depuis toujours, il est l’auteur de plusieurs ouvrages sur Arduino, Processing et le Raspberry Pi.

LE GRAND LIVRE D’ARDUINO


CHEZ LE MÊME ÉDITEUR

Dans la collection « Serial Makers » 

D. Knox. – Petits robots à fabriquer.

N°67575, 2018, 160 pages.

J. Boyer. – Réparez vous-même vos appareils électroniques (2e édition). À paraître.

N°67621, 2018, 384 pages.

S. MonK. – Mouvement, lumière et son avec Arduino et Raspberry Pi. N°11807, 2016, 352 pages.

C. Platt. – L’électronique en pratique (2e édition).

N°14425, 2016, 328 pages.

C. Platt. – L’électronique en pratique 2. N°14179, 2015, 336 pages.

E. De Keyser. – Le Mavic Pro et DJI GO. N°67525, 2017, 208 pages.

E.       De Keyser. – Filmer et photographier avec un drone (2e édition). N°67435, 2017, 224 pages.

F.       Botton. – Les drones de loisir (3e édition). N°67444, 2017, 230 pages.

R. JoBarD. – Les drones (3e édition).

N°67434, 2017, 184 pages.

M. laury. – À la découverte des cartes Nucleo.

N°67369, 2017, 280 pages.

C. Bosqué, O. noor et L. ricarD. – FabLabs, etc. Les nouveaux lieux de fabrication numérique.

N°13938, 2015, 216 pages.

A. BanKs, Macuser et iFixit. – Réparez vous-même votre Apple.

N°14251, 2015, 146 pages.


Erik Bartmann

 
 

LE GRAND LIVRE D’ARDUINO

3e édition


ÉDITIONS EYROLLES 61, bd Saint-Germain

75240 Paris Cedex 05

Authorized French translation of the German edition of Mit Arduino die elektronische Welt entdecken, 3. Auflage by Erik Bartmann, ISBN 978-3-946496-00-7 © 2017 by Bombini Verlags GmbH. This translation is published and sold by permission of Bombini Verlags GmbH, which owns or controls all rights to publish and sell the same.

Traduction autorisée de l’ouvrage en langue allemande intitulé Mit Arduino die elektronische Welt entdecken, 3. Auflage d’Erik Bartmann (ISBN : 978-3-946496-00-7)

Adapté de l’allemand par Danielle Lafarge et Patrick Chantereau

L’éditeur remercie vivement Jean Boyer pour sa validation technique de l’ouvrage.

En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le présent ouvrage, sur quelque support que ce soit, sans l’autorisation de l’Éditeur ou du Centre français d’exploitation du droit de copie, 20, rue des Grands-Augustins, 75006 Paris.

© Planner/shutterstock pour la photo page 203

© Groupe Eyrolles, 2014, 2015, 2018, ISBN : 978-2-212-67488-0

Quand il s’agit de fabriquer un produit tendance, innovant ou génial à base de composants électroniques ou de microcontrôleurs, un outil est incontournable : Arduino. Ce livre donnera un coup de pouce à tous ceux qui auraient toujours voulu savoir comment ça fonctionne, mais qui n’ont jamais osé se lancer. Il y a dix ans, le mot « électronique » en rebutait plus d’un et effrayait les autres. Si vous n’aviez pas fait d’études d’électrotechnique, vous n’aviez aucune chance de réussir à réaliser les montages que je vais vous présenter dans ce livre.

Ce n’est pas aussi terrible que ça en a l’air. Les choses ont évidemment beaucoup évolué depuis l’époque – qui remonte tout de même à une trentaine d’années – où j’usais mon fond de culotte sur les bancs de l’école. En cours de sciences physiques, on apprenait déjà à réaliser des montages électroniques à l’aide de composants tels que des résistances, des condensateurs, des diodes ou des transistors. Mais le but était simplement de mieux comprendre des processus physiques. Comme il n’y avait pas d’application concrète, la plupart des élèves se comportaient comme des diodes dans le sens non passant : ils faisaient un blocage ! La motivation de créer quelque chose soi-même était réservée aux rares individus qui pratiquaient durant leurs loisirs. Il y avait très peu de nouvelles recrues et les rares qui s’y essayaient rebroussaient chemin très vite. Je suis reconnaissant à mes enseignants, car ils ont su me montrer ce qu’il ne fallait pas faire. Leurs insuffisances pédagogiques et leur exécution stupide du programme scolaire, en mettant un point d’honneur à appliquer le règlement à la lettre, m’ont donné envie de procéder autrement.

L’autre sujet que j’aimerais aborder ici est celui de la programmation d’un ordinateur. C’était l’époque des Apple II ou du Commodore C64, s’il ne fallait en citer que deux. En effet, c’étaient les PC les plus appréciés du grand public et les plus répandus. Les rares individus qui s’intéressaient à la programmation étaient de vrais passionnés. Pourtant, dans le domaine des loisirs, ces deux u nivers, celui de l’électronique et celui de la programmation, ne faisaient que se côtoyer. Ces ordinateurs offraient naturellement diverses possibilités d’extension par l’intermédiaire d’interfaces disponibles dans les boutiques spécialisées. Les geeks bricolaient des modules géniaux afin de compléter les fonctionnalités de leur ordinateur. Mais ce privilège n’était pas à la portée de tous. L’Apple disposait de plusieurs slots (ports) qui équipent aujourd’hui encore les PC. On pouvait y connecter des cartes spéciales qui permettaient de communiquer avec le monde extérieur. Le C64, quant à lui, possédait notamment un port d’expansion qui offrait des possibilités similaires. Les interfaces compatibles, comme les ports USB, I²C ou SPI, n’existaient pas encore ou étaient très peu répandus.

Même si l’inspiration était là, la réalisation et le coût relativement élevé de la mise en œuvre en ont freiné plus d’un. Ce n’est pas facile d’avancer avec le frein à main serré… Ce livre vous permettra de le desserrer et de passer la vitesse supérieure.

Ce bref rappel historique me permet d’arriver en douceur au sujet qui nous intéresse : Arduino. Cette plateforme, qui se compose d’un microcontrôleur et de quelques autres composants, est au cœur d’un concept génial qui a été repris par des bricoleurs du monde entier. La combinaison de composants matériels et logiciels est enfin à la portée de tous !

Le bricoleur motivé encore appelé maker – dispose désormais d’un outil lui permettant de réaliser ses rêves. Le mot-clé  prototyping est sur toutes les lèvres. Le prototypage consiste à créer rapidement des montages afin d’en vérifier la faisabilité. Cela comprend aussi bien la réalisation des connexions que la programmation. Cela nous amène à notre second mot-clé. Parce que l’Arduino englobe des composants non seulement matériels, mais aussi logiciels, qui fonctionnent en parfaite symbiose, cette collaboration se nomme le  physical computing. Il établit une relation interactive entre l’homme et la machine. L’ordinateur réagit à des influences extérieures reçues par le biais de capteurs. Il les interprète à l’aide de programmes créés et enregistrés par l’homme. Il commande alors des réactions qui sont exécutées par le biais d’acteurs, comme des servomoteurs ou des moteurs. Et la boucle est bouclée !

Nous en arrivons au dernier mot-clé : Open Source. En effet, l’Arduino repose sur des logiciels libres. Puisque toutes les informations sont en libre accès, tout le monde peut participer au développement de projets et y apporter sa contribution. Cette forme de collaboration entre passionnés recèle un immense potentiel qui permet de faire avancer les projets. Les résultats parlent d’eux-mêmes et ils n’ont rien à envier aux produits commercialisés.


Cet ouvrage traite de deux thématiques fondamentales, dont nous ne pouvons nous affranchir :

•    l’électronique : les bases, les composants essentiels et leurs fonctions ;

•    le microcontrôleur : la carte Arduino.

Au début, tout sera simple et facile au point que certains se demanderont quel est l’intérêt de faire clignoter une LED. Pourtant, soyez assuré que ce petit montage est lui aussi une pierre de l’édifice. N’oubliez pas qu’une phrase est composée de lettres qui, prises isolément, ne veulent pas dire grand-chose, mais qui, une fois assemblées, nous permettent de communiquer. En électronique, c’est le même principe : tout circuit n’est ni plus ni moins qu’une association judicieuse de composants électriques.

Vous allez certainement vite remarquer que le style employé dans cet ouvrage diffère un peu de ce qu’on peut lire habituellement. En effet, j’ai opté pour un ton familier et complice. Je m’adresse à vous comme mon égal. Au fil des pages, je fais également intervenir un candide qui pose çà et là des questions, qui vous sembleront pertinentes dans certains cas, et stupides dans d’autres – mais c’est totalement voulu. En raison de la clarté et de la simplicité de certains sujets, on se refuse parfois à poser des questions de peur d’être ridicule. Dans ce livre, vous ne connaîtrez pas ce sentiment puisque, par chance, quelqu’un d’autre posera ces questions à votre place !

Par ailleurs, j’ai préféré ne pas vous confronter dès le début de l’ouvrage aux principes de l’électronique et de la programmation Arduino, car cela aurait donné au livre une approche trop scolaire que je souhaitais précisément éviter. Aussi, les thématiques seront abordées en temps voulu et intégrées dans des exemples. Vous ne disposerez ainsi que du strict nécessaire au moment précis de l’apprentissage.

Le premier chapitre vous présentera tout ce qu’il faut savoir sur  l’Arduino Uno, la carte Arduino la plus populaire à l’aide de laquelle vous pourrez réaliser tous vos projets. Mais l’univers de l’Arduino ne se limite pas aux éléments matériels. Il englobe aussi les aspects logiciels. Par conséquent, vous n’échapperez pas à une présentation détaillée de l’IDE Arduino, logiciel permettant de programmer le microcontrôleur de la carte. J’en profiterai pour répondre à toutes les questions que vous vous posez sur cet outil et vous proposer une introduction à la programmation.

Nous ne rentrerons véritablement dans le vif du sujet que dans la seconde partie qui est consacrée aux montages. Nous débuterons par des projets relativement simples qui vous mettront le pied à l’étrier.

Tous les projets se présentent de la même façon. Au début, j’évoque les différents thèmes abordés afin de vous offrir une vue d’ensemble de ce qui vous attend. En conclusion, je vous propose un résumé des sujets traités afin de vous permettre de consolider les connaissances que vous aurez acquises.

Voici comment sont présentés la plupart des montages proposés dans l’ouvrage. Vous y trouverez, dans l’ordre :

•   les composants nécessaires

•   le code du programme ;

•   la revue de code (l’analyse du code) ;

•   le schéma électrique ;

•   la conception des circuits ;

•   les problèmes couramment rencontrés (et que faire si cela ne marche pas du premier coup ?) ;

•   un exercice complémentaire pour approfondir la thématique.

•   qu’avez-vous appris ?

Certaines expériences sont accompagnées de relevés d’oscilloscope ou d’enregistrements d’analyseur logique visant à mieux faire comprendre le parcours du signal.

Pour certains montages, je proposerai des solutions Quick & Dirty qui pourront surprendre à première vue. Mais elles seront suivies d’une variante améliorée qui devrait vous faire dire : « Tiens, ça marche aussi comme ça et même pas mal du tout ! Cette solution est encore meilleure. » Si c’est le cas, alors j’aurai atteint le but que je m’étais fixé. Sinon, ce n’est pas grave : tous les chemins mènent à Rome. 

Le code des sketches Arduino présentés dans cet ouvrage se trouve à l’adresse suivante : . Vous y trouverez également des compléments et des liens utiles.

Le seul prérequis personnel est d’aimer le bricolage et les expériences. Nul besoin d’être un geek pour comprendre et reproduire les montages de ce livre.

Nous commencerons en douceur afin que chacun puisse suivre. Ne vous mettez pas de pression, le premier objectif de cet ouvrage est de vous distraire !

Notre carte Arduino est certes bien sympathique, et nous apprécions que tout y soit si bien pensé et si petit. Mais il faudra quand même passer à l’étape suivante et connaître tout ce qu’il est possible d’y raccorder. Si vous n’avez pas l’habitude de manipuler des composants électroniques (résistances, condensateurs, transistors, diodes…), pas d’inquiétude. Chacun fera l’objet d’une description détaillée, afin que vous sachiez comment il réagit individuellement et au sein du circuit. Pour chaque montage, j’indiquerai en outre la liste des composants nécessaires. Naturellement, l’élément-clé de tout circuit sera toujours la carte Arduino, mais je ne la mentionnerai pas forcément de manière explicite. À ceux qui se demandent combien coûte une carte Arduino et s’ils peuvent conserver leur train de vie après un tel achat, je répondrai : « Yes, you can ! » Elle est très bon marché, aux alentours de 25 euros.

Je l’utilise dans tous les exemples.


t Figure 1 La carte Arduino Uno

Le modèle que vous voyez ici se compose d’un microcontrôleur monté sur un socle. Il existe également des modèles dotés d’un module SMD (Surface Mounted Device), appelé en français CMS (composant monté en surface). Mais cela revient au même. En outre, le fait qu’il s’agisse d’une carte Arduino originale ou non n’a pas vraiment d’importance. Elles fonctionnent toutes plus ou moins de la même façon. La figure 2 représente une carte Arduino UNO SMD qui n’est pas une carte originale.

Figure 2 u

La carte Arduino Uno SMD

Toutefois, le pilote USB fait réellement une différence qui vaut la peine d’être soulignée. Sur la carte Arduino Uno originale, il s’agit d’un microcontrôleur de type MEGA16U2 qui peut être reprogrammé au besoin.

Figure 3 u

La carte Arduino Uno avec son microcontrôleur 

MEGA16U2

La programmation peut s’effectuer par le biais de la liaison ISP (In System Programmer) Breakout à condition de disposer du programmeur correspondant. Le modèle présenté sur la figure 3 est doté d’un module d’interfaçage bon marché, fabriqué en Chine, de type CH340.

Vous trouverez de nombreuses informations au sujet de ce composant sur Internet.

Pour clore cet avant-propos, je vous propose un petit rappel historique sur les débuts d’Arduino. Comment en sommes-nous arrivés là ? En 2005, un projet dont personne n’avait imaginé les conséquences fut lancé à l’Interactive Design Institute Ivrea, à Ivrée en Italie. Une plaque de prototypage fut développée pour donner aux étudiants un moyen simple de concevoir des produits innovants. Un nom revient sans cesse dans ce contexte, celui de Massimo Banzi. C’est l’un des codéveloppeurs et cofondateurs de la société Arduino LLC. Pour l’anecdote, le nom Arduino a été emprunté à un bar d’Ivrée où se réunissaient régulièrement les instigateurs du projet.

La philosophie qui a motivé toute l’affaire est la simplification et la facilitation de l’accès à l’univers de l’électronique et des microcontrôleurs afin que chacun puisse l’utiliser sans être pour autant un spécialiste de ces domaines. La grande disponibilité et le coût modique de la carte Arduino, ainsi que des composants et modules électroniques, ont également contribué à la popularité rapide de la carte.

Pour finir, je vous présente votre guide, qui se prénomme Ardus. Il sera présent à vos côtés tout au long de ce livre et posera les questions que personne n’ose poser. Il était déjà présent dans les précédentes éditions de ce livre et il a un peu changé. Comme celle de l’auteur, sa chevelure s’est quelque peu clairsemée, signe que le temps a aussi prise sur lui.

Le moment est venu que je vous abandonne à votre destin et que je me retire sur la pointe des pieds.

Bon divertissement et bonne réussite dans la découverte de l’univers de l’électroniqueavec votre carte Arduino.


 


Table des matières

Avant-propos .. V

 

Partie I : Les bases

Chapitre 1 : La carte Arduino  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .             3

Les différentes cartes Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  . 3

La carte Arduino Uno  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .         5

Chapitre 2 : L’environnement Arduino  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .       19

L’environnement de développement Arduino Create  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . 20

L’IDE Arduino  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .    30

Raccordement de la carte Arduino  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .    37

Si ça ne fonctionne pas comme prévu  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .        48

Matériel nécessaire aux montages du livre  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .             49

    De l’idée jusqu’au téléversement dans le microcontrôleur  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . 51

Chapitre 3 : Les bases de la programmation  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .              53

Qu’est-ce qu’un programme ou sketch ?  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .          53

Que signifie traitement des données ?  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .        54

Partie II : Les montages

Montage 0 : La carte Arduino SimpleBoard  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .

        75

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

        76

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

        77

Montage 1 : Faire clignoter une LED  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .

        79

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

        79

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

        80

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

        80

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

        81

Bases de calculs de la résistance série .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .

        87

Commande par MLI  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

        93

Informations supplémentaires  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .

        94

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      100

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      101

Montage 2 : Interrogation d’un bouton-poussoir .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

 103

Manipulation d’une résistance pull-up interne  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .

      103

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      107

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      107

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      108

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      109

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      109

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      111

Montage 3 : Clignotement avec gestion des intervalles .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

 113

Appuyez sur le bouton-poussoir et il réagit  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .

      113

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      114

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      114

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      115

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      115

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      118

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      121

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      122

Montage 4 : Le bouton-poussoir récalcitrant  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .

 123

Une histoire de rebond  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      123

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      125

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      125

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

126

 

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

126

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

127

Dépannage  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

128

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

128

Montage 5 : Le séquenceur de lumière  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .

 129

C’est chacun son tour  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      129

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      130

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      131

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      131

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      132

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      132

Manipulation des registres  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      139

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .



      146

Qu’avez-vous appris ?   .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      146

Montage 6 : Extension de port  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

 147

Le registre à décalage  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      147

Registre à décalage conventionnel  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .

      151

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      151

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      152

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      153

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      153

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      154

Extension du sketch : première partie  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .

      157

Extension du sketch : deuxième partie  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .

      162

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      164

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      165

Montage 7 : Les feux de circulation  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .

 167

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      167

Phases de signalisation  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      168

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      168

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      169

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      171

Des feux de circulation interactifs  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

      175

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      187

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      187

Cadeau !  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      188

Montage 8 : Programmation de bas niveau  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .

 189

Entrées et sorties du microcontrôleur  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .

189

Programmation d’un port  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

190

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

192

Registres et instructions en C ++  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

198

Autres informations utiles  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

199

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      201

Montage 9 : Le dé électronique  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

 203

Qu’est-ce qu’un dé électronique ?  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .

      203

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      205

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      205

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      206

Code du sketch  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      207

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      207

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      220

Montage du dé électronique sur une platine .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .

      220

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      222

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      222

Montage 10 : Comment créer une bibliothèque ? .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

 223

Les bibliothèques  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      223

Qu’est-ce qu’une bibliothèque exactement ? .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .

      224

En quoi les bibliothèques sont-elles utiles ?  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .

      225

Que signifie programmation orientée objet ? .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .

      226

La bibliothèque-dé  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      235

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      243

Montage 11 : Des détecteurs de lumière  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .

 245

La résistance variable  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      246

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      247

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      247

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      248

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      248

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      249

Devenons communicatifs  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      253

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      259

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      260

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      260

Montage 12 : L’afficheur sept segments  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .

 261

Qu’est-ce qu’un afficheur sept segments ? .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .

      261

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      265

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

265

 

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

265

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

266

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

267

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

274

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      274

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      275

Montage 13 : Le clavier numérique  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .

 277

Qu’est-ce qu’un clavier numérique ?  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .

      277

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      279

Réflexions préliminaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      279

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      282

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      283

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      283

Réalisation du shield  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      290

Construction d’un shield Arduino  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .

      292

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      296

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      296

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      296

Montage 14 : Un afficheur alphanumérique  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .

 297

Qu’est-ce qu’un afficheur LCD ?  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

      297

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      298

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      301

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      302

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      302

Jeu : deviner un nombre  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      305

Définir des caractères personnels  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

      311

Un afficheur LCD multiligne  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .

      314

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      315

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      316

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      316

Montage 15 : Le moteur pas-à-pas  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .

 317

Encore plus de mouvement   .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .

      317

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      320

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      321

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      321

Revue de code   .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      322

Construire un shield pour moteur  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

      324

Commande de servomoteurs  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

      325

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      326

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

327

 

Montage 16 : La température  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  . 329

Chaud ou froid ?  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                               329

Composants nécessaires  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                                     334

Schéma  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                     334

Réalisation du circuit  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                                  335

Sketch Arduino  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                           335

Revue de code  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                               336

Affichage de valeurs analogiques sur l’IDE Arduino  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .                                                                             337

Problèmes courants  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                                  341

Qu’avez-vous appris ?  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                                     341

Montage 17 : Commande d’un ventilateur  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  . 343

Un peu de pratique  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                               343

Composants nécessaires  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .                                                     344

Schéma d’un circuit de commande de moteur  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .                                                                      344

Schéma d’un circuit de commande du ventilateur  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .                                                                         350



Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      351

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      352

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      354

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      355

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      355

Montage 18 : Faire de la musique avec Arduino .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

 357

Y a pas le son ?  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      357

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      358

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      358

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      359

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      359

Jeu de la séquence des couleurs  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .

      362

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      370

Montage 19 : L’Arduino-Talker  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

 373

Communiquer avec l’Arduino  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .

      373

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      374

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      374

Comprendre le code, étape par étape  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .

      376

Utilisation d’un filtre passe-bas  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .

      383

Qu’avez-vous appris?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      387

Montage 20 : Communication sans fil par Bluetooth .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

 389

Qu’est-ce que la communication radio ?  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .

389

 

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      390

Utilisation d’un adaptateur Bluetooth  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .

      392

Ajout d’un nouveau shield BT  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .

      396

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      396

Le module Bluetooth HC-06  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .

      399

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      401

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      402

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      402

Montage 21 : Programmation avec Scratch et mBlock .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

 403

Le langage de programmation visuelle Scratch  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .

      403

Le Mode Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      414

L’afficheur de fonction  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      418

Simple Pong  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      422

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      431

Montage 22 : Communication réseau  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .

 433

Qu’est-ce qu’un réseau ?  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      433

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      438

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      440

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      442

Exercice complémentaire  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      447

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      447

Qu’avez-vous appris ?  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      448

Montage 23 : Le module Wi-Fi ESP8266  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .

 449

Présentation de l’ESP8266   .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .

      449

Intégration de l’ESP8266  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .

      452

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      454

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      454

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      456

Le log de températures  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      457

Problèmes courants  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      465

Montage 24 : Numérique appelle analogique  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

 467

Comment convertir des signaux numériques en signaux analogiques ?  .  .  .  .  .  .  .  .  .

      467

Composants nécessaires  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .

      469

Schéma  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      470

Réalisation du circuit  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      471

Sketch Arduino  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      471

Revue de code  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

      472

Réalisation du shield  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

472

Commande du registre de port  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  . 473

Problèmes courants  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .          478

Exercice complémentaire  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .            478

Qu’avez-vous appris ?  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .           478

Montage 25 : Quand Arduino rencontre Raspberry Pi  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  . 479

Réveillons l’Arduino qui sommeille dans tout Raspberry Pi  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . 479 Liaison série entre le Raspberry Pi et l’Arduino  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  . 493

Qu’avez-vous appris ?  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .           497

Index .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . .  .  .  .  .  .  .  .  .  .  .  . 499


Partie I Les bases


 


Chapitre

              La carte Arduino                                    

Il semblerait qu’un bar d’Ivrée, en Italie, ait donné son nom au projet Arduino. Le bar a lui-même été nommé d’après Arduin d’Ivrée, qui fut roi d’Italie de 1002 à 1014. C’est en ce lieu que se retrouvaient régulièrement Massimo Banzi et David Cuartielles, qui développèrent la première carte Arduino en 2005. Depuis, Arduino désigne la plateforme logicielle et matérielle de la carte.

Les différentes cartes Arduino

Dans ce livre, nous utiliserons surtout la carte la plus répandue :  l’Arduino Uno. Pourquoi celle-là plutôt qu’une autre ? Sur la figure 1-1, vous pouvez voir quatre cartes Arduino qui ont été développées par l’équipe Arduino.

                                Arduino Uno R3                                     Arduino Leonardo                t Figure 1-1

La famille Arduino 

(une petite sélection)

                             Arduino Mega 2560                                     Arduino Nano

Il suffit d’un coup d’œil pour constater que les cartes se différencient par leur taille et par le nombre de broches de connexions, et donc de possibilités de raccordement avec le monde extérieur. Elles ont aussi différents processeurs, fréquences d’horloge et capacités de stockage. Pourtant, elles fonctionnent toutes selon le même principe et elles peuvent être adressées et programmées par l’intermédiaire du même environnement de développement. Selon le domaine d’application et des besoins du projet, une carte Arduino sera peut-être plus adaptée qu’une autre. L’un aura besoin d’une carte dotée de nombreuses broches d’E/S et choisira par exemple l’Arduino Mega ou la Due. L’autre préfèrera l’Arduino Micro ou Nano pour leur petite taille qui leur permet de se glisser dans un petit boîtier.

À mes yeux, la plus géniale est la carte Arduino Uno qui le restera encore pendant longtemps. Elle constitue une plateforme idéale pour débuter dans l’univers des microcontrôleurs. La majorité des tutoriels, projets et discussions que vous trouverez sur Internet tournent autour d’elle. Si vos projets deviennent plus ambitieux, vous pourrez passer facilement à un autre modèle, car leur prix reste raisonnable. Au fil du temps, vous vous constituerez une collection de cartes qui vous permettront d’accumuler de plus en plus d’expérience, ce qui, à mon avis, est une évolution normale. Vous trouverez plus d’informations sur les différentes cartes aux adresses suivantes :

8 Liens

•   Arduino Uno : 

                                                        

•   Arduino Mega :

                                                        

•   Arduino Leonardo :

                                                        

•   Arduino Micro :

                                                        

•   Arduino Nano :        

Il existe d’autres cartes Arduino dont vous trouverez des descriptions aux adresses suivantes :

8 Liens

•  

•  

Comme je l’ai déjà expliqué, Ardus, nous nous servirons surtout de l’Arduino Uno. C’est la plus adaptée pour faire ses premiers pas dans l’univers de l’électronique. Toutes les autres cartes se basent sur ce modèle et offrent des possibilités supplémentaires, telles qu’un plus grand nombre de broches d’entrées-sorties, un autre microcontrôleur ou d’autres fréquences d’horloge. Toutefois, cela ne pose aucune difficulté, car la programmation s’effectue par le biais de l’environnement de développement Arduino dans lequel la carte employée est sélectionnée. Tout ce que vous aurez appris à réaliser avec une platine Arduino Uno pourra être appliqué aux autres cartes Arduino.

La carte Arduino Uno

Examinons la carte Arduino Uno. Les principaux composants de la platine sont identifiés sur la figure 1-2.

t Figure 1-2 La carte Arduino Uno

Nous allons passer en revue les différents éléments de la carte Arduino Uno. Tout ne vous paraîtra peut-être pas encore très clair. Mais je vous promets que nous les examinerons en détail un peu plus loin.

Le microcontrôleur

Le microcontrôleur est le cœur de la carte Arduino. L’Arduino Uno que nous utiliserons pour les montages présentés dans ce livre est équipée d’un microcontrôleur Atmel AVR de type ATmega328. Sur la figure 1-2, c’est le gros composant noir muni de nombreuses broches. Le tableau 1-1 résume ses principales spécifications.

Catégorie

Valeur

Microcontrôleur

ATmega328

Tension de service

5 V

Tension d’entrée (recommandée)

7-12 V

Tension d’entrée (limites)

6-20 V

Ports numériques

14 entrées et sorties (6 sorties commutables en MLI – modulation de largeur d’impulsion)

Ports analogiques

6 entrées analogiques

Courant maxi. par broche d’E/S (c.c.)

40 mA

Courant maxi. par broche 3,3 V

50 mA

Mémoire

32 Ko (ATmega328), dont 0,5 Ko est utilisé par le chargeur d’amorçage

SRAM

2 Ko (ATmega328)

EEPROM

1 Ko (ATmega328)

Fréquence d’horloge

16 MHz

Tableau 1-1 u

Spécifications de la carte Arduino Uno

Vous trouverez de plus amples informations à l’adresse suivante :

sorties sont disponibles pour communiquer avec la carte Arduino. Elles constituent l’interface avec le monde extérieur et permettent d’échanger des données avec le microcontrôleur, comme l’indique le schéma ci-après.

t Figure 1-3

Entrées et sorties  de la carte Arduino

Sur le côté gauche, vous pouvez voir le microcontrôleur Arduino qui peut communiquer avec nous via certaines interfaces. Certains ports servent d’entrées et d’autres d’entrées et de sorties. Un port est ici un chemin d’accès défini au microcontrôleur, pratiquement une porte vers l’intérieur qu’il est possible d’actionner.

Vous apercevez également des réglettes de raccordement noires sur ses bords supérieur et inférieur.

Bien observé, Ardus ! Mais le schéma est tout à fait correct. La raison en est la suivante et fera l’objet d’une explication plus détaillée : notre carte Arduino n’est pas équipée de sorties analogiques séparées. Cela peut paraître bizarre au premier abord, mais certaines broches numériques sont détournées de leur destination première et servent de sorties analogiques.

Maintenant, vous devez vous demander comment tout cela fonctionne ! Voici donc un avant-goût de ce qui sera expliqué dans la section « Les entrées et sorties analogiques » (page 14) à propos de la modulation de largeur d’impulsion. Il s’agit d’un procédé dans lequel le signal présente des phases à niveau haut et des phases à niveau bas plus ou moins longues. Si la phase à niveau haut, dans laquelle le courant circule, est plus longue que celle à niveau bas, une lampe branchée par exemple sur la broche correspondante éclairera visiblement plus fort que si la phase à niveau bas était la plus longue. Plus d’énergie sera donc apportée en un temps donné sous forme de courant électrique. À cause de la persistance rétinienne de notre œil, nous ne pouvons différencier des événements changeant rapidement que sous certaines conditions, et un certain retard se produit aussi lorsque la lampe passe de l’état allumé à celui éteint, et réciproquement. Cela m’a tout l’air d’une tension de sortie qui se modifie, bizarre non ?

En tout cas, ce mode de gestion des ports présente d’emblée un inconvénient. Quand vous utilisez une ou plusieurs sorties analogiques, c’est au détriment de la disponibilité des ports numériques – il y en a alors d’autant moins à disposition – mais cela ne saurait nous gêner outre mesure, car nous n’atteignons pratiquement pas les limites de la carte. De ce fait, nous n’avons pas de restriction sur les montages expérimentaux à tester. logiciel qui a sa place dans une certaine zone de la mémoire flash du microcontrôleur et assure le chargement du programme proprement dit. La mémoire flash disponible est diminuée de la part attribuée au chargeur d’amorçage. Normalement, un microcontrôleur reçoit son programme de travail d’un matériel informatique supplémentaire, par exemple un programmateur ISP (In System Programming). Le chargeur d’amorçage évite cela, ce qui rend le téléchargement du logiciel vraiment facile. Sitôt dans la mémoire de travail du contrôleur, le programme de travail est exécuté. Si jamais vous deviez changer, pour une raison quelconque, votre microcontrôleur ATmega328 sur la carte, le nouveau circuit ne saurait pas ce qu’il doit faire, car le chargeur d’amorçage n’est pas chargé par défaut. Cette fonctionnalité peut être installée selon différentes procédures que je ne peux pas expliquer ici faute de place. Cependant, vous trouverez sur Internet suffisamment d’informations pour vous permettre d’installer le chargeur d’amorçage approprié au microcontrôleur.

L’alimentation électrique

Commençons par la tension d’alimentation, car sans elle, rien n’est possible. Il existe différentes possibilités. Quand nous travaillons avec Arduino ou que nous le programmons, il est indispensable d’établir une connexion USB avec l’ordinateur. Cette liaison assure deux fonctions :

•    transmettre l’indispensable tension d’alimentation de 5 V ;

•    offrir un canal de communication entre l’ordinateur et la carte Arduino.

Les deux fonctions sont remplies par le port USB argenté que vous pouvez voir sur la figure 1-4. Dans le chapitre suivant, nous examinerons la prise de plus près, ainsi que son type et la procédure d’installation du logiciel. Ce chemin d’accès à la carte est employé pour le développement et le test de programme. Une seconde prise se trouve juste à côté de la première : c’est la prise d’alimentation. Elle permet de déconnecter la carte de l’ordinateur une fois sa programmation effectuée. À quoi cela sert-il ? Imaginons que nous construisions un robot motorisé et que la carte Arduino doive réceptionner des commandes transmises par un émetteur radio et exécuter les actions correspondantes. Le câble USB limiterait considérablement le rayon d’action du véhicule. Nous avons simplement besoin d’une alimentation électrique pour la carte et éventuellement pour les moteurs, car la programmation est terminée. Comme le déclare la NASA au décollage des fusées : Guidance is internal (le guidage est interne). La carte Arduino est autonome ! La figure 1-4 présente une alimentation électrique externe à l’aide d’un bloc 9 V.

t Figure 1-4

La carte Arduino Uno avec une alimentation électrique externe

La tension d’alimentation doit être comprise entre 7 et 12 V CC (CC = courant continu). Vous trouverez de plus amples informations aux adresses suivantes :

8 Liens

•  

•  

Vous en savez maintenant un peu plus sur la tension d’alimentation. Toutefois, vous ne savez ni ce qu’est une tension ni comment elle est produite. Nous n’avons pas non plus abordé la question du courant et ce qu’il provoque.



3147