ARDUINO

JACK FELLERS
Cher lecteur, chère lectrice, pour te remercier de la confiance que tu m’as
témoignée en achetant mon livre, voici un cadeau pour toi, un guide pour
fortifier encore plus tes connaissances en programmation Web !
Scannez le code ou cliquez sur le lien pour l’échanger en moins d’une
minute :

Lien alternatif pour le code QR :

https://webhawk.tech/optin-it/

Bonne lecture !
 TABLE DES MATIÈRES

Avant-propos

1. Le langage Arduino
2. La philosophie d’Arduino
3. La plate-forme
4. Programmation
5. Notions de théorie
6. Lumière intelligente
7. Maestro de la musique !
8. Thermomètre numérique
9. Graphiques sur LCD
10. Pistolet élastique
11. Un projet plus important
12. Domotique et RFID
13. Domotique extrême
14. Dépannage

Conclusion
 AVANT-PROPOS

Depuis que je suis tout-petit, j’ai toujours été fasciné par la découverte du
fonctionnement des objets, et je les démontais fréquemment afin de mieux
les comprendre. Cette passion a grandi au fur et à mesure que je ciblais tout
objet inutilisé dans la maison et que je le démontais en petits morceaux.
Enfin, des amis et des parents ont commencé à m’apporter toutes sortes
d’appareils afin que je puisse les disséquer.
Mes plus gros projets à l’époque étaient un lave-vaisselle et l’ordinateur
d’un ami, qui avait une grande imprimante, des circuits imprimés, des
lecteurs de cartes magnétiques et de plusieurs autres pièces qui se sont
avérées intéressantes et complexes à démonter complètement. Après une
excellente partie de cette analyse, je savais ce qu’étaient les composants
électroniques et plus ou moins ce qu’ils faisaient.
De plus, ma maison était remplie de vieux magazines d’électronique, et
je passais des heures à lire les articles et à observer les schémas de circuits
sans tout comprendre. Toutefois, la lecture répétée des articles, avec le
bénéfice des connaissances acquises en démontant les circuits, a créé un
lent cercle vertueux.
Un grand pas en avant a été franchi lorsque mon père m’a donné un kit
qui aidaient les adolescents de s’initier à l’électronique. Chaque composant
était logé dans un cube en plastique qui s’emboîtait magnétiquement avec
d’autres cubes, établissant ainsi une connexion. En fait, le symbole
électronique était inscrit au sommet.
Avec ce nouvel outil, je pouvais assembler de façon très rapide des
circuits et les tester pour voir ce qui se passait, de sorte que le cycle de
prototypage était de plus en plus court. Après cela, j’ai construit des radios,
des amplificateurs, des circuits qui faisaient des bruits terribles et des sons
agréables, des capteurs de pluie et des robots minuscules.
J’ai longtemps cherché un mot anglais qui résumerait cette manière de
travailler sans plan précis, en partant d’une idée et en aboutissant à un
résultat totalement inattendu. Enfin, j’ai pensé au mot « bricolage » et la
meilleure définition que j’ai pu trouver est celle d’une exposition à
l’Exploratorium de San Francisco : le bricolage, c’est ce qui se passe quand
on essaie quelque chose que l’on ne sait pas faire, sous l’effet du caprice,
de l’imagination et de la curiosité.
En bricolant, il n’y a pas d’instructions, mais il n’y a pas non plus
d’échecs, pas d’excellentes ou de mauvaises manières de faire les choses, il
s’agit de comprendre la façon que les choses fonctionnent et de les
retravailler.
Plus tard, j’ai appris les bases des mathématiques binaires et de la
programmation. C’est là que j’ai compris que dans plusieurs applications,
les ingénieurs ne construisaient plus des circuits à partir de composants de
base, mais mettaient en œuvre une véritable intelligence dans leurs produits
à l’aide de microprocesseurs. Notez que le logiciel remplace plusieurs
heures de conception électronique et permet un cycle de prototypage plus
court.
J’ai alors commencé à économiser, car je voulais acheter un ordinateur
pour apprendre la programmation. Après l’avoir acheté, il est devenu
évident qu’écrire des lignes de code prendrait moins de temps que de
changer des circuits difficiles. Plusieurs années plus tard, j’aime à penser
que cette expérience me permet d’enseigner à des individus qui ne se
souviennent même pas d’avoir suivi des cours de mathématiques et de leur
insuffler le même enthousiasme et les mêmes talents de bricoleur que
j’avais dans ma jeunesse et que j’ai conservés depuis.
 1

LE LANGAGE ARDUINO

A rduino est une plateforme de traitement physique open source basée sur
une simple carte d’entrée/sortie (E/S) et un environnement de
développement qui met en œuvre le langage de traitement.
Arduino peut être employé afin de développer des objets interactifs
autonomes ou être connecté à un logiciel sur l’ordinateur (comme Flash,
Processing, VVV ou Max/MSP). Il est important de savoir que les cartes
peuvent être achetées en deux variantes  : assemblées à la main ou pré-
assemblées, et l’IDE (Integrated Development Environment) open source
peut être téléchargé gratuitement.
Arduino se différencie des autres plateformes du marché par les
caractéristiques suivantes :

Il s’agit d’un matériel et d’un logiciel open source : si vous le

voulez, vous pouvez télécharger le schéma du circuit, acheter
l’ensemble des composants et créer le vôtre, sans rien payer aux
fabricants de l’Arduino ;
Il s’agit d’un environnement multi-plateforme, qui peut alors
fonctionner sous Windows, Macintosh et Linux ;
Le projet Arduino a été développé dans un environnement
éducatif, il est alors idéal pour les débutants, notamment pour
une mise en route rapide ;
Le soutien d’une grande communauté d’utilisateurs actifs, de
sorte que de nombreux individus sont en mesure de vous aider ;
 Le matériel est bon marché, effectivement, la carte USB coûte
moins de 50 € (selon la version) et le remplacement d’une puce
brûlée sur la carte est facile et ne coûte pas plus de quelques
euros. De cette manière, vous pouvez vous aider à commettre
des erreurs ;
Vous le programmez via un câble USB, pas un port série. Cette
fonction est utile, car plusieurs ordinateurs modernes ne
disposent pas de ports série ;
Il est basé sur l’IDE de programmation Processing, un
environnement de développement simple à utiliser, aussi utilisé
par les artistes et les designers.

Ce livre électronique est conçu précisément afin d’aider les débutants à

comprendre les avantages qu’ils peuvent tirer de l’apprentissage de la
plateforme Arduino et de l’adoption de sa philosophie. Ce livre électronique
est écrit pour les utilisateurs « originaux » d’Arduino  : les designers et les
artistes. Par conséquent, je vais tenter d’expliquer les choses d’une façon
qui pourrait rendre quelques ingénieurs fous.
Observons les choses en face : la majorité des ingénieurs ne peuvent pas
expliquer ce qu’ils font à un autre ingénieur, et encore moins à un être
humain normal. Quand l’Arduino a débuté à devenir populaire, j’ai réalisé
que les expérimentateurs, les amateurs et les hackers de toutes sortes
commençaient à l’utiliser afin de créer des choses belles, intéressantes et
folles.
Arduino a été créé afin d’enseigner le design d’interaction, une
discipline de conception qui place le prototypage au centre de sa
méthodologie. Il existe plusieurs définitions du design d’interaction, mais
celle que je préfère est celle décrite ci-dessous :

Le design d’interaction est la conception de toute expérience interactive.

Dans le monde d’aujourd’hui, le design d’interaction consiste à créer

des expériences significatives entre les humains et les objets. C’est une
excellente façon d’explorer la création d’expériences magnifiques, et
probablement même controversées, entre nous et la technologie. Le design
d’interaction encourage la conception par un processus itératif basé sur des
prototypes de fidélité croissante. Cette approche, qui fait aussi partie de
certains types de conception « conventionnelle », peut être étendue afin
d’inclure le prototypage avec la technologie, en particulier le prototypage
avec l’électronique.
De plus, le domaine spécifique du design d’interaction impliqué dans
Arduino est l’informatique physique (ou design d’interaction physique).

Qu’est-ce que l’informatique physique ?

L’informatique physique, connue sous le nom de « physical computing »,
emploie l’électronique afin de prototyper de nouveaux matériaux pour les
designers et les artistes. Elle implique la conception d’objets interactifs,
capables de communiquer avec les humains, à l’aide de capteurs et
d’actionneurs contrôlés par un comportement mis en œuvre sous forme de
logiciel fonctionnant à l’intérieur d’un microcontrôleur, un petit ordinateur
sur une seule puce.
Dans le passé, notez que l’utilisation de l’électronique impliquait de
traiter en permanence avec des ingénieurs et de construire des circuits avec
de petits composants à la fois ; ces soucis limitaient quelque peu la
créativité de quelques concepteurs. La majorité des outils étaient destinés
aux ingénieurs et nécessitaient des connaissances approfondies.
Ces dernières années, les microcontrôleurs sont devenus moins chers et
plus simples à utiliser, aidant à la création de meilleurs outils. Le progrès
réalisé avec Arduino a pour but de rapprocher ces outils du débutant,
permettant aux gens de débuter à construire quelque chose après seulement
deux ou trois jours.
Grâce à Arduino, un designer ou un artiste peut apprendre les bases de
l’électronique et des capteurs vraiment rapides et peut commencer à
construire des prototypes avec très peu d’investissement.
L’informatique physique est une approche de l’apprentissage de la
communication humaine par le biais des ordinateurs qui débute par l’étude
de la façon dont les humains s’expriment physiquement. Plusieurs
instructions initiales de conception d’interfaces informatiques considèrent le
matériel informatique comme acquis, c’est-à-dire qu’il y a un clavier, un
écran, probablement des haut-parleurs et une souris - et se concentrent sur
l’enseignement du logiciel requis afin de concevoir dans ces limites. Dans
ce cas, nous prenons le corps humain comme une donnée et tentons de
concevoir dans les limites de son expression.
Cela veut dire que nous devons apprendre comment un ordinateur
convertit les variations de l’énergie émise par notre corps, sous forme de
chaleur, de lumière, de son, et ainsi de suite, en signaux électroniques
mutables qu’il peut lire et interpréter. Nous découvrons les capteurs qui font
cela, ainsi que des ordinateurs vraiment faciles, nommés microcontrôleurs,
qui lisent les capteurs et convertissent leur sortie en données. Finalement,
nous apprenons comment les microcontrôleurs communiquent avec d’autres
ordinateurs.
L’informatique physique possède une approche pratique, ce qui
implique de passer beaucoup de temps à construire des circuits, à souder, à
écrire des programmes, à construire des structures afin d’accueillir des
capteurs et des contrôleurs, ainsi qu’à comprendre la façon de relier
l’ensemble des éléments à l’expression d’une personne.
Quand vous construisez des robots, vous vous concentrez en général sur
la création d’un objet autonome, capable d’ignorer les gens et de naviguer
dans le monde par ses propres méthodes. Cela demande beaucoup de travail
et les applications de traitement physique ont tendance à s’appuyer
davantage sur les personnes pour les entrées et à amplifier ces entrées sous
une autre forme, comme l’animation, le son ou le mouvement. La robotique
tend à dupliquer ce que les humains sont en mesure de faire, en remplaçant
le cerveau humain par un cerveau informatique ; l’informatique physique
tend à étendre ce qu’ils peuvent faire, en laissant le cerveau et le corps
humains au centre de tout. À partir de là, nous pourrions entamer une
discussion intéressante sur l’intelligence artificielle et ses liens avec
l’informatique physique, mais le sujet est si large qu’il dépasse le cadre de
cet ouvrage.
 2

LA PHILOSOPHIE D’ARDUINO

L asurphilosophie d’Arduino est basée sur la création de projets plutôt que

le fait d’en parler. En effet, il s’agit d’une recherche constante du
moyen le plus rapide et le plus puissant afin de construire de meilleurs
prototypes. Il existe plusieurs techniques de prototypage et des manières
développées de penser avec nos mains.
L’ingénierie classique repose sur un processus rigoureux pour aller de A
à B ; Arduino se réjouit de la possibilité de se perdre en chemin et de
trouver C à la place. C’est le processus de « bricolage » que nous aimons
tant  : jouer avec le support de façon ouverte et trouver l’inattendu. Dans
cette recherche de moyens pour construire de meilleurs prototypes, nous
avons aussi sélectionné un certain nombre de progiciels qui aident au
processus de manipulation constante du support logiciel et matériel.
Nous présenterons sous peu certaines des philosophies, événements et
pionniers qui ont inspiré l’Arduino. Le concept de prototypage est
cependant au cœur d’Arduino : nous créons des choses et construisons des
objets qui interagissent avec d’autres objets, personnes et réseaux. Nous
nous efforçons de trouver la méthode la plus facile et la plus rapide de
réaliser des prototypes à un coût aussi bas que possible.
Plusieurs débutants qui abordent l’électronique pour la première fois
pensent qu’ils doivent apprendre à tout construire à partir de zéro. C’est un
gaspillage d’énergie. En effet, ce que vous souhaitez, c’est être capable de
confirmer que quelque chose fonctionne vraiment rapidement afin de vous
motiver à passer à la prochaine étape ou probablement même de motiver
quelqu’un d’autre à vous financer.
 C’est la raison pour laquelle le « prototypage opportuniste » a été
conçu  : pourquoi dépenser du temps et de l’énergie afin de construire à
partir de zéro, un processus qui demande du temps et des connaissances
techniques approfondies, tandis que nous pouvons utiliser des dispositifs
prêts à l’emploi pour tirer parti du travail acharné des grandes entreprises et
des excellents ingénieurs ?
L’idée d’Arduino remonte à James Dyson, qui a fabriqué 5127
prototypes de son aspirateur avant d’être convaincu d’avoir trouvé
l’excellente solution. Il est important de jouer avec la technologie, en
explorant diverses possibilités directement sur le matériel et les logiciels,
quelquefois sans objectif clairement défini. La réutilisation des technologies
existantes est l’une des meilleures manières de bricoler.
Se procurer des jouets bon marché ou de vieux équipements mis au
rebut et les changer pour leur faire faire quelque chose de nouveau est l’une
des meilleures méthodes d’obtenir d’excellents résultats.
J’ai toujours été fasciné par la modularité et la possibilité de construire
des systèmes complexes en reliant entre eux des dispositifs faciles. Ce
processus est vraiment bien représenté par Robert Moog et ses synthétiseurs
analogiques. Les musiciens construisaient des sons en essayant des
combinaisons infinies en « joignant » divers modules à l’aide de câbles.
Cette approche a fait ressembler le synthétiseur à un vieux commutateur
téléphonique, mais combiné aux nombreux boutons, c’était la plateforme
parfaite afin de bricoler le son et la musique innovante. Moog l’a décrit
comme un processus entre « témoignage et découverte ». Je suis certain
qu’au début, la majorité des musiciens ne savaient pas ce que faisaient ces
centaines de boutons, mais ils ont essayé et essayé, perfectionnant leur style
sans interrompre le flux.
De plus, réduire le nombre d’interruptions dans le flux est vraiment
essentiel pour la créativité  : plus le processus est fluide, plus il y a de
bricolage. Cette technique a été transposée dans le monde des logiciels par
des environnements de « programmation visuelle » tels que Max, Pure Data
ou VVV. Ces outils peuvent être visualisés comme des « boîtes » pour les
diverses fonctionnalités qu’ils proposent, ce qui aide l’utilisateur de créer
des « patchs » en reliant ces boîtes entre elles.
Ces environnements aident l’utilisateur d’expérimenter la
programmation sans les interruptions constantes typiques du cycle : « écrire
un programme, compiler, il y a une erreur, corriger l’erreur, compiler,
exécuter ». Si vous avez une mentalité plus visuelle, je vous conseille de les
essayer.
Le circuit bending est l’une des formes les plus intéressantes de
bricolage. Ce terme fait référence à la pratique consistant à changer de
façon créative des appareils à basse tension ou des instruments
électroniques alimentés par des piles au moyen de simples courts-circuits.
L’objectif est d’en extrapoler des sons inédits et de créer de nouveaux
instruments de musique et des générateurs de sons bizarres. Au cœur de ce
processus se trouve « l’art du hasard ». Tout a débuté en 1966 lorsque Reed
Ghazala a accidentellement court-circuité un amplificateur jouet contre un
objet métallique dans le tiroir de son bureau, produisant un flux de sons
inhabituels.
Ce que j’aime chez les bidouilleurs de circuits, c’est leur capacité à
créer les dispositifs les plus fous en bricolant la technologie sans
nécessairement comprendre ce qu’ils font sur le plan théorique. Ne laissez
pas les experts d’un domaine vous mentionner que vous ne serez jamais
l’un d’entre eux ; ignorez-les et surprenez-les.

Interaction avec un PC
Après plus de 60 ans, les claviers d’ordinateurs restent la principale
méthode d’interagir avec un ordinateur. Alex Pentland, universitaire en chef
du MIT Media Laboratory, a fait remarquer un jour  : « Excusez
l’expression, mais les urinoirs humains sont plus intelligents que les
ordinateurs. Les ordinateurs sont isolés de leur environnement ».
Nous pouvons mettre en œuvre de nouveaux modes d’interaction avec
les logiciels en remplaçant les claviers par des dispositifs capables de
détecter l’environnement. Le démontage d’un clavier d’ordinateur révèle un
dispositif vraiment facile (et bon marché). Le noyau est une petite carte, en
général un circuit vert ou brun avec deux jeux de contacts qui vont à deux
couches de plastique qui maintiennent les connexions entre les diverses
touches. Si vous retirez le circuit et utilisez un câble afin de connecter deux
contacts, vous observerez une lettre apparaître sur l’écran de l’ordinateur.
En fait, il y a un autre souci qui est au cœur de la philosophie de
l’Arduino. De nos jours, les gens jettent de nombreux d’appareils
technologiques  : vieilles imprimantes, ordinateurs, machines de bureau
complexes, équipements techniques et même matériel militaire.
 Il y a toujours eu un grand marché pour cette technologie excédentaire,
notamment chez les jeunes et/ou les collectionneurs. Il accumule
fréquemment des déchets et vous devez les passer en revue avant de débuter
à construire quelque chose à partir de zéro.
Pensez au nombre de jouets qui sont jetés chaque année. Avec l’afflux
actuel de milliers de jouets high-tech vraiment bon marché en provenance
de Chine, vous pouvez élaborer des idées vraiment rapidement. Tout cela
vous fait prendre conscience que la technologie n’est ni effrayante ni
complexe à utiliser.
Le dernier principe qui sous-tend la philosophie Arduino est la
collaboration entre les utilisateurs. C’est l’un des principes clés de l’univers
Arduino  : grâce aux forums, des individus de diverses régions du monde
s’entraident afin d’apprendre à connaître la plateforme. L’équipe Arduino
encourage aussi les gens à collaborer localement en les aidant à créer des
groupes d’utilisateurs dans chaque ville qu’ils visitent.
Un wiki nommé « Playground » a aussi été créé, où les utilisateurs
documentent leurs découvertes. C’est formidable de voir la quantité de
connaissances que ces personnes déversent sur le Web pour que tout le
monde puisse en profiter. Cette culture du partage et de l’entraide est l’une
des plus belles choses du Web, selon moi.
 3

LA PLATE-FORME

L ’Arduino se compose de deux parties principales : la carte Arduino, qui

est le matériel sur lequel vous travaillez quand vous construisez vos
objets, et l’IDE Arduino, qui est le logiciel que vous exécutez sur votre
ordinateur. Vous utilisez l’IDE afin de créer un sketch (un petit programme
informatique) que vous téléchargez sur la carte Arduino. L’esquisse affiche
au conseil ce qu’il doit faire.
Il n’y a pas si longtemps, travailler sur du matériel informatique
signifiait construire des circuits à partir de rien, en employant des centaines
de composants divers portant des noms bizarres comme résistance,
condensateur, inductance, transistor et ainsi de suite. Chaque circuit était « 
câblé » afin de réaliser une application spécifique et les changements
nécessitaient des opérations comme la coupe des fils, le soudage des
connexions et ainsi de suite.
De plus, avec l’émergence des technologies numériques et des
microprocesseurs, ces fonctions, autrefois réalisées à l’aide de câbles, ont
été remplacées par des programmes logiciels, car les logiciels sont plus
simples à changer que le matériel. En appuyant sur quelques boutons, vous
pouvez changer radicalement la logique d’un appareil et essayer deux ou
trois versions dans le même laps de temps qu’il faudrait afin de souder
quelques résistances.

Matériel informatique
La carte Arduino est une petite carte à microcontrôleur, cela signifie qu’un
petit circuit (la carte) qui détient un ordinateur entier sur une petite puce (le
microcontrôleur). Cet ordinateur est au moins mille fois moins puissant que
le MacBook que j’utilise afin d’écrire ces lignes, mais il est beaucoup
moins cher et vraiment utile afin de construire des appareils intéressants.
Regardez la carte Arduino : vous observerez une puce noire avec 28 « 
jambes »  : cette puce est l’ATmega328, le cœur de votre carte. L’équipe
Arduino a placé sur cette carte tous les composants nécessaires au bon
fonctionnement de ce microcontrôleur et à sa communication avec votre
ordinateur.
De plus, il existe de nombreuses versions de cette carte ; celle que nous
utiliserons dans ce livre électronique est l’Arduino Uno, qui est la plus
simple à utiliser et la meilleure à apprendre, toutefois, ces instructions
s’appliquent aux versions antérieures de la carte. En observant la carte, tous
ces connecteurs peuvent être un peu déroutants. Voici ci-dessous une
explication de ce que fait chaque élément du tableau :

14 broches d’E/S numériques (broches 0-13) : elles peuvent être

des entrées ou des sorties, spécifiées par le sketch créé dans
l’IDE ;
6 broches de sortie analogique (broches 3, 5, 6, 9, 10 et 11) : Ce
sont en fait six des broches numériques qui peuvent être
reprogrammées pour une sortie analogique en employant le
sketch créé dans l’IDE ;
6 Broches d’entrée analogique (broches 0-5) : Ces broches
d’entrée analogique dédiées prennent des valeurs analogiques
(cela signifie que des lectures de tension d’un capteur) et les
convertissent en un nombre compris entre 0 et 1023.

La carte peut être alimentée par le port USB de l’ordinateur, la majorité

des chargeurs USB ou un adaptateur secteur (conseillé 9 volts, pointe
cylindrique 2,1 mm, centre positif). Si aucune alimentation n’est connectée
à la prise, l’alimentation proviendra de la carte USB, mais dès qu’une
alimentation est connectée, la carte l’utilisera automatiquement.
Logiciel IDE
L’IDE, qui veut dire Integrated Development Environment (environnement
de développement intégré), est un programme spécial fonctionnant sur votre
ordinateur qui vous aide à écrire des croquis pour la carte Arduino dans un
langage facile calqué sur le langage Processing. La magie opère quand vous
appuyez sur le bouton qui charge le sketch sur la carte : le code que vous
écrivez est traduit en langage C (qui est en général assez complexe à utiliser
pour un débutant), puis transmis au compilateur avr-gcc, un logiciel
essentiel open source qui effectue la traduction finale dans le langage
compris par le microcontrôleur.
De plus, cette dernière étape est assez fondamentale, car c’est là
qu’Arduino facilite la vie en masquant autant que possible les difficultés de
la programmation des microcontrôleurs. Le cycle de programmation de
l’Arduino est essentiellement le suivant :

1. Connectez la carte à un port USB de l’ordinateur ;

2. Rédigez un croquis qui donnera vie au tableau ;
3. Chargez ce sketch sur la carte par la connexion USB et attendez
quelques secondes afin que la carte redémarre ;
4. La carte exécute le sketch que vous avez écrit.

Afin de programmer la carte Arduino, vous devez d’abord télécharger

l’environnement de développement (l’IDE). Sélectionnez la bonne version
pour votre système d’exploitation : téléchargez le fichier et double-cliquez
dessus pour l’ouvrir ; sous Windows ou Linux, cela crée un dossier appelé
arduino- [version], par exemple arduino-1.0. Faites glisser le dossier où
vous souhaitez  : sur le bureau, dans le dossier Program Files (sous
Windows), et ainsi de suite.
Sur le Mac, en double-cliquant dessus, vous ouvrirez une image disque
avec une application Arduino (faites-la glisser dans le dossier
Applications). Maintenant, toutes les fois que vous souhaitez exécuter l’IDE
Arduino, vous ouvrirez le dossier arduino (Windows et Linux) ou
Applications (Mac) et vous double-cliquerez sur l’icône Arduino. Avant de
continuer, toutefois, il y a encore une étape à franchir : vous devez installer
les pilotes qui aident votre ordinateur à communiquer avec votre carte par le
port USB.

Installation du pilote Mac

L’Arduino Uno sur un Mac utilise les pilotes fournis par le système
d’exploitation, la procédure est alors assez facile. Connectez la carte à
l’ordinateur, le voyant PWR de la carte doit s’allumer et la LED jaune
marquée 'L’ doit débuter à clignoter.
Vous observerez probablement une fenêtre contextuelle vous informant
qu’une nouvelle interface réseau a été détectée. Si c’est le cas, cliquez sur « 
Préférences réseau ... » et quand il apparaît, cliquez sur « Appliquer ».
L’Arduino Uno apparaîtra comme « Non configuré », mais il fonctionne
correctement. Quittez les préférences système.
Finalement, vous devez choisir le bon port pour votre carte. Dans le
menu « Tools » de l’IDE Arduino, sélectionnez « Serial Port » et choisissez
le port débutant par /dev/cu.usbmodem ; c’est le nom que votre ordinateur
utilise pour se référer à la carte Arduino.

Installation du pilote Windows

Connectez la carte Arduino à l’ordinateur ; quand la fenêtre "Assistant
nouveau matériel" apparaît, Windows va d’abord tenter de trouver le pilote
sur le site Windows Update.
Sur le prochain écran, sélectionnez « Installer à partir d’une liste ou
d’un emplacement spécifique » et cliquez sur « Suivant ». Localisez et
sélectionnez le fichier pilote de l’Uno, appelé ArduinoUNO.inf, situé dans
le dossier Drivers du téléchargement du logiciel Arduino (pas le sous-
répertoire « FTDI USB Drivers »).
De plus, Windows finira d’installer le pilote à partir de là. Une fois les
pilotes installés, vous pouvez lancer l’IDE Arduino et débuter à utiliser
Arduino.
Par la suite, vous devez déterminer quel port série est attribué à votre
carte Arduino  : notez que vous aurez besoin de cette information pour la
programmer plus tard. Sous Windows, le processus est un peu plus difficile,
du moins au début. Ouvrez le « Gestionnaire de périphériques » en cliquant
sur le menu « Démarrer », en faisant un clic droit sur Poste de travail et en
sélectionnant Propriétés. Recherchez le périphérique Arduino dans la liste
sous « Ports (COM et LPT) », Arduino apparaîtra comme "Arduino UNO"
et aura un nom comme COM3. Une fois que vous avez compris
l’affectation du port COM, vous pouvez choisir ce port dans le menu
« Tools » > "Serial Port" dans l’IDE Arduino. Désormais, l’environnement
de développement Arduino peut parler à la carte Arduino et la programmer.
Remarque : Sur quelques machines Windows, le port COM a un numéro
supérieur à 9 ; cette numérotation crée certains soucis quand l’Arduino tente
de communiquer avec lui.
 4

PROGRAMMATION

V ous allez maintenant apprendre à créer et à programmer un dispositif

interactif. L’ensemble des objets que nous allons construire à l’aide
d’Arduino suivent un schéma vraiment facile que nous nommons « 
Dispositif interactif ». Le dispositif interactif est un circuit électronique qui
peut détecter l’environnement à l’aide de capteurs (composants
électroniques qui convertissent les mesures du monde réel en signaux
électriques).
De plus, l’appareil traite les informations qu’il obtient des capteurs avec
un comportement implémenté sous forme de logiciel. L’appareil est alors en
mesure d’interagir avec le monde via des actionneurs, cela veut dire que des
composants électroniques capables de convertir un signal électrique en une
action physique. Les capteurs et les actionneurs sont des composants
électroniques qui aident à un composant électronique d’interagir avec le
monde.
Le microcontrôleur étant un ordinateur vraiment facile, il ne peut traiter
que des signaux électriques (un peu comme les impulsions électriques qui
sont envoyées entre les neurones de notre cerveau). Afin qu’il puisse
percevoir la lumière, la température ou d’autres quantités physiques, il a
besoin de quelque chose qui puisse les convertir en électricité. Dans notre
corps, par exemple, l’œil convertit la lumière en signaux qui sont envoyés
au cerveau par les nerfs. En électronique, nous sommes en mesure d’utiliser
un dispositif facile nommé résistance dépendant de la lumière (une LDR ou
photorésistance) qui est capable de mesurer la quantité de lumière qui la
frappe et la transmettre sous forme de signal compréhensible par le
microcontrôleur.
De plus, une fois que les capteurs ont été lus, l’appareil dispose des
informations nécessaires afin de décider la façon de réagir. Le processus de
décision est géré par le microcontrôleur et la réaction est effectuée par les
actionneurs. Dans notre corps, par exemple, les muscles reçoivent des
signaux électriques du cerveau et les convertissent en un mouvement. Dans
le monde électronique, ces fonctions seraient en mesure d’être assurées par
une lampe ou un moteur électrique. Vous apprendrez sous peu à lire des
capteurs de divers types et à commander divers types d’actionneurs.

LED clignotante
Le sketch pour la LED clignotante est le premier programme que vous
devez exécuter afin de vérifier si votre carte Arduino fonctionne et est
configurée correctement.
C’est aussi en général le premier exercice de programmation que nous
effectuons quand nous apprenons à programmer un microcontrôleur. Une
diode électroluminescente (DEL) est un petit composant électronique qui
ressemble un peu à une ampoule électrique, mais qui est plus efficace et
nécessite des tensions plus faibles afin de fonctionner. Notez que votre carte
Arduino est livrée avec une LED préinstallée, marquée ‘L’. Vous pouvez
aussi ajouter votre propre LED en connectant K qui indique la cathode
(négatif) ou le fil le plus court et A qui affiche l’anode (positif) ou le fil le
plus long.
De plus, une fois que la LED est connectée, vous devez dire à l’Arduino
ce qu’il doit faire. Cela se fait par code, cela signifie que par une liste
d’instructions que nous offrons au microcontrôleur pour qu’il fasse ce que
nous souhaitons qu’il fasse. Sur votre ordinateur, ouvrez le dossier dans
lequel vous avez copié l’IDE Arduino. Double-cliquez sur l’icône Arduino
afin de le démarrer. Sélectionnez « Fichier » > « Nouveau » et il vous sera
demandé de sélectionner un nom pour le dossier du sketch  : c’est là que
votre sketch Arduino sera stocké.
Nommez-le Blink_LED et cliquez sur OK. Par la suite, tapez le texte
suivant dans l’éditeur de croquis Arduino (la fenêtre principale de l’IDE
Arduino) :
// LED connectée à la broche 13
 const int LED = 13 ;
void setup()
{
// définir la broche numérique comme sortie
pinMode(LED, OUTPUT) ;
}
void loop()
{
// allume la LED
digitalWrite(LED, HIGH) ;
delay(1000) ; // attendre une seconde
// éteint la LED
digitalWrite(LED, LOW) ;
delay(1000) ; // attendre une seconde
}

Maintenant que le code est dans votre IDE, vous devez vérifier qu’il est
correct. Appuyez sur le bouton « Verify » ; si tout est correct, vous
observerez le message « Compilation Complete » apparaître en bas de l’IDE
Arduino. Ce message veut dire que l’IDE Arduino a traduit votre croquis en
un programme exécutable qui peut être exécuté à partir de la carte, un peu
comme un fichier .exe sous Windows ou un fichier .app sur un Mac.
À cette étape, vous pouvez le charger dans la carte : appuyez sur le
bouton Load de la carte I/O. Cela va réinitialiser la carte, la forçant à arrêter
ce qu’elle fait et à écouter les instructions du port USB. L’IDE Arduino
envoie le sketch actuel à la carte, qui le stockera dans sa mémoire et
l’exécutera éventuellement.
Vous observerez certains messages apparaître dans la zone noire au bas
de la fenêtre, et juste au-dessus de cette zone, vous observerez apparaître le
message « Loading Complete » afin de vous informer que le processus s’est
déroulé avec succès. Il y a deux DEL, marquées RX et TX, sur la carte ;
elles clignotent chaque fois qu’un octet est envoyé ou reçu de la carte. Lors
du processus de téléchargement, elles continuent de clignoter ; si vous
n’observez pas les DEL clignoter ou si vous recevez un message d’erreur au
lieu de « Upload complete », il y a un souci de communication entre votre
ordinateur et l’Arduino.
 Vérifiez que vous avez choisi le bon port série dans le menu Outils >
Port série. Vérifiez aussi dans le menu Outils > Carte que le bon modèle
d’Arduino a été choisi.
Il est important de savoir qu’une fois que le code est sur votre carte
Arduino, il y restera jusqu’à ce que vous y chargiez un autre sketch. Le
sketch survivra si la carte est réinitialisée ou éteinte, un peu comme les
données du disque dur de votre ordinateur. En assumant que le sketch a été
chargé correctement, vous observerez la DEL « L’ s’allumer durant une
seconde, puis s’éteindre lors d’une seconde. Si vous avez installé une LED
séparée, cette LED clignotera aussi.
Il est important de savoir que ce que vous venez d’écrire et d’exécuter
est un « programme informatique », ou une esquisse, comme nous appelons
les programmes Arduino. L’Arduino, comme mentionné précédemment, est
un petit ordinateur et peut être programmé pour faire ce que vous voulez.
Afin de ce faire, vous utilisez un langage de programmation afin de saisir
un ensemble d’instructions dans l’IDE Arduino, qui le transforme en un
exécutable pour votre carte Arduino.

Analyse du code
Cependant comment fonctionne un sketch ? En premier lieu, l’Arduino
exécute le code de haut en bas, de sorte que la ligne du haut est la première
lue ; par la suite, il se déplace vers le bas, un peu comme la tête de lecture
d’un lecteur vidéo comme QuickTime Player ou Windows Media Player se
déplace de gauche à droite afin de démontrer où vous vous trouvez dans le
film.
Remarquez la présence des crochets, qui sont employés afin de
regrouper les lignes de code. Ils sont particulièrement utiles quand vous
voulez donner un nom à un groupe d’instructions. Si vous êtes à table et que
vous posez à quelqu’un cette question suivante : « Passez-moi le parmesan,
s’il vous plaît », cela déclenche une série d’actions qui sont résumées par la
petite phrase que vous venez de prononcer. Effectivement, comme nous
sommes des êtres humains, tout vient naturellement, mais toutes les petites
actions individuelles requises pour y parvenir doivent être expliquées à
Arduino, car il n’est pas aussi puissant que notre cerveau. Alors, afin de
regrouper une série d’instructions, insérez un {avant le code et un} après
celui-ci.
 Vous pouvez constater qu’il y a deux blocs de code qui sont définis de
cette manière ici. Devant chacun d’eux se situe une commande bizarre :
void setup (). Cette ligne donne un nom à un bloc de code ; si vous deviez
écrire une liste d’instructions qui apprennent à l’Arduino comment passer le
parmesan, vous devriez écrire void passParmigiano () au début d’un bloc, et
ce bloc deviendrait une instruction que vous pourriez appeler de n’importe
où dans le code de l’Arduino.
De plus, ces blocs sont nommés fonctions. Si après avoir défini cette
fonction, vous écrivez passParmigiano () n’importe où dans votre code,
l’Arduino exécutera ces instructions et continuera là où il s’est arrêté.
Il est important de savoir qu’Arduino s’attend à ce qu’il y ait deux
fonctions : une nommée setup () et une nommée loop (). La fonction setup
() est l’endroit où vous mettez tout le code que vous souhaitez exécuter une
fois au début de votre programme, et loop () possède le cœur de votre
programme, qui est exécuté encore et encore.
Effectivement, l’Arduino n’est pas un ordinateur comme les autres : il
ne peut pas exécuter plusieurs programmes en même temps et les
programmes ne peuvent pas se fermer. Quand vous allumez la carte, le code
s’exécute ; quand vous souhaitez arrêter, vous l’éteignez.
Vous avez probablement remarqué des symboles bizarres comme // dans
le code. Tout texte qui débute par // est ignoré par Arduino. Ces lignes sont
des commentaires, ce sont des notes que vous laissez dans le programme
pour vous-même, pour que vous puissiez vous souvenir de ce que vous avez
fait quand vous l’avez écrit, ou pour quelqu’un d’autre, pour qu’il puisse
comprendre votre code.
Il est vraiment fréquent d’écrire un morceau de code, de le télécharger
sur le tableau et de se dire « OK, je n’aurai plus jamais à toucher à ce code
! » afin de se rendre compte quelques mois plus tard qu’il faut mettre à jour
le code ou corriger un bogue. À cette étape, vous ouvrez le programme et si
vous n’avez pas inclus de commentaires dans le programme original, vous
vous dites : « Wow, quel gâchis ! Où est-ce que je débute ? » Au fur et à
mesure, vous observerez certaines astuces afin de rendre vos programmes
plus lisibles et plus faciles à maintenir. Au début, vous pourriez considérer
ce genre d’explication comme inutile, un peu comme quand j’étais à l’école
et que je devais étudier la Divine Comédie de Dante. Pour chaque ligne des
poèmes, il y avait une centaine de lignes de commentaires ! Cependant,
l’explication sera beaucoup plus utile ici, quand vous passerez à l’écriture
de vos propres programmes.
Examinons le code ligne par ligne :
const int veut dire que la LED est un entier non modifiable (ce qui veut
dire une constante) dont la valeur est fixée à 13. En fait, c’est comme un
code de recherche et de remplacement automatique ; dans ce cas, il
démontre à l’Arduino d’écrire le nombre 13 toutes les fois que le mot LED
apparaît. Nous employons cette commande afin de spécifier que la LED que
nous souhaitons faire clignoter est connectée à la broche 13 de l’Arduino.
void setup() présente à l’Arduino que le prochain bloc de code sera
nommé setup() et le crochet ouvert affiche l’ouverture du bloc. Ce bloc ne
détient qu’une seule instruction, mais est vraiment intéressant. pinMode
affiche à l’Arduino la façon de configurer une broche particulière. Les
broches numériques peuvent être employées comme INPUT ou OUTPUT.
Dans ce cas, nous avons besoin d’une broche de sortie afin de contrôler
notre LED, nous entrons alors le numéro de la broche et son mode entre
parenthèses. pinMode est une fonction et les mots (ou nombres) spécifiés
entre parenthèses sont des arguments.
Il est important de noter qu’INPUT et OUTPUT sont des constantes
dans le langage Arduino (comme les variables, les constantes se voient
attribuer des valeurs, mais les valeurs constantes sont prédéfinies et ne
changent jamais). Après cette instruction, nous voyons une accolade fermée
qui affiche la fermeture du bloc.
Par la suite, nous trouvons la définition de la fonction loop(), qui
correspond à l’endroit où vous spécifiez le comportement principal de votre
dispositif interactif. En fait, cette méthode sera répétée à l’infini jusqu’à ce
que vous éteigniez le tableau.
De plus, comme spécifié dans le commentaire, digitalWrite() est en
mesure d’allumer (ou d’éteindre) toute broche qui a été configurée comme
OUTPUT. Le premier argument (dans ce cas, LED) illustre quelle broche
doit être activée ou désactivée (souvenez-vous que LED est une valeur
constante se référant à la broche 13, c’est alors cette broche qui est activée).
Le deuxième argument peut activer (HIGH) ou désactiver (LOW) la broche.
Imaginez que chaque broche de sortie est une minuscule prise, comme
celles que vous possédez sur les murs de votre appartement. Les
européennes sont en 230V, les américaines en 110V, et l’Arduino fonctionne
à une tension plus modeste de 5V. La magie ici, c’est quand le logiciel
devient matériel ; effectivement, lorsque vous écrivez digitalWrite(LED,
HIGH), l’Arduino met la broche de sortie à 5V et si vous branchez une
LED, elle s’allume.
Alors, à ce stade du code, une instruction du logiciel provoque un
événement dans le monde physique en contrôlant le flux d’électricité vers la
broche. En allumant et en éteignant la broche à volonté, nous traduisons
maintenant cela en quelque chose de plus visible pour un être humain ; la
LED est notre actionneur.
Arduino a une structure très simple. Par conséquent, si vous souhaitez
que les choses se produisent avec une certaine régularité, dites-lui de ne rien
faire jusqu’à ce qu’il soit temps de passer à la prochaine étape. La fonction
delay() met le processeur en pause et ne fait rien durant le nombre de
millisecondes que vous passez en argument. Les millisecondes sont des
millièmes de seconde ; par conséquent, 1000 millisecondes sont égales à 1
seconde, et la LED reste alors allumée pendant une seconde.
La prochaine instruction donne la chance d’éteindre la LED que nous
avons précédemment allumée. Pourquoi employons-nous les termes HIGH
et LOW ? Il s’agit d’une vieille convention en électronique numérique.
HIGH qui veut dire que la broche est activée et, dans le cas de l’Arduino,
sera réglée sur 5 V, LOW signifie 0 V. Vous êtes aussi en mesure de
remplacer mentalement ces termes par ON et OFF.
Finalement, nous faisons attendre le processeur une seconde de plus,
ensuite la LED s’éteint durant une seconde et les crochets fermés illustrent
la fermeture du verrou sur cette fonction.
Afin de résumer, ce programme fait ceci :

Transforme la broche 13 en une sortie (seulement une fois au

début) ;
Il entre dans un cycle ;
Allume la LED connectée à la broche 13 ;
Il attend une seconde ;
Éteint la LED connectée à la broche 13 ;
Attends une seconde ;
Retour au début du cycle.

J’espère que ce n’était pas trop complexe à saisir. Les prochains

exemples vous donneront la chance d’en apprendre plus sur la
programmation. Avant de passer à la prochaine suivante, je veux que vous
jouiez avec le code. Par exemple, réduisez le délai, en employant des
nombres distincts pour les impulsions d’allumage et d’extinction pour voir
divers modèles de clignotement. En particulier, vous devriez observer ce
qui se passe quand vous réduisez les délais, mais utilisez des délais
différents pour l’activation et la désactivation... il y a un moment où
quelque chose de bizarre se produit, tentez d’expérimenter.
 5

NOTIONS DE THÉORIE

J ’ai toujours été captivé par la lumière et la possibilité de contrôler

diverses sources de lumière grâce à la technologie. J’ai eu la chance de
travailler sur des projets intéressants impliquant le contrôle de la lumière et
son interaction avec les gens. Sous peu, nous travaillerons sur la conception
de « lampes interactives », en employant Arduino comme façon d’apprendre
les bases de la construction de dispositifs interactifs. Toutefois, il est
important d’avoir une base pour pouvoir continuer.
En fait, si vous avez déjà fait de la plomberie à la maison, l’électronique
ne sera pas un souci pour vous. Afin de comprendre le fonctionnement de
l’électricité et des circuits électriques, la meilleure méthode est d’employer
une métaphore nommée « analogie de l’eau ». Prenons un appareil simple,
comme un ventilateur portable alimenté par une batterie ; si vous démontez
un ventilateur, vous observerez qu’il détient une petite batterie, quelques
fils et un moteur électrique ; en outre, l’un des fils allant au moteur est
interrompu par un interrupteur. Si vous avez une nouvelle batterie et que
vous allumez l’interrupteur, le moteur débutera à tourner, donnant le
refroidissement requis.
Comment cela fonctionne-t-il ? Supposez que la batterie soit un
réservoir d’eau et une pompe, que l’interrupteur soit un robinet et que le
moteur soit une de ces roues que l’on voit dans les moulins à eau. Quand
vous ouvrez le robinet, l’eau s’écoule de la pompe et pousse la roue en
mouvement.
Dans ce système hydraulique facile, deux facteurs sont fondamentaux :
la pression de l’eau (déterminée par la puissance de la pompe) et la quantité
d’eau qui circule dans les tuyaux (qui dépend de la taille des tuyaux et de la
résistance que la roue oppose au flux d’eau qui la frappe). Vous vous
rendrez vite compte que si vous souhaitez que la roue tourne plus vite, vous
devez augmenter la taille des tuyaux (toutefois cela ne fonctionne que
jusqu’à un certain point) et augmenter la pression que la pompe peut
atteindre.
De plus, en augmentant la taille des tubes, on laisse passer plus d’eau ;
en les agrandissant, nous avons en effet réduit la résistance des tubes à
l’écoulement de l’eau. Cette approche fonctionne jusqu’à un certain point,
où la roue ne tourne pas plus rapidement, car la pression de l’eau n’est pas
assez forte. En fait, quand nous atteignons ce point, nous avons besoin que
la pompe soit plus forte.
De plus, cette méthode d’accélération du moulin à eau peut durer
jusqu’au moment où la roue se brise parce que le flux d’eau est vraiment
fort et qu’elle est détruite. Vous remarquerez aussi que quand la roue tourne,
l’essieu chauffe un peu, car quelle que soit la qualité du montage de la roue,
la friction entre l’essieu et les trous où il est monté génère de la chaleur.
Il est essentiel de réaliser que dans un système comme celui-ci, toute
l’énergie que vous pompez dans le système ne sera pas convertie en
mouvement ; une partie sera perdue parmi un certain nombre d’inefficacités
et se manifestera en général sous forme de chaleur émanant de quelques
parties du système. Quelles sont alors les parties importantes du système ?
La pression produite par la pompe est vraiment essentielle ; la résistance
que les tuyaux et la roue proposent à l’écoulement de l’eau et le débit réel
de l’eau (disons qu’il est représenté par le nombre de litres d’eau qui
s’écoulent en une seconde).
L’électricité fonctionne un peu comme l’eau : vous détenez une sorte de
pompe (n’importe quelle source d’électricité, comme une batterie ou une
prise murale) qui pousse des charges électriques (imaginez-les comme des
« gouttes » d’électricité) dans des tuyaux, qui sont représentés par des fils.
Quelques appareils sont en mesure de les utiliser afin de produire de la
chaleur (une couverture électrique), de la lumière (la lampe de votre
chambre), du son (votre chaîne stéréo), du mouvement (votre ventilateur),
et ainsi de suite.
Alors, quand vous lisez que la tension d’une pile est de 9 V, considérez
cette tension comme la pression d’eau qui est potentiellement capable d’être
produite par cette petite « pompe ». Il est important de noter que la tension
est mesurée en volts, du nom d’Alessandro Volta, l’inventeur de la première
batterie. Tout comme la pression de l’eau a un équivalent électrique, le débit
de l’eau en a aussi un et se mesure en ampères (d’après André-Marie
Ampère, pionnier de l’électromagnétisme).
Remarquez que la relation entre la tension et le courant est en mesure
d’être montrée en revenant à la roue à eau : une tension (pression) plus
élevée donne la chance à une roue de tourner plus rapidement ; un débit
(courant) plus élevé permet à une roue plus grande de tourner. Finalement,
la résistance qui s’oppose à la circulation du courant sur n’importe quel
chemin qu’il emprunte est nommée résistance, et se mesure en ohms (du
nom du physicien allemand Georg Ohm).
Herr Ohm est aussi responsable de la formulation de la loi la plus
essentielle sur l’électricité et c’est également la seule formule dont vous
devez vraiment vous rappeler. Il a pu illustrer que dans un circuit, la
tension, le courant et la résistance sont tous liés les uns aux autres et, en
particulier, que la résistance d’un circuit détermine la quantité de courant
qui le traverse, pour une certaine tension d’alimentation. C’est vraiment
intuitif si vous y pensez.
Prenez une pile de 9 V et connectez-la à un circuit simple. En mesurant
le courant, vous verrez que plus vous ajoutez de résistances au circuit,
moins le courant y circule. Revenons à l’analogie de l’eau qui coule dans
des tuyaux : étant donné une certaine pompe, si j’installe une vanne (que
nous pouvons assimiler à une résistance qui varie en électricité), plus je
ferme la vanne (augmentant la résistance à l’écoulement de l’eau), moins
l’eau coulera dans les tuyaux.
De plus, notez qu’Ohm a résumé sa loi dans ces formules :
R(résistance)=V(tension)/I(courant)
V=R*I
I=V/R
Il est important de savoir que c’est la seule règle que vous devez
vraiment mémoriser et apprendre à employer, car dans la majorité de vos
travaux, c’est la seule dont vous aurez vraiment besoin.
 6

LUMIÈRE INTELLIGENTE

L aidéal
fabrication d’un flash LED était simple, mais je ne crois pas qu’il soit
de faire clignoter votre lampe de bureau lorsque que vous tentiez
de lire un livre, vous devez alors apprendre à le contrôler. Dans notre
exemple précédent, la LED était notre actionneur et notre Arduino la
contrôlait, ce qui manque afin de compléter le tableau est un capteur.
Dans ce cas, nous emploierons la forme la plus facile de capteur
disponible : un bouton. Si vous deviez démonter un bouton, vous
observeriez qu’il s’agit d’un dispositif vraiment facile : deux pièces de
métal maintenues séparées par un ressort et un capuchon en plastique qui,
quand il est pressé, met les deux pièces de métal en contact. Quand les
morceaux de métal sont séparés, il n’y a pas de circulation de courant dans
le bouton (un peu comme quand une vanne d’eau est fermée) ; quand nous
appuyons dessus, nous établissons une connexion.
Afin de surveiller l’état d’un interrupteur, il existe une nouvelle
instruction Arduino que vous allez apprendre : la fonction digitalRead().
Cette fonction vérifie si une tension est appliquée à la broche spécifiée entre
parenthèses et renvoie une valeur de HIGH ou LOW, selon le résultat.
Il est important de noter que les autres instructions que nous avons
employées jusqu’à présent n’ont renvoyé aucune information : elles ont
simplement exécuté ce que nous leur avons demandé. Toutefois ce type de
fonction est un peu limité, car il nous demande à suivre des séquences
d’instructions vraiment prévisibles, sans aucun apport du monde extérieur.
Avec digitalRead(), nous pouvons « poser une question à l’Arduino » et
recevoir une réponse qui peut être stockée en mémoire quelque part et
utilisée afin de prendre des décisions à l’instant ou à une date ultérieure.
Construisons un petit circuit, vous devrez vous procurer certaines pièces
énumérées :

Planche à pain sans couture MKKN3 ;

Câbles de démarrage prédécoupés ;
Interrupteur momentané avec bouton tactile ;
Une résistance de 10K Ohm.

Créez le circuit en connectant la sortie 5V de l’Arduino à une extrémité

de la planche à pain d’une façon qui correspond à une broche sur le bouton.
Connectez par la suite la sortie GND à une extrémité de la résistance tandis
que l’autre extrémité de la résistance doit être connectée à la broche numéro
7.
Analysons le code que nous emploierons afin de contrôler la LED avec
notre bouton :
const int LED = 13 ; // la broche pour la LED
// la broche d'entrée à laquelle le bouton est connecté
const int BUTTON = 7 ;
// val sera utilisé pour stocker l'état de la broche d'entrée.
int val = 0 ;
void setup() {
pinMode(LED, OUTPUT) ; // la LED de l'Arduino est une sortie
pinMode(BUTTON, INPUT) ; // et BUTTON est une entrée
}
void loop(){
val = digitalRead(BUTTON) ; // lit la valeur d'entrée et la stocke
// vérifie si l'entrée est HIGH (bouton pressé)
if (val == HIGH) {
digitalWrite(LED, HIGH) ; // allume la LED
} else {
digitalWrite(LED, LOW) ;
}
}
Il est important de savoir que dans Arduino, sélectionnez Fichier >
Nouveau (si vous avez un autre sketch ouvert, vous pouvez l’enregistrer
d’abord). Quand Arduino vous demande de nommer votre nouveau dossier
de sketchs, tapez ControlButton.
Ensuite, entrez le code proposé et si tout est correct, le voyant
s’allumera quand vous appuierez sur le bouton.
Mais comment cela fonctionne-t-il ? J’ai introduit deux nouveaux
concepts avec cet exemple de programme : les fonctions qui renvoient le
résultat de leur travail, et l’instruction if. L’instruction if est probablement
l’instruction la plus fondamentale dans un langage de programmation parce
qu’elle donne la chance à l’ordinateur (et souvenez-vous, l’Arduino est un
petit ordinateur) de prendre des décisions.
Après le mot-clé if, vous devez écrire une « question » entre parenthèses
et si la « réponse », ou résultat, est vraie, le premier bloc de code sera
exécuté ; sinon, le bloc de code prochain sera exécuté. Remarquez que j’ai
employé le symbole == au lieu de =, le premier est employé quand deux
entités sont comparées et renvoie VRAI ou FAUX ; le second attribue une
valeur à une variable. Veillez à utiliser la bonne, car il est vraiment simple
de se tromper et de n’utiliser que =, auquel cas votre programme ne
fonctionnera jamais.
Après de nombreuses années de programmation, il lui arrive encore de
commettre cette erreur. Garder le doigt sur le bouton aussi longtemps que
nécessaire pour allumer n’est donc pas vraiment pratique.
Notez que même si vous vous demandez combien d’énergie vous
gaspillez quand vous vous éloignez d’une lampe que vous avez laissée
allumée, nous devons comprendre la façon de faire en sorte que le bouton
d’alimentation reste allumé.
Il est important de savoir que le grand avantage de l’électronique
numérique et programmable sur l’électronique classique devient désormais
évident : je vous illustrerai comment mettre en œuvre plusieurs « 
comportements » divers en employant le même circuit électronique,
simplement en changeant le logiciel. Comme je l’ai déjà mentionné, il n’est
pas vraiment pratique de garder son doigt sur le bouton pour allumer la
lumière. Nous devons alors mettre en place une forme de « mémoire », sous
la forme d’un mécanisme logiciel qui se souviendra du moment où nous
avons appuyé sur le bouton et qui gardera la lumière allumée même après
que nous l’ayons relâchée.
 Pour l’exécuter, nous emploierons ce que nous nommons une variable,
qui est un endroit de la mémoire de l’Arduino où vous pouvez stocker des
données. Pensez-y comme à l’une de ces notes autocollantes que vous
employez afin de vous souvenir de quelque chose, comme un numéro de
téléphone : vous en prenez une, vous écrivez quelque chose dessus et vous
la collez sur votre écran d’ordinateur ou votre réfrigérateur. Dans Arduino,
c’est tout aussi facile : vous choisissez le type de données que vous
souhaitez stocker (un nombre ou du texte, par exemple), vous lui donnez un
nom, et quand vous souhaitez, vous pouvez stocker les données ou les
récupérer.
Par exemple : int val = 0 ; où int signifie que votre variable stockera un
nombre entier, val est le nom de la variable et = 0 lui donne une valeur
initiale de zéro.
De plus, une variable, comme son nom l’indique, peut être changée
n’importe où dans le code, de sorte que par la suite dans le programme,
vous pouvez écrire : val = 112 ; ce qui réaffecte une nouvelle valeur à la
variable. Dans le prochain programme, val est employé afin de stocker le
résultat de digitalRead() ; tout ce que l’Arduino reçoit de l’entrée se
retrouve dans la variable et y restera jusqu’à ce qu’une autre ligne de code
le modifie. Remarquez que les variables emploient un type de mémoire
appelé RAM qui est assez vite, mais quand vous éteignez la carte, toutes les
données stockées dans la RAM sont perdues (ce qui veut dire que chaque
variable est restaurée à sa valeur initiale lorsque la carte est rallumée).
Il est important de savoir que vos programmes, en revanche, sont
stockés dans une mémoire flash, du même type que celle utilisée par votre
téléphone portable afin de stocker les numéros de téléphone, qui conserve
son contenu même lorsque la carte est éteinte. Employons désormais une
autre variable pour nous souvenir si la LED doit rester allumée ou éteinte
après avoir relâché le bouton. Voyons un premier essai afin d’y parvenir :
const int LED = 13 ;
const int BUTTON = 7 ;
int val = 0 ;
int state = 0 ; // 0 = LED éteinte, 1 = LED allumée
void setup() {
pinMode(LED, OUTPUT) ;
pinMode(BUTTON, INPUT) ;
}
 void loop() {
val = digitalRead(BUTTON) ; // lit la valeur d'entrée et la stocke
// vérifie si l'entrée est HIGH (bouton pressé) et change le statut
if (val == HIGH) {
état = 1 - état ;
}
if (state == 1) {
digitalWrite(LED, HIGH) ;
} else {
digitalWrite(LED, LOW) ;
}
}

Maintenant, allez-y et tentez ce code. Vous allez conclure que la lumière

change si rapidement que vous n’êtes pas en mesure de l’allumer ou
l’éteindre de façon fiable en appuyant sur un bouton. Observons les parties
intéressantes du code : notez que state est une variable qui stocke 0 ou 1
afin de se souvenir si la LED est allumée ou éteinte. Après avoir relâché le
bouton, nous l’initialisons à 0 (LED éteinte).
Par la suite, nous lisons l’état actuel du bouton et, s’il est enfoncé (val
== HIGH), nous changeons l’état de 0 à 1, ou vice versa.
L’astuce que j’emploie consiste en une petite expression mathématique
basée sur l’idée que 1 - 0 est égal à 1 et que 1 - 1 est égal à 0 : state = 1 -
state ; cela n’a probablement pas beaucoup de sens en mathématiques, mais
cela en a en programmation.
Il est important de savoir que le symbole = signifie "assigner le résultat
de ce qui est après moi au nom de la variable avant moi" : dans ce cas, la
nouvelle valeur de state est assignée à la valeur 1 moins l’ancienne valeur
de state. Plus tard dans le programme, vous observerez que nous employons
l’état pour déterminer si la LED doit être allumée ou éteinte, mais, comme
je l’ai déjà mentionné, cela conduit à des résultats plutôt instables.
Il est important de noter que les résultats sont instables à cause de la
manière dont nous lisons le bouton. L’Arduino est vraiment rapide ; il
exécute ses instructions internes à un rythme de 16 millions par seconde - il
pourrait bien exécuter quelques millions de lignes de code par seconde.
Cela veut dire que lorsque votre doigt appuie sur le bouton, l’Arduino
pourrait lire la position du bouton quelques milliers de fois et changer l’état
en conséquence. Les résultats deviennent imprévisibles ; le programme peut
illustrer le bon comportement de temps en temps, mais la majorité du
temps, il sera faux. Comment pouvons-nous résoudre ce souci ?
Eh bien, nous devons détecter le moment exact où le bouton est pressé :
c’est le seul moment où nous devons changer d’état. La manière dont j’aime
procéder est de stocker la valeur de val avant d’en lire une nouvelle ; cela
nous aide à comparer la position actuelle du bouton avec la précédente et de
ne changer d’état que quand le bouton devient HAUT après avoir été BAS.
const int LED = 13 ;
const int BUTTON = 7 ;
int val = 0 ;
int old_val = 0 ; // cette variable stocke la valeur précédente de 'val'.
int state = 0 ;

void setup() {
pinMode(LED, OUTPUT) ;
pinMode(BUTTON, INPUT) ;

}
void loop(){
val = digitalRead(BUTTON) ;
// vérifie s'il y a eu une transition
si ((val == HIGH) && (old_val == LOW)){
état = 1 - état ;
}
old_val = val ; // val est maintenant vieux, stockez-le
if (state == 1) {
digitalWrite(LED, HIGH) ;
} else {
digitalWrite(LED, LOW) ;
}
}
Essayez ce code : vous y êtes presque ! Vous avez peut-être remarqué que
cette approche n’est pas tout à fait excellente, en raison d’un autre souci lié
aux interrupteurs mécaniques. Les boutons sont des dispositifs très simples :
deux pièces de métal maintenues à distance par un ressort. Quand nous
appuyons sur le bouton, les deux contacts se rapprochent et l’électricité est
capable de circuler.
Cela semble beau et facile, mais dans la vie réelle, la connexion n’est
pas si parfaite, surtout quand le bouton n’est pas complètement enfoncé et
génère des signaux parasites nommés rebonds. Quand le bouton rebondit,
l’Arduino voit une séquence vraiment rapide de signaux de marche et
d’arrêt. Il existe plusieurs techniques développées pour effectuer le
débouclement, mais dans ce simple morceau de code, j’ai remarqué qu’il est
généralement suffisant d’ajouter un délai de 10 à 50 millisecondes quand le
code détecte une transition.
Voici ci-dessous le code illustré dans sa version finale :
const int LED = 13 ;
const int BUTTON = 7 ;
int val = 0 ;
int old_val = 0 ;
int state = 0 ;

void setup() {
pinMode(LED, OUTPUT) ;
pinMode(BUTTON, INPUT) ;
}
void loop(){
val = digitalRead(BUTTON) ;
si ((val == HIGH) && (old_val == LOW)){
état = 1 - état ;
retard (10) ;
}
old_val = val ;
if (state == 1) {
digitalWrite(LED, HIGH) ;
} else {
digitalWrite(LED, LOW) ;
}
}
 7

MAESTRO DE LA MUSIQUE !

J usqu’à maintenant, nous n’avons joué qu’avec les lumières. Dans ce

chapitre, nous ajouterons la création de sons et de mélodies faciles. Pour
produire un son, nous allumons et éteignons le haut-parleur un certain
nombre de fois par seconde. Plus précisément, la central (une note de
musique) est de 440 Hz. (Hz est l’abréviation de "Hertz" - le nombre de fois
(ou cycles) par seconde). Alors, tout ce que nous avons à faire pour
reproduire un la méthode est de créer une onde sonore qui tourne 440 fois
par seconde. Notez que nous allons approximer l’onde sinusoïdale par une
onde carrée (ces termes ne décrivent que la forme). Nous calculons le temps
requis à l’allumage de l’enceinte :
timeDelay = 1 seconde / (2* toneFrequency)
Il est important de savoir que cette formule a un 2 au dénominateur
parce que la moitié du temps se passe avec le haut-parleur allumé et l’autre
moitié avec le haut-parleur éteint.
timeDelay = 1 seconde / (2* 440) = 1136 microsecondes (une
microseconde correspond à 1 000 000e de seconde)
Sympa en théorie, mais en pratique ? En premier lieu, nous connectons
le haut-parleur à la broche 9 (l’autre broche du haut-parleur est tout
simplement reliée à la masse).

1. Connectez la colonne la plus à droite (Ground) à GND sur

l’Arduino ;
2. Connectez la colonne suivante à droite (+) à 5 V sur l’Arduino ;
 3. Connectez le fil noir du haut-parleur à la colonne à l’extrême
droite (masse) ;
4. Connectez le fil rouge du haut-parleur à la broche 9 de
l’Arduino.

CONSEIL : si le haut-parleur est trop fort, il faut simplement d’insérer

une résistance de 330 Ω entre le haut-parleur et la broche 9 de l’Arduino.
Nous avons déjà discuté de la fonction delay(), il se trouve aussi une
fonction delayMicroseconds() où une microseconde correspond à 1:1 000
000 de seconde. Tout ce que nous devons faire, c’est de définir la broche du
haut-parleur, ensuite d’augmenter et de diminuer la tension sur cette broche
440 fois par seconde. Souvenez-vous, au début de ce chapitre, nous avons
réalisé que nous devions avoir le haut-parleur allumé (puis éteint) pendant
1136 microsecondes. Exécutez ce programme et vous devriez entendre un A
(note de musique) qui ne s’arrête pas (jusqu’à ce que vous éteigniez
l’appareil).
const int kPinSpeaker = 9 ;
const int k_timeDelay = 1136 ;

void setup()
{
pinMode(kPinSpeaker, OUTPUT) ;
}

void loop()
{
digitalWrite(kPinSpeaker, HIGH) ;
delayMicroseconds(k_timeDelay) ;
digitalWrite(kPinSpeaker, LOW) ;
delayMicroseconds(k_timeDelay) ;
}
Maintenant que nous pouvons jouer une simple note, nous pouvons faire de
la musique. L’Arduino contient 2 fonctions intégrées qui gèrent aussi la
production de sons. La première est tone() qui accepte 2 paramètres
obligatoires (et un troisième optionnel), tone (pin, fréquence, durée) ou
vous pouvez employer tone (pin, fréquence). Les deux reviennent tout de
suite, quelle que soit la durée que vous leur donnez. Il est important de
savoir que si vous n’incluez pas de durée, le son sera joué jusqu’à ce que
vous appeliez à nouveau tone() ou que vous appeliez la fonction noTone().
(Cela peut demander l’utilisation d’une fonction de retard si la lecture d’un
son est l’activité principale). La durée est en millisecondes, la raison pour
laquelle la durée est utile est que vous êtes en mesure de lui offrir quelque
temps afin de jouer et ensuite vous pouvez faire d’autres choses. Dès que la
durée se finit, elle s’arrête. La deuxième fonction est noTone() qui accepte
un seul paramètre : noTone(pin).
En fait, il interrompt le son qui est joué sur cette broche. Conseil :
quand la fonction tone() est en cours d’exécution, la modulation de largeur
d’impulsion (PWM) ne fonctionnera pas sur les broches 3 et 11. Alors, si
vous employez un haut-parleur dans votre sketch, vous pouvez éviter
d’utiliser complètement ces broches comme PWM). Vous êtes en mesure de
connecter un haut-parleur à n’importe laquelle des broches, voici un
exemple à essayer sur votre Arduino : (OK, c’est une simple gamme de C et
peut-être pas une mélodie, mais c’est correct pour notre test) :
#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTES_B4 494
#define NOTE_C5 523

const int kPinSpeaker = 9 ;

void setup()
 {
pinMode(kPinSpeaker, OUTPUT) ;
}

void loop()
{
tone(kPinSpeaker, NOTE_C4, 500) ;
delay(500) ;
tone(kPinSpeaker, NOTE_D4, 500) ;
delay(500) ;
tone(kPinSpeaker, NOTE_E4, 500) ;
delay(500) ;
tone(kPinSpeaker, NOTE_F4, 500) ;
delay(500) ;
tone(kPinSpeaker, NOTE_G4, 500) ;
delay(500) ;
tone(kPinSpeaker, NOTE_A4, 500) ;
delay(500) ;
tone(kPinSpeaker, NOTE_B4, 500) ;
delay(500) ;
tone(kPinSpeaker, NOTE_C5, 500) ;
delay(500) ;

noTone(kPinSpeaker) ;

retard (2000) ;
}

La seule chose que vous n’avez pas encore observée est l’instruction
#define. Il s’agit d’une commande qui fait office de recherche et de
remplacement pour l’ordinateur lors de la compilation. Toutes les fois qu’il
trouve la première chose (jusqu’à l’espace), il la remplace par le reste de la
ligne. Ainsi, dans cet exemple, quand l’ordinateur trouve NOTE_E4, il le
remplace par une valeur de 330. Nous ne nous étendrons pas dans cette
section sur la façon de déterminer la fréquence de chaque note.

Faire de la musique avec des fonctions

Il semble y avoir une méthode de réduire toutes les répétitions ci-dessus.
Jusqu’à maintenant, nous n’avons employé que les deux fonctions
obligatoires ou les fonctions données avec l’Arduino. Il est désormais temps
de créer notre fonction ! Chaque fonction débute par le type de variable
qu’elle renvoie, void étant un type qui signifie qu’elle ne renvoie rien. Nous
aurons par la suite le nom de la fonction (son nom), une parenthèse ouverte
"(" et ensuite une liste de paramètres séparés par des virgules. Chaque
paramètre possède un type de variable suivi d’un nom. Par la suite, il a une
parenthèse fermée ")". Les paramètres sont en mesure d’être employés dans
la fonction comme des variables. Par exemple, nous allons créer une
fonction nommée ourTone() qui combinera les lignes tone() et delay() pour
que la fonction ne revienne pas avant que la note ait été jouée.
#define NOTE_C4 262
Définissez NOTE_D4 294
Définissez NOTE_E4 330
définir NOTE_F4 349
définir NOTE_G4 392
Définissez NOTE_A4 440
Définissez NOTE_B4 494
Définissez NOTE_C5 523

const int kPinSpeaker = 9 ;

void setup()
{
pinMode(kPinSpeaker, OUTPUT) ;
}
void loop()
{
notreTonalité(NOTE_C4, 500) ;
notreTonalité(NOTE_D4, 500) ;
notreTonalité(NOTE_E4, 500) ;
notreTonalité(NOTE_F4, 500) ;
notreTonalité(NOTE_G4, 500) ;
notreTonalité(NOTE_A4, 500) ;
notreTonalité(NOTE_B4, 500) ;
notreTonalité(NOTE_C5, 500) ;

noTone(kPinSpeaker) ;
retard (2000) ;
}

void ourTone(int freq, int duration)

{
tone(kPinSpeaker, freq, duration) ;
retard (durée) ;
}

Les fonctions peuvent être d’une grande aide afin de rendre votre
programme plus simple à comprendre. Voici un exemple afin que nous
puissions désormais spécifier ce que nous souhaitons jouer dans deux
tableaux (un possédant les notes et un contenant les mélodies).
#include "pitches.h"

int kPinSpeaker = 9 ;
#define NUM_NOTES 15

const int notes[NUM_NOTES] = // un 0 représente un repos

{
NOTE_C4, NOTE_C4, NOTE_G4,
NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
};

const int beats[NUM_NOTES] = {

1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 } ;
const int beat_length = 300 ;

void setup()
{
pinMode(kPinSpeaker, OUTPUT) ;
}

void loop()
{
for (int i = 0 ; i < NUM_NOTES ; i++) {
si (notes[i] == 0) {
delay(beats[i] * beat_length) ; // repos
}
else {
ourTone(notes[i], beats[i] * beat_length) ;
}
// pause entre les notes
noTone(kPinSpeaker) ;
delay(beat_length / 2) ;
 }
}

void ourTone(int freq, int duration)

{
tone(kPinSpeaker, freq, duration) ;
retard (durée) ;
}

À la ligne 1, vous observerez l’instruction #include. Ce qu’il fait, c’est

prendre le fichier entier entre guillemets et l’insérer là où se trouve
l’instruction #include. Par convention, ils sont pratiquement toujours placés
au début d’un programme. À titre d’exercice, vous êtes en mesure de jouer
la mélodie de la chanson classique d’anniversaire "Happy Birthday",
composée de DO. C. D, C. FA, MI ou vous pourriez employer des boutons
physiques pour que votre Arduino démarre et arrête les sons, c’est à vous
d’expérimenter !
 8

THERMOMÈTRE NUMÉRIQUE

A vant de débuter le travail amusant de création d’un thermomètre

numérique, nous allons exécuter une petite diversion dans la prochaine
section pour pouvoir tester quelques parties de notre programme avant de
les assembler. Écrire de petites parties de votre programme et s’assurer
qu’elles fonctionnent avant de coder davantage est l’approche la plus sage
que vous puissiez adopter, car il est beaucoup plus simple de repérer les
bogues ou les problèmes. Jusqu’à maintenant, quand nos programmes
(croquis) ne fonctionnaient pas, nous nous arrachions simplement les
cheveux et aiguisions nos yeux. Certains d’entre vous ont probablement
inséré une LED supplémentaire et l’ont allumée et éteinte à quelques
moments du programme pour savoir ce que le programme faisait. Eh bien,
nous allons donc apprendre une méthode beaucoup plus facile. La
plateforme Arduino permet de répondre à l’ordinateur de l’utilisateur. Vous
avez probablement remarqué qu’à côté des broches 0 et 1 de l’Arduino se
trouvent les lettres 'RX' et 'TX'. Ces broches sont contrôlées par une autre
puce sur l’Arduino qui les convertit afin de leur permettre de passer sur le
câble USB (s’il est connecté à la fois à votre Arduino et à votre ordinateur).
Dans ce programme, nous analyserons les nouvelles parties après le
programme d’exemple.
const int kPinLed = 13 ;
void setup()
{
pinMode(kPinLed, OUTPUT) ;
Serial. begin(9600) ;
 }

int delayTime = 1000 ;

void loop()
{
delayTime = delayTime - 100 ;
si(delayTime <= 0){
delayTime = 1000 ;
}
Serial. print("delayTime = ') ;
Serial. println(delayTime) ;
digitalWrite(kPinLed, HIGH) ;
delay(delayTime) ;
digitalWrite(kPinLed, LOW) ;
delay(delayTime) ;
}

Vous remarquerez certaines nouveautés. Tout d’abord, il y a une nouvelle

ligne dans la fonction setup(). L’instruction Serial.begin(9600) indique en
gros que nous souhaitons utiliser le code Serial et le lancer à 9600 bauds.
Ce numéro et celui du moniteur série (décrit plus loin) DOIVENT
correspondre, sinon vous observerez des mots absurdes sur le moniteur
série (9600 est le paramètre par défaut, il est alors plus simple à utiliser).
L’unique différence entre Serial.print et Serial.println est que Serial.println
indique que l’envoi suivant du port série après cette instruction
commencera sur la prochaine ligne. Il y a une troisième nouvelle
fonctionnalité que vous avez probablement remarquée. Il y a quelque chose
entre guillemets ("), cette nouveauté se nomme une chaîne de caractères.
Dans ce livre, nous n’employons que des chaînes de caractères comme
constantes. Chargez ce code et exécutez-le. Vous devriez voir le voyant
clignoter et rien d’autre ne semble s’être produit (mais nous observons
maintenant le voyant TX clignoter sur la carte). C’est parce que nous
n’avons pas la fenêtre Serial Monitor ouverte.
Ouvrez le moniteur série en cliquant sur la case 'Serial Monitor' dans
l’IDE. Assurez-vous que le baud (vitesse) est réglé sur 9600. Il se trouve en
bas à droite, mais l’essentiel est qu’il soit réglé de la même façon dans notre
programme et ici. Comme le paramètre par défaut est ici de 9600, nous
réglons notre programme sur la même valeur afin de minimiser le besoin de
changer les paramètres. Si le baud est réglé différemment, vous observerez
des valeurs très distinctes de celles auxquelles vous vous attendez. Avant
d’aller plus loin, assurez-vous que quand vous faites votre programme, vous
observerez les lignes "delayTime = " avec la valeur de delayTime sur le
moniteur série.

Construisons le thermomètre
Nous employons une puce appelée TMP36. Il peut rétablir la température
de -40 degrés Celsius à 150 degrés Celsius (ou de -40 degrés Fahrenheit à
302 degrés Fahrenheit). La précision diminue après 125 degrés Celsius,
mais comme l’eau bout à 100 degrés Celsius, c’est plus qu’excellent. Voici
ci-dessous une photo du circuit :

Connectez la colonne la plus à droite à la masse (GND) de l’Arduino ;

Connectez la prochaine colonne à droite au +5V ;
Mettez la broche 1 du TMP36 dans f1. (La partie incurvée de la sonde
de température doit être orientée vers le bord gauche de la planche d’essai.
Il est important de savoir que si vous l’insérez dans l’autre sens, il
deviendra chaud et vous risquez de vous brûler ;
Connectez j1 à la colonne la plus à droite (GND).
Connectez j3 à la colonne suivante sur la droite (+5V).
Connectez j2 à A0 sur l’Arduino.
Voici maintenant le code qui va lire le capteur de température et envoyer
les valeurs au moniteur série de l’ordinateur. Une fois encore, nous allons
premièrement démontrer l’ensemble du code, et ensuite d’analyser les
nouvelles sections.
const int kPinTemp = A0 ;

void setup()
{
Serial. begin(9600) ;
}

void loop()
{
float temperatureC = getTemperatureC() ;

Serial. print(temperatureC) ;
Serial. println(" degrés C ") ;

// maintenant convertir en Fahrenheit

float temperatureF = convertToF(temperatureC) ;

Serial. print(temperatureF) ;
Serial. println(" degrés F ") ;
delay(500) ;
}

float getTemperatureC()
{
int lecture = analogRead(kPinTemp) ;

float voltage = (reading * 5.0) / 1024 ;

// convertir de 10 mv par degré avec un décalage de 500mV
// en degrés ((tension - 500mV) * 100)
retourner (tension - 0,5) * 100 ;
}

float convertir en F(float temperatureC)

{
retourner (températureC * 9,0 / 5,0) + 32,0 ;
}

Vous remarquerez que nous avons employé le type de variable float. Ce

type de variable est le seul qui vous aide à stocker autre chose que des
nombres entiers (nombres sans décimales ou parties fractionnaires). Les
flottants ont une précision d’environ 6-7 chiffres, ce qui n’est essentiel que
parce que vous pouvez avoir des erreurs d’arrondi quand vous les
employez. Alors, quand vous effectuez des comparaisons, veillez à vérifier
si elles sont « proches » plutôt qu’égales.
La fonction getTemperatureC fait les calculs nécessaires afin de
convertir les données proposées par le capteur en température à l’échelle
Celsius. Comme notre analogIn() peut renvoyer une valeur comprise entre 0
et 1023, nous pouvons calculer la tension en multipliant notre lecture par
5,0 et en la divisant par 1024. Le capteur que nous employons envoie 500
mV à 0 Celsius (afin de pouvoir lire des températures négatives), par la
suite augmente de 10 mV par degré C. Voici la première fonction que nous
avons écrite et qui renvoie une valeur. (Souvenez-vous que toutes les autres
fonctions étaient de type void, ce qui signifie qu’elles ne renvoient pas de
valeur). Vous observerez que pour retourner la valeur, il suffit d’entrer
return suivi de la valeur à retourner (plutôt qu’une valeur, vous pouvez
entrer un calcul comme nous l’avons fait ici). Renvoyer une valeur veut dire
que quand vous appelez une fonction, celle-ci a une « réponse » que vous
pouvez affecter à une variable. Nous l’envoyons au moniteur série et le
convertissons ensuite en Fahrenheit4 en appelant convertToF(). Cette
fonction prend la température en Celsius et la convertit en Fahrenheit. La
conversion de Fahrenheit en Celsius est donnée par la formule : Fahrenheit
= 9/5 * (Celsius) + 32.

L’écran LCD
LCD veut dire que Liquid Crystal Display (affichage à cristaux liquides).
Nous le nommerons LCD ou simplement écran pour faire court. Il se trouve
un grand nombre de types divers de LCD. Ils sont de toutes formes et de
toutes tailles, certains ne peuvent afficher que des caractères (lettres et
chiffres) et d’autres sont en mesure d’afficher des graphiques (ou des
images). Pour ce livre, nous employons un LCD graphique 84x48, ce qui
signifie qu’il y a 84 pixels (points) en largeur et 48 pixels en profondeur.
Contrôler un LCD directement serait très complexe, c’est pourquoi la
majorité des LCD sont équipés d’une puce de contrôle. Dans ce cas, le nôtre
a un PCD8544 pour son contrôleur, nous allons le brancher et utiliser
quelques routines afin de mettre du texte sur l’écran. Par la suite, nous
allons explorer un peu plus en détail ce que nous pouvons faire et aussi
illustrer certains graphiques sur l’écran. Le LCD fonctionne à 3.3V tandis
que la tension pour l’Arduino est de 5V, la puce sur le PCB fait la
conversion de tension pour nous, ainsi nous n’endommagerons pas le LCD.
Il y a 8 broches sur la carte. Voici ci-dessous une liste des broches et de ce
qu’elles font :
PIN
Description
GND
Mise à la terre de l’Arduino
3,3V
 Connectez l’alimentation de 3.3 V sur l’Arduino, c’est l’alimentation
pour le LCD. Il est crucial qu’il soit connecté à 3,3 V et NON à 5 V, sinon
vous risquez d’endommager le LCD.
CLK
Horloge série
DIN
C’est là que les données série sont envoyées
D/C
Cela permet au LCD de savoir si ce qui lui est envoyé est une
commande ou une donnée.
CS
Quand cette valeur est basse, la puce écoute sur D/C, DIN, CLK et
RST), peut être connectée à la masse (ce qui la fera toujours écouter) ou
utilisée de manière à ce que les broches puissent aussi être utilisées à
d’autres fins.
RST
Ceci réinitialise le contrôleur sur le LCD
LED
Il contrôle le rétro-éclairage. Nous sommes en mesure de le connecter
au +5V pour qu’il soit toujours allumé, ou au GND pour qu’il soit toujours
éteint, ou à une broche pour l’allumer ou l’éteindre.

Désormais, nous allons câbler le circuit, voici ci-dessous une image qui
peut vous aider :
 1. Placez le PCB LCD + dans le breadboard à l’endroit où les
broches étiquetées sur le PCB violet sont situées dans a4-a11.
2. Connectez la colonne la plus à droite à GND sur l’Arduino.
3. Connectez la colonne suivante à droite au +5V de l’Arduino.
4. Connectez c4 à la colonne à l’extrême droite (masse).
5. Connectez c5 à 3V3 sur Arduino. (TRÈS IMPORTANT !
Effectuez un double contrôle avant de connecter l’alimentation
électrique).
6. Connectez c6 (CLK) à la broche 5 de l’Arduino.
7. Connectez c7 (DIN) à la broche 6 de l’Arduino.
8. Connectez c8 (D/C) à la broche 7 de l’Arduino.
9. Connectez c9 (CS) à la colonne de l’extrême droite (masse).
10. Connectez c10 (RST) à la broche 8 de l’Arduino.
11. Connectez c11 (LED) à la colonne suivante sur la droite (+5V).
Cela veut dire que le rétroéclairage sera toujours allumé.
12. Nous serions en mesure aussi d’écrire tout le code afin de parler
à l’écran LCD, mais cela serait trop coûteux et hors sujet, nous
emploierons alors quelques fonctions dans une bibliothèque.
Une bibliothèque est une collection de code qui peut être
employée par de nombreux programmes. Cela nous aide à
appeler simplement des fonctions qui facilitent la
communication avec le LCD. Si vous êtes intéressé par le
fonctionnement du LCD, vous pouvez observer l’intérieur de la
bibliothèque, mais expliquer ce code est hors de propos pour le
moment. Créez un répertoire nommé « libraries » dans le
répertoire de votre sketchbook, puis redémarrez l’IDE Arduino
en le fermant et en débutant. Il est important de noter que si vous
ne redémarrez pas l’IDE Arduino, vous ne pourrez pas utiliser la
bibliothèque.

Voici le fichier PCD8554.h :

#ifndef PCD8544_H
#define PCD8544_H

#include <WProgram.h>.
 #include <Print.h>.

classe PCD8544 : public Print {

public :
// Toutes les broches peuvent être modifiées à partir des valeurs par
défaut...
PCD8544(unsigned char sclk = 7,
unsigned char sdin = 6,
unsigned char dc = 5,
unsigned char reset = -1,
unsigned char backlight = -1,
unsigned char cs = -1) ;

void init() ;

void clear() ;

void setBacklight(bool on) ;

void setBacklight_PWM(int level) ;

void setInverse(bool inverse) ;

// Place le curseur à la position (colonne, ligne)

void setCursor(unsigned char column, unsigned char line) ;

// Écrire un caractère à la position actuelle du curseur.

virtual void write(unsigned char chr) ;
// Dessinez un bitmap à la position actuelle du curseur.
void drawBitmap(const unsigned char *data, unsigned char columns,
unsigned char lines) ;

privé :
Caractère non signé pin_sclk ;
Caractère non signé pin_sdin ;
Caractère non signé pin_dc ;
unsigned char pin_reset ;
Caractère non signé pin_cs ;
unsigned char pin_backlight ;

unsigned char curr_column ;

unsigned char curr_line ;

// Envoyer une commande ou des données à l'écran

void command(unsigned char cmd) ;
void data(unsigned char data) ;
void send(unsigned char type, unsigned char data) ;
};

#endif

Comme nous l’avons déjà fait à de nombreuses reprises, nous débuterons

par l’ensemble du programme, par la suite nous examinerons et discuterons
de nouvelles sections.
#include <PCD8544.h>.
const int kPin_CLK = 5 ;
const int kPin_DIN = 6 ;
const int kPin_DC = 7 ;
const int kPin_RESET = 8 ;

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) ;

void setup()
{
lcd. init() ;
lcd. setCursor(0,0) ;
lcd. print('Hello, World!') ;
}

void loop()
{
lcd. setCursor(0,1) ;
lcd. print(millis()) ;
}

L’instruction #include présente à l’ordinateur de prendre le fichier

mentionné et, quand il «  compile  » le programme, de remplacer
l’instruction #include par le contenu de ce fichier. Un #include peut
comporter des crochets affichant qu’il faut chercher dans le répertoire de la
bibliothèque ou des guillemets indiquant qu’il faut chercher dans le même
répertoire que celui où se trouve le sketch. Les quelques lignes suivantes
sont nos définitions de broches. Nous créons par la suite une variable d’un
nouveau type.
 Nous avons défini une variable appelée lcd de type PCD854410,
présentant à l’ordinateur quelles sont les broches connectées sur l’Arduino.
Afin de définir la variable, nous indiquons à quelles broches clk, din, dc et
reset sont associées. Avec l’instruction lcd.init() nous initialisons le LCD.
Nous plaçons le curseur en haut à gauche de l’écran (il y a 84 « colonnes »
et 6 « lignes  » dans cet affichage, comme dans les tableaux, il commence
par 0 au lieu de 1.) Par la suite, nous imprimons un message, c’est vraiment
similaire à la manière dont nous avons envoyé des messages via serial plus
tôt dans ce chapitre, sauf que nous employons lcd.print au lieu de
serial.print. C’est le code qui est appelé encore et encore. Finalement, nous
plaçons le curseur sur la colonne numéro 0 (tout à gauche) et la première
ligne. (Attention : n’oubliez pas que le point de départ est 0, il s’agit alors
en réalité de la deuxième ligne).
Toutefois, dans ce cas, comme nous n’avions pas besoin de la valeur du
nombre de millisecondes pour autre chose, nous avons simplement envoyé
le résultat de la fonction millis() directement à lcd.print().

Nous combinons deux projets

Alors, désormais, nous combinons le code du thermomètre que nous avons
fait plus tôt avec le code de l’écran que nous venons d’employer.
#include <PCD8544.h>.

const int kPin_CLK = 5 ;

const int kPin_DIN = 6 ;
const int kPin_DC = 7 ;
const int kPin_RESET = 8 ;
const int kPin_Temp = A0 ;

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) ;

void setup()
 {
lcd. init() ;
lcd. setCursor(10,0) ;
lcd. print("Température :") ;
}

void loop()
{
float temperatureC = getTemperatureC() ;
float temperatureF = convertToF(temperatureC) ;

lcd. setCursor(21,1) ;
lcd. print(temperatureC) ;
lcd. print(' C') ;
lcd. setCursor(21,2) ;
lcd. print(temperatureF) ;
lcd. print(' F') ;
delay(100) ;
}

float getTemperatureC()
{
int lecture = analogRead(kPin_Temp) ;

float voltage = (reading * 5.0) / 1024 ;

retourner (tension - 0,5) * 100 ;
}

float convertir en F(float temperatureC)

{
 retourner (températureC * 9,0 / 5,0) + 32,0 ;
}

La seule chose nouvelle et intéressante dans ce programme est que nous

avons employé la fonction setCursor() afin de positionner le texte de façon
plus centrée sur l’écran. Félicitations, vous avez désormais un thermomètre
numérique qui affiche la température en Celsius et en Fahrenheit !
 9

GRAPHIQUES SUR LCD

J usqu’à maintenant, nous n’avions que du texte sur notre écran LCD,
mais comme nous avons un écran LCD graphique, il est temps d’y
dessiner des images. En premier lieu, nous allons dessiner certains
graphiques statiques (cela signifie que nous savons à l’avance ce que nous
allons dessiner. Par la suite, nous laisserons l’Arduino décider de ce qu’il
faut dessiner en fonction de l’entrée. Toutefois, avant de passer au dessin,
nous devrons faire une petite diversion afin d’expliquer quelques détails qui
seront demandés afin d’envoyer les graphiques à l’écran. Quand vous
comptez, vous utilisez normalement la base 10, ce qui signifie que chaque
chiffre a une valeur 10 fois supérieure à celle de son voisin de droite. Par
exemple :
1
10 = 1 x 10
100 = 10 x 10
1,000 = 10 x 10
10 000 = 10 x 10 x 10
...
Quand nous observons un nombre comme 423, nous savons qu’il s’agit
en fait de : (4 x 100) + (2 x 10) + 3. Le souci réside dans le fait que les
appareils électroniques numériques n’ont que les 2 états suivants : HIGH et
LOW (ou ON et OFF). Notez que ceux-ci sont normalement représentés par
0 et 1. Ainsi, en base 2 (communément nommée binaire), chaque chiffre a
une valeur 2 fois supérieure à celle de son voisin de droite. Par exemple :
10 = 1 x 2
 100 = 2 x 2 (4)
1000 = 2 x 2 x 2 (8)
1 0000 = 2 x 2 x 2 (16)
...
Alors, quand un ordinateur voit 1101, nous savons qu’il s’agit en fait de
: (1 x 8) + (1 x 4) + (0 x 2) + (1 x 1) ou 13 (en base 10). Vous pouvez en
effet insérer des valeurs binaires dans votre code grâce au préfixe 0b : int
value = 0b1101 ;
Cette approche serait vraiment coûteuse, imaginez le nombre 200 : (1 x
128) + (1 x 64) + (0 x 32) + (0 x 16) + (1 x 8) + (0 x 4) + (0x 2) + (0x 1) :
int value = 0b11001000 ;
Remarquez que les programmeurs n’aiment pas perdre du temps, c’est
pourquoi la majorité des ordinateurs fonctionnent sur le concept d’octets de
8 bits (d’où 8 «  chiffres  » en base 2). Afin de faciliter la saisie (tout en
restant simple à convertir du format binaire), nous employons la base 16
(communément nommée hexadécimale). En base 16, nous aurons ce qui
suit :
1
10 = 1 x 16 (16)
100 = 16 x 16 (256)
1000 = 16 x 16 (4096)
...
(Vous avez probablement remarqué que j’avais l’habitude d’avoir un
espace après 4 chiffres en base 2. Il s’agit d’une convention, car 4 chiffres
en base 2 se convertissent en exactement 1 chiffre en base 16). Il y a un
souci. Nous n’avons que les chiffres de 0 à 9, car nous sommes habitués à la
base 10. Des symboles totalement nouveaux auraient pu être inventés,
toutefois la solution consiste à utiliser des lettres. (A = 10, B = 11, C = 12,
D = 13, E = 14 et F = 15) Alors, afin de représenter 200 (base 10) en base
16, nous aurions :
C8
(12 * 16) + (8 * 1)
192+8
200
Nous pouvons insérer des valeurs hexadécimales dans notre code avec
le préfixe 0x afin d’indiquer au compilateur que nous employons des
valeurs hexadécimales. C’est l’une des rares fois où vous pouvez employer
des lettres minuscules ou majuscules sans faire de distinction : int value =
0xC8 ;

OK, notre digression est finie, désormais dessinons vraiment certains

graphiques sur notre LCD. Cet écran comporte des pixels (points) qui
peuvent être activés ou désactivés. La puce du contrôleur représente la
valeur "on" par "1" et "off" par "0" (c’est pourquoi elle est binaire). Nous
écrivons une colonne de 8 pixels à l’écran à la fois, alors si nous voulions
que les 8 soient allumés, nous pourrions envoyer 0b1111 (binaire) ou 0xFF
(hexadécimal) à l’écran. Si nous voulions que les 8 soient désactivés, nous
pourrions envoyer 0b000000 ou 0x003. Afin de donner un exemple, si nous
souhaitons envoyer une image représentant une ligne diagonale, comme ci-
dessous :

Comme nous envoyons les données à l’écran LCD une colonne à la fois,
ce serait : 0b000001, 0b0000010, 0b00000100, 0b00001000, 0b000100,
0b00100000, 0b010000, 0b10000000. Alternativement, comme les
programmeurs emploient en général la base 16 dans leurs programmes au
lieu de la base 2, ils seraient : 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
0x80). Veuillez remarquer l’ordre, le pixel supérieur de chaque colonne est
représenté par 1, le suivant par 2, le suivant par 4 et ainsi de suite. Vous
pouvez employer cette méthode et du papier millimétré afin de déterminer
précisément ce que vous devez envoyer. Cela serait complexe et prendrait
du temps (et il serait facile de commettre une erreur). Heureusement, il
existe une méthode meilleure et plus simple. L’un d’entre nous (Jordan
Liggitt) a gentiment écrit un programme qui fonctionnera sur n’importe
quel navigateur moderne et générera le code dont vous avez besoin dans
votre programme : http://www.introtoarduino.com/utils/pcd8544.html.
Vous êtes en mesure de changer la largeur de l’image à n’importe quel
nombre jusqu’à la largeur de l’écran. Mais la hauteur de l’image ne peut se
faire que par lot de 8. Afin d’activer un pixel (foncé), il suffit de cliquer sur
le carré. Vous pouvez faire un clic droit afin de désactiver à nouveau un
pixel. Ici, nous l’employons afin de réaliser un graphique qui ressemble à
un thermomètre et qui sera montré à l’écran :

Après l’avoir dessiné, vous pouvez choisir le texte dans la boîte de

sortie et le copier (en employant Ctrl-C sur un PC ou Cmd-C sur un Mac),
ensuite le coller dans votre programme Arduino (en employant Ctrl-V sur
un PC ou Cmd-V sur un Mac). Si vous commettez une erreur, vous êtes
aussi en mesure de la copier de votre programme et la coller dans la case
« sortie » et le programme vous reprendra à partir de là. Si vous rencontrez
des soucis, rechargez la page Web et réessayez. L’ensemble du programme
est en premier lieu illustré, puis nous analyserons les nouvelles parties.
#include <PCD8544.h>.

const int kPin_CLK = 5 ;

 const int kPin_DIN = 6 ;
const int kPin_DC = 7 ;
const int kPin_RESET = 8 ;
const int kPin_Temp = A0 ;

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) ;

// Un graphique bitmap (5x1) d'un symbole de degré.

const int DEGREE_WIDTH = 5 ;
const int DEGREE_HEIGHT = 1 ;
const byte degreesBitmap[1 * 5] = {
0x00, 0x07, 0x05, 0x07, 0x00 } ;

// Un graphique bitmap (10x2) d'un thermomètre...

const int THERMO_WIDTH = 10 ;
const int THERMO_HEIGHT = 2 ;
const byte thermometerBitmap[2 * 10] =
{
0x00, 0x00, 0x48, 0xfe, 0x01, 0xfe, 0x00, 0x02, 0x05, 0x02,
0x00, 0x00, 0x62, 0xff, 0xfe, 0x60, 0x00, 0x00← !
};

const int LCD_WIDTH = 84 ;

const int LCD_HEIGHT = 6 ;

void setup()
{
lcd. init() ;
lcd. setCursor(10,0) ;
lcd. print("Température :") ;
 lcd. setCursor((LCD_WIDTH-THERMO_WIDTH) / 2, 3) ;
lcd. drawBitmap(thermometerBitmap, THERMO_WIDTH, ← !
THERMO_HAUTEUR) ;
}

void loop()
{
float temperatureC = getTemperatureC() ;
// maintenant convertir en Fahrenheit
float temperatureF = convertToF(temperatureC) ;

lcd. setCursor(21,1) ;
lcd. print(temperatureF) ;
lcd. drawBitmap(degreesBitmap, DEGREE_WIDTH,
DEGREE_HEIGHT) ;
lcd. print(' F') ;
lcd. setCursor(21, 2) ;
lcd. print(temperatureC) ;
lcd. drawBitmap(degreesBitmap, DEGREE_WIDTH,
DEGREE_HEIGHT) ;
lcd. print(' C') ;

delay(500) ;
}

float getTemperatureC()
{
int lecture = analogRead(kPin_Temp) ;

float voltage = (reading * 5.0) / 1024 ;

 // convertir de 10 mv par degré avec un décalage de 500mV
// en degrés ((tension - 500mV) * 100)
retourner (tension - 0,5) * 100 ;
}

float convertir en F(float temperatureC)

{
retourner (températureC * 9,0 / 5,0) + 32,0 ;
}

Nous avons déjà analysé une importante partie du code, mais les
nouveautés concernent la définition d’un petit graphique (5 pixels de large
sur 1 « ligne » (8 pixels) de haut) que nous emploierons comme symbole de
degré.
Après avoir défini la largeur et la hauteur de l’écran LCD, nous
emploierons par la suite ces variables afin de calculer où positionner les
éléments pour qu’ils soient centrés. En fait, afin de centrer un graphique, il
suffit de le régler sur lcdWidth-graphicWidth / 2 . Il faudra probablement
certains exemples pour vous convaincre de son efficacité, mais il n’en
manque pas une. Nous employons cette méthode afin de déterminer la
colonne de départ, dans ce cas la « ligne » de départ est 3, alors en dessous
de notre affichage. Rappelez-vous que les lignes débutent à 0, il s’agit donc
en fait de la quatrième ligne. Finalement, nous nommons la méthode
drawBitmap() pour dessiner le bitmap. (Bitmap est le nom d’un élément
graphique dans lequel vous donnez les pixels exacts qui doivent être activés
ou désactivés). Cela dessine tout simplement un bitmap de qualité
inférieure.

Création d’un graphique

Nous allons désormais créer un programme qui ne se contente pas
d’afficher la température, mais qui présente aussi un graphique des mesures
récentes (pour savoir si la température se réchauffe ou se refroidit). Une fois
de plus, nous allons en premier démontrer l’ensemble du programme et
analyser les nouvelles parties plus tard. Nous allons enlever la température
en Celsius afin d’avoir plus d’espace pour le graphique.
#include <PCD8544.h>.

const int kPin_CLK = 5 ;

const int kPin_DIN = 6 ;
const int kPin_DC = 7 ;
const int kPin_RESET = 8 ;
const int kPin_Temp = A0 ;

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) ;

// Un graphique bitmap (5x1) d'un symbole de degré.

const int DEGREE_WIDTH = 5 ;
const int DEGREE_HEIGHT = 1 ;
const byte degreesBitmap[] = { 0x00, 0x07, 0x05, 0x07, 0x00 ← !
};

// Un graphique bitmap (10x2) d'un thermomètre...

const int THERMO_WIDTH = 10 ;
const int THERMO_HEIGHT = 2 ;
const octet thermometerBitmap[] =
{ 0x00, 0x00, 0x48, 0xfe, 0x01, 0xfe, 0x00, 0x02, 0x05, 0x02,
0x00, 0x00, 0x62, 0xff, 0xfe, 0x60, 0x00, 0x00← !
};

const int LCD_WIDTH = 84 ;

const int LCD_HEIGHT = 6 ;
const int GRAPH_HEIGHT = 5 ;
const int MIN_TEMP = 50 ;
const int MAX_TEMP = 100 ;

void setup()
{
lcd. init() ;
lcd. setCursor(10,0) ;
lcd. print("Température :") ;
lcd. setCursor(0, LCD_HEIGHT - THERMO_HEIGHT) ;
lcd. drawBitmap(thermometerBitmap, THERMO_WIDTH, ← !
THERMO_HAUTEUR) ;
}

int xChart = LCD_WIDTH ;

void loop()
{
float temperatureC = getTemperatureC() ;
// maintenant convertir en Fahrenheit
float temperatureF = convertToF(temperatureC) ;

lcd. setCursor(21,1) ;
lcd. print(temperatureF) ;
lcd. drawBitmap(degreesBitmap, DEGREE_WIDTH,
DEGREE_HEIGHT) ;
lcd. print(' F') ;
si(xChart >= LCD_WIDTH){
xChart = THERMO_WIDTH + 2 ;
}
lcd. setCursor(xChart, 2) ;
int dataHeight = map(temperatureF, MIN_TEMP, MAX_TEMP, 0, ← !
 HAUTEUR DU GRAPHIQUE * 8) ;

drawColumn(dataHeight) ;
drawColumn(0) ; // marqueur pour voir la position actuelle du
graphique
xChart++ ;

delay(500) ;
}

float getTemperatureC()
{
int lecture = analogRead(kPin_Temp) ;

float voltage = (reading * 5.0) / 1024 ;

// convertir de 10 mv par degré avec un décalage de 500mV
// en degrés ((tension - 500mV) * 100)
retourner (tension - 0,5) * 100 ;
}

float convertir en F(float temperatureC)

{
retourner (températureC * 9,0 / 5,0) + 32,0 ;
}

const octet dataBitmap[] =

{0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE} ;
void drawColumn(unsigned int value)
{
octet graphBitmap[GRAPH_HEIGHT] ;
int i ;

si(valeur > (GRAPH_HEIGHT * 8)){

valeur = GRAPH_HEIGHT * 8 ;
}
// la valeur est le nombre de pixels à dessiner

//1. effacer tous les pixels de graphBitmap

for(i = 0 ; i < GRAPH_HEIGHT ; i++){
graphBitmap[i] = 0x00 ;
}

//2. Remplir tous ceux qui doivent l'être complètement.

i=0;
while(value >= 8){
graphBitmap[GRAPH_HEIGHT - 1 - i] = 0xFF ;
valeur -= 8 ;
i++ ;
}
si(i != GRAPH_HEIGHT){
graphBitmap[GRAPH_HEIGHT - 1 - i] = dataBitmap[value] ;
}
lcd. drawBitmap(graphBitmap, 1, GRAPH_HEIGHT) ;
}

Il est important de savoir que nous avons défini la valeur inférieure et

supérieure de notre graphique, en sélectionnant deux valeurs qui
couvriraient peut-être n’importe quelle température ambiante. Afin de
déterminer l’emplacement du graphique du thermomètre, nous soustrayons
la hauteur du graphique du thermomètre à la hauteur de l’écran LCD. Cela
placera le graphique du thermomètre dans le coin inférieur gauche. Nous
créons désormais une nouvelle variable afin de savoir où nous en sommes
sur notre graphique. La valeur initiale sera LCD_WIDTH, c’est une
variable globale qui peut être placée au-dessus de setup(). Je l’ai mis à cet
endroit afin qu’il soit à côté de la fonction loop().
Si notre xChart se situe au bord de l’écran (ou au-delà), nous le
réinitialisons à 2 au-delà de la largeur du thermomètre. Le 2 est juste afin
d’offrir un peu plus d’espace. Vous avez probablement remarqué que la
valeur initiale était LCD_WIDTH, la première fois qu’elle sera réinitialisée
de cette manière ; par conséquent, si nous décidons de changer
l’espacement, cela ne doit être fait qu’à un seul endroit.
De plus, nous plaçons le curseur de sorte que la chose suivante que nous
envoyons à l’écran LCD se trouve à cette position.
int dataHeight = map(temperatureF, MIN_TEMP, MAX_TEMP, 0,
GRAPH_HEIGHT * 8) ;

drawColumn(dataHeight) ;
drawColumn(0) ; // marqueur pour voir la position actuelle du
graphique
xChart++ ;

De plus, nous calculons la hauteur de la colonne actuelle dans le graphique

à l’aide de notre vieille amie la fonction map(), puis nous appelons
drawColumn() afin de dessiner la colonne. Finalement, nous appelons
drawColumn() avec zéro pour qu’il dessine une colonne vide après celle
que nous venons de dessiner, ce qui donne un indicateur visuel de notre
position. Nous incrémentons xChart pour être à la prochaine position dans
le graphique la prochaine fois que nous sommes ici.
La majorité des nouveautés se trouvent dans notre fonction
drawColumn(). Cette fonction prend en entrée une valeur qui est la
"hauteur" de la ligne à dessiner. L’idée de la fonction est d’ajouter très vite
des segments de 8, puis de calculer la taille du dernier segment. La première
chose que nous faisons est de nous assurer que notre valeur n’est pas
supérieure à ce qu’elle devrait être. Cela ne devrait jamais se produire, mais
nous écririons donc sur la fin de notre tableau, ce qui est vraiment
dangereux et complexe à déboguer, mais cela vaut la peine de vérifier. Nous
mettons alors la valeur de tout ce qui se situe dans graphBitmap à zéro (tous
les pixels sont éteints). Nous faisons cela afin de ne pas avoir à nous soucier
de ce qui a été mis dans ce tableau, car aucune valeur par défaut n’a été
attribuée. La dernière partie de la fonction drawColumn() peut sembler
difficile et vous devrez peut-être exécuter certains exemples afin de vous
convaincre qu’elle fonctionne. Faisons-en un ensemble et ensuite vous
pourrez en faire d’autres afin de mieux comprendre la manière dont cela
fonctionne. Que diriez-vous de valeur == 20 ?
valeur >= 8 - Oui, 20 est supérieur à 8
graphBitmap[GRAPH_HEIGHT - 1 - i] = 0xFF // tout est activé
puisque GRAPH_HEIGHT est 5 et i est 0, donc cela mettra graphBitmap[4]
à 0xFF
valeur -= 8. valeur = 12
i++. (i est maintenant 1)
valeur >= 8 - Oui, 12 est supérieur à 8
graphBitmap[GRAPH_HEIGHT - 1 - i (1)] = 0xFF puisque
GRAPH_HEIGHT est 5 et i est 1, graphBitmap[3] sera mis à 0xFF
valeur -= 8. Maintenant valeur = 4
i++ (i est maintenant 2)
valeur >= 8 - Non, 4 n’est pas supérieur à 8
if(i != GRAPH_HEIGHT) (not is, i = 2, GRAPH_HEIGHT = 5)
graphBitmap[GRAPH_HEIGHT - 1 - i (2)] = dataBitmap[valeur (4) )]
puisque GRAPH_HEIGHT est 5 et i est 2, ceci définira graphBitmap[2] à la
valeur de dataBitmap[4] qui est 0xF0. Au final, notre graphBitmap
ressemblera donc à : 0x00, 0x00, 0xF0, 0xFF, 0xFF (ou en binaire :
0b000000, 0b000000, 0b111100, 0b111111, 0b111111).
En guise d’exercice supplémentaire, vous êtes en mesure de changer le
circuit et le programme de façon à ce qu’un bouton soit attaché et que le
graphique soit redessiné quand nous appuyons sur le bouton, ou vous
pouvez changer le circuit et le programme de manière à ce qu’il y ait un
bouton qui vous aide à passer de Celsius à Farenheit et vice versa.
 10

PISTOLET ÉLASTIQUE

N ous aurons besoin de certains éléments pour ce petit projet, notamment

un servo, qui est un moteur que vous pouvez commander pour un angle
particulier. Un servo a 3 broches : alimentation (normalement rouge), masse
(normalement noire) et une broche de signal (normalement blanche) ; les
servos reçoivent une commande sur l’angle à tourner (entre 0 et 180) et ils
tournent précisément à cette position. Cela en fait un favori pour plusieurs
utilisations parce qu’ils sont relativement simples à contrôler. Le langage
Arduino a un support intégré pour les servos, ce qui les rend très simples à
employer. Afin de commencer, nous allons connecter un servo et un
potentiomètre.

1. Connectez la colonne la plus à droite à GND sur l’Arduino.

2. Connectez la colonne suivante à droite au +5V de l’Arduino.
3. Réglez le potentiomètre sur f1, f2, f3.
4. Connectez j1 à la colonne suivante sur la droite (+5V).
 5. Connectez j3 à la colonne la plus à droite (GND).
6. Connectez j2 à A0 sur l’Arduino.
7. Connectez le fil rouge du servo au +5V (à côté de la colonne de
droite).
8. Connectez le fil noir du servo à GND (colonne de droite).
9. Connectez le fil blanc du servo à la broche 9 de l’Arduino.
10. Ce programme vous donne la chance de tourner le potentiomètre
et de faire tourner le servo en même temps que vous le tournez :

#include <Servo.h>.

Servo servo1 ;

const int kPinPot = A0 ;

const int kPinServo1 = 9 ;

void setup()
{
servo1.attach(kPinServo1) ;
}

void loop()
{
int val = analogRead(kPinPot) ;
val = map(val, 0, 1023, 0, 180) ;
servo1.write(val) ;
retard (15) ;
}
Il n’y a que deux choses qui sont nouvelles ici. Effectivement, nous avons
connecté le servo (en lui indiquant sur quelle broche il se trouve) et envoyé
une valeur (0 à 180) pour l’angle.
Un joystick, qui peut être employé avec le pouce, sera aussi nécessaire
pour notre petit projet. Il se compose de 2 potentiomètres (un pour l’axe des
x et un pour l’axe des y) et d’un interrupteur (pour le moment où l’on
appuie sur le bouton).

1. Connectez la colonne la plus à droite à GND sur l’Arduino.

2. Connectez la colonne suivante à droite au +5V de l’Arduino.
3. Insérez la carte breakout du joystick dans d1-d5.
4. Connectez a1 à la colonne suivante sur la droite (+5V).
5. Connectez a2 à A5 sur l’Arduino.
6. Connectez a3 à A4 sur l’Arduino.
7. Connectez a4 à la broche 2 de l’Arduino.
8. Connectez a5 à la colonne la plus à droite (GND).

Nous autorisons une « zone morte » au centre du joystick où aucune

direction n’est enregistrée. Cela nous aide à ne pas avoir à nous soucier de
la « gigue » inhérente aux dispositifs mécaniques. Vous pouvez constater les
valeurs modifier dans le moniteur série.
const int kPinJoystickX = A5 ;
const int kPinJoystickY = A4 ;
const int kPinJoystickFire = 2 ;
const int JOYX_LEFT = 300 ;
const int JOYX_RIGHT = 700 ;
const int JOYY_UP = 700 ;
const int JOYY_DOWN = 300 ;

void setup()
{
pinMode(kPinJoystickFire, INPUT) ;
digitalWrite(kPinJoystickFire, HIGH) ; // activer la résistance pull-up
Serial. begin(9600) ;
}

void loop()
{
int xVal = analogRead(kPinJoystickX) ;
int yVal = analogRead(kPinJoystickY) ;

Serial. print("x = ") ;

Serial. print(xVal) ;
Serial. print(' y = ') ;
Serial. print(yVal) ;
Serial. print(' ') ;

si(xVal < JOYX_LEFT){

Serial. print('L') ;
}
else if(xVal > JOYX_RIGHT){
Serial. print('R') ;
}
 si(yVal < JOYY_DOWN){
Serial. print('D') ;
}
else if(yVal > JOYY_UP){
Serial. print('U') ;
}
si(digitalRead(kPinJoystickFire) == LOW){
Serial. print("+F") ;
}
Serial. println() ;

delay(100) ; // Empêcher la série de s'emballer

}

Comme les lectures du joystick se trouvent dans une plage comprise entre 0
et 1023, nous divisons cette plage en sections. Nous définissons une valeur
inférieure à 300 comme GAUCHE (ou HAUT), supérieure à 700 comme
DROITE (ou BAS) et tout ce qui se situe entre les deux est CENTRAL. Le
+F affiche que le joystick a été pressé.
Maintenant que nous disposons d’une excellente base, il ne nous
manque plus que deux composants afin de mener à bien notre petit projet,
dont le support panoramique/inclinable. Nous avons attaché deux servos au
support de pan/tilt. Cela nous aidera à effectuer un panoramique (0-180
degrés) et une inclinaison (0-180 degrés). Attachons-le au joystick pour la
visée.
 Voici une recommandation : si vous ne démontez pas le circuit dans la
dernière section, vous pouvez débuter par l’étape 9.
1. Connectez la colonne la plus à droite à GND sur l’Arduino.
2. Connectez la colonne suivante à droite au +5V de l’Arduino.
3. Réglez le circuit imprimé du joystick sur d1-d5.
4. Connectez a1 sur la planche à pain à la colonne suivante sur la droite
(+5V).
5. Connectez a2 sur la planche à pain à A5 sur l’Arduino.
6. Connectez a3 sur la planche à pain à A4 sur l’Arduino.
7. Connectez a4 sur la planche à pain à la broche 2 de l’Arduino.
8. Connectez a5 sur la planche à pain à la colonne la plus à droite
(GND).
9. Connectez le fil noir du servo du bas (le servo panoramique) à la
colonne de l’extrême droite (GND).
10. Connectez le fil rouge du servo du bas (le servo panoramique) à la
colonne suivante sur la droite (+5V)
11. Connectez le fil blanc du servo en bas (le plateau du servo) à la
broche 9 de l’Arduino.
12. Connectez le fil noir du servo au centre (le servo d’inclinaison) à la
colonne à l’extrême droite (GND).
13. Connectez le fil rouge du servo au centre (le servo d’inclinaison) à
la colonne suivante à droite (+5V).
14. Connectez le fil blanc du servo au centre (le servo d’inclinaison) à la
broche 10 de l’Arduino.
Voici ci-dessous le code dont vous avez besoin :
#include <Servo.h>.

const int kPinJoystickX = A5 ;

const int kPinJoystickY = A4 ;
const int kPinJoystickFire = 2 ;
const int kPinServoPan = 9 ;
const int kPinServoTilt = 10 ;

const int JOYX_LEFT = 300 ;

 const int JOYX_RIGHT = 700 ;
const int JOYY_UP = 700 ;
const int JOYY_DOWN = 300 ;

Servo panServo ;
TiltServo ;

int panAngle = 0 ;
int tiltAngle = 90 ;

void setup()
{
panServo. attach(kPinServoPan) ;
tiltServo. attach(kPinServoTilt) ;
}

void loop()
{
int xVal = analogRead(kPinJoystickX) ;
int yVal = analogRead(kPinJoystickY) ;

si(xVal < JOYX_LEFT){

panAngle-- ;
}
else if(xVal > JOYX_RIGHT){
panAngle++ ;
}
si(yVal < JOYY_DOWN){
tiltAngle-- ;
}
 else if(yVal > JOYY_UP){
tiltAngle++ ;
}
tiltAngle = constrain(tiltAngle, 0, 180) ;
panAngle = constrain(panAngle, 0, 180) ;

panServo. write(panAngle) ;
tiltServo. write(tiltAngle) ;
delay(20) ; // attendez que les servos arrivent.
}

Notre vieille amie, la fonction constrain(), veille à ce que PanAngle et

TiltAngle restent dans la plage de valeurs dans laquelle les servos peuvent
fonctionner. Désormais, nous connectons un autre servo afin d’activer
l’élastique et notre pistolet sera prêt sous peu. Si vous n’avez pas démonté
le circuit dans la dernière section, vous pouvez débuter par l’étape 15.

1. Connectez la colonne la plus à droite à GND sur l’Arduino.

2. Connectez la colonne suivante à droite au +5V de l’Arduino.
3. Mettez le circuit imprimé du joystick dans d1-d5.
4. Connectez a1 sur la planche à pain à la colonne suivante sur la
droite (+5V).
5. Connectez a2 sur la planche à pain à A5 sur Arduino.
6. Connectez a3 sur la planche à pain à A4 sur Arduino.
7. Connectez a4 sur la planche à pain à la broche 2 de l’Arduino.
8. Connectez a5 sur la planche à pain à la colonne la plus à droite
(GND).
9. Connectez le fil noir du servo du bas (le servo panoramique) à la
colonne à l’extrême droite (GND).
10. Connectez le fil rouge du servo du bas (le servo de
panoramique) à la colonne suivante sur la droite (+5V).
11. Connectez le fil blanc du servo en bas (le plateau du servo) à la
broche 9 de l’Arduino.
 12. Connectez le fil noir du servo au centre (le servo d’inclinaison) à
la colonne à l’extrême droite (GND).
13. Connectez le fil rouge du servo au centre (le servo d’inclinaison)
à la colonne suivante sur la droite (+5V).
14. Connectez le fil blanc du servo au centre (le servo d’inclinaison)
à la broche 10 de l’Arduino.
15. Connectez le fil noir du servo supérieur (le servo de tir) à la
colonne à l’extrême droite (GND).
16. Connectez le fil rouge du servo supérieur (le servo de feu) à la
colonne suivante sur la droite (+5V).
17. Connectez le fil blanc du servo supérieur (le servo de feu) à la
broche 11 de l’Arduino.

#include <Servo.h>.

const int kPinJoystickX = A5 ;

const int kPinJoystickY = A4 ;
const int kPinJoystickFire = 2 ;
const int kPinServoPan = 9 ;
const int kPinServoTilt = 10 ;
const int kPinServoFire = 11 ;

const int JOYX_LEFT = 300 ;

const int JOYX_RIGHT = 700 ;
const int JOYY_UP = 700 ;
const int JOYY_DOWN = 300 ;

Servo panServo ;
TiltServo ;
Servo fireServo ;
int panAngle = 90 ;
int tiltAngle = 90 ;
int fireAngle = 0 ;

void setup()
{
pinMode(kPinJoystickFire, INPUT) ;
digitalWrite(kPinJoystickFire, HIGH) ; // activer le pull-up â†!
résistance
fireServo. attach(kPinServoFire) ;
fireServo. write(0) ;
delay(500) ;
fireServo. detach() ;
panServo. attach(kPinServoPan) ;
tiltServo. attach(kPinServoTilt) ;
}

void loop()
{
int xVal = analogRead(kPinJoystickX) ;
int yVal = analogRead(kPinJoystickY) ;

si(xVal < JOYX_LEFT){

panAngle-- ;
}
else if(xVal > JOYX_RIGHT){
panAngle++ ;
}
si(yVal < JOYY_DOWN){
tiltAngle-- ;
}
else if(yVal > JOYY_UP){
tiltAngle++ ;
 }
tiltAngle = constrain(tiltAngle, 0, 180) ;
panAngle = constrain(panAngle, 0, 180) ;

panServo. write(panAngle) ;
tiltServo. write(tiltAngle) ;
delay(20) ; // attendez que les servos arrivent.

si(digitalRead(kPinJoystickFire) == LOW){
fireServo. attach(kPinServoFire) ;
fireServo. write(180) ;
delay(500) ;
fireServo. write(0) ;
delay(500) ;
fireServo. detach() ;
while(digitalRead(kPinJoystickFire) == LOW){
// attendre qu'il ne soit plus bas
}
}
}

La raison pour laquelle nous attachons et détachons le fireServo est que

nous ne le déplaçons pas vraiment de manière fréquente et que nous ne
souhaitons pas lui envoyer des commandes en permanence tandis que nous
savons que nous ne l’emploierons pas vraiment souvent. L’appel
fireServo.write(180) est celui qui active réellement l’élastique. Il revient par
la suite à 0 afin que l’élastique suivant puisse être chargé. À titre d’exercice,
vous pourriez connecter le joystick et 5 LED, une affichant lorsque le
joystick est pressé vers le haut, une quand il est pressé vers le bas, une à
gauche, une à droite et une pour le feu. En fait, vous pouvez demander à un
servo d’effectuer un balayage lent de 0 à 180, puis de revenir en arrière.
 11

UN PROJET PLUS IMPORTANT

D ans ce chapitre, nous allons mettre en œuvre une configuration

domotique facile à faire soi-même en employant un kit de
développement de microcontrôleur Arduino. Vous apprendrez à transformer
n’importe quel appareil ménager en un dispositif de maison intelligente et à
le contrôler depuis votre téléphone intelligent. Qu’il s’agisse de contrôler
les lumières de votre chambre avec votre téléphone intelligent ou de
programmer des événements qui se produisent automatiquement, la
domotique a porté la commodité et l’utilité à un tout autre niveau. Au lieu
d’employer des interrupteurs mécaniques, vous pouvez maintenant
contrôler tous les appareils de votre maison du bout des doigts. Cependant,
ce confort a un prix assez élevé. Par exemple, une ampoule LED ordinaire
coûte certains euros. Le kit de maison intelligente Philips Hue est
disponible pour à peu près 100 euros, chaque ampoule coûtant à peu près 30
euros. Il se trouve des prises intelligentes qui vous aident à contrôler
n’importe quel appareil électrique depuis votre téléphone intelligent et les
prix débutent à environ 25 euros. À moins que vous ne soyez prêt à
dépenser des centaines d’euros pour des appareils domestiques intelligents,
vous ne pourrez pas étendre le champ d’application de la domotique afin de
contrôler tous les appareils de votre maison. Ce chapitre illustre la façon de
mettre en place une domotique facile à faire soi-même à l’aide d’un
Arduino, ce qui vous aidera à économiser beaucoup d’argent. L’ensemble
de la configuration prend moins de 15 minutes et vous coûte moins de 30
euros. En fait, le coût supplémentaire lié à l’ajout d’appareils
supplémentaires est réduit à certains euros par appareil.
 Voici ci-dessous ce dont vous aurez besoin afin de débuter :

Arduino UNO (ou Mega, Pro, Mini)

Module de relais
Module sans fil Bluetooth HC 05
Lampe
Résistance de 2.2k ohm
Résistance de 1k ohm
Planche à pain
Câbles de connexion

Une fois que vous avez l’ensemble des composants nécessaires, voici la
façon que vous devez câbler votre Arduino :

Comment connecter le Bluetooth HC-05 à Arduino ?

1. Connectez les broches +5V et GND de l’Arduino aux bandes de

bus sur la planche à pain, comme affiché dans le schéma de
circuit illustré ci-dessus.
2. Alimentez le module HC-05 en connectant les broches 5V et
GND aux bandes de bus sur la planche d’essai. Le HC-05 est
alimenté à 5 V DC, mais détient un régulateur de tension intégré
qui génère une alimentation de 3,3 V afin d’alimenter le
 transceiver. Cela veut dire que les broches TXD/RXD
fonctionnent à 3,3 V seulement.
3. Connectez la broche TXD du module HC-05 avec la broche
RXD (Pin 0) de l’Arduino. Cette connexion aide le HC-05 à
envoyer des données à l’Arduino. La raison de combiner TXD
sur le module Bluetooth avec RXD sur l’Arduino est simple. La
broche TXD est employée afin de transmettre des données
depuis l’émetteur-récepteur Bluetooth, alors que la broche RXD
est employée afin de recevoir des données sur l’Arduino. Bien
que l’Arduino emploie des niveaux de signal de 5 V et que le
HC-05 n’emploie que des niveaux de signal de 3,3 V, aucun
changement de niveau n’est requis sur ce signal particulier.
Effectivement, l’Arduino est basé sur un microcontrôleur Atmel
ATmega328 qui définit la logique "haute" comme tout niveau
supérieur à 3V. Par conséquent, aucun changement de niveau
n’est requis pendant le passage de 3,3V à 5V. Toutefois, ce n’est
pas toujours vrai lorsqu’on va dans le sens inverse, de 5V à
3,3V, comme nous allons le constater à la prochaine étape.

Désormais nous devons connecter la broche TXD de l’Arduino à la

broche RXD du HC-05. Cette connexion formera la seconde moitié de la
communication bidirectionnelle et constitue la façon dont l’Arduino envoie
des informations au HC-05.
Comme les lignes de données du récepteur du HC-05 ne tolèrent que
3,3V, il est requis de convertir le signal de transmission de 5V de l’Arduino
en un signal de 3,3V. Bien qu’il soit en général préférable d’utiliser un
convertisseur de niveau logique, nous employons plutôt un simple diviseur
de tension afin de convertir le signal 5V en un signal 3,3V.
Comme illustré dans le schéma du circuit, nous avons connecté une
résistance de 1k ohm et une résistance de 2,2k ohm entre les broches GND
et TXD de l’Arduino. Nous l’appelons un diviseur résistif parce qu’il divise
la tension d’entrée. Nous obtenons le signal de niveau 3.3V à l’intersection
de ces deux résistances.
L’équation en ce qui concerne une tension divisée est la suivante :
Vout = [2.2k/(2.2k + 1k)]*5V = (2.2k/3.2k)*5V = 3.46V, ce qui est
suffisamment proche de 3.3V afin de ne pas endommager le module HC-05.
 Cette solution rudimentaire ne doit jamais être employée avec un signal
à haute vitesse, car les résistances forment un filtre RC passe-bas sur la
connexion. Après avoir connecté le module HC-05 à l’Arduino, vous êtes
en mesure d’alimenter l’Arduino avec une alimentation 12 V DC ou un
câble USB. Si les LEDs rouges et bleues du HC-05 clignotent, cela veut
dire que vous avez correctement connecté le module Bluetooth avec
l’Arduino.
Nous n’employons pas les broches STATE et EN sur le module HC-05
parce qu’elles ne sont pas nécessaires pour cette configuration.

L’étape suivante consiste à connecter l’Arduino à un module relais, afin

de pouvoir allumer ou éteindre le dispositif connecté. Comme l’illustre le
schéma de circuit ci-dessus, nous allons connecter le module de relais en
série, de sorte que nous puissions couper la connexion lorsque nous
souhaitons éteindre l’appareil et compléter le circuit quand nous souhaitons
l’allumer. En ce qui concerne cette application, nous employons un module
de relais qui possède le circuit de commande du relais à connecter
directement à une broche GPIO du microcontrôleur.
REMARQUE : Le module de relais que nous employons peut gérer
jusqu’à 10 ampères de courant jusqu’à 240 VAC. Ce courant est suffisant
pour plusieurs appareils, mais pas pour les appareils à forte puissance
comme un sèche-linge ou une pompe à chaleur. Pour les appareils à forte
puissance, vous aurez probablement besoin d’environ deux fois la capacité
de courant (~20 ampères). Vous pouvez améliorer cette configuration avec
un relais à courant plus élevé ou placer de nombreux relais en parallèle.
Deux relais de 10 A en parallèle sont équivalents à un seul relais de 20 A
parce que la moitié du courant passe par chaque relais.
Voici ci-dessous la manière de connecter le module relais à l’Arduino :

1. En premier lieu, connectez les broches 5V et GND du module

relais aux bornes du bus sur la planche d’essai.
2. Deuxièmement, connectez la broche IN1 du module relais avec
la broche 4 de l’Arduino. Si vous avez un module multicanal (2,
4 ou 8 canaux), vous pouvez connecter IN2, IN3 ... In(n) avec
différentes broches numériques sur l’Arduino et répéter les
étapes suivantes afin de configurer les autres broches.
3. Nous devons désormais connecter la charge CA au module de
relais. Si vous observez attentivement le bornier du module
relais, vous trouverez les trois termes suivants :

C : Municipalité
NC : Normalement fermé
NO : Normalement ouvert

Quand le relais est désactivé, la borne COM est connectée à la borne

NC (normalement fermée), ce qui veut dire que si nous connectons
l’ampoule à la borne NC, elle s’allumera même si le relais n’est pas
alimenté. Mais ce n’est pas ce que nous souhaitons, nous souhaitons
simplement allumer l’ampoule quand nous envoyons un signal depuis notre
téléphone intelligent. C’est pourquoi nous connectons la charge à la borne
NO (normalement ouverte), de sorte que quand le relais est alimenté par
l’Arduino, le contact passe de la borne NC à la borne NO, complétant ainsi
le circuit.
Après avoir câblé tout correctement, la prochaine étape consiste à
télécharger le code sur l’Arduino. Afin de télécharger le code, connectez
l’Arduino via le port USB de votre ordinateur et ouvrez l’IDE Arduino. Par
la suite, copiez le sketch ci-dessous dans une nouvelle fenêtre et tentez de
l’exécuter sur votre Arduino.
#define RELAY_ON 0
#define RELAY_OFF 1
#define RELAY_1 4
char data = 0 ;
void setup() {
// Définir la broche comme sortie.
pinMode(RELAY_1, OUTPUT) ;
// Initialiser le relais 1 comme étant désactivé afin qu'il soit désactivé
par défaut lors de la réinitialisation.
digitalWrite(RELAY_1, RELAY_OFF) ;
Serial. begin(9600) ;
Serial. print("Type : 1 pour allumer l'ampoule. 0 pour l'éteindre !") ;
}
void loop() {
if (Serial. available() > 0) {
data = Serial. read() ; //Lire les données entrantes et les stocker dans la
variable data
Serial. print(data) ; //Imprimez la valeur contenue dans data dans le
moniteur Serial.
Serial. print("\n") ; //Nouvelle ligne
if(data == '1'){
digitalWrite(RELAIS_1, RELAIS_ON) ;
Serial. println("L'ampoule est maintenant allumée. ") ;
}
else if(data == '0'){
digitalWrite(RELAY_1, RELAY_OFF) ;
Serial. println("L'ampoule est maintenant éteinte. ") ;
}
}
 }

Le code est en fait assez facile. Il initialise tout d’abord le relais dans la
méthode setup(), puis attend une entrée sur le port série dans la méthode
loop(). Si un '1' est reçu en entrée, le relais est activé ; si un '0' est reçu, le
relais est désactivé. Comme l’Arduino UNO utilise son port UART pour la
programmation, il ne peut pas communiquer avec l’ordinateur et recevoir
des données du module Bluetooth HC-05 en même temps. Si vous tentez le
code ci-dessus sur un Arduino UNO, vous devriez recevoir l’erreur ci-
dessous :
avrdude : stk500_getsync() attempt 1 of 10 : not in sync : resp=0x00
Une erreur s'est produite lors du téléchargement de l'esquisse

Mais ne vous inquiétez pas. Il suffit de déconnecter le fil du cavalier

connecté à la broche 0 de l’Arduino UNO (broche RXD) et de réessayer la
mise à jour du code. Vous devriez maintenant être en mesure de mettre à
jour le code correctement. Quand vous avez fini la programmation,
rebranchez le câble de liaison et tout devrait fonctionner.

Contrôle des ampoules depuis votre appareil Android

Désormais que nous avons configuré le matériel et chargé le code
correctement, l’étape ci-dessous consiste à contrôler l’installation depuis un
téléphone intelligent. Afin de ce faire, vous devez télécharger l’application
Arduino Bluetooth Controller sur votre appareil Android.
Voici la façon de configurer votre appareil Android afin d’envoyer des
commandes à l’Arduino :

1. Ouvrez l’application sur votre téléphone intelligent, elle vous

demandera des autorisations Bluetooth, ensuite cliquez sur
« Autoriser ».
2. Ensuite, la liste de tous les appareils disponibles à proximité sera
affichée. Sélectionnez HC-05.
 3. Une fois que vous avez sélectionné le dispositif, vous serez
connecté au transceiver HC-05. L’application vous demandera
alors de saisir le mode que vous voulez utiliser.
4. Vous devriez être redirigé vers l’écran suivant. Cliquez sur
l’icône « Paramètres » dans le coin supérieur droit de l’écran.
5. Finalement, il vous demandera de définir des valeurs pour ON et
OFF. Tapez '1' dans la zone de texte ON et '0' dans la zone de
texte OFF. Sauvegardez la configuration.

En employant la configuration ci-dessus, vous pouvez transformer

n’importe quel appareil en un appareil intelligent qui peut être contrôlé par
votre téléphone intelligent. Bien qu’un seul relais ait été utilisé dans cet
exemple, vous pouvez simplement étendre le système en utilisant un
module de relais à 8 canaux.
Remarque : afin de simplifier les choses, nous avons employé une
application Bluetooth qui n’aide à contrôler qu’un seul appareil, mais si
vous voulez contrôler de nombreux appareils, vous pouvez employer une
application de contrôle Bluetooth plus avancée ou écrire votre propre
application Android. Il est important de noter que dans cet exemple, nous
avons posé les bases du contrôle des charges électriques à l’aide d’un
contrôleur Arduino et d’un téléphone intelligent. Toutefois, ce que nous
avons réussi à réaliser jusqu’à maintenant ne représente qu’un minuscule
cas d’utilisation de la domotique. Idéalement, nous devrions être en mesure
de faire beaucoup plus, par exemple :
- Programmez l’allumage et l’extinction des appareils à des heures
précises ;
- Baisse de la température de la maison ou des lumières à des niveaux
prédéfinis ;
- Contrôlez les dispositifs infrarouges (IR) dans la maison ;
- Verrouiller ou déverrouiller les portes.

Bien que les cas ci-dessus soient certainement plus difficiles que la
commande d’un appareil électrique via un relais, notre objectif ultime est de
construire un système domotique à faire soi-même, peu coûteux et évolutif.
Je vous invite alors à expérimenter, à rechercher et à développer de
nouvelles solutions, toujours en toute sécurité. ATTENTION : Le courant
alternatif haute tension peut être potentiellement vraiment dangereux,
veillez donc à respecter les mesures de sécurité appropriées. Nous
n’assumons aucune responsabilité pour toute blessure ou tout dommage qui
pourrait survenir en suivant ce livre. Si vous avez des doutes, demandez à
un expert ou renseignez-vous sur Internet.
 12

DOMOTIQUE ET RFID

D ans ce chapitre, qui fait suite au chapitre précédent sur la domotique,

nous allons apprendre ce qu’est la RFID, la façon dont elle fonctionne
et la manière de mettre en œuvre une serrure RFID basée sur Arduino.
La RFID (Radio Frequency IDentification) est une technologie sans
contact largement employée dans de nombreux secteurs pour des activités
comme le suivi du personnel, le contrôle d’accès, la gestion de la chaîne
d’approvisionnement, le suivi des livres dans les bibliothèques, les systèmes
de péage et ainsi de suite.

Comment fonctionne la RFID

Un système RFID se compose de deux éléments principaux : un
transpondeur ou une étiquette sur l’objet que nous voulons identifier, et un
émetteur-récepteur ou un lecteur. Le lecteur RFID se compose d’un module
radiofréquence, d’une unité de contrôle et d’une bobine d’antenne qui
génère un champ électromagnétique à haute fréquence. D’autre part,
l’étiquette est en général un composant passif, constitué uniquement d’une
antenne et d’une puce électronique. Par conséquent, quand elle s’approche
du champ électromagnétique de l’émetteur-récepteur, par induction, une
tension est générée dans sa bobine d’antenne. En fait, cette tension sert
d’alimentation pour la puce.
Désormais, quand l’étiquette est alimentée, elle peut extraire le message
transmis par le lecteur et employer une technique nommée manipulation de
charge pour envoyer le message au lecteur. De plus, l’activation et la
désactivation d’une charge sur l’antenne de l’étiquette affectera la
consommation d’énergie de l’antenne du lecteur, qui peut être mesurée
comme une chute de tension. Notez que ces variations de tension seront
saisies sous forme de uns et de zéros et c’est ainsi que les données sont
transférées de l’étiquette au lecteur. Il existe aussi une autre manière de
transférer des données entre le lecteur et l’étiquette, appelé couplage
rétrodiffusé. Dans ce cas, l’étiquette emploie une partie de l’énergie reçue
afin de générer un autre champ électromagnétique qui sera capté par
l’antenne du lecteur.

RFID et Arduino
C’est le principe de fonctionnement de base et maintenant observons la
façon que nous pouvons employer la RFID avec Arduino et construire notre
propre serrure RFID. Nous emploierons des étiquettes basées sur le
protocole MIFARE et le lecteur RFID MFRC522, qui ne coûte que
quelques euros.
Ces étiquettes possèdent une mémoire de 1 kb et une puce capable
d’effectuer des opérations arithmétiques. Il est important de noter que leur
fréquence de fonctionnement est de 13,56 MHz et la distance de
fonctionnement peut atteindre 10 cm selon la géométrie de l’antenne.
Remarquez que si l’on tient l’une de ces étiquettes à la lumière ou devant
une source lumineuse, nous sommes en mesure de constater que l’antenne
et la micropuce mentionnées ci-dessus.
Quant au module de lecture RFID, il emploie le protocole SPI pour
communiquer avec la carte Arduino et voici la façon dont nous devons les
connecter. Veuillez remarquer que nous devons connecter le VCC du
module à 3.3V et que pour les autres broches, nous n’avons pas à nous
inquiéter parce qu’elles sont tolérantes à 5V.
 Voici aussi le mapping du PIN sur l’Arduino :

Il est important de savoir qu’une fois le module connecté, nous devons

télécharger la bibliothèque MFRC522 sur GitHub à partir du lien suivant :
https://github.com/miguelbalboa/rfid. L’utilisation d’une bibliothèque n’est
pas quelque chose de mauvais parce qu’elle vous aide simplement à ne pas
réinventer la roue, en concentrant davantage votre attention sur votre projet.
La bibliothèque en question est accompagnée de plusieurs bons exemples à
partir desquels nous avons la chance d’apprendre à employer le module.
Premièrement, nous pouvons charger l’exemple 'DumpInfo' et vérifier si
notre système fonctionne correctement. Maintenant, si vous illustrez le
moniteur série et approchez le tag du module, le lecteur débutera à lire le
tag et toutes les informations du tag seront présentées sur le moniteur série.
Nous sommes en mesure de constater ici le numéro UID de l’étiquette ainsi
que 1 KB de mémoire qui est en fait divisé en 16 secteurs, chaque secteur
en 4 blocs et chaque bloc est en mesure de stocker 2 bytes de données. Pour
ce chapitre, nous n’emploierons pas la mémoire du tag, nous utiliserons
seulement le numéro UID du tag.
Avant d’analyser le code de notre projet de serrure RFID, jetons un
coup d’œil aux composants et aux schémas de circuit de ce projet :

En plus du module RFID, nous emploierons un capteur de proximité

afin de vérifier si la porte est fermée ou ouverte, un servomoteur pour le
mécanisme de verrouillage et un afficheur de caractères.
Vous pouvez vous procurer les composants requis à ce projet Arduino
sur Amazon ou bien sur les principales plateformes en ligne :

Module RFID MFRC522

Servomoteur
Affichage LCD
Carte Arduino
Planche à pain et câbles de connexion
Capteur de proximité CNY70

Le projet se déroule de la façon ci-dessous : nous devons en premier

lieu mettre en place un tag maître, ensuite le système passe en mode
normal. Si nous scannons une balise inconnue, l’accès nous sera refusé,
mais si nous scannons le maître, nous entrerons dans un mode programme à
partir duquel nous pourrons ajouter et autoriser la balise inconnue. Plus
tard, si nous scannons à nouveau l’étiquette, l’accès sera accordé et nous
pourrons ouvrir la porte.
De plus, la porte se verrouille automatiquement après sa fermeture. Si
nous souhaitons retirer une étiquette du système, il nous suffit de revenir en
mode programme, de scanner l’étiquette connue et elle sera retirée. En
premier lieu, nous devons inclure les bibliothèques en ce qui concerne le
module RFID, l’écran et le servomoteur, définir quelques variables
nécessaires au programme sous-jacent et créer les instances des
bibliothèques.
#include <SPI.h>.
#include <MFRC522.h>.
#include <LiquidCrystal.h>.
#include <Servo.h>.

#define RST_PIN 9
#define SS_PIN 10

octet readCard[4] ;
char* myTags[100] = {} ;
int tagsCount = 0 ;
String tagID = '' ;
boolean successRead = false ;
booléen correctTag = false ;
int proximitySensor ;
booléen doorOpened = false ;

// Créer des instances

MFRC522 mfrc522(SS_PIN, RST_PIN) ;
LiquidCrystal lcd(2, 3, 4, 5, 6, 7) ; //Paramètres : (rs, enable, d4, d5, d6,
d7)
Servo myServo ; // Servo moteur
Dans la partie configuration, nous débutons par initialiser les modules et
définissons la valeur initiale du servomoteur sur une position de blocage.
Par la suite, nous imprimons le message initial sur l'écran et avec la boucle
'while' suivante, nous attendons qu’une étiquette maître soit scannée. La
fonction personnalisée getID() obtient l'UID du tag et nous l’insérons dans
la première position du tableau myTags[0].
void setup() {
// Initiation
SPI. begin() ; // bus SPI
mfrc522.PCD_Init() ; // MFRC522
lcd. begin(16, 2) ; // écran LCD
myServo. attach(8) ; // Servo moteur

myServo. write(10) ; // Position initiale de verrouillage du servomoteur

// Imprime le message initial
lcd. print("-No Master Tag!-") ;
lcd. setCursor(0, 1) ;
lcd. print(" SCAN NOW") ;
// Attend qu'une carte maîtresse soit scannée.
while ( ! successRead) {
successRead = getID() ;
si ( successRead == true) {
myTags[tagsCount] = strdup(tagID. c_str()) ; // Place le tag maître à la
position 0 dans le tableau
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print("Master Tag Set !") ;
tagsCount++ ;
}
}
successRead = false ;
printNormalModeMessage() ;
}
Jetons un coup d’œil à la fonction personnalisée getID(). Il vérifie en
premier lieu s’il y a une nouvelle étiquette placée à côté du lecteur et si
c’est le cas, nous continuons avec la boucle for qui obtiendra l’UID de
l’étiquette. Les étiquettes que nous employions ont un numéro UID de 4
octets, c’est pourquoi nous devons faire 4 itérations avec cette boucle et en
employant la fonction concat() nous ajoutons les 4 octets dans une seule
variable de type String. Nous mettons aussi tous les caractères de la chaîne
en majuscules et arrêtons la lecture à la fin.
uint8_t getID() {
// Se préparer à la lecture des PICC
if ( ! mfrc522.PICC_IsNewCardPresent()) { //Si un nouveau PICC est
placé sur le lecteur RFID, continuez.
retourner 0 ;
}
if ( ! mfrc522.PICC_ReadCardSerial()) { //Puisqu'un PICC est placé,
récupérer Serial et continuer
retourner 0 ;
}
tagID = '' ;
for ( uint8_t i = 0 ; i < 4 ; i++) { // Les PICC MIFARE que nous
utilisons ont 4 octets UID
readCard[i] = mfrc522.uid. uidByte[i] ;
tagID. concat(String(mfrc522.uid. uidByte[i], HEX)) ; // Ajoute les 4
octets dans une seule variable String
}
tagID. toUpperCase() ;
mfrc522.PICC_HaltA() ; // Arrêt de la lecture
retour 1 ;
}

Avant d'entrer dans la boucle principale, à la fin de la section de

configuration, nous appelons aussi la fonction personnalisée
printNormalModeMessage() qui imprime le message sur l'écran.
void printNormalModeMessage() {
retard (1500) ;
lcd. clear() ;
 lcd. print("-Access Control-") ;
lcd. setCursor(0, 1) ;
lcd. print(' Scan Your Tag!') ;
}

Dans le cycle principal, nous débutons par lire la valeur du capteur de

proximité, qui nous affiche si la porte est fermée ou non.
int proximitySensor = analogRead(A0) ;

Par la suite, si la porte est fermée, en employant les mêmes lignes que nous
avons décrites dans la fonction personnalisée getID(), nous scannerons et
obtiendrons l’UID du nouveau tag. Nous pouvons observer ici que le code
n’ira pas plus loin tant que nous n’aurons pas scanné une balise, en raison
de l’instruction « return » de l’instruction « if ». Une fois que le tag a été
scanné, nous vérifions si ce tag est le maître que nous avons précédemment
enregistré, si c’est le cas, nous entrons dans le mode dédié. Il est important
de savoir que dans ce mode, si nous scannons une étiquette déjà autorisée,
elle sera supprimée du système ou, si l’étiquette est inconnue, elle sera
ajoutée au système comme autorisée.
// Vérifie si l'étiquette scannée est l'étiquette principale.
if (tagID == myTags[0]) {
lcd. clear() ;
lcd. print("Mode programme :") ;
lcd. setCursor(0, 1) ;
lcd. print("Add/Remove Tag") ;
while ( ! successRead) {
successRead = getID() ;
si ( successRead == true) {
for (int i = 0 ; i < 100 ; i++) {
if (tagID == myTags[i]) {
myTags[i] = '' ;
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(' Tag Removed!') ;
 printNormalModeMessage() ;
retour ;
}
}
myTags[tagsCount] = strdup(tagID. c_str()) ;
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(' Tag Added!') ;
printNormalModeMessage() ;
tagsCount++ ;
retour ;
}
}
}

En dehors du mode dédié, avec la boucle 'for' suivante, nous vérifions si le

tag scanné est égal à l’un des tags enregistrés et ouvrons la porte ou gardons
l’accès refusé. Finalement, dans l'instruction « else », nous attendons que la
porte soit fermée, ensuite nous la fermons et imprimons à nouveau le
message en mode normal.
// Vérifie si l'étiquette scannée est autorisée.
for (int i = 0 ; i < 100 ; i++) {
if (tagID == myTags[i]) {
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(" Accès autorisé ! ") ;
myServo. write(170) ; // Déverrouille la porte
printNormalModeMessage() ;
correctTag = true ;
}
}
si (correctTag == false) {
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(' Accès refusé!') ;
printNormalModeMessage() ;
 }
}
// Si la porte est ouverte...
else {
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(' Door Opened!') ;
while ( ! doorOpened) {
proximitySensor = analogRead(A0) ;
if (proximitySensor > 200) {
doorOpened = true ;
}
}
doorOpened = false ;
delay(500) ;
myServo. write(10) ; // Verrouille la porte
printNormalModeMessage() ;
}

Nous avons examiné chaque section du code, et voici le code complet du

projet :
#include <SPI.h>.
#include <MFRC522.h>.
#include <LiquidCrystal.h>.
#include <Servo.h>.

#define RST_PIN 9
#define SS_PIN 10

octet readCard[4] ;
char* myTags[100] = {} ;
int tagsCount = 0 ;
String tagID = '' ;
 boolean successRead = false ;
booléen correctTag = false ;
int proximitySensor ;
booléen doorOpened = false ;

// Créer des instances

MFRC522 mfrc522(SS_PIN, RST_PIN) ;
LiquidCrystal lcd(2, 3, 4, 5, 6, 7) ; //Paramètres : (rs, enable, d4, d5, d6,
d7)
Servo myServo ; // Servo moteur

void setup() {
// Initiation
SPI. begin() ; // bus SPI
mfrc522.PCD_Init() ; // MFRC522
lcd. begin(16, 2) ; // écran LCD
myServo. attach(8) ; // Servo moteur

myServo. write(10) ; // Position initiale de verrouillage du servomoteur

// Imprime le message initial
lcd. print("-No Master Tag!-") ;
lcd. setCursor(0, 1) ;
lcd. print(" SCAN NOW") ;
// Attend qu'une carte maîtresse soit scannée.
while ( ! successRead) {
successRead = getID() ;
si ( successRead == true) {
myTags[tagsCount] = strdup(tagID. c_str()) ; // Place le tag maître à la
position 0 dans le tableau
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print("Master Tag Set !") ;
tagsCount++ ;
 }
}
successRead = false ;
printNormalModeMessage() ;
}

void loop() {
int proximitySensor = analogRead(A0) ;
// Si la porte est fermée...
if (proximitySensor > 200) {
if ( ! mfrc522.PICC_IsNewCardPresent()) { //Si un nouveau PICC est
placé sur le lecteur RFID, continuez.
retour ;
}
if ( ! mfrc522.PICC_ReadCardSerial()) { //Puisqu'un PICC est placé,
récupérer Serial et continuer
retour ;
}
tagID = '' ;
// Les PICC MIFARE que nous utilisons ont des UID de 4 octets.
for ( uint8_t i = 0 ; i < 4 ; i++) { //
readCard[i] = mfrc522.uid. uidByte[i] ;
tagID. concat(String(mfrc522.uid. uidByte[i], HEX)) ; // Ajoute les 4
octets dans une seule variable String
}
tagID. toUpperCase() ;
mfrc522.PICC_HaltA() ; // Arrêt de la lecture

correctTag = false ;
// Vérifie si l'étiquette scannée est l'étiquette principale.
if (tagID == myTags[0]) {
lcd. clear() ;
lcd. print("Mode programme :") ;
lcd. setCursor(0, 1) ;
lcd. print("Add/Remove Tag") ;
while ( ! successRead) {
successRead = getID() ;
si ( successRead == true) {
for (int i = 0 ; i < 100 ; i++) {
if (tagID == myTags[i]) {
myTags[i] = '' ;
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(' Tag Removed!') ;
printNormalModeMessage() ;
retour ;
}
}
myTags[tagsCount] = strdup(tagID. c_str()) ;
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(' Tag Added!') ;
printNormalModeMessage() ;
tagsCount++ ;
retour ;
}
}
}
successRead = false ;
// Vérifie si l'étiquette scannée est autorisée.
for (int i = 0 ; i < 100 ; i++) {
if (tagID == myTags[i]) {
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(" Accès autorisé ! ") ;
myServo. write(170) ; // Déverrouille la porte
printNormalModeMessage() ;
correctTag = true ;
}
}
si (correctTag == false) {
 lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(' Accès refusé!') ;
printNormalModeMessage() ;
}
}
// Si la porte est ouverte...
else {
lcd. clear() ;
lcd. setCursor(0, 0) ;
lcd. print(' Door Opened!') ;
while ( ! doorOpened) {
proximitySensor = analogRead(A0) ;
if (proximitySensor > 200) {
doorOpened = true ;
}
}
doorOpened = false ;
delay(500) ;
myServo. write(10) ; // Verrouille la porte
printNormalModeMessage() ;
}
}

uint8_t getID() {
// Se préparer à la lecture des PICC
if ( ! mfrc522.PICC_IsNewCardPresent()) { //Si un nouveau PICC est
placé sur le lecteur RFID, continuez.
retourner 0 ;
}
if ( ! mfrc522.PICC_ReadCardSerial()) { //Puisqu'un PICC a été placé,
récupérer Serial et continuer
retourner 0 ;
}
tagID = '' ;
 for ( uint8_t i = 0 ; i < 4 ; i++) { // Les PICC MIFARE que nous
utilisons ont 4 octets UID
readCard[i] = mfrc522.uid. uidByte[i] ;
tagID. concat(String(mfrc522.uid. uidByte[i], HEX)) ; // Ajoute les 4
octets dans une seule variable String
}
tagID. toUpperCase() ;
mfrc522.PICC_HaltA() ; // Arrêt de la lecture
retour 1 ;
}

void printNormalModeMessage() {
retard (1500) ;
lcd. clear() ;
lcd. print("-Access Control-") ;
lcd. setCursor(0, 1) ;
lcd. print(' Scan Your Tag!') ;
}
 13

DOMOTIQUE EXTRÊME

V oici un autre chapitre sur la domotique, c’est probablement trop, mais la

technologie ne s’arrête jamais. Combien d’entre vous auraient pensé
pouvoir allumer la lumière à distance il y a quelques décennies ? Voilà
pourquoi nous devons nous développer, progresser et apprendre de nos
erreurs pour avoir un meilleur avenir, de mieux employer nos ressources et
d’améliorer ainsi notre qualité de vie.
De plus, c’est le contexte d’un projet qui peut sembler sans intérêt, mais
si vous pensez aux moments où vous partez en vacances ou aux pépinières
qui ont des milliers de plantes, cela peut avoir beaucoup de sens. De quoi
s’agit-il ? Un système d’irrigation intelligent, construit avec notre Arduino.
Devez-vous partir en voyage ? Vous ne souhaitez pas embêter vos voisins
avec vos plantes d’intérieur ? Cette solution arrose automatiquement quatre
plantes (ou moins) tous les jours, ou une fois tous les « x » jours (jusqu’à
sept jours) avec un volume d’eau réglable. Un micro-contrôleur gère le
contrôle du temps et la commutation 120AC (via un relais). Le relais
alimente une pompe de fontaine qui sert de système d’alimentation en eau.
Vous aurez besoin des éléments ci-dessous en ce qui concerne ce projet :

Pompe de fontaine (qui peut fournir de l’eau vers le haut)

Tube en nylon
Bulbes (les bons pour les plantes)
Lustre
Microcontrôleur
Carte relais
 Écran à cristaux liquides
Filo
Bassin de rétention d’eau
Panneaux de contreplaqué en érable

Le coût total est d’environ 50 euros, mais peut varier en fonction des
éléments et de la qualité des composants sélectionnés. L’idée est de
fabriquer une boîte pour accueillir ce système, une sorte de tout-en-un. Je
n’entrerai pas dans les détails de la fabrication de la boîte, car vous pouvez
trouver de bons tutoriels en ligne, mais tout ce dont vous avez besoin, c’est
d’un peu de dextérité manuelle et probablement de savoir faire usage d’un
pistolet à clous ou de la colle à bois.
Comme nous construisons un système de pompage d’eau, il pourrait
être utile de protéger le bois de l’eau, j’ai alors appliqué environ 4 couches
de Polycrylic afin de rendre le bois « tolérant à l’eau ». Dans mon cas, la
boîte a été découpée, ensuite les panneaux ont été collés ensemble.

L’Arduino gardera la trace de l’heure et du jour du mois, quand l’alarme

est déclenchée, l’Arduino alimentera un relais. Ce relais complétera le
circuit de 120 V pour une pompe à eau. La pompe arrosera la plante pour
nous ! C’est assez facile, mais chaque sous-étape a sa propre difficulté.
Remarque : ce projet, comme tous les autres, est conçu et réalisé
uniquement afin de prototyper, comprendre et utiliser notre Arduino. Par
conséquent, veuillez accorder une attention particulière aux environnements
humides, construisez votre prototype, mais toujours en toute sécurité. Selon
le tableau de relais que vous achetez, le câblage 120AC peut être distinct.
 Résumons brièvement le schéma : 120 V entrent dans le relais et quand
le relais se ferme, ce 120 V est transmis à la prise, alimentant la pompe. La
prise est une bande unique, toutefois il est fondamental de noter que j’ai
retiré les languettes qui relient les deux prises ensemble. Les prises peuvent
désormais être câblées indépendamment : l’une est toujours allumée, l’autre
est commutée par des relais. Ma configuration emploie deux relais afin
d’allumer et éteindre le 120AC. Plutôt que de faire passer le fil neutre par la
prise et de ne commuter que la ligne L, je commute effectivement les lignes
N et L sur des relais séparés. Doublement de la redondance pour des raisons
peu prévisibles : j’ai coupé le câble d’alimentation en deux (au lieu d’un
seul fil).
Notez que la prise et le tableau de relais seront montés sur le côté de
notre boîte, mais je vais vous recommander une chose : si le réservoir d’eau
devait tomber en panne et fuir à l’intérieur de notre boîte, il serait préférable
d’illustrer toute ligne transportant 120 AC au-dessus de la « zone
d’inondation ».
Le panneau de commande sera câblé et laissé à l’intérieur de notre
boîte, n’oubliez pas de fixer et de câbler l’écran LCD aussi.

Planification
Un simple programme de chronométrage qui suit aussi la journée est au
cœur de notre Arduino. J’ai écrit certains compteurs « push » de base qui
vous aident à régler l’heure et les minutes localement pour l’heure et
l’irrigation. Le suivi des jours est arbitraire et débute à partir du premier
jour. Le décompte se fait jusqu’à un jour « x » selon le mois. J’ai pensé à
construire un système flexible, en fait, ce code a la capacité énumérée ci-
dessous :

forcer manuellement la pompe

contrôler la durée pendant laquelle la pompe est active (contrôle
du volume d’eau délivré)
vérifiez combien de fois par semaine les plantes sont arrosées.

La section la plus intéressante de ce code concerne le contrôle du

nombre de fois par semaine où les plantes sont arrosées. En d’autres mots,
comment rendre l’opération d’arrosage des plantes tous les « x » jours aussi
simple que possible ?
SI (Day_Month Mod (Water every x days) = 0), alors arrosez la plante !
De plus, la fonction Modulo est la clé de ce code, considérez les jours
du mois et divisez [modulo] par x (eau le jour « x »). Si le reste est égal à
zéro, il active le relais ou la pompe. C’est tout ce que notre programme doit
faire. C’est beaucoup plus simple que de créer une table de consultation
pour chaque jour de la semaine, ensuite une commande à répéter semaine
après semaine. Merci au cours de Maths Discrètes de m’avoir fait faire
l’ensemble de ces tests de logique, finalement la fonction module est utile.
/*Horloge avec programmation de l'heure locale à distance.
Réveil standard avec déclenchement par relais sur A0-A3

*/

#include<Time.h>
#include<TimeAlarms.h>
#include<LiquidCrystal.h>

int x = 0 ;

long previousMillis = 0 ;
long intervalIdle = 300 ;
int LCDalarm=0 ;

Écran à cristaux liquides (12, 11, 5, 4, 3, 2) ;

const int relayPinA0=A0 ; //Logic low déclenche le relais

 const int relayPinA1=A1 ;
const int relayPinA2=A2 ;
const int relayPinA3=A3 ;
int potPin1 =A4 ;
int potPin2 =A5 ;

const int relayOverride = 0 ;

const int alarm1EnablePin = 1 ;

const int minutePin = 6 ;

const int hourPin =7 ;
const int timeSetButton = 8 ;
int buzzer = 9 ; // broche pour connecter le transducteur PEZIO (pas un
haut-parleur !)
const int alarmLED = 13 ;
const int alarm1SetButton = 10 ;
int pumpDuration = 0 ;
int dayInterval =1 ; //utilisé uniquement pour les tests

unsigned char delayms = 250 ; // délai entre les bips (fait le buzzer)

int minutePushCounter =0 ;
int minuteState= 0 ;
int lastminuteState = 0 ;

int hourPushCounter =0 ;
int hourState= 0 ;
int lasthourState = 0 ;
int setButtonState = 0 ;

int alarmHRPushCounter =1 ;
int alarmMinPushCounter =1 ;

int alarmHR = 0 ;
int alarmHRState = 0 ;
int lastalarmHRState = 0 ;

int alarmMin = 0 ;
int alarmMinState = 0 ;
int lastalarmMinState = 0 ;

//=========================== tableaux pour construire des

segments de police personnalisés=======================

eau octet[8] ={
B01110, B00100, B10100, B11110, B11111, B10001, B00000, B00001}
;

octet calendrier[8] ={
B01010, B11111, B11111, B10001, B10001, B10001, B11111} ;

int dayoftheweek = 1 ;

void setup() {
 lcd. begin(20.4) ;

setTime(12,00,05,5,9,1999) ; //mise sous tension (HH,MM,SS,Jour, Mois,

Année)

pinMode(minutePin, INPUT_PULLUP) ;
pinMode(hourPin, INPUT_PULLUP) ;
pinMode(timeSetButton, INPUT_PULLUP) ;
pinMode(alarm1SetButton, INPUT_PULLUP) ;
pinMode(alarm1EnablePin, INPUT_PULLUP) ;

pinMode(alarmLED, OUTPUT) ;
pinMode(relayOverride, INPUT_PULLUP) ;

pinMode(relayPinA0, OUTPUT) ;
pinMode(relayPinA1, OUTPUT) ;
pinMode(relayPinA2, OUTPUT) ;
pinMode(relayPinA3, OUTPUT) ;

lcd. createChar(1,water) ;
lcd. createChar(2,calendar) ;

//==================Basic Clock
Protocals===========================
void loop() {
//lire la tension au potentiomètre convertir en 0-1023

digitalClockDisplay() ;
minute_reset59() ;
hour_reset24() ;
setAlarmHR_Min() ;
setTime_Hour_Minute() ;
AmPm() ;

lcd. setCursor(0,3) ; lcd. write(1) ; lcd. print(" every ") ;

printDigits(dayInterval) ; lcd. setCursor(10,3) ; lcd. print(" days ") ;
lcd. setCursor(17,3) ; lcd. write(2) ; lcd. setCursor(18,3) ;
printDigits(day()) ;
si (second()==59){lcd. clear() ; }

//=============Day Alarm================

/*
if (digitalRead(alarm1EnablePin)==LOW) { //code par défaut. au cas où
ce code serait détruit
alarme() ; } */

si (digitalRead(alarm1EnablePin)==LOW) {
lcd. setCursor(1,1) ; lcd. print("=ACTIVE") ;
si (day()%dayInterval==0)
alarme() ; }
else{
lcd. setCursor(1,1) ; lcd. print("=off ") ;

digitalWrite(relayPinA0,LOW) ; digitalWrite(relayPinA1,LOW) ;
digitalWrite(relayPinA2,LOW) ; digitalWrite(relayPinA3,LOW) ;
digitalWrite(alarmLED,LOW) ;
}

//--------------------RELAY OFF Toggles-----------------------------------------

if (hour()==alarmHRPushCounter &&
minute()==alarmMinPushCounter && seconde()==pumpDuration/29)
//le relais s'éteint après 1 minute à partir de l'heure de l'alarme.
{
digitalWrite(relayPinA0,LOW) ; delay(200) ;
digitalWrite(relayPinA1,LOW) ; delay(200) ;
digitalWrite(relayPinA2,LOW) ; delay(200) ;
digitalWrite(relayPinA3,LOW) ;
}

//-----------RELAY OverRide Toggles-----------------------------------------

si (digitalRead(relayOverride)==LOW &&
digitalRead(alarm1EnablePin)==LOW)
{ lcd. setCursor(15,1) ; lcd. print("OvrR") ; //Relay override ne
s'activera que si Alarm Enable est également actif.
digitalWrite(relayPinA0,HIGH) ; delay(200) ;
digitalWrite(relayPinA1,HIGH) ; delay(200) ;
digitalWrite(relayPinA2,HIGH) ; delay(200) ;
digitalWrite(relayPinA3,HIGH) ; }
}
//=========Begin Clock Subroutine
Section================================================
=======================================

void setAlarmHR_Min() {
while (digitalRead(alarm1SetButton)==LOW) {

alarmHRState = digitalRead(hourPin) ;
if (alarmHRState != lastalarmHRState) {
if (alarmHRState == LOW) {
alarmeHRPushCounter ++ ; }}

alarmMinState = digitalRead(minutePin) ;
if (alarmMinState != lastalarmMinState) {
si (alarmMinState == LOW) {
alarmMinPushCounter ++ ; }}

lastalarmHRState = alarmHRState ;
lastalarmMinState = alarmMinState ;
digitalClockDisplay() ;
minute_reset59() ;
hour_reset24() ;
}
}

void alarm(){
//--------------------RELAY Alarm ON Toggles------------------------------------
-----
if (hour()== alarmHRPushCounter &&
minute()==alarmMinPushCounter && second()<=1){ //définit le temps
de déclenchement de l'alarme
digitalWrite(relayPinA0,HIGH) ; // la carte relais se déclenche sur
HIGH
delay(100) ; digitalWrite(relayPinA1,HIGH) ;
delay(100) ; digitalWrite(relayPinA2,HIGH) ;
delay(100) ; digitalWrite(relayPinA3,HIGH) ; }

if (hour()== alarmHRPushCounter &&

minute()==alarmMinPushCounter && second()<=4){ //l'alarme retentira
pendant 10secondes
analogWrite(buzzer, 10) ; // Cycle d'utilisation PWM pour la sortie ; ne
pas utiliser 0 ou 255
delay(delayms) ; // attendre un délai ms
analogWrite(buzzer, 0) ; // 0 l'éteint
delay(delayms) ; // attendre un délai ms

unsigned long currentMillis = millis() ;

if(currentMillis - previousMillis > intervalIdle) { // enregistrer la
dernière fois que vous avez écrit sur le LCD
previousMillis = currentMillis ;
si (LCDalarm == 0){
LCDalarm = LCDalarm + 1 ;
lcd. setCursor(15,1) ; lcd. print(" (") ; lcd. write(1) ; lcd. print(") ") ;
digitalWrite(alarmLED,HIGH) ;
}
else {
lcd. setCursor(15,1) ; lcd. print("( ") ; lcd. write(1) ; lcd. print(" )") ;
LCDalarm = LCDalarm - 1 ;
digitalWrite(alarmLED,LOW) ;
}}}
 }
//--------------------------------------------------------
void minute_reset59() {
if (minutePushCounter > 59){
minutePushCounter = 0;}

si (alarmMinPushCounter > 59){

alarmMinPushCounter = 0;}

void hour_reset24() {
si (hourPushCounter > 23){
hourPushCounter = 0;}

si (alarmHRPushCounter > 23){

alarmHRPushCounter = 0;}

void setTime_Hour_Minute () {
minuteState = digitalRead(minutePin) ;
if (minuteState != lastminuteState) {
if (minuteState == LOW) {
minutePushCounter++ ;
}
}

hourState = digitalRead(hourPin) ;
if (hourState != lasthourState) {
if (hourState == LOW) {
compteur d'heures++ ;
}
}
 lastminuteState = minuteState ;
lasthourState = hourState ;

setButtonState = digitalRead(timeSetButton) ;
if (setButtonState == LOW) {
setTime(hourPushCounter, minutePushCounter,00,dayoftheweek, 7,
2000) ; // (HH,MM,SS,Day, Month, Year)
}
}
//--------------------------------------------------------
void AmPm () {
if (hour()>=12) {lcd. setCursor(18,0) ; lcd. print('PM') ; }
else { lcd. setCursor(18,0) ; lcd. print("AM") ; }

//--------------------------------------------------------
void digitalClockDisplay() {
pumpDuration = analogRead(potPin1) ;
dayInterval = analogRead(potPin2) ;
dayInterval = map(dayInterval, 0,1000, 1,7) ;

lcd. setCursor(4,0) ; lcd. print("Time") ;

lcd. setCursor(9,0) ; printDigits(hour()) ; lcd. print(" :") ;
lcd. setCursor(12,0) ; printDigits(minute()) ; lcd. print(" :") ;
lcd. setCursor(15,0) ; printDigits(second()) ;
lcd. setCursor(0,1) ; lcd. write(1) ;

lcd. setCursor(9,1) ; lcd. print("Set @ ') ;

lcd. setCursor(15,1) ; printDigits(alarmHRPushCounter) ; lcd. print(':')
;
lcd. setCursor(18,1) ; printDigits(alarmMinPushCounter) ;
 lcd. setCursor(0,2) ; lcd. print("Pump duration : ") ;
printDigits(pumpDuration/29) ;
lcd. setCursor(17,2) ; lcd. print("sec") ;
}

//--------------------------------------------------------
void printDigits(int digits) {
si (chiffres < 10)
lcd. print('0') ;
lcd. print(digits) ;
}

//--------------------------------------------------------

Il est important de savoir que vous placez la pompe dans le réservoir (cuve)
et vous alimentez les tuyaux de sortie dans un joint en T. De plus, vous
pouvez diviser les lignes d’arrosage en fonction du nombre de vos plantes.
Notez que j’ai mis en place ce système à quatre lignes, car je ne veux
m’occuper que de quelques plantes d’intérieur, les plus délicates et les plus
belles. Mettre les plantes dans une « boîte » n’est probablement pas la
meilleure chose à faire ; il faut alors que la lumière du soleil soit artificielle
et c’est pourquoi je vais employer des ampoules fluorescentes compactes.
Je vous conseille de choisir les bonnes ampoules qui donneront à votre
plante la bonne lumière [UV] dont elle a besoin. L’ensemble sera monté sur
le dessus de ma boîte et les ampoules descendront à travers une grille qui
maintiendra les tubes en nylon.
Oui, nous avons de l’eau juste à côté du 120 V. Je vous invite alors, une
fois de plus, à ne pas essayer chez vous ou ailleurs. L’Arduino et les
lumières sont connectés à une seule prise. La pompe est connectée à l’autre
prise qui est contrôlée par le relais (Arduino).
Finalement, j’ai imprimé en 3D des clips faciles qui acheminent et
fixent le tuyau d’eau au pot de la plante, mais vous pouvez aussi employer
des colliers de serrage ordinaires, une méthode simple et moyennement
efficace.
Voici ci-dessous à quoi ressemble le résultat final :

Je suis personnellement vraiment satisfait du résultat final, mais il y a

un certain nombre d’améliorations ou de développements futurs qui
pourraient être apportés. Ce serait bien de concevoir quelque chose de
similaire pour les plantes de notre balcon et probablement de ne les arroser
que lorsque quelques paramètres d’humidité et de température sont réunis.
C’est logique parce qu’en été, il faudra probablement arroser les plantes à
19 heures, mais seulement s’il n’a pas encore plu ! De plus, il serait
agréable de pouvoir « personnaliser » l’arrosage de chaque plante parce
qu’une plante succulente n’aura probablement besoin d’être arrosée qu’une
fois toutes les trois semaines, une orchidée une fois tous les quinze jours et
ainsi de suite en fonction du type de plante.

Considérations finales
Ce projet peut sembler vraiment avancé, mais pensez au temps que vous
avez passé à arroser vos plantes, surtout si vous avez une villa ou un grand
jardin !
De plus, la domotique rend votre maison intelligente : des serrures qui
s’ouvrent d’une simple pression, des appareils qui font ce que vous
souhaitez quand vous n’êtes pas chez vous, des thermostats qui peuvent être
programmés en fonction de vos besoins. Tout peut être contrôlé et géré via
un téléphone portable.
Avec la diffusion des nouvelles technologies et des télécommunications,
dont Internet et les interfaces numériques, les experts ont commencé à
développer une nouvelle science, la domotique, dont le nom dérive de « 
domus » (maison en latin) et « robotique ». La domotique examine les
technologies appliquées à l’environnement domestique en mettant l’accent
sur les questions environnementales, les économies d’énergie et
l’amélioration des modes de vie. L’Arduino vous aide à avoir une approche
distincte, plus proche de ce que vous souhaitez réaliser, sans avoir à
compter sur quelque chose de tout fait et construit par d’autres. Les
installations traditionnelles disposent d’un dispositif de contrôle comme un
interrupteur d’éclairage mécanique ou un thermostat, mais, depuis
l’invention de la domotique et des installations intelligentes, ces fonctions
peuvent être gérées par un système à distance et connectées directement aux
téléphones intelligents, tablettes, PC, comme nous l’avons fait dans les
chapitres précédents. Cela vous aide à surveiller la situation de votre
maison à tout moment, même quand vous en êtes absent. La maison du
futur sera certainement intelligente parce qu’elle impliquera des niveaux
élevés d’interaction entre les utilisateurs et les appareils qu’ils ont à
l’intérieur de leur maison, garantissant le contrôle, la sécurité et les
économies d’énergie. De plus, ce dernier point est l’un des principes de
base de la domotique.
Les systèmes d’alimentation électrique intelligents visent à réduire la
quantité d’électricité utilisée. Comment ? En contrôlant à distance vos
appareils afin d’éviter de dépasser la limite maximale du compteur
électrique ; en enregistrant et en signalant les anomalies potentielles du
système ; en vous alertant si des appareils fonctionnent alors que vous
n’êtes pas chez vous. Permettez-moi vous donner un exemple concret : en
plein été, vous devez quitter la maison et vous savez que vous devrez rester
dehors durant 5 heures, malheureusement il fait vraiment chaud et vous
souhaitez trouver la maison fraîche à votre retour. Sans une maison
domotique, vous devriez laisser votre climatiseur allumé, probablement au
ralenti, afin de trouver la maison fraîche à votre retour. Avec une maison
domotique, vous pourriez allumer votre climatiseur à distance,
probablement avec un Arduino faisant office de télécommande infrarouge.
Ce serait vraiment facile et cela vous aiderait d’économiser de l’énergie et
de l’argent. Respectueux de l’environnement, mais surtout des personnes.
En simplifiant la manière dont nous gérons les dispositifs et les
appareils, il est possible de réduire le gaspillage d’énergie qui a un impact
négatif sur l’environnement et augmente les coûts. De plus, les maisons
intelligentes aident à économiser de l’argent et consistent en des systèmes
aidant d’éviter les déchets ménagers. Finalement, la domotique est
aujourd’hui moins coûteuse qu’auparavant : elle ne nécessite pas de
systèmes et de câbles onéreux, dans la plupart des cas, un signal Wi-Fi
suffit. Grâce à la télécommande, vous êtes en mesure d’utiliser votre four,
votre machine à laver, votre plaque à induction au moment de la journée où
l’électricité est moins chère, ou même recharger votre voiture électrique si
vous en avez une.
Le monde change, probablement avons-nous vraiment pris conscience
que nous ne disposons pas de ressources infinies et que nous ferions mieux
de débuter à bien les utiliser, probablement en améliorant notre qualité de
vie.
 14

DÉPANNAGE

I letarrivera un moment dans votre expérimentation où rien ne fonctionnera

où vous devrez trouver une solution. Le dépannage et le débogage sont
des arts anciens où il existe certaines règles faciles, mais où la majorité des
résultats sont obtenus avec beaucoup de travail. Plus vous travaillerez avec
l’électronique et Arduino, plus vous apprendrez et gagnerez de
l’expérience, ce qui finira par rendre le processus moins pénible. Ne vous
laissez pas décourager par les soucis que vous rencontrerez : tout est plus
simple qu’il n’y paraît au début.
Comme chaque projet basé sur Arduino est composé à la fois de
matériel et de logiciel, il y aura plus d’un endroit où regarder si quelque
chose ne va pas. Pendant la recherche d’un bogue, vous devez opérer selon
trois axes :

Compréhension : tentez de comprendre autant que possible le

fonctionnement des pièces que vous employez et la façon dont
elles doivent contribuer à la conception finale. Cette approche
vous permettra de trouver une méthode de tester chaque
composant séparément ;
Simplification et segmentation : les anciens Romains disaient
« diviser pour régner ». Tentez de décomposer (mentalement) le
projet en ses composantes en employant la compréhension et
déterminez où commence et où termine la responsabilité de
chaque composante.
 Exclusion et certitude : pendant l’enquête, testez chaque
composant séparément afin d’être absolument certain que
chacun d’eux fonctionne seul. Vous gagnerez progressivement
en confiance afin de savoir quelles parties du projet effectuent
bien leur travail et lesquelles sont suspectes.

Le débogage est le terme employé afin décrire ce processus appliqué

aux logiciels. La légende veut qu’il ait été employé pour la première fois
par Grace Hopper dans les années 1940, lorsque les ordinateurs étaient
essentiellement électromécaniques et que l’un d’entre eux a cessé de
fonctionner, car de véritables insectes étaient coincés dans les mécanismes.
Plusieurs bogues actuels ne sont plus physiques : ils sont virtuels et
invisibles, du moins en partie. Par conséquent, leur identification demande
un processus quelquefois long et fastidieux.

Test de la carte
De plus, si le premier exemple, le clignotement d’une LED, ne fonctionnait
pas ? Ne serait-ce pas un peu déprimant ? Tentons de savoir ce qu’il faut
faire. Avant de débuter à blâmer le projet, vous devez vous assurer que
certaines choses sont en ordre, comme le font les pilotes de ligne quand ils
passent par une liste de contrôle afin de s’assurer que l’avion volera
correctement avant le décollage : branchez votre Arduino dans une prise
USB de votre ordinateur.

Assurez-vous que l’ordinateur est allumé (oui, cela semble idiot,

mais c’est le cas). Si l’observant vert marqué PWR s’allume,
cela veut dire que l’ordinateur alimente la carte en électricité. Si
la LED semble vraiment faible, quelque chose ne va pas avec
l’alimentation : tentez un autre câble USB, inspectez le port
USB de l’ordinateur et la prise USB de l’Arduino afin de voir
s’ils sont endommagés. Si tout le reste échoue, tentez un autre
port USB sur votre ordinateur ou un ordinateur complètement
distinct ;
Si l’Arduino est neuf, la LED jaune marquée ‘ L’ débutera à
clignoter nerveusement ; c’est le programme de test qui a été
 chargé en usine pour tester la carte ;
Si vous avez employé une alimentation externe et que vous
utilisez un vieil Arduino, assurez-vous que l’alimentation est
connectée et que le cavalier marqué SV1 relie les deux broches
les plus proches du connecteur d’alimentation externe.

Si vous avez fait toutes ces étapes correctement, vous pouvez être
certain que votre Arduino fonctionne correctement.

Test du circuit
Connectez maintenant la carte à la planche d’essai en reliant les connexions
5V et GND aux rails positifs et négatifs de la planche d’essai. Si le voyant
vert PWR s’éteint, retirez tout de suite les fils.
Cela veut dire qu’il y a une grosse erreur dans votre circuit et que vous
avez un « court-circuit » quelque part. Quand cela se produit, votre carte
consomme trop de courant et l’alimentation est coupée afin de protéger
votre ordinateur. Si vous rencontrez un court-circuit, notez que vous devez
effectuer le processus de « simplification et de segmentation », cela signifie
que vous devez passer en revue tous les capteurs de la conception et les
connecter un par un.
La première chose à faire est toujours de débuter par l’alimentation (les
connexions 5V et GND). Vérifiez bien le circuit et assurez-vous que chaque
partie du circuit est alimentée correctement. Travailler étape par étape et
effectuer un seul changement à la fois est la règle numéro un pour bien faire
les choses.
C’est vraiment essentiel, car vous saurez ainsi ce qui a résolu le
problème (il est trop simple de perdre de vue la modification qui a
réellement résolu le souci, voilà pourquoi il est si essentiel d’en faire une à
la fois). Chaque expérience de débogage créera une « base de
connaissances » des défauts et des solutions possibles dans votre tête, et
avant que vous ne le sachiez, vous deviendrez un expert. Alors, tout sera
parfait, car dès qu’un débutant vous dira « Ça ne marche pas ! », vous
jetterez un coup d’œil rapide et vous aurez la réponse en une fraction de
seconde - c’est ça l’expérience !
Isoler le problème
Une autre règle essentielle consiste à trouver un moyen fiable de reproduire
un problème. Si votre circuit se comporte bizarrement à des moments
aléatoires, efforcez-vous de déterminer le moment exact où le souci se
produit et la cause. Ce processus vous aidera à penser à une cause possible,
il est également vraiment utile pendant que vous devez expliquer à
quelqu’un d’autre ce qui se passe.
Décrire le souci aussi précisément que possible est aussi une excellente
méthode afin de trouver une solution. Tentez de trouver quelqu’un à qui
vous pouvez expliquer le souci : dans de nombreux cas, une solution vous
viendra en formulant le souci.
Si vous êtes bloqué, ne passez pas des jours seuls à chercher le souci :
demandez de l’aide. L’une des meilleures choses à propos d’Arduino est sa
communauté, vous pouvez toujours trouver de l’aide si vous pouvez décrire
votre souci correctement.
Prenez l’habitude de couper et de coller les erreurs dans un moteur de
recherche et observez si quelqu’un les mentionne. Par exemple, pendant
que l’IDE Arduino renvoie un mauvais message d’erreur, copiez et collez-le
dans une recherche Google et observez ce qui en ressort. Faites de même
avec les morceaux de code sur lesquels vous travaillez ou simplement le
nom d’une fonction spécifique. Regardez autour de vous : tout a déjà été
inventé et est stocké quelque part sur une page Web.
Pour en savoir plus, visitez le site Web principal www.arduino.cc et
consultez la FAQ, puis passez au terrain de jeu, un wiki librement
modifiable que tout utilisateur peut éditer afin de contribuer à la
documentation, c’est l’un des meilleurs aspects de la philosophie du logiciel
libre.
Les gens aident à la documentation et aux exemples de tout ce que vous
pouvez exécuter avec Arduino. Avant de débuter un projet, cherchez sur le
terrain de jeu et vous trouverez un code ou un schéma de circuit afin de
vous aider à démarrer.

Problèmes avec l’IDE

Dans certains cas, vous êtes en mesure de rencontrer des soucis avec l’IDE
Arduino, notamment sous Windows. Si vous obtenez une erreur en double-
cliquant sur l’icône Arduino, ou si rien ne se passe, tentez de double-cliquer
sur le fichier run.bat comme méthode alternative pour démarrer Arduino.
Les utilisateurs de Windows sont aussi en mesure de rencontrer un souci
si le système d’exploitation attribue un numéro de port COM10 ou
supérieur à l’Arduino. Si cela se produit, vous pouvez en général
convaincre Windows d’attribuer un numéro de port inférieur à l’Arduino.
Premièrement, ouvrez le « Gestionnaire de périphériques » en cliquant
sur le menu « Démarrer », en faisant un clic droit sur Poste de travail et en
choisissant « Propriétés ».
Recherchez les périphériques série dans la liste sous « Ports (COM et
LPT) ». Trouvez un périphérique série que vous n’employez pas avec le
numéro COM9 ou inférieur. Exécutez un clic droit et sélectionnez « 
Propriétés » dans le menu, ensuite sélectionnez l’onglet « Paramètres du
port » et cliquez sur « Avancé ».
Réglez le numéro du port COM sur COM10 ou supérieur, cliquez sur « 
OK » et cliquez à nouveau sur « OK » pour fermer la boîte de dialogue
Propriétés. Exécutez maintenant la même chose avec le périphérique USB
Serial Port représentant l’Arduino, avec un changement : attribuez-lui le
numéro de port COM (COM9 ou inférieur) que vous venez de libérer. Si
ces suggestions ne vous aident pas, ou si vous avez un souci non décrit ici,
consultez la page de dépannage de l’Arduino.
 CONCLUSION

J’ai rassemblé, de façon schématique, les diverses commandes à donner à

Arduino. Ils sont écrits dans le langage Arduino et peuvent être utiles pour
une rapide remise à niveau en programmation avant de débuter à utiliser le
langage Arduino dans son intégralité.

Void setup () est la première partie du sketch, utilisée afin de configurer les
broches, les variables, les bibliothèques et les communications série ;
La boucle vide () est mise en place après la configuration, et exécute
cycliquement ce qui y est écrit ;
/*..... */ est le bloc de commentaires ;
// est le bloc de commentaires pour une seule ligne ;
#define attribue une valeur constante avant la phase de compilation ;
Delay () ; met en pause l’esquisse pendant la période indiquée dans les
rubriques ;
Millis () ; renvoie le temps écoulé depuis que l’Arduino a débuté à
exécuter le sketch ;
Faux une valeur de 0 ;
Vrai toutes les conditions de vrai dans un sens bouilli ;
INPUT configure la broche comme une entrée ;
OUTPUT configure la broche comme une sortie ;
À des significations diverses selon la configuration des broches ;
LOW si la broche est en entrée, elle a la valeur low ; si la broche est en
sortie, elle a la valeur OV ;
Le booléen ne prend que deux valeurs : true et false ;
 Char a un seul caractère :
Unsigned char une variable qui utilise des nombres non signés ;
Byte est la variable qui remplace unsigned char ;
Unsigned int stocke les entiers non signés ;
Nombres à virgule flottante
Nombre à double virgule flottante ;
Char str définit un ensemble d’éléments du même type ;
Char () convertit une valeur en un type de données char ;
Byte () convertit une valeur en octets ;
Int () convertit une valeur en int ;
Word () convertit une valeur en mot ;
Long () convertit une valeur en long ;
Float () convertit une valeur en un flottant ;
Si exécute des blocs d’esquisses ;
Interrupteur ... Le cas compare la valeur d’une variable avec un
ensemble de données ;
Interrompre vous permet d’interrompre la recherche de cas lorsqu’une
correspondance est trouvée ;
Partie d’esquisse facultative par défaut à insérer à la fin de switch.case ;
Pour répéter l’instruction ou un bloc d’instructions un nombre fixe de
fois ;
Condition la condition évaluée à chaque répétition ;
L’incrémentation est employée afin de modifier une valeur ou pour
l’amener à l’état où la condition est fausse ;
While : une instruction répétée jusqu’à ce que la condition soit vraie ;
Do ... while la condition est toujours vérifiée après que le bloc de
commande a été exécuté au moins une fois ;
Goto afin de faire des sauts d’un point à un autre dans le code ;
|| Symbole affichant que l’une des deux conditions doit être remplie ;
= est l’opérateur d’affectation et aide à stocker la valeur située à droite
du symbole dans la variable située à gauche ;
Addition (+), soustraction (-), multiplication (*), division (/) : les
opérations qui permettent d’obtenir la somme, la différence, le produit et le
quotient entre deux valeurs ;
% calcule le reste d’une division.
Finalement, je voudrais demander pourquoi un prototype électronique est
une première étape importante pour toute entreprise, grande ou petite, afin
de développer un nouveau produit ou un dispositif matériel, ou même
simplement pour le plaisir.
La principale raison pour laquelle Arduino est une excellente plateforme
pour le prototypage électronique est sa courbe d’apprentissage rapide. Les
personnes ayant peu d’expérience sur le plan du matériel ou de
micrologiciel peuvent lire certains tutoriels et être tout de suite en mesure
de débuter à travailler sur la mise en œuvre au sein de l’écosystème
Arduino. Cela n’est pas possible lorsque nous essayions de développer une
solution matérielle d’une autre façon. Bien que cela ne soit pas impossible,
il serait complexe d’attendre d’un entrepreneur qu’il apprenne à concevoir
des circuits imprimés et à programmer des microprogrammes en un temps
raisonnablement court.
Une autre raison importante pour laquelle Arduino est devenu un tel
succès est la communauté qui l’entoure. Il existe des milliers et des milliers
de tutoriels sur Internet. Plusieurs entreprises ont aussi débuté à suivre la
méthodologie open source grâce à Arduino. Cette vaste communauté aide à
répondre aux questions et de résoudre les soucis gratuitement. Le forum
officiel Arduino et divers subreddits sont tous deux incroyablement actifs et
donnent une assistance gratuite. Nous ne pouvions nier la rapidité avec
laquelle nous pouvons réaliser un prototype en employant Arduino. Si vous
disposez d’un laboratoire d’électronique bien approvisionné en cartes
Arduino, vous pouvez concevoir et construire un prototype grossier en un
après-midi. Il est impossible d’atteindre cette vitesse avec d’autres
approches et sans Arduino.
Je tiens aussi à mentionner le grand nombre de bibliothèques de
micrologiciels à code source ouvert. C’est un autre gain de temps
considérable et, comme vous l’avez vu, nous en avons employé quelques-
uns dans ce livre. Il est bien connu que, souvent, l’aspect du matériel qui
cause les plus grands retards dans la planification est en fait le micrologiciel
qui le sous-tend. Les bogues et les soucis de microprogrammes ont
tendance à être beaucoup plus complexes à diagnostiquer et à résoudre que
les soucis matériels. La possibilité de tirer parti des bibliothèques Arduino
existantes est un outil incroyable. Bien que leur optimisation laisse quelque
peu à désirer, ils constituent un excellent point de départ.
 Maintenant que vous faites vous aussi partie de la grande communauté
Arduino, vous serez certainement en mesure de créer quelque chose d’utile
et d’intéressant, probablement le prochain produit sur le marché ! Continuez
à expérimenter, ne vous arrêtez pas, et vous observerez que tous vos efforts
seront récompensés !