info@edurobot.

ch Arduino à l’école Cours pour l’apprentissage des bases de l’électronique et de la

programmation sur Arduino. [Link] Frédéric Genevey & Jean-Pierre Dulex Édition
février 2018 VERSION 5.0 Arduino à l'école 2 À propos de ce cours Ce cours est publié pour la
communauté Arduino d’[Link] via son site [Link] Il s’agit d’une ressource
éducative libre1, sous licence CC BY-NC-SA2. L’utilisation gratuite de ce cours dans le cadre d’une
formation payante est tolérée. Un avis à l'auteur est néanmoins bienvenu. Les écoles publiques,
lycées, gymnases, universités, les associations et les FabLab peuvent demander gratuitement une
version Word de ce document, afin de l’adapter plus aisément à leurs besoins. Vous pouvez envoyer
vos remarques, vos idées et corrections à info@[Link]. Un merci particulier à Jean-Pierre Dulex
pour la relecture et les tests réalisés avec ses élèves ainsi qu'au professeur Jean-Daniel Nicoud, qui
m'a mis le pied à l'étrier et beaucoup soutenu au début de cette aventure. Les codes utilisés dans ce
cours peuvent être téléchargés à l'adresse suivante: [Link] 1
[Link] 2
[Link] Arduino à l'école 3 Matériel nécessaire Voici
la liste minimum du matériel nécessaire pour suivre ce cours: Une carte Arduino ou compatible
Arduino Une platine d'expérimentation (breadboard) Des câbles de liaison (jumpers) 6 LEDs rouges 2
LEDs vertes 2 LEDs jaunes ou orange 10 résistances de 220 à 470Ω 2 résistances de 1 à 10kΩ 2
condensateurs 10nF 2 boutons-poussoirs 1 photorésistance 1 bargraphe 10 LEDs* 1 multimètre 1
potentiomètre (résistance variable) 1 servo Pour pouvoir aller plus loin, voici les composants
nécessaires: Capteur de température et d'humidité DHT11 1 écran LED 2x12 (*optionnel) Note: cette
liste évoluera en même temps que le cours Arduino à l'école 4 Consignes de sécurité L’électricité
peut être mortelle! Pour éviter tout risque, en particulier avec des élèves, il convient de ne travailler
qu’avec de la très basse tension (TBT). La tension de fonctionnement de l’Arduino se situe autour de
5 Volts. Quelques règles élémentaires de sécurité Ne jamais connecter directement l’Arduino sur le
secteur (230 Volts alternatifs). Pour l’alimentation des projets, utiliser des transformateurs
répondants aux normes de sécurité en vigueur. Ne pas démonter d’appareils électroniques, sans
supervision. Certains composants, comme les condensateurs, peuvent délivrer des décharges
électriques mortelles, même lorsqu’ils ne sont pas connectés au secteur. Ce cours ne permet PAS
d'acquérir les compétences et notions de sécurité nécessaires pour travailler avec le secteur (230 V),
ni avec l'électricité automobile. Arduino à l'école 5 Table des matières A PROPOS DE CE
COURS.......................................................................................................................................................
2 MATERIEL
NECESSAIRE ..............................................................................................................................................
...........3 CONSIGNES DE
SECURITE....................................................................................................................................................
.4 QUELQUES REGLES ELEMENTAIRES DE
SECURITE....................................................................................................4 TABLE DES
MATIERES..................................................................................................................................................
..........5
PREFACE.....................................................................................................................................................
...............................8
INTRODUCTION .........................................................................................................................................
................................9
REFERENCES...............................................................................................................................................
............9
BIBLIOGRAPHIE..........................................................................................................................................
............10 LES MEILLEURS COURS EN
LIGNE...........................................................................................................................11 À PROPOS DES
SCHEMAS ELECTRONIQUES............................................................................................................12
DECOUVERTE DE LA PLATEFORME
ARDUINO ................................................................................................................13 SCHEMA D'UNE
PLATINE ARDUINO UNO .................................................................................................................14 LE
MICROCONTROLEUR.................................................................................................................................
.........14
L’ALIMENTATION ......................................................................................................................................
..............15 LA
CONNECTIQUE ..........................................................................................................................................
........15 Exploration des broches
Arduino ...................................................................................................................15 LA PLATINE
D’EXPERIMENTATION ...........................................................................................................................16
LE LOGICIEL ARDUINO
IDE...................................................................................................................................................17 LES
BASES DE
L’ELECTRONIQUE......................................................................................................................................
18 PETIT RAPPEL SUR
L’ELECTRICITE..........................................................................................................................18
Quelques ressources pour comprendre
l’électricité:.....................................................................................18 LES
DIODES ......................................................................................................................................................
.....19 LES
RESISTANCES .............................................................................................................................................
....20 PROJET 1: LE CIRCUIT
ELECTRIQUE.................................................................................................................................22 Liste
des
composants .....................................................................................................................................22
Observations..............................................................................................................................................
......22 LE CIRCUIT
ELECTRIQUE ........................................................................................................................................23
PROJET 2: FAIRE CLIGNOTER UNE
LED............................................................................................................................24 Liste des
composants .....................................................................................................................................24 LE
LOGICIEL ARDUINO
IDE ....................................................................................................................................25 Le
menu .........................................................................................................................................................
..25 CODE 1: FAIRE CLIGNOTER UNE LED SUR LA BROCHE
13 ......................................................................................26
Liens ..........................................................................................................................................................
.......26
Observations..............................................................................................................................................
......26
Débugger ..................................................................................................................................................
.......26 Introduction au
code........................................................................................................................................27 Analyse
du code 1...........................................................................................................................................29
Modifions le
code.............................................................................................................................................30
PROJET 3: FAIRE CLIGNOTER QUATRE
LEDS.................................................................................................................31 Liste des
composants .....................................................................................................................................31
CODE 2: FAIRE CLIGNOTER 4
LEDS .......................................................................................................................32
Liens ..........................................................................................................................................................
.......32 CODE 3: REALISER UN CHENILLARD A 4
LEDS. ......................................................................................................33
Liens ..........................................................................................................................................................
.......33 Arduino à l'école 6 PROJET 4: INTRODUCTION AUX
VARIABLES...................................................................................................................34 UNE VARIABLE,
QU'EST CE QUE C'EST ? .................................................................................................................34 Le
nom d'une
variable.....................................................................................................................................34 Définir
une variable .........................................................................................................................................35
DEFINIR LES BROCHES DU
MICROCONTROLEUR .....................................................................................................36 PROJET 5: LES
FEUX DE
CIRCULATION............................................................................................................................37 Liste
des
composants .....................................................................................................................................38
CODE 4: LE FEU DE
CIRCULATION...........................................................................................................................39
Liens ..........................................................................................................................................................
.......39
Variantes ...................................................................................................................................................
.......40 PROJET 6:
L’INCREMENTATION .................................................................................................................................
.........41 LISTE DES
COMPOSANTS: ......................................................................................................................................41
Liens ..........................................................................................................................................................
.......42 Analyse du
code..............................................................................................................................................43
CODE 6: REALISER UN CHENILLARD SUR LES BROCHES 10 A 13 AVEC UN
FOR.......................................................44
Liens ..........................................................................................................................................................
.......44 Analyse du
code..............................................................................................................................................45
PROJET 7: PWM, VARIATION EN DOUCEUR D'UNE
LED ................................................................................................46 CODE 7: FAIRE VARIER LA
LUMINOSITE D'UNE LED EN MODIFIANT LA VALEUR PWM ..............................................47
Liens ..........................................................................................................................................................
.......47 Analyse du
code..............................................................................................................................................48
CODE 8: FAIRE VARIER LA LUMINOSITE D'UNE LED EN
DOUCEUR ...........................................................................48
Liens ..........................................................................................................................................................
.......48 Analyse du
code..............................................................................................................................................49
CODE 9: ALTERNATIVE POUR FAIRE VARIER LA LUMINOSITE D'UNE
LED .................................................................49
Liens ..........................................................................................................................................................
.......50 PROJET 8: LES INPUTS
NUMERIQUES...............................................................................................................................51
PROTEGER
L’ARDUINO ..........................................................................................................................................51
RESISTANCE PULL-DOWN / PULL-
UP.....................................................................................................................51 Circuit avec une une
résistance pull-down....................................................................................................51 Circuit avec
une résistance pull-up ................................................................................................................52
Résistance pull-down ou pull-
up? ..................................................................................................................52 CIRCUIT 6: MONTAGE
AVEC RESISTANCE PULL-DOWN (RAPPEL AU MOINS) .............................................................53 Liste
des
composants: ....................................................................................................................................53
CODE 10: ALLUMER UNE LED EN FONCTION DE L'ETAT DU BOUTON
POUSSOIR ......................................................54
Liens ..........................................................................................................................................................
.......54 Analysons le
code: ..........................................................................................................................................55 CODE
11: UN CODE PLUS
ELEGANT .......................................................................................................................56
Liens ..........................................................................................................................................................
.......56 PETITS EXERCICES: BOUTON POUSSOIR ET LED QUI
CLIGNOTE .............................................................................57 LE
BARGRAPHE...............................................................................................................................................
.......58 Liste des
composants .....................................................................................................................................59
CODE 12: LE
BARGRAPHE ......................................................................................................................................60
Liens ..........................................................................................................................................................
.......61
Vidéo .........................................................................................................................................................
.......61 Analyse du
code:.............................................................................................................................................62
DEPARASITER A L'AIDE DE
CONDENSATEURS .........................................................................................................64 Qu'est-ce
qu'un condensateur?......................................................................................................................64
VARIATION: LE BARGRAPHE A 10
LEDS.................................................................................................................66 CODE 13: LE
BARGRAPHE A 10 LEDS....................................................................................................................66
Liens ..........................................................................................................................................................
.......68 VARIATION: L’AFFICHEUR
NUMERIQUE....................................................................................................................69 Identification
de la position des LEDs............................................................................................................70
Liens ..........................................................................................................................................................
.......71 Arduino à l'école 7 SYNTHESE: APPRENDRE A
COMPTER .....................................................................................................................75
Objectif .....................................................................................................................................................
........75 Schéma électronique du
montage .................................................................................................................75 CODE 15:
APPRENDRE A
COMPTER........................................................................................................................77
Liens ..........................................................................................................................................................
.......80 PROJET 9: LES INPUTS
ANALOGIQUES ............................................................................................................................81 LA
PHOTORESISTANCE....................................................................................................................................
.......81 CIRCUIT 7: DIVISEUR DE
TENSION ..........................................................................................................................82 Liste des
composants .....................................................................................................................................82
CODE 16: VALEUR DE
SEUIL...................................................................................................................................84
Liens ..........................................................................................................................................................
.......84 CODE 17: VARIATION DE LA LUMINOSITE D'UNE LED EN FONCTION DE LA LUMIERE AMBIANTE
................................85 CODE 18: MAPPAGE DE
DONNÉES..........................................................................................................................86 PROJET 10:
LE
POTENTIOMETRE ......................................................................................................................................
.87 PROJET 11 : CONSTRUIRE UNE STATION
METEO...........................................................................................................91 CODE 20: ACQUERIR LES
DONNEES DU CAPTEUR ET LES AFFICHER.......................................................................93 Liste des
composants : ...................................................................................................................................95
CODE 21: AFFICHER LES DONNEES SUR L’ECRAN
LCD..........................................................................................96 PROJET 12 : UTILISER UN
SERVOMOTEUR ......................................................................................................................98 Arduino
à l'école 8 Préface Lorsque Massimo Banzi et ses collègues de l’Interaction Design Institute d’Ivrea,
en Italie, ont développé l’Arduino, l’objectif était de permettre aux étudiants de pouvoir disposer
d’une plateforme valant le prix d’une pizza pour réaliser des projets interactifs3. Ainsi, l’Arduino a été
conçu dès le départ dans un but pédagogique, pour être bon marché, doté d’une grande quantité
d’entrées et de sorties, compatible Mac, Windows et Linux, programmable avec un langage très
simple et open source. Il n’y a là que des avantages pour le monde scolaire, en particulier parce que
l’Arduino se situe au croisement entre l’informatique, l’électronique et les travaux manuels4.
L’approche pédagogique de l’Arduino est particulière. Il ne s’agit pas d’aborder la matière d’une
manière linéaire, mais en bricolant et en «bidouillant»: on câble, on branche et on regarde ce que
cela donne. C’est une approche par la pratique et l’expérimentation qui convient très bien à des
élèves, même (et surtout) peu scolaires. Il y a bien sûr un risque de «griller» un Arduino; mais il ne
s’agit que de 30 francs de matériel, et pas d’un ordinateur à 1200 francs! L’Arduino est un excellent
outil pour le learning by doing et le project based learning. Une approche par la théorie, même si elle
reste possible, serait contre-productive. La meilleure preuve que l’Arduino est parfaitement adapté
aux élèves est qu’en quelques leçons, ils sont déjà prêts à réaliser des projets concrets. Ce cours a été
pensé pour des élèves (et des enseignants) qui n’ont aucune notion en programmation et en
électronique. Par rapport au gigantesque potentiel de l’Arduino, il est volontairement limité, mais il
s’efforce d’être progressif et surtout axé sur la pratique. Il n'est pas fait pour être suivi de manière
linéaire. Après les bases acquises, l'enseignant peut choisir ses modules. Note: Il n'y a pas de
différence entre du matériel Arduino et Genuino. Faites attention avec les copies chinoises
d'Arduino. Les moins chères peuvent poser des problèmes d'utilisation assez importants (drivers
nécessaires, câblage avec faux contacts…). Diduino, compatible Arduino, développé à Lausanne 3
Histoire de l’Arduino: [Link] 4
Références: [Link] et
[Link] Arduino à l'école 9 Introduction Références Ce document est une
compilation et une adaptation de textes et d’exercices, depuis les sources suivantes: Sources
principales: [Link] [Link] [Link]
[Link]
[Link]
[Link]
[Link] Sources annexes:
[Link]
[Link]
[Link]
[Link] [Link]
[Link] Ce cours ne permet qu’une introduction à l’électronique. Un cours bien
plus complet et très bien fait est disponible ici: [Link]
electronique-de-zero Par ailleurs, il faut noter l'excellent wiki suivant, qui propose de très
nombreuses expériences sur Arduino. Idéal pour des TP ou pour donner des défis aux élèves:
[Link]/[Link]?title=Catégorie:Arduino Arduino à l'école 10 Bibliographie Il
existe de nombreux livres sur Arduino et sur l’électronique. Voici une sélection de livres que nous
avons évalués et sélectionnés. Note: nous vous encourageons à commander ces livres chez votre
libraire. Mais si vous désirez les commander chez Amazon, nous vous serions reconnaissants d'utiliser
les liens sponsorisés ci-dessous. Electronique: L’électronique en pratique, de Charles Platt ISBN: 978-
2212135077 L’approche pédagogique de ce livre est l’apprentissage par la pratique. On commence
par expérimenter et découvrir, et ensuite seulement vient la théorie pour affermir et expliciter les
découvertes. Cela en fait donc un ouvrage de référence pour l’apprentissage de l’électronique à
l’école; en particulier en complément des Arduino et Raspberry Pi. Il s'agit donc d'un excellent livre
pour l'enseignant. Feuilleter ce livre sur [Link] Commander sur [Link] L’électronique pour les
Kids, de Øyvind Nydal Dahl ISBN: 978-2212118629 Il est parfois difficile d’aborder et de faire
comprendre les notions d’électricité et d’électronique aux élèves. C’est là que le livre L’électronique
pour les kids vient apporter une approche intéressante: on ne s’embarrasse pas d’Arduino et de
programmation. L’entier du premier tiers du livre, soit la partie 1, est consacré à l’électricité. De
manière simple et pédagogique, l’enfant comprend ce qu’est l’électricité. La seconde partie permet
la découverte des différents composants électroniques au travers de petits circuits, dont certains
sont soudés. Enfin, la troisième partie est une approche du monde numérique, mais par
l’électronique. Et c’est cette partie, elle est géniale! On aborde les circuits logiques, le binaire…
Feuilleter ce livre sur [Link] Commander sur [Link] Arduino à l'école 11 Arduino: Le grand
livre d’Arduino, d’Erik Bartmann ISBN: 978-2212137019 Ce livre est sans doute l’un des meilleurs
pour débuter sur Arduino. Il offre une introduction rapide à l’électronique et surtout le code est très
bien expliqué, agrémenté de schémas. Il ne se limite enfin pas à quelques notions de base, mais va
assez loin. Feuilleter sur [Link] Commander sur [Link] Démarrez avec Arduino – 2e édition:
Principes de base et premiers montages, par Massimo Banzi ISBN: 978-2100701520 Massimo Banzi
est l’un des principaux créateurs d’Arduino. Autant dire qu’il connaît son sujet! L’accent de cet
ouvrage est mis sur une initiation à la programmation de l’Arduino, plus que sur l’électronique. A
conseiller à tous les débutants. Commander le livre sur [Link] A l'aventure avec Arduino – Dès 10
ans, par Becky Stewart ISBN: 978-2212143140 Le sous-titre; « dès 10 ans » implique que ce livre
manque complètement sa cible: gros pavés de textes, présentation dense, touffue et un peu triste
ainsi que de devoir attendre la page 41 avant de réaliser son premier montage (une résistance, une
LED… Maintenant, ce livre a quand même des avantages certains, pour un enseignant ou un parent
qui va accompagner des enfants: les exercices sont bien agencés, les explications sont claires et
simples à comprendre. Les objectifs sont ambitieux, puisqu’on va aller jusqu’à aborder les registres à
décalage et les servos. • Commander le livre sur [Link] Les meilleurs cours en ligne
[Link] (français) [Link]
Class (anglais) Arduino à l'école 12 À propos des schémas électroniques Pour réaliser les schémas
électroniques, nous utilisons les outils suivants, disponibles gratuitement sur Mac et PC: Fritzing:
[Link] Solve Elec: [Link] Fido Cadj:
[Link] QElectroTech
[Link] iCircuit [Link] Il existe aussi une solution très élégante en
ligne5: [Link] Ce site permet de créer des schémas électroniques ainsi que la
réalisation de circuits électroniques. Un simulateur Arduino est aussi disponible à cette adresse:
[Link] Il permet la réalisation de schémas d'implantation des composants sur
les platines d'expérimentation, tout comme Fritzing, mais aussi la réalisation de schémas et de
circuits électroniques. 5 Ce sera la solution utilisée principalement dans ce cours. Pour plus
d'informations: [Link] Arduino à l'école 13 Découverte de la plateforme
Arduino Arduino fait partie de la famille des platines de développement. Contrairement aux
Raspberry Pi et aux Beaglebone, il ne possède pas d'OS basé sur Linux. Il reste par contre l'un des
plus abordables et des plus répandus. Une platine de développement est en général un circuit
imprimé équipé d'un microprocesseur ou d'un microcontrôleur. Comme Arduino est open source, il
existe un grand nombre de clones et de platines compatibles, tout comme il existe de nombreux
modèles d'Arduino officiels, avec des fonctions particulières: Pour ce cours, nous nous baserons sur
le plus connu: l'Arduino Uno. Mais un autre modèle ou un clone fera aussi bien l'affaire. Vous pouvez
par exemple trouver le Diduino, réalisé spécialement pour l'éducation ici:
[Link] Arduino à l'école 14 Schéma d'une platine
Arduino Uno Le microcontrôleur C’est le cerveau de notre carte. Il va recevoir le programme que
nous allons créer et va le stocker dans sa mémoire avant de l’exécuter. Grâce à ce programme, il va
savoir faire des choses, qui peuvent être : faire clignoter une LED, afficher des caractères sur un
écran, envoyer des données à un ordinateur, mettre en route ou arrêter un moteur… Il existe deux
modèles d’Arduino Uno: l’un avec un microcontrôleur de grande taille, et un autre avec un
microcontrôleur dit SMD (SMD: Surface Mounted Device, soit composants montés en surface, en
opposition aux composants qui traversent la carte électronique et qui sont soudés du côté opposé).
D’un point de vue utilisation, il n’y a pas de différence entre les deux types de microcontrôleurs. Les
couleurs de l'Arduino peuvent varier du bleu au bleu-vert, en fonction des modèles et années de
production. Arduino Uno Arduino Uno SMD Arduino à l'école 15 L’alimentation Pour fonctionner, une
carte Arduino a besoin d'une alimentation. Le microcontrôleur fonctionnant sous 5V, la carte peut
être alimentée en 5V par le port USB ou bien par une alimentation externe qui est comprise entre 7V
et 12V. Un régulateur se charge ensuite de réduire la tension à 5V pour le bon fonctionnement de la
carte. Attention: les cartes Arduino Due ainsi que d'autres cartes récentes fonctionnent avec un
voltage de 3.3V au niveau des sorties! Le voltage de l’alimentation est similaire à l’Arduino Uno. Dans
ce cours, nous partons du principe que le voltage des montages est en 5 Volts. La connectique A part
une LED sur la broche 13, la carte Arduino ne possède pas de composants (résistances, diodes,
moteurs...) qui peuvent être utilisés pour un programme. Il est nécessaire de les rajouter. Mais pour
cela, il faut les connecter à la carte. C'est là qu'interviennent les connecteurs, aussi appelés broches
(pins, en anglais). Sur les Arduino et sur beaucoup de cartes compatibles Arduino, les broches se
trouvent au même endroit. Cela permet de fixer des cartes d’extension, appelée shields en les
empilant. Exploration des broches Arduino 0 à 13 Entrées/sorties numériques A0 à A5
Entrées/sorties analogiques GND Terre ou masse (0V) 5V Alimentation +5V 3.3V Alimentation +3.3V
Vin Alimentation non stabilisée (= le même voltage que celui à l’entrée de la carte) Les connexions
entre les composants sont réalisées par des jumpers, sortes de petits câbles. Arduino à l'école 16 La
platine d’expérimentation Une platine d’expérimentation (appelée breadboard) permet de réaliser
des prototypes de montages électroniques sans soudure et donc de pouvoir réutiliser les
composants. Tous les connecteurs dans une rangée de 5 sont reliés entre eux. Donc si on branche
deux éléments dans un groupe de cinq connecteurs, ils seront reliés entre eux. Il en est de même des
alignements de connecteurs rouges (pour l’alimentation) et bleus (pour la terre). Ainsi, les liens
peuvent être schématisés ainsi: Les composants doivent ainsi être placés à cheval sur des
connecteurs qui n'ont pas de liens électriques entre eux, comme sur le schéma ci-contre. Les longues
rangées sont utilisées pour connecter la masse (GND), en bleu et le +5V, en rouge Tous les
connecteurs d’une ligne extérieure sont électriquement reliés entre-eux Les connecteurs sont
électriquement reliés entre-eux par 5 Il n’y a pas de lien électrique au-travers de la ligne de partage
Arduino à l'école 17 Le logiciel Arduino IDE Le logiciel Arduino IDE fonctionne sur Mac, Windows et
Linux. C'est grâce à ce logiciel que nous allons créer, tester et envoyer les programmes sur l'Arduino.
L'IDE est téléchargeable à l'adresse suivante: [Link] Une version en ligne de l'éditeur de
code est disponible à cette adresse: [Link] Arduino à l'école 18 Les bases
de l’électronique Petit rappel sur l’électricité L’électricité est un déplacement d’électrons dans un
milieu conducteur. Pour que ces électrons se déplacent tous dans un même sens, il faut qu'il y ait
une différence du nombre d'électrons entre les deux extrémités du circuit électrique. Pour maintenir
cette différence du nombre d'électrons, on utilise un générateur (pile, accumulateur, alternateur...)
La différence de quantité d’électrons entre deux parties d’un circuit s’appelle la différence de
potentiel et elle se mesure en Volts (V). On peut comparer le fonctionnement d’un circuit électrique
à celui d’un barrage hydroélectrique: • Les électrons seraient l’eau • Le générateur serait le réservoir
d’eau • Les conducteurs sont naturellement les conduites forcées • Le consommateur (une ampoule
ou une diode, par exemple) est la turbine, qui exploite l’énergie du déplacement des électrons Sur un
barrage, plus la différence entre l’altitude du niveau du réservoir et celui de la turbine est
importante, plus la pression de l’eau sera importante. Pour un barrage on appelle cette différence
d’altitude hauteur de chute. Cela équivaut sur un circuit électrique à la différence de potentiel, qui se
mesure en Volts (V) et se note U. Le débit de l’eau (=la quantité d’eau qui s’écoule par unité de
temps) correspond à l’intensité, aussi appelée courant, qui est donc le débit d’électrons. Elle se
mesure en Ampères (A) et se note I. La puissance électrique se note P et se mesure en Watts (W). Elle
exprime la quantité de courant (I), transformée en chaleur ou en mouvement. Sur un barrage, elle

l'intensité I. 𝑃 = 𝑈 ∙ 𝐼 Quelques ressources pour comprendre l’électricité: C’est pas sorcier sur
correspond à l’énergie produite par la turbine. La puissance P est le produit de la tension U et de

l’électricité: [Link] C'est pas sorcier sur le transport de

l'électricité: [Link] C’est pas sorcier sur les batteries et
les piles: [Link] Site pédagogique sur l'électricité Hydro-
Qébec: [Link] La bataille de l'électricité:
[Link] Arduino à l'école 19 Les diodes Il est possible de
remplacer l’ampoule par une diode électroluminescente, aussi appelée LED6. Elle a la particularité de
ne laisser passer le courant électrique que dans un sens. Le courant électrique ne peut traverser la
diode que dans le sens de l’anode vers la cathode. On reconnaît l’anode, car il s’agit de la broche la
plus longue. Lorsque les deux broches sont de même longueur, on peut distinguer l’anode de la
cathode, par un méplat du côté de cette dernière. Le symbole de la LED est le suivant: Attention: le
courant produit par l’Arduino est trop important pour y brancher directement une LED dessus.
L’utilisation d’une résistance est obligatoire, pour ne pas griller la LED. En utilisant divers matériaux
semi-conducteurs, on fait varier la couleur de la lumière émise par la LED. Il existe enfin une grande
variété de formes de LEDs. 6 [Link] Arduino à
l'école 20 Les résistances Une résistance est un composant électronique ou électrique dont la
principale caractéristique est d'opposer une plus ou moins grande résistance (mesurée en ohms: Ω) à
la circulation du courant électrique. On peut alors comparer, le débit d’eau au courant électrique I
(qui est d’ailleurs le débit d’électrons), la différence de pression à la différence de potentiel
électrique (qui est la tension U) et, enfin, le rétrécissement à la résistance R. Ainsi, pour une tension

par la loi d’Ohm: 𝑈 = 𝑅 ∙ 𝐼 𝑒𝑡 𝑑𝑜𝑛𝑐 𝑅 = 𝑈 𝐼 𝑒𝑡 𝐼 = 𝑈 𝑅 Une résistance est un milieu peu

fixe, plus la résistance est faible, plus le courant la traversant est fort. Cette proportion est vérifiée

conducteur; les électrons peinent à s’y déplacer. Leur énergie se dissipe alors en général sous forme
de chaleur. C’est ce principe utilisé pour les bouilloires électriques ou les ampoules à filaments. La
valeur de la résistance se mesure en Ohms (Ω). La valeur d’une résistance est déterminée par ses
bandes de couleurs. Arduino à l'école 21 vOutre le tableau ci-dessus, on peut s’aider du petit mode
d’emploi qui se trouve ici: [Link] La
résistance est schématisée de ces deux manières (européenne à gauche et américaine à droite): Un
calculateur de valeurs de résistances est disponible à cette adresse: [Link]
Arduino à l'école 22 Projet 1: le circuit électrique Réalise le circuit suivant: Note: la couleur des fils
électriques importe peu, de même que leur position sur la platine d'expérimentation. Circuit 1 Liste
des composants 1 Led 1 résistance de 220 à 470Ω 2 câbles Observations Voici ce que cela donne au
niveau du schéma électronique. Lorsqu'on branche l'Arduino à l'ordinateur, via le câble USB, il y a
50% de chances que la LED s'allume. En effet, si elle ne s’allume pas, il faut tourner la LED dans
l’autre sens. Sa particularité est que l'électricité ne peut la traverser que dans un sens. +5V 220Ω
RÉSISTANCE LED D1 Arduino à l'école 23 Le circuit électrique Lors de l'exercice 1, tu as réalisé un
circuit électrique: tu as relié une source d'électron à la terre. Leur déplacement a ainsi permis à la
LED de s'allumer. L'Arduino ne sert qu'à l'alimentation électrique, comme une pile. Une pile est
constituée d’un milieu contenant de nombreux électrons en trop, et d’un second milieu en manque
d’électrons. Quand on relie les deux pôles de la pile (le + et le -) avec un fil électrique (le conducteur),
les électrons vont alors se déplacer du milieu riche en électrons vers le milieu pauvre. Si on place une
lampe électrique entre les deux, le passage des électrons va générer de la lumière. Circuit électrique
Voici le schéma électrique du circuit ci-dessus: Lorsque l'interrupteur est enclenché, on dit que le
circuit est fermé. Les électrons vont alors se déplacer et l'énergie de ce déplacement pourra être
exploitée pour allumer une lampe ou faire fonctionner un moteur, par exemple. Lorsque
l'interrupteur est déclenché, on dit que le circuit est ouvert. Le pôle positif n'étant alors plus relié au
pôle négatif, les électrons ne peuvent plus se déplacer. S1 L1 5 V1 Interrupteur Ampoule Pile Arduino
à l'école 24 Projet 2: faire clignoter une LED Comme premier programme, nous allons faire clignoter
une LED D1, connectée sur la broche 13. Voici le schéma de câblage: Circuit 2 Liste des composants 1
Led 1 résistance de 220 à 470 Ω 2 câbles ARDUINO U1 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12
D13 GND AREF A5 A4 A3 A2 A1 A0 VIN GND1 GND2 5V 3V RESET ARDUINO Duemilanove Diecimila
UNO R1R2 220 Ω R1 LED D1 Arduino à l'école 25 Le logiciel Arduino IDE La programmation se fait
dans le logiciel Arduino IDE: Le menu Bouton 1 : Ce bouton permet de vérifier le programme, il
actionne un module qui cherche les erreurs dans le programme Bouton 2 : Envoi du programme sur
l’Arduino Bouton 3 : Créer un nouveau fichier Bouton 4 : Ouvrir un fichier existant Bouton 5 :
Enregistrer un fichier Commençons tout de suite par un petit code. Nous l’analyserons ensuite. Une
fois le code écrit (ou collé) dans la fenêtre de programmation, il faut l’envoyer sur l’Arduino. Pour
cela, après avoir connecté l'Arduino à l'ordinateur, il faut sélectionner le port (tty_usbmodemXXXXX)
et le type de carte (Arduino Uno, dans notre cas). Ces deux réglages sont dans le menu Outils. Cliquer
enfin sur le bouton téléverser (upload). Menu Fenêtre de programmation Fenêtre de contrôle
Arduino à l'école 26 Code 1: faire clignoter une LED sur la broche 13 /* Code 1 - [Link], destiné
à l'Arduino Objectif: faire clignoter la LED montée sur la broche 13 */ //***** FONCTION SETUP =
Code d'initialisation ***** // La fonction setup() est exécutée en premier et une seule fois, au
démarrage du programme void setup() // début de la fonction setup() { pinMode(13, OUTPUT); //
Initialise la broche 13 comme sortie [Link](9600); // Ouvre le port série à 9600 bauds } // fin de
la fonction setup() //***** FONCTION LOOP = Boucle sans fin = coeur du programme ***** // la
fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension void
loop() // début de la fonction loop() { digitalWrite(13, HIGH); // Met la broche 13 au niveau haut =
allume la LED delay(500); // Pause de 500ms digitalWrite(13, LOW); // Met la broche 13 au niveau
bas = éteint la LED delay(500); // Pause 500ms } // fin de la fonction loop() Liens Télécharger le code
[Link] Observations Ce code permet de faire clignoter la LED D1
située sur la broche 13. Une LED, soudée sur l'Arduino et reliée à la broche 13 clignote elle aussi. La
résistante R1 de 220Ω sert à abaisser la tension et éviter que la LED ne grille. Débugger Il y a de
nombreuses erreurs possibles dans un programme Arduino. La lecture et la compréhension de ces
erreurs dans Arduino IDE ne sont pas évidentes. Vous trouverez de précieux conseils ici:
[Link] Arduino à l'école 27 Introduction au code Le
déroulement du programme Le programme se déroule de la façon suivante : 1. Prise en compte des
instructions de la partie déclarative 2. Exécution de la partie configuration ( fonction setup( ) ), 3.
Exécution de la boucle sans fin ( fonction loop ( ) ): le code compris dans la boucle sans fin est
exécuté indéfiniment. Nous verrons petit à petit les divers éléments présents dans le schéma.
L’important pour le moment est de savoir qu’un programme est divisé en trois parties: en-tête
déclarative, fonction setup et fonction loop. La suite va nous permettre d’entrer dans le code
minimal: les fonctions setup et loop. Le code minimal Avec Arduino, nous devons utiliser un code
minimal lorsqu'on crée un programme. Ce code permet de diviser le programme en deux parties.
void setup() { } void loop() { } Nous avons donc devant nous le code minimal qu'il faut insérer dans
notre programme. Mais que peut-il bien signifier pour quelqu'un qui n'a jamais programmé ?
Arduino à l'école 28 La fonction Dans le code 1, se trouvent deux fonctions. Les fonctions sont en fait
des portions de code. Première fonction: void setup() { } Cette fonction setup() est appelée une seule
fois lorsque le programme commence. C'est pourquoi c'est dans cette fonction que l'on va écrire le
code qui n'a besoin d'être exécuté qu’une seule fois. On appelle cette fonction : "fonction
d'initialisation". On y retrouvera la mise en place des différentes sorties et quelques autres réglages.
Une fois que l'on a initialisé le programme, il faut ensuite créer son "cœur", autrement dit le
programme en luimême. Deuxième fonction: void loop() { } C'est donc dans cette fonction loop() que
l’on va écrire le contenu du programme. Il faut savoir que cette fonction est appelée en permanence,
c'est-à-dire qu'elle est exécutée une fois, puis lorsque son exécution est terminée, on la réexécute,
encore et encore. On parle de boucle infinie. Les instructions Maintenant que nous avons vu la
structure des fonctions, regardons ce qu’elles peuvent contenir. Les instructions sont des lignes de
code qui disent au programme : "fais ceci, fais cela..." Ce sont donc les ordres qui seront exécutés par
l’Arduino. Il est très important de respecter exactement la syntaxe; faute de quoi, le code ne pourra
pas être exécuté. Les points virgules ; Les points virgules terminent les instructions. Si par exemple on
dit dans notre programme : "appelle la fonction mangerLeChat", on doit mettre un point virgule
après l'appel de cette fonction. Lorsque le code ne fonctionne pas, c’est souvent parce qu’il manque
un point-virgule. Il faut donc être très attentif à ne pas les oublier! Les accolades { } Les accolades
sont les "conteneurs" du code du programme. Elles sont propres aux fonctions, aux conditions et aux
boucles. Les instructions du programme sont écrites à l'intérieur de ces accolades. Pour ouvrir une
accolade sur Mac, taper alt-8 et alt-9 pour la fermer. Les commentaires Les commentaires sont des
lignes de codes qui seront ignorées par le programme. Elles ne servent en rien lors de l'exécution du
programme. Ils permettent d'annoter et de commenter le programme. Ligne unique de commentaire
: //cette ligne est un commentaire sur UNE SEULE ligne Arduino à l'école 29 Ligne ou paragraphe sur
plusieurs lignes : /*cette ligne est un commentaire, sur PLUSIEURS lignes qui sera ignoré par le
programme, mais pas par celui qui lit le code ;) */ Les accents Il est formellement interdit de mettre
des accents en programmation! Sauf dans les commentaires... Analyse du code 1 Revenons
maintenant à notre code. La ligne pinMode(13, OUTPUT); initialise la broche 13 du microcontrôleur
comme sortie, c'est-à-dire que des données seront envoyées depuis le microcontrôleur vers cette
broche (on va envoyer de l'électricité). La ligne [Link](9600); initialise le port série qui permet à
l'Arduino d'envoyer et de recevoir des informations à l'ordinateur. C'est recommandé, mais cela
fonctionne aussi sans. Avec l'instruction digitalWrite(13, HIGH);, le microcontrôleur connecte la
broche D13 au +5V ce qui a pour effet d'allumer la LED (de l'électricité sort de la broche D13).
L'instruction delay(500); indique au microcontrôleur de ne rien faire pendant 500 millisecondes, soit
½ seconde. Avec l'instruction digitalWrite(13, LOW);, le microcontrôleur connecte la broche D13 à la
masse (Gnd) ce qui a pour effet d'éteindre la LED (on coupe l'alimentation en électricité).
L'instruction delay(500); indique au microcontrôleur à nouveau de ne rien faire pendant 500ms soit
½ seconde. Le résultat est donc que la LED s'allume pendant ½ seconde, puis s'éteint pendant une ½
seconde puis s'allume pendant ½ seconde... elle clignote donc. Profitons maintenant pour voir ce que
signifie le terme Output. Il s’agit de préciser si la broche est une entrée ou une sortie. En effet, le
microcontrôleur a la capacité d'utiliser certaines de ses broches en entrée (INPUT) Arduino à l'école
30 ou en sortie (OUTPUT). Il suffit simplement d’interchanger une ligne de code pour dire qu'il faut
utiliser une broche en entrée (récupération de données) ou en sortie (envoi de données). Cette ligne
de code doit se trouver dans la fonction setup(). La fonction est pinMode(), comme dans l'exemple ci-
dessous: void setup() { pinMode(13, OUTPUT); [Link](9600); } Modifions le code Faisons varier
les valeurs de l’instruction delay et modifions le code selon les exemples ci-dessous. Essai 1:
digitalWrite(13, HIGH); delay(50); digitalWrite(13, LOW); delay(50); Essai 2: digitalWrite(13, HIGH);
delay(500); digitalWrite(13, LOW); delay(2000); Essai 3: digitalWrite(13, HIGH); delay(50);
digitalWrite(13, LOW); delay(50); digitalWrite(13, HIGH); delay(1000); digitalWrite(13, LOW);
delay(1000); Arduino à l'école 31 Projet 3: faire clignoter quatre LEDs Voici le montage à réaliser. Les
LEDs sont connectées aux broches 10 à 13. Circuit 3 Liste des composants 4 Leds 4 résistances de 220
à 470Ω 6 câbles ARDUINO U1 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13 GND AREF A5 A4 A3
A2 A1 A0 VIN GND1 GND2 5V 3V RESET ARDUINO Duemilanove Diecimila UNO R1R2 220 Ω R1 LED D1
LED D2 220 Ω R2 220 Ω R3 220 Ω R4 LED D3 LED D4 Arduino à l'école 32 Code 2: faire clignoter 4 LEDs
Ce code fait clignoter les 4 LEDs en même temps. /* Code 2 - [Link], destiné à l'Arduino
Objectif: faire clignoter les 4 LEDs montées sur les broches 10 à 13 */ //***** FONCTION SETUP =
Code d'initialisation ***** // La fonction setup() est exécutée en premier et une seule fois, au
démarrage du programme void setup() // début de la fonction setup() { pinMode(10, OUTPUT); //
Initialise la broche 10 comme sortie pinMode(11, OUTPUT); // Initialise la broche 11 comme sortie
pinMode(12, OUTPUT); // Initialise la broche 12 comme sortie pinMode(13, OUTPUT); // Initialise la
broche 13 comme sortie [Link](9600); // Ouvre le port série à 9600 bauds } // fin de la fonction
setup() //***** FONCTION LOOP = Boucle sans fin = coeur du programme ***** // la fonction loop()
s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension void loop() // début de la
fonction loop() { digitalWrite(10, HIGH); // Met la broche 10 au niveau haut = allume la LED
digitalWrite(11, HIGH); // Met la broche 11 au niveau haut = allume la LED digitalWrite(12, HIGH); //
Met la broche 12 au niveau haut = allume la LED digitalWrite(13, HIGH); // Met la broche 13 au
niveau haut = allume la LED delay(500); // Pause de 500ms digitalWrite(10, LOW); // Met la broche
10 au niveau bas = éteint la LED digitalWrite(11, LOW); // Met la broche 11 au niveau bas = éteint la
LED digitalWrite(12, LOW); // Met la broche 12 au niveau bas = éteint la LED digitalWrite(13,
LOW); // Met la broche 13 au niveau bas = éteint la LED delay(500); // Pause 500ms } // fin de la
fonction loop() Liens Télécharger le code Simulateur Arduino
[Link] [Link] Arduino à l'école 33
Code 3: réaliser un chenillard à 4 LEDs. /* Code 3 - [Link], destiné à l'Arduino Objectif: faire un
chenillard à 4 LEDs montées sur les broches 10 à 13 */ void setup() // début de la fonction setup()
{ pinMode(10, OUTPUT); // Initialise la broche 10 comme sortie pinMode(11, OUTPUT); // Initialise la
broche 11 comme sortie pinMode(12, OUTPUT); // Initialise la broche 12 comme sortie pinMode(13,
OUTPUT); // Initialise la broche 13 comme sortie [Link](9600); // Ouvre le port série à 9600
bauds } // fin de la fonction setup() void loop() // début de la fonction loop() { digitalWrite(10,
HIGH); // Met la broche 10 au niveau haut = allume la LED digitalWrite(11, LOW); // Met la broche 11
au niveau bas = éteint la LED digitalWrite(12, LOW); // Met la broche 12 au niveau bas = éteint la LED
digitalWrite(13, LOW); // Met la broche 13 au niveau bas = éteint la LED delay(100); // Pause de
100ms digitalWrite(10, LOW); // Met la broche 10 au niveau bas = éteint la LED digitalWrite(11,
HIGH); // Met la broche 11 au niveau haut = allume la LED delay(100); // Pause de 100ms
digitalWrite(11, LOW); // Met la broche 11 au niveau bas = éteint la LED digitalWrite(12, HIGH); //
Met la broche 12 au niveau haut = allume la LED delay(100); // Pause de 100ms digitalWrite(12,
LOW); // Met la broche 12 au niveau bas = éteint la LED digitalWrite(13, HIGH); // Met la broche 13
au niveau haut = allume la LED delay(100); // Pause de 100ms digitalWrite(13, LOW); // Met la
broche 13 au niveau bas = éteint la LED digitalWrite(12, HIGH); // Met la broche 12 au niveau haut =
allume la LED delay(100); // Pause de 100ms digitalWrite(12, LOW); // Met la broche 12 au niveau
bas = éteint la LED digitalWrite(11, HIGH); // Met la broche 11 au niveau haut = allume la LED
delay(100); // Pause de 100ms } // fin de la fonction loop Liens Télécharger le code
[Link] Arduino à l'école 34 Projet 4: introduction aux variables
Une variable, qu'est ce que c'est ? Imaginons un nombre dont nous devons nous souvenir. Ce
nombre est stocké dans un espace de stockage de la mémoire vive (RAM) du microcontrôleur.
Chaque espace de stockage est identifié de manière unique. Le nombre stocké a la particularité de
changer de valeur. En effet, la variable n'est que le conteneur. Son contenu va donc pouvoir être
modifié. Et ce conteneur va être stocké dans une case de la mémoire. Si on matérialise cette
explication par un schéma, cela donnerait : nombre ➞ variable ➞ mémoire le symbole "➞"
signifiant : "est contenu dans..." Imaginons que nous stockons le nombre dans un container (la
variable). Chaque container est lui, déposé dans un espace bien précis, afin de le retrouver. Chaque
container (variable) est aussi identifié par un nom unique. Le nom d'une variable Le nom de variable
n'accepte que l'alphabet alphanumérique ([a-z], [A-Z], [0-9]) et _ (underscore). Il est unique; il ne
peut donc pas y avoir deux variables portant le même nom. Arduino à l'école 35 Définir une variable
Imaginons que nous voulons stocker le nombre 4 dans une variable. Il tiendrait dans un petit carton.
Mais on pourrait le stocker dans un grand container. Oui... mais non! Un microcontrôleur, ce n'est
pas un ordinateur 3GHz multicore, 8Go de RAM ! Ici, il s’agit d'un système qui fonctionne avec un
CPU à 16MHz (soit 0,016 GHz) et 2 Ko de SRAM pour la mémoire vive. Il y a donc au moins deux
raisons pour choisir ses variables de manière judicieuse : 1. La RAM n'est pas extensible, quand il y en
a plus, y en a plus! Dans un même volume, on peut stocker bien plus de petits cartons de que gros
containers. Il faut donc optimiser la place. 2. Le processeur est de type 8 bits (sur un Arduino UNO),
donc il est optimisé pour faire des traitements sur des variables de taille 8 bits, un traitement sur une
variable 32 bits prendra donc (beaucoup) plus de temps. Si les variables de la taille d’un container
sont sur 32 bits, autant prendre un carton qui n’occupe que 8 bits quand la variable tient dedans!
Type de variable Type de nombre stocké Valeurs maximales du nombre stocké Nombre sur X bits
Nombre d’octets int entier -32’768 à +32’767 16 bits 2 octets long entier -2’147’483’648 à
+2’147’483’647 32 bits 4 octets char entier -128 à +127 8 bits 1 octet float décimale -3.4 x 1038 à
+3.4 x 1038 32 bits 4 octets double décimale -3.4 x 1038 à +3.4 x 1038 32 bits 4 octets Prenons
maintenant une variable que nous allons appeler «x». Par exemple, si notre variable "x" ne prend
que des valeurs décimales, on utilisera les types int, long, ou char. Si maintenant la variable "x" ne
dépasse pas la valeur 64 ou 87, alors on utilisera le type char. char x = 0; Si en revanche x = 260, alors
on utilisera le type supérieur (qui accepte une plus grande quantité de nombre) à char, autrement dit
int ou long. int x = 0; Si à présent notre variable "x" ne prend jamais une valeur négative (-20, -78, ...),
alors on utilisera un type non-signé. C'est à dire, dans notre cas, un char dont la valeur n'est plus de -
128 à +127, mais de 0 à 255. Voici le tableau des types non signés, on repère ces types par le mot
unsigned (de l'anglais : non-signé) qui les précède : Type de variable Type de nombre stocké Valeurs
maximales du nombre stocké Nombre sur X bits Nombre d’octets unsigned char entier non négatif 0
à 255 8 bits 1 octet unsigned float entier non négatif 0 à 65’535 16 bits 2 octets unsigned double
entier non négatif 0 à 4’294’967’295 32 bits 4 octets Arduino à l'école 36 Une des particularités du
langage Arduino est qu'il accepte un nombre plus important de types de variables, listées dans ce
tableau: Type de variable Type de nombre stocké Valeurs maximales du nombre stocké Nombre sur X
bits Nombre d’octets byte entier non négatif 0 à 255 8 bits 1 octet word entier non négatif 0 à 65’535
16 bits 2 octets boolean entier non négatif 0 à 1 1 bits 1 octet . Définir les broches du
microcontrôleur Jusqu’à maintenant, nous avons identifié les broches du microcontrôleur à l’aide de
leurs numéros, comme dans l’exemple suivant: pinMode(13, OUTPUT);. Cela ne pose pas de
problème quand on a une ou deux LEDs connectées. Mais dès qu’on a des montages plus
compliqués, cela devient difficile de savoir qui fait quoi. Il est donc possible de renommer chaque
broche du microcontrôleur. Premièrement, définissons la broche utilisée du microcontrôleur en tant
que variable. const int led1 = 13; Le terme const signifie que l'on définit la variable comme étant
constante. Par conséquent, on change la nature de la variable qui devient alors constante. Le terme
int correspond à un type de variable. Dans une variable de ce type, on peut stocker un nombre allant
de -2147483648 à +2147483647, ce qui sera suffisant! Ainsi, la broche 13 s’appellera led1. Nous
sommes donc en présence d'une variable, nommée led1, qui est en fait une constante, qui peut
prendre une valeur allant de -2147483648 à +2147483647. Dans notre cas, cette constante est
assignée au nombre 13. Concrètement, qu’est-ce que cela signifie? Observons la différence entre les
deux codes. Broche non-définie Broche définie void setup() { pinMode(13, OUTPUT); // Initialise la
broche 13 comme sortie [Link](9600); } void loop() { digitalWrite(13, HIGH); delay(500);
digitalWrite(13, LOW); delay(500); } const int led1= 13; //La broche 13 devient led1 void setup()
{ pinMode(led1, OUTPUT); // Initialise led1 comme broche de sortie [Link](9600); } void loop() {
digitalWrite(led1, HIGH); delay(500); digitalWrite(led1, LOW); delay(500); } On peut trouver que de
définir les broches allonge le code. Mais quand nous aurons de nombreuses broches en fonction, cela
nous permettra de les identifier plus facilement. Ainsi, si nous avons plusieurs LED, nous pouvons les
appeler Led1, Led2, Led3,... et si nous utilisons des LED de plusieurs couleurs, nous pourrons les
appeler rouge, vert, bleu,... Enfin (et surtout!), si on veut changer la broche utilisée, il suffit de
corriger la variable au départ, sans devoir corriger tout le code. Comme pour les variables, nous
pouvons donner n'importe quel nom aux broches. Arduino à l'école 37 Projet 5: Les feux de
circulation Afin de mettre en pratique l'utilisation de variables, voici un petit exercice. On peut se
baser sur le code 3 pour débuter. L’objectif de cet exercice est de créer deux feux de circulation et de
les faire fonctionner de manière synchrone. Voici les phases de deux feux de circulation que tu dois
recréer: Tu peux visionner une vidéo de présentation ici: [Link]
3067 Circuit 4 1 2 3 4 Feu 1 Feu 2 phases 6 sec 2 sec 6 sec 2 sec Arduino à l'école 38 Liste des
composants 2 LEDs rouges 2 LEDs jaunes ou oranges 2 LEDs vertes 6 résistances de 220 à 470Ω Afin
de faciliter l'identification de chaque LED, nous allons renommer les broches comme suit: Feu 1: LED
rouge connectée sur la broche 4 et renommée R1 LED jaune connectée sur la broche 5 et renommée
J1 LED verte connectée sur la broche 6 et renommée V1 Feu 2: LED rouge connectée sur la broche 8
et renommée R2 LED jaune connectée sur la broche 9 et renommée J2 LED verte connectée sur la
broche 10 et renommée V2 Enfin, nous utiliserons deux variables timer1 et timer2 pour définir les
temps d'allumages. Avant de regarder le code à la page suivante, essaie de faire l'exercice seul.
ARDUINOR3 U1 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13 GND AREF A5SCL A4SDA A3 A2
A1 A0 VIN GND1 GND2 5V 3V RESET IOREF RESERVED SDA SCL ARDUINO UNO R3 220 R1 220 R2 220
R3 220 R4 220 R5 220 R6 R1 D1 J1 D2 V1 D3 R2 D4 J2 D5 V2 D6 Arduino à l'école 39 Code 4: le feu de
circulation /* Code 4 - [Link], destiné à l'Arduino Objectif: gérer des feux de circulation */ //
On définit les variables pour chaque broche //FEU 1 const int R1 = 4; //La broche 4 devient le feu
rouge 1 const int J1 = 5; //La broche 3 devient le feu jaune 1 const int V1 = 6; //La broche 2 devient le
feu vert 1 //FEU2 const int R2 = 8; //La broche 8 devient le feu rouge 2 const int J2 = 9; //La broche 9
devient le feu jaune 2 const int V2 = 10; //La broche 10 devient le feu vert 2 //TEMPS int timer1 =
2000; //Le temps est fixé à 2 secondes int timer2 = 6000; //Le temps est fixé à 6 secondes void
setup() { //On initialise les sorties pinMode(R1, OUTPUT); pinMode(J1, OUTPUT); pinMode(V1,
OUTPUT); pinMode(R2, OUTPUT); pinMode(J2, OUTPUT); pinMode(V2, OUTPUT); } void loop() {
//Phase 1: R1 et V2 sont allumés, R2, J1 et J2 sont éteints digitalWrite(R2, LOW); //R2 éteint
digitalWrite(J1, LOW); //J1 éteint digitalWrite(J2, LOW); //J2 éteint digitalWrite(R1, HIGH); //R1
allumé digitalWrite(V2, HIGH); //V2 allumé delay(timer2); //durée: 6'000 millisecondes, soit 6
secondes //Phase 2: R1, J1, J2 allumés et V2 éteint digitalWrite(V2, LOW); //V2 éteint digitalWrite(J1,
HIGH); //J1 allumé digitalWrite(J2, HIGH); //J2 allumé delay(timer1); //durée: 2'000 millisecondes,
soit 2 secondes //Phase 3: R1, J1, J2 éteints et V1 et R2 allumés digitalWrite(R1, LOW); //R1 éteint
digitalWrite(J1, LOW); //J1 éteint digitalWrite(J2, LOW); //J2 éteint digitalWrite(V1, HIGH); //V1
allumé digitalWrite(R2, HIGH); //R2 allumé delay(timer2); //Phase 4: V1 éteint et J1, J2 et R2 allumés
digitalWrite(V1, LOW); //V1 éteint digitalWrite(J1, HIGH); //J1 allumé digitalWrite(J2, HIGH); //J2
allumé digitalWrite(R2, HIGH); //R2 allumé delay(timer1); } Liens Télécharger le code
[Link] Arduino à l'école 40 Variantes Variante 1 Il y a souvent un
décalage entre le passage d’un feu au rouge et le passage au vert de l’autre feu. C’est en particulier le
cas pour les feux de chantier. Cela permet aux voitures encore engagées dans la zone de chantier de
la quitter, avant de laisser la place aux voitures venant en face. Décrire les phases des feux et les
programmer pour tenir compte du délai. Variante 2 Intégrer un troisième feu, qui passe du rouge au
vert en alternance avec les deux autres feux. Réaliser le schéma électronique et programmer les
feux. Variante 3 Réaliser les feux pour un carrefour: Arduino à l'école 41 Projet 6: L’incrémentation Il
est possible d’appliquer aux valeurs des variables diverses opérations mathématiques. Commençons
tout de suite par un petit exemple: l’incrémentation. Il s’agit simplement d’additionner 1 à la
variable. A chaque fois qu’on répète le code, on prend la valeur de la variable et on y ajoute 1. Cela
se fait grâce à ce code (var étant une variable à choix): var++; var++; revient à écrire : "var = var + 1;".
Le circuit sera des plus classiques: on va reprendre notre chenillard. Circuit 5 Liste des composants: 4
LEDs rouges 4 résistances de 220 à 470Ω ARDUINO U1 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12
D13 GND AREF A5 A4 A3 A2 A1 A0 VIN GND1 GND2 5V 3V RESET ARDUINO Duemilanove Diecimila
UNO R1R2 220 Ω R1 LED D1 LED D2 220 Ω R2 220 Ω R3 220 Ω R4 LED D3 LED D4 Arduino à l'école 42
Code 5: faire clignoter 10 fois la LED 13 /* Code 5 - [Link], destiné à l'Arduino Objectif: faire
clignoter 10 fois la LED montée sur le port 13 */ //***** EN-TETE DECLARATIVE ***** // On déclare
les variables, les constantes... byte compteur; //On définit la variable "compteur" const int led1=
13; //On renomme la broche 10 en "led1" //***** FONCTION SETUP = Code d'initialisation ***** //
La fonction setup() est exécutée en premier et une seule fois, au démarrage du programme void
setup() { pinMode(led1, OUTPUT); // Initialise la broche 13 comme sortie [Link](9600); // Ouvre
le port série à 9600 bauds // Exécute le programme entre accolades en partant de zéro et en
incrémentant à chaque fois la valeur de +1: 0+1/2+1/3+1... jusqu’à ce que la variable “compteur“ soit
égale à 9 (plus petit que 10). for(compteur=0 ; compteur< 14; thisPin++) { pinMode(thisPin, OUTPUT);
} } void loop() { // boucle de la broche 10 à la broche 13: for (int thisPin = 10; thisPin < 14; thisPin++)
{ //Incrément faisant passer la variable thisPin de 10 à 13 digitalWrite(thisPin, HIGH); //Allumer la
LED delay(timer); //Durée digitalWrite(thisPin, LOW); //Eteindre la LED } // boucle de la broche 13 à
la broche 10: for (int thisPin = 13; thisPin >= 10; thisPin--) { //Décrément faisant passer la variable
thisPin de 13 à 10 digitalWrite(thisPin, HIGH); //Allumer la LED delay(timer); //Durée
digitalWrite(thisPin, LOW); //Eteindre la LED; } } Liens Télécharger le code
[Link] Arduino à l'école 45 Analyse du code Regardons
maintenant un peu ce code, en particulier: for (int thisPin = 10; thisPin < 14; thisPin++)
{ pinMode(thisPin, OUTPUT); } Sa première particularité est la manière de définir les broches. Au lieu
d'accumuler les pinMode (xxx, OUTPUT);, on créé une variable de type int qu'on appelle thisPin8 et
donc la valeur initiale est de 10. Un for avec un incrément (++) permet de permet d'incrémenter la
valeur de la variable de 10 à 14. Il suffit ensuite de remplacer dans le pinMode le numéro de la
proche par la variable thisPin. Ainsi, les broches 10, 11, 12, 13 et 14 sont définies en output.
Naturellement, cela ne fonctionne que si les broches utilisées se suivent (par exemple: 10, 11, 12, 13.
Cela ne fonctionnera pas pour des broches 3, 5, 7, 8, 10). Passons maintenant à la seconde partie: for
(int thisPin = 10; thisPin < 14; thisPin++) { //Incrément faisant passer la variable thisPin de 10 à 13
digitalWrite(thisPin, HIGH); //Allumer la LED delay(timer); //Durée digitalWrite(thisPin, LOW);
//Eteindre la LED } Comme pour la définition des broches en OUTPUT, on utilise la fonction for pour
incrémenter la variable thisPin de 10 à 13. Ainsi, on allume les LEDs connectés sur les broches 10 à 13
l'une après l'autre. Enfin dans la troisième partie du code, on va allumer les LEDs de la broche 13 à la
broche 10 avec une fonction for et une décrémentation. Pour cela, on remplace le ++ par un --. //
boucle de la broche 13 à la broche 10: for (int thisPin = 13; thisPin >= 10; thisPin--) { //Décrément
faisant passer la variable thisPin de 13 à 10 digitalWrite(thisPin, HIGH); //Allumer la LED delay(timer);
//Durée digitalWrite(thisPin, LOW); //Eteindre la LED; 8 Mais on aurait aussi pu l'appeler
petite_fleur… Arduino à l'école 46 Projet 7: PWM, variation en douceur d'une LED Le plus simple
moyen de faire varier la luminosité d'une LED, c'est de faire varier le courant qui la traverse. Mais
lorsqu'elle est branchée sur la broche d'un Arduino, ce n'est pas possible: les broches 1 à 13 sont en
effet numériques. C'est-à-dire qu'elles n'ont que deux états: 0 ou 1; allumé ou éteint. Alors pour faire
varier la luminosité d'une LED, on va utiliser une fonction appelée PWM: Pulse Width Modulation,
soit modulation de largeur d'impulsions. Il s'agit de faire varier les périodes hautes (allumé) et basses
(éteint) des broches à grande fréquence. Ainsi, lors d'un cycle de 25% en position haute et 75% en
position basse, la LED sera moins brillante que pour un cycle à 50%/50%. En d'autre terme, cela
signifie qu'on va faire clignoter très vite les LEDs; tellement vite que l'œil ne percevra qu'une lumière
continue. Mais plus en augmentera la durée des périodes où la LED est éteinte, moins il y aura de
lumière émise; et donc moins la LED semblera brillante. Les broches capables de supporter du PWM
sont identifiées par un "~". Il s'agit des broches 3, 5, 6, 9, 10,11. Par distinction, au lieu d'utiliser
l'instruction DigitalWrite, pour utiliser le PWM, on utilise AnalogWrite. La valeur du PWM s'étend sur

suivante: 𝑉𝑎𝑙𝑒𝑢𝑟 𝑃𝑊𝑀 = 56789:;<=>: ?67@=A<= 255; fadeValue += 5) { // Définition de la valeur

256 paliers, de 0 (=0%) à 255 (=100%). On peut ainsi définir la valeur PWM souhaitée avec la formule

de luminosité (de 0 à 255) analogWrite(ledPin, fadeValue); // Attente de 30 millisecondes entre

chaque palier pour voir l'effet. delay(30); } // Variation du max au min par soustraction de 5 depuis
256 for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) { // Définition de la valeur de
luminosité (de 0 à 255) analogWrite(ledPin, fadeValue); // Attente de 30 millisecondes entre chaque
palier pour voir l'effet. delay(30); } } Liens Télécharger le code
[Link] Arduino à l'école 49 Analyse du code La fonction for, on
commence à bien la connaître. Sinon, voici un petit rappel: Dans notre code, nous commençons avec
un for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5). On créé donc une variable fadeValue de
type int, qui stocke le chiffre 0. Le test de la condition plus petit ou égal à 255 (fadeValue <= 255)
permet une sortie de la fonction dès qu'on atteint le nombre 256. Enfin; et c'est la nouveauté, on ne
fait pas une incrémentation (++), mais on additionne 5 à fadeValue avec la formule +=5. La
commande analogWrite(ledPin, fadeValue); permet ainsi d'envoyer la valeur de fadeValue à la LED
ledPin. Comme fadeValue augmente à chaque fois de +5, la luminosité de la LED augmente petit-à-
petit. Enfin, le delay permet de configurer la vitesse d'augmentation de la luminosité. Chaque palier
de 5 prend 30 millisecondes. Il faut 51 paliers de 5 pour passer de 0 à 255. Ainsi, il faudra 51 ∙ 30 =
1530 millisecondes pour passer de la LED éteinte à la LED à sa luminosité maximum, soit environ une
seconde et demie. Ensuite, une fois la LED à sa luminosité maximum, il s'agit de baisser sa luminosité
jusqu'à l'éteindre, grace au code for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5). Le +=5 est
remplacé par un -=5, afin de soustraire à chaque fois 5 à la variable fadeValue. Code 9: alternative
pour faire varier la luminosité d'une LED Avec le code 8, nous avons fait varier la luminosité d'une
LED de 0 à 255 par paliers de 5. On peut tout aussi bien utiliser un incrément ++ pour arriver au
même résultat. Voilà ce que cela donne: /* Code 9 - [Link], destiné à l'Arduino Objectif: faire
varier la luminosité d'une LED sur la broche 10 */ //***** EN-TETE DECLARATIVE ***** int ledPin =
10; //On renomme la broche 10 en "ledPin" //***** SETUP ***** void setup() { } //***** LOOP
***** void loop() { // Variation du min au max par incrément for (int fadeValue =0; fadeValue <= 255;
fadeValue ++){ analogWrite(ledPin, fadeValue); delay(10); } // Variation du max au min par
décrément for (int fadeValue =255; fadeValue >= 0; fadeValue --){ analogWrite(ledPin, fadeValue);
delay(10); } } for(int compteur=0 ; compteur= 1) // "si la valeur reçue est plus grande ou égale à 1..." {
digitalWrite(led_0, HIGH); // "on allume la LED 0 } if(valeur_recue >= 2) // "si la valeur reçue est plus
grande ou égale à 2..." { digitalWrite(led_1, HIGH); // "on allume la LED 1 (sous-entendu que la LED 0
est allumée, puisque la valeur est plus grande que 1) } if(valeur_recue >= 3) // "si la valeur reçue est
plus grande ou égale à 3..." { digitalWrite(led_2, HIGH); // "on allume la LED 2 } if(valeur_recue >=
4) // "si la valeur reçue est plus grande ou égale à 4..." { digitalWrite(led_3, HIGH); // "on allume la
LED 3 } } Liens Télécharger le code [Link] Vidéo Vidéo de
présentation du bargraphe: [Link] -1 Arduino à l'école
62 Analyse du code: En se référant au schéma de montage, on déclare les constantes pour chaque
broche: les boutons poussoirs sont connectés sur les broches 3 et 4, alors que les LEDs sont
connectées aux broches 8 à 11. /* Déclaration des constantes pour les noms des broches */ const int
btn_minus = 3; //Bouton 1 pour décrémenter le nombre de LEDs allumées const int btn_plus = 4;
//Bouton 2 pour incrémenter le nombre de LEDs allumés const int led_0 = 8; //Led 0 const int led_1 =
9; //Led 1 const int led_2 = 10; //Led 2 const int led_3 = 11; //Led 3 On crée ensuite les variables
nécessaires et on initialise leur état. /* Déclaration des variables utilisées pour le comptage et le
décomptage */ int nombre_led = 0; //le nombre qui sera incrémenté et décrémenté int etat_bouton;
//lecture de l'état des boutons (un seul à la fois, mais une variable suffit; en effet, il n'est pas prévu
d'appuyer sur les deux boutons simultanément) int memoire_plus = LOW; //état relâché par défaut
pour le bouton 2 int memoire_minus = LOW; //état relâché par défaut pour le bouton 1 On initialise
ensuite les broches, selon qu’il s’agit des entrées (les boutons) ou des sorties (les LEDs). /*
Initialisation des broches en entrée/sortie: entrées pour les boutons, sorties pour les LEDs */ void
setup() { pinMode(btn_plus, INPUT); pinMode(btn_minus, INPUT); pinMode(led_0, OUTPUT);
pinMode(led_1, OUTPUT); pinMode(led_2, OUTPUT); pinMode(led_3, OUTPUT); } Allons-y pour la
partie du programme dans la boucle sans fin (loop). On utilise digitalRead pour lire l’état du bouton
(btn_plus) et inscrire cet état dans la variable etat_bouton. void loop() { //lecture de l'état du bouton
d'incrémentation (on lit l'état du btn_plus et on l'inscrit dans la variable etat_bouton) etat_bouton =
digitalRead(btn_plus); Maintenant, ça devient sérieux. Regardons ce qui suit: //Si le bouton a un état
différent que celui enregistré ET que cet état est "appuyé" if((etat_bouton != memoire_plus) &&
(etat_bouton == HIGH)) Traduisons cela en français: si l’état du bouton 2 est différent de celui
enregistré, et que quelqu’un appuie sur le bouton, alors... Arduino à l'école 63 Le != signifie est
différent de (teste la différence entre deux variables) et l’opérateur logique && signifie ET ( Pour être
précis, nous avons: si ... et... avec le if ... &&... Exemple: si il fait beau et chaud, alors on va à la plage).
Rappelons-nous maintenant de l’opération ++, qui incrémente une variable (variable = variable + 1,
c’est-àdire; on ajoute à chaque fois 1 à la variable). Dans notre cas, il s’agit de la valeur de la variable
nombre_led qu’on incrémente. { nombre_led++; //on incrémente la variable qui indique combien de
LEDs devront s'allumer } Et zou! On enregistre le nouvel état du bouton pour la suite! memoire_plus
= etat_bouton; //on enregistre l'état du bouton pour le tour suivant. Maintenant, on recommence le
tout, mais pour le bouton 1. //et maintenant pareil pour le bouton qui décrémente etat_bouton =
digitalRead(btn_minus); //lecture de son état //Si le bouton a un état différent que celui enregistré
ET que cet état est "appuyé" if((etat_bouton != memoire_minus) && (etat_bouton == HIGH))
{ nombre_led--; //on décrémente la valeur de nombre_led } memoire_minus = etat_bouton; //on
enregistre l'état du bouton pour le tour suivant Nous allons maintenant limiter le nombre de LEDs à
connecter. En effet, dans notre cas, nous avons 4 LEDs. Alors si on appuie 10 fois sur le bouton 2, cela
n’allumera que les 4 LEDs. //on applique des limites au nombre pour ne pas dépasser 4 ou 0
(puisqu'on a 4 LEDs) if(nombre_led > 4) { nombre_led = 4; } Traduisons: si on appuie plus de 4 fois sur
le bouton, le résultat sera égal à 4 Même chose maintenant pour le bouton 1. if(nombre_led < 0)
{ nombre_led = 0; } Maintenant, nous devons gérer l’allumage des LEDs. Pour simplifier le code, on va
créer une fonction qui servira à gérer l’affichage. Nous allons appeler cette fonction affiche, avec un
paramètre int valeur_recue. Ce paramètre représente le nombre à afficher. //On créé une fonction
affiche() pour l'affichage du résultat //on lui envoie alors en paramètre la valeur du nombre de LED à
éclairer affiche(nombre_led); } void affiche(int valeur_recue) On commence d’abord par éteindre
toutes les LEDs. { //on éteint toutes les leds digitalWrite(led_0, LOW); digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW); digitalWrite(led_3, LOW); Arduino à l'école 64 Si la fonction reçoit le
nombre 1, on allume la LED 1. Si elle reçoit le nombre 2, elle allume la LED 1 et 2. Si elle reçoit 3, elle
allume la LED 1, 2 et 3. Enfin, si elle reçoit 4, alors elle allume toutes les LEDs: //Puis on les allume
une à une if(valeur_recue >= 1) // "si la valeur reçue est plus grande ou égale à 1..."
{ digitalWrite(led_0, HIGH); // "on allume la LED 0 } if(valeur_recue >= 2) // "si la valeur reçue est plus
grande ou égale à 2..." { digitalWrite(led_1, HIGH); // "on allume la LED 1 (sous-entendu que la LED 0
est allumée, puisque la valeur est plus grande que 1) } if(valeur_recue >= 3) // "si la valeur reçue est
plus grande ou égale à 3..." { digitalWrite(led_2, HIGH); // "on allume la LED 2 } if(valeur_recue >=
4) // "si la valeur reçue est plus grande ou égale à 4..." { digitalWrite(led_3, HIGH; // "on allume la
LED 3 } } Le symbole >= signife: ...est supérieur ou égal à.... Il s’agit de tester la supériorité ou l'égalité
d'une variable par rapport à une valeur. Ainsi, dans: if(valeur_recue >= 4) { digitalWrite(led_3,
HIGH); // "on allume la LED 3 } Il faut lire: si la variable valeur_recue est supérieure ou égale à 4, alors
on allume la LED 3. Déparasiter à l'aide de condensateurs Vous l'avez sans doute constaté: malgré
des pull-down, les boutons-poussoirs sont peu précis. En effet, parfois, deux LEDs s'allument ou
s'éteignes pour une pression sur le bouton. Cela est dû au fait que le boutonpoussoir n'est
mécaniquement pas parfait. Lorsqu'on appuie dessus, le signal n'est pas forcément propre. Pendant
quelques millisecondes, le signal va passer de 0V à 5V plusieurs fois avant de se stabiliser. L'Arduino
peut interpréter un de ces mouvements parasites pour un signal d'entrée et va donc réagir en
fonction. Par exemple, en appuyant une fois sur le bouton-poussoir, l'Arduino peut enregistrer deux
impulsions en entrée et allumera deux LEDs au lieu d'une seule. Il y a moyen de déparasiter le
bouton-poussoir et d'absorber ces rebonds en montant en parallèle du boutonpoussoir un
condensateur de faible capacité (10nF). Qu'est-ce qu'un condensateur? Le condensateur est un
composant électronique passif, comme les résistances. Il a pour faculté d'emmagasiner une charge
électrique, avant de pouvoir la restituer en cas de baisse de la tension. On utilise ainsi les
condensateur comme régulateur de tension, Mais on utilise aussi sa capacité à se charger pour
absorber les brusques, mais courtes fluctuations de tension que sont les parasites. La capacité de
charge se mesure en Farads (F). Condensateur céramique Condensateur électrolytique Symbole du
condensateur Arduino à l'école 65 Circuit 9 ARDUINO U1 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11
D12 D13 GND AREF A5 A4 A3 A2 A1 A0 VIN GND1 GND2 5V 3V RESET ARDUINO Duemilanove
Diecimila UNO R1R2 220Ω R1 220Ω R2 220Ω R3 220Ω R4 LED1 LED2 LED3 LED4 220Ω R5 220Ω R6
10kΩ R7 10kΩ R8 SW1 SW2 R5 et R6: résistances de protection R7 et R8: résistances pull-down LED1
à LED4: à choix SW1 et SW2: boutons-poussoirs 10nF C1 10nF C2 C1 et C2: condensateurs Arduino à
l'école 66 Comme on peut le voir sur le circuit ci-dessus, deux condensateurs de faible capacité ont
été ajoutés en parallèle aux boutons-poussoirs. Si la parade n'est pas absolue, cela permet de
considérablement augmenter la précision des boutons. L'installation des condensateurs n'a aucune
influence au niveau du code. Il n'est donc pas nécessaire de le modifier. Variation: Le bargraphe à 10
LEDs Il existe des bargraphes intégrants 10 LEDs. On peut les utiliser en remplacement des 4 LEDs du
précédent montage. Références utilisées dans cet exercice: Kingbright DC-10EWA ou DC7G3EWA.
D’un côté se trouvent les cathodes, de l’autre les anodes. Dans notre cas, les anodes sont du côté où
se trouvent les inscriptions. Le code, lui, doit être adapté en conséquence pour 10 LEDs. Un exemple
se trouve ici: Code 13: le bargraphe à 10 LEDs /* Code 13 - [Link], destiné à l'Arduino Le
barregraphe L'objectif est de réalier un barregraphe, avec deux boutons poussoirs: un pour
incrémenter le nombre de LEDs allumées, l'autre pour le décrémenter. Le barregraphe est composé
de 10 LEDs. */ /* Déclaration des constantes pour les noms des broches */ const int btn_minus =
2; //Bouton 1 pour décrémenter le nombre de LEDs allumés const int btn_plus = 3; //Bouton 2 pour
incrémenter le nombre de LEDs allumés const int led_0 = 4; //Led 0 const int led_1 = 5; //Led 1 const
int led_2 = 6; //Led 2 const int led_3 = 7; //Led 3 const int led_4 = 8; //Led 4 const int led_5 = 9; //Led
5 const int led_6 = 10; //Led 6 const int led_7 = 11; //Led 7 Arduino à l'école 67 const int led_8 =
12; //Led 8 const int led_9 = 13; //Led 9 /* Déclaration des variables utilisées pour le comptage et le
décomptage */ int nombre_led = 0; //le nombre qui sera incrémenté et décrémenté int etat_bouton;
//lecture de l'état des boutons (un seul à la fois, mais une variable suffit; en effet, il n'est pas prévu
d'appuyer sur les deux boutons simultanément) int memoire_plus = LOW; //état relâché par défaut
pour le bouton 2 int memoire_minus = LOW; //état relâché par défaut pour le bouton 1 /*
Initialisation des broches en entrée/sortie: entrées pour les boutons, sorties pour les LEDs */ void
setup() { pinMode(btn_plus, INPUT); pinMode(btn_minus, INPUT); pinMode(led_0, OUTPUT);
pinMode(led_1, OUTPUT); pinMode(led_2, OUTPUT); pinMode(led_3, OUTPUT); pinMode(led_4,
OUTPUT); pinMode(led_5, OUTPUT); pinMode(led_6, OUTPUT); pinMode(led_7, OUTPUT);
pinMode(led_8, OUTPUT); pinMode(led_9, OUTPUT); } void loop() { //lecture de l'état du bouton
d'incrémentation (on lit l'état du btn_plus et on l'inscrit dans la variable etat_bouton) etat_bouton =
digitalRead(btn_plus); //Si le bouton a un état différent que celui enregistré ET que cet état est
"appuyé" if ((etat_bouton != memoire_plus) && (etat_bouton == HIGH)) { nombre_led++; //on
incrémente la variable qui indique combien de LEDs devrons s'allumer } memoire_plus =
etat_bouton; //on enregistre l'état du bouton pour le tour suivant //et maintenant pareil pour le
bouton qui décrémente etat_bouton = digitalRead(btn_minus); //lecture de son état //Si le bouton a
un état différent que celui enregistré ET que cet état est "appuyé" if ((etat_bouton !=
memoire_minus) && (etat_bouton == HIGH)) { nombre_led--; //on décrémente la valeur de
nombre_led } memoire_minus = etat_bouton; //on enregistre l'état du bouton pour le tour
suivant //on applique des limites au nombre pour ne pas dépasser 4 ou 0 (puisqu'on a 4 LEDs) if
(nombre_led > 10) { nombre_led = 10; } if (nombre_led < 0) { nombre_led = 0; } //On créé une
fonction affiche() pour l'affichage du résultat //on lui envoie alors en paramètre la valeur du nombre
de LED à éclairer affiche(nombre_led); Arduino à l'école 68 } void affiche(int valeur_recue) { //on
éteint toutes les leds digitalWrite(led_0, LOW); digitalWrite(led_1, LOW); digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW); digitalWrite(led_4, LOW); digitalWrite(led_5, LOW); digitalWrite(led_6,
LOW); digitalWrite(led_7, LOW); digitalWrite(led_8, LOW); digitalWrite(led_9, LOW); //Puis on les
allume une à une if (valeur_recue >= 1) // "si la valeur reçue est plus grande ou égale à 1..."
{ digitalWrite(led_0, HIGH); // "on allume la LED 0 } if (valeur_recue >= 2) // "si la valeur reçue est
plus grande ou égale à 2..." { digitalWrite(led_1, HIGH); // "on allume la LED 1 (sous-entendu que la
LED 0 est allumée, puisque la valeur est plus grande que 1) } if (valeur_recue >= 3) // "si la valeur
reçue est plus grande ou égale à 3..." { digitalWrite(led_2, HIGH); // "on allume la LED 2 } if
(valeur_recue >= 4) // "si la valeur reçue est plus grande ou égale à 4..." { digitalWrite(led_3,
HIGH); // "on allume la LED 3 } if (valeur_recue >= 5) // "si la valeur reçue est plus grande ou égale à
4..." { digitalWrite(led_4, HIGH); // "on allume la LED 3 } if (valeur_recue >= 6) // "si la valeur reçue
est plus grande ou égale à 4..." { digitalWrite(led_5, HIGH); // "on allume la LED 3 } if (valeur_recue >=
7) // "si la valeur reçue est plus grande ou égale à 4..." { digitalWrite(led_6, HIGH); // "on allume la
LED 3 } if (valeur_recue >= 8) // "si la valeur reçue est plus grande ou égale à 4..." { digitalWrite(led_7,
HIGH); // "on allume la LED 3 } if (valeur_recue >= 9) // "si la valeur reçue est plus grande ou égale à
4..." { digitalWrite(led_8, HIGH); // "on allume la LED 3 } if (valeur_recue >= 10) // "si la valeur reçue
est plus grande ou égale à 4..." { digitalWrite(led_9, HIGH); // "on allume la LED 3 } } Liens
Télécharger le code [Link] Arduino à l'école 69 Variation:
l’afficheur numérique Pour ce montage, nous allons utiliser un afficheur numérique à LED. La
référence utilisée ici est un afficheur à anode commune Kingbright SA56-11 SRWA9. Dans le cas
d’une anode commune, cette dernière est branchée sur le +5V. Les cathodes sont branchées sur les
broches. Au niveau du code, cela implique que les LEDs sont allumée en position LOW et éteintes en
position HIGH. Avec un composant à cathode commune, c’est le contraire. Dans notre exemple, nous
allons commencer par allumer toutes les diodes, puis l’une après l’autre, pour les identifier. On peut
ensuite écrire des chiffres. 9 Disponible ici: [Link]/episode/arduino-lecole-apprendre-
compter 220 Ohms 220 Ohms D6 D7 D8 D9 D10 D11 D12 D13 D4 100 Ohms D3 100 Ohms 10 kOhms
123 4 A c dot MAN6960 5 e d 10 9876 g f A a b Arduino à l'école 70 Identification de la position des
LEDs Le code suivant permet d’identifier la position des LEDs en les allumant l’une après l’autre: /*
Code 14 - [Link], destiné à l'Arduino L'afficheur 7 ou 8 segments L'objectif est d'afficher des
chiffres sur un afficheur 7 segments (7 digits). Ce code a pour objectif d'allumer toutes les LEDS puis
l'une après l'autre pour identifier leur position. */ /* Déclaration des constantes pour les noms des
broches */ const int led_1 = 6; //Led 1 const int led_2 = 7; //Led 2 const int led_3 = 8; //Led 3 const
int led_4 = 9; const int led_5 = 10; const int led_6 = 11; const int led_7 = 12; const int led_8 = 13; void
setup() { pinMode(led_1, OUTPUT); pinMode(led_2, OUTPUT); pinMode(led_3, OUTPUT);
pinMode(led_4, OUTPUT); pinMode(led_5, OUTPUT); pinMode(led_6, OUTPUT); pinMode(led_7,
OUTPUT); pinMode(led_8, OUTPUT); } /* Et c'est parti pour le programme! */ void loop() { //on
allume toutes les leds digitalWrite(led_1, LOW); digitalWrite(led_2, LOW); digitalWrite(led_3, LOW);
digitalWrite(led_4, LOW); digitalWrite(led_5, LOW); digitalWrite(led_6, LOW); digitalWrite(led_7,
LOW); digitalWrite(led_8, LOW); delay(1500); //on éteint toutes les leds digitalWrite(led_1, HIGH);
digitalWrite(led_2, HIGH); digitalWrite(led_3, HIGH); digitalWrite(led_4, HIGH); digitalWrite(led_5,
HIGH); digitalWrite(led_6, HIGH); digitalWrite(led_7, HIGH); digitalWrite(led_8, HIGH);
delay(500); //on allume une diode après l'autre pour identifier sa position digitalWrite(led_1, LOW);
Arduino à l'école 71 delay(1500); digitalWrite(led_1, HIGH); digitalWrite(led_2, LOW); delay(1500);
digitalWrite(led_2, HIGH); digitalWrite(led_3, LOW); delay(1500); digitalWrite(led_3, HIGH);
digitalWrite(led_4, LOW); delay(1500); digitalWrite(led_4, HIGH); digitalWrite(led_5, LOW);
delay(1500); digitalWrite(led_5, HIGH); digitalWrite(led_6, LOW); delay(1500); digitalWrite(led_6,
HIGH); digitalWrite(led_7, LOW); delay(1500); digitalWrite(led_7, HIGH); digitalWrite(led_8, LOW);
delay(1500); } Liens Télécharger le code [Link] Arduino à l'école
72 L’objectif est d’identifier chaque LED sur le schéma ci-dessous: Voici donc, dans notre cas, les LEDs
qui doivent être allumées pour écrire les chiffres suivants: # led_1 led_2 led_3 led_4 led_5 led_6
led_7 1 X X 2 X X X X X 3 X X X X X 4 X X X X 5 X X X X X 6 X X X X X X 7 X X X 8 X X X X X X X 9 X X X X X 0
X X X X X X Nous n’utilisons pas la led_8, qui représente un point. Le code pour compter de 0 à 9 est
ici: [Link] Arduino à l'école 73 A ton tour: # led_1 led_2 led_3
led_4 led_5 led_6 led_7 1 2 3 4 5 6 7 8 9 0 Arduino à l'école 74 Il est aussi possible d’écrire les lettres
de l’alphabet à l’aide d’un affichage 7 segments10: Exemple: Évidemment, cela reste artisanal; mais
ça peut donner des résultats acceptables, comme on peut le voir ici: 10 Source de la police:
[Link] Arduino à l'école 75 Synthèse: apprendre à compter Objectif Cette
dernière leçon va synthétiser tout ce que nous avons vu jusqu’à maintenant. L’objectif est de réaliser
un montage, avec deux boutons poussoirs et un affichage 7 segments. L’un des boutons va servir à
incrémenter les chiffres sur l’affichage, et l’autre à les décrémenter. Ainsi, en appuyant 6 fois sur le
bouton-poussoir, les chiffres de 1 à 6 vont successivement s’afficher. Schéma électronique du
montage Sur le schéma qui suit, l’affichage 7 segments est à anode commune. Comme d’habitude,
chaque boutonpoussoir est doté d’une résistance pull-down de 1kΩ ou 10kΩ et d’une résistance de
protection de l’input de 100Ω. L'ordre de branchement de l'afficheur importe peu, puisqu'on va
utiliser le code 14 pour identifier l'ordre d'activation des broches. 220 Ohms 220 Ohms D6 D7 D8 D9
D10 D11 D12 D13 D4 100 Ohms D3 100 Ohms 10 kOhms 123 4 A c dot MAN6960 5 e d 10 9876 g f A a
b Arduino à l'école 76 Circuit 10 ARDUINO U1 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13
GND AREF A5 A4 A3 A2 A1 A0 VIN GND1 GND2 5V 3V RESET ARDUINO Duemilanove Diecimila UNO
R1R2 220Ω R5 220Ω R6 10kΩ R7 10kΩ R8 SW1 SW2 10nF C1 10nF C2 LED1 1 2 3 4 5 10 9 8 7 6 a b c d
e f g dp 220Ω R1 220Ω R2 220Ω R3 220Ω R4 220Ω R9 220Ω R10 220Ω R11 220Ω R12 Arduino à l'école
77 Code 15: apprendre à compter Le code peut être téléchargé à l’adresse suivante:
[Link] Il est très similaire aux codes précédents. La principale
différence réside dans le if(valeur_recue == 1) , qui dans ce cas signifie "si la valeur reçue est égale à
1, on allume les segments pour afficher le chiffre 1". Contrairement au if(valeur_recue >= 1), qui
permet de cumuler l’allumage des LEDs (1 LED pour 1, deux LEDs pour 2,...), l’objectif est ici de
n’allumer que les LEDs nécessaires à l’affichage du bon chiffre. Il ne faudrait en effet pas qu’un 3
devienne ensuite un 9 au lieu d’un 4, parce qu’on cumule les LEDs allumées. /* Code 15 -
[Link], destiné à l'Arduino Apprendre à compter L'objectif est d'afficher des chiffres sur un
afficheur 7 segments. Un bouton permet d'incrémenter le chiffre, l'autre de le décrémenter. On
compte ainsi de 0 à 9 ou de 1 à 0. */ /* Déclaration des constantes pour les noms des broches. Notre
affichage est un 8 segments, avec donc un point. Même si nous ne l’utilisons pas, nous l’avons quand
même câblé. */ const int btn_minus = 3; //Bouton 1 pour décrémenter les chiffres const int btn_plus
= 4; //Bouton 2 pour incrémenter les chiffres const int led_1 = 6; //Led 1 const int led_2 = 7; //Led 2
const int led_3 = 8; //Led 3 const int led_4 = 9; //Led 4 const int led_5 = 10; const int led_6 = 11;
const int led_7 = 12; const int led_8 = 13; /* Déclaration des variables utilisées pour le comptage et le
décomptage */ int nombre_led = 0; //le nombre qui sera incrémenté et décrémenté int etat_bouton;
//lecture de l'état des boutons (un seul à la fois, mais une variable suffit; en effet, il n'est pas prévu
d'appuyer sur les deux boutons simultanément) int memoire_plus = LOW; //état relâché par défaut
pour le bouton 2 int memoire_minus = LOW; //état relâché par défaut pour le bouton 1 /*
Inutilisation des broches en entrée/sortie: entrées pour les boutons, sorties pour les LEDs */ void
setup() { pinMode(btn_plus, INPUT); pinMode(btn_minus, INPUT); pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT); pinMode(led_3, OUTPUT); pinMode(led_4, OUTPUT); pinMode(led_5,
OUTPUT); pinMode(led_6, OUTPUT); pinMode(led_7, OUTPUT); pinMode(led_8, OUTPUT); } /* Et
c'est parti pour le programme! */ Arduino à l'école 78 void loop() { //lecture de l'état du bouton
d'incrémentation (on lit l'état du btn_plus et on l'inscrit dans la variable etat_bouton) etat_bouton =
digitalRead(btn_plus); //Si le bouton a un état différent que celui enregistré ET que cet état est
"appuyé" if((etat_bouton != memoire_plus) && (etat_bouton == HIGH)) { nombre_led++; //on
incrémente la variable qui indique combien de LEDs devrons s'allumer } memoire_plus =
etat_bouton; //on enregistre l'état du bouton pour le tour suivant //et maintenant pareil pour le
bouton qui décrémente etat_bouton = digitalRead(btn_minus); //lecture de son état //Si le bouton a
un état différent que celui enregistré ET que cet état est "appuyé" if((etat_bouton !=
memoire_minus) && (etat_bouton == HIGH)) { nombre_led--; //on décrémente la valeur de
nombre_led } memoire_minus = etat_bouton; //on enregistre l'état du bouton pour le tour
suivant //on applique des limites au nombre pour ne pas dépasser 4 ou 0 (puisqu'on a 4 LEDs)
if(nombre_led > 10) { nombre_led = 10; } if(nombre_led < 0) { nombre_led = 0; } //On créé une
fonction affiche() pour l'affichage du résultat //on lui envoie alors en paramètre la valeur du nombre
de LED à éclairer affiche(nombre_led); } void affiche(int valeur_recue) { //on éteint toutes les leds
digitalWrite(led_1, HIGH); digitalWrite(led_2, HIGH); digitalWrite(led_3, HIGH); digitalWrite(led_4,
HIGH); digitalWrite(led_5, HIGH); digitalWrite(led_6, HIGH); digitalWrite(led_7, HIGH);
digitalWrite(led_8, HIGH); //Pour chaque chiffre, le plus simple est de lister toutes les LEDs //et de
leur attribuer la valeur voulue if(valeur_recue == 1) // "si la valeur reçue est égale à 1, on allume les
segments pour afficher le chiffre 1" { digitalWrite(led_1, LOW); digitalWrite(led_2, HIGH);
digitalWrite(led_3, HIGH); digitalWrite(led_4, LOW); digitalWrite(led_5, HIGH); digitalWrite(led_6,
HIGH); digitalWrite(led_7, HIGH); digitalWrite(led_8, HIGH); } if(valeur_recue == 2) // "si la valeur
reçue est égale à 2, on allume les segments pour afficher le chiffre 2" Arduino à l'école 79
{ digitalWrite(led_1, LOW); digitalWrite(led_2, LOW); digitalWrite(led_3, LOW); digitalWrite(led_4,
HIGH); digitalWrite(led_5, LOW); digitalWrite(led_6, LOW); digitalWrite(led_7, HIGH);
digitalWrite(led_8, HIGH); } if(valeur_recue == 3) // "si la valeur reçue est égale... enfin... tu connais la
suite... { digitalWrite(led_1, HIGH); digitalWrite(led_2, LOW); digitalWrite(led_3, LOW);
digitalWrite(led_4, HIGH); digitalWrite(led_5, LOW); digitalWrite(led_6, LOW); digitalWrite(led_7,
LOW); digitalWrite(led_8, HIGH); } if(valeur_recue == 4) { digitalWrite(led_1, HIGH);
digitalWrite(led_2, HIGH); digitalWrite(led_3, LOW); digitalWrite(led_4, LOW); digitalWrite(led_5,
HIGH); digitalWrite(led_6, LOW); digitalWrite(led_7, LOW); digitalWrite(led_8, HIGH); }
if(valeur_recue == 5) { digitalWrite(led_1, HIGH); digitalWrite(led_2, LOW); digitalWrite(led_3, LOW);
digitalWrite(led_4, LOW); digitalWrite(led_5, LOW); digitalWrite(led_6, HIGH); digitalWrite(led_7,
LOW); digitalWrite(led_8, HIGH); } if(valeur_recue == 6) { digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW); digitalWrite(led_3, LOW); digitalWrite(led_4, LOW); digitalWrite(led_5,
LOW); digitalWrite(led_6, HIGH); digitalWrite(led_7, LOW); digitalWrite(led_8, HIGH); }
if(valeur_recue == 7) { digitalWrite(led_1, HIGH); digitalWrite(led_2, HIGH); digitalWrite(led_3, HIGH);
digitalWrite(led_4, HIGH); digitalWrite(led_5, LOW); digitalWrite(led_6, LOW); Arduino à l'école 80
digitalWrite(led_7, LOW); digitalWrite(led_8, HIGH); } if(valeur_recue == 8) { digitalWrite(led_1,
LOW); digitalWrite(led_2, LOW); digitalWrite(led_3, LOW); digitalWrite(led_4, LOW);
digitalWrite(led_5, LOW); digitalWrite(led_6, LOW); digitalWrite(led_7, LOW); digitalWrite(led_8,
LOW); } if(valeur_recue == 9) { digitalWrite(led_1, HIGH); digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW); digitalWrite(led_4, LOW); digitalWrite(led_5, LOW); digitalWrite(led_6,
LOW); digitalWrite(led_7, LOW); digitalWrite(led_8, LOW); } if(valeur_recue == 10)
{ digitalWrite(led_1, LOW); digitalWrite(led_2, LOW); digitalWrite(led_3, HIGH); digitalWrite(led_4,
LOW); digitalWrite(led_5, LOW); digitalWrite(led_6, LOW); digitalWrite(led_7, LOW);
digitalWrite(led_8, LOW); } } Le code se termine avec le chiffre 0, à défaut du 10. Le code n'est pas
optimisé; on pourrait se passer de répéter les digitalWrite qui sont en position LOW plusieurs fois de
suite. Néanmoins, cela permet de pouvoir comprendre et analyser le code bien plus simplement; à
commencer par les élèves. Liens Télécharger le code [Link]
Arduino à l'école 81 Projet 9: les inputs analogiques Un signal analogique11 varie de façon continue
au cours du temps. Sa valeur est donc un nombre réel. On trouve des signaux analogiques
constamment, comme la température, la vitesse… L'Arduino Uno possède 6 entrées analogiques,
numérotées A0 à A5. En réalité, le microcontrôleur n'est pas capable de comprendre un signal
analogique. Il faut donc d'abord le convertir en signal numérique par un circuit spécial appelé
convertisseur analogique/numérique. Ce convertisseur va échantillonner le signal reçu sous la forme
d'une variation de tension et le transformer en valeurs comprises entre 0 et 1023. Attention à ne pas
faire entrer une tension supérieure à 5V, ce qui détruirait l'Arduino. La photorésistance Une
photorésistance est un composant électronique dont la résistance (en Ohm Ω) varie en fonction de
l'intensité lumineuse. Plus la luminosité est élevée, plus la résistance est basse. On peut donc
l'utiliser comme capteur lumineux pour: • Mesure de la lumière ambiante pour une station météo. •
Détecteur de lumière dans une pièce. • Suiveur de lumière dans un robot. • Détecteur de passage. •
… 11 Plus d'informations:
[Link]
Signal numérique Signal analogique Arduino à l'école 82 Ses symboles électroniques sont les
suivants: L'avantage des photorésistances est qu'elles sont très bon marché. Par contre, leur réaction
à la lumière est différente pour chaque photorésistance, même quand elles ont été produites dans le
même lot. On peut ainsi noter une différence de résistance de plus de 50% entre deux
photorésistances du même modèle pour la même luminosité. On ne peut donc pas l'utiliser pour une
mesure précise de la lumière. Par contre, elles sont idéales pour mesurer des changements simples
de la luminosité. Circuit 7: diviseur de tension Pour le circuit 7, nous aurons besoin d'une
photorésistance que nous connecterons à la broche A0. Le montage résistance fixe – photorésistance
constitue ce qu’on appelle un diviseur de tension . 5V sont introduits dans le circuit depuis
l'[Link] relie le point entre les deux résistances à une broche analogique de l'Arduino et on
mesure la tension par la fonction analogRead (broche). Tout changement de la tension mesurée est
dû à la photorésistance puisque c’est la seule qui change dans ce circuit, en fonction de la lumière.
Liste des composants 1 LED 1 résistance de 220Ω 1 résistance de 10kΩ 1 photorésistance Arduino à
l'école 83 Circuit 11 ARDUINO U1 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13 GND AREF A5
A4 A3 A2 A1 A0 VIN GND1 GND2 5V 3V RESET ARDUINO Duemilanove Diecimila UNO R1R2 220 Ω R1
LED D1 Photorésistance LDR1 10kΩ R2 Arduino à l'école 84 Code 16: valeur de seuil L'objectif de ce
code est de définir un seuil de luminosité au-delà duquel on éteint une LED. Nous allons pour cela
utiliser une nouvelle instruction: if ... else (si ... sinon). C’est donc une condition. Voici ce qui va se
passer: Si la luminosité dépasse le seuil (if (analogRead (lightPin)> seuil)), éteindre la LED
(digitalWrite (ledPin, LOW));sinon (else), allumer la LED (digitalWrite (ledPin, HIGH)). L’instruction ==
vérifie si deux expressions sont égales. Si elles le sont, alors le résultat sera vrai (true) sinon le
résultat sera faux (false). Dans ce cas, le seuil est fixé à 900 (sur 1023). En variant la valeur du seuil,
on modifie la sensibilité de détection de la luminosité. /* Code 16 - [Link], destiné à l'Arduino
Objectif: Eteindre une LED dès que la luminosité est suffisante */ //***** EN-TETE DECLARATIVE
***** int lightPin = 0; //On renomme la broche A0 en "lightPin" int ledPin = 9; //On renomme la
broche 9 en "ledPin" //***** FONCTION SETUP = Code d'initialisation ***** // La fonction setup()
est exécutée en premier et une seule fois, au démarrage du programme void setup() { pinMode
(ledPin, OUTPUT); [Link](9600); } void loop() { int seuil = 900; //On définit un seuil de luminosité
(sur 1023) à partir duquel la LED s'éteint if (analogRead (lightPin)> seuil) //Si la luminosité est plus
élevée que le seuil... { digitalWrite (ledPin, LOW); //... alors on éteint la LED. } else //Sinon...
{ digitalWrite (ledPin, HIGH); //...on allume la LED } } Liens Télécharger le code
[Link] Arduino à l'école 85 Code 17: variation de la luminosité
d'une LED en fonction de la lumière ambiante Imaginons maintenant que l'on veut faire varier la
luminosité d'une LED en fonction de la luminosité de la pièce dans laquelle elle se trouve: plus il faut
jour, moins la LED est lumineuse. Théoriquement, cela n'a rien de compliqué; il suffit de combiner le
signal de la photorésistance avec la valeur PWM de la LED. Pratiquement, on se retrouve avec un
signal en entrée (la photorésistance) découpé en 1024 paliers, alors que ceux du signal PWM
comptent 256 paliers. Seulement, 1024, c'est 256 x 4. En divisant la valeur de la variable lightReading
par 4, on la rend compatible avec les 256 paliers de variation de luminosité de la LED. /* Code 17 -
[Link], destiné à l'Arduino Objectif: Faire varier la luminosité de la LED en fonction de la
luminosité de la pièce Source: [Link] */ int lightPin = 0; // La
photorésistance et la résistance pulldown de 1 à 10K sont connectés à A0 int lightReading; // Lecture
analogique de la valeur de la photorésistance avec le diviseur de tension int ledPin = 9; // LED en
PWM sur la broche 9 int ledBrightness; // Variable pour stocker la valeur de luminosité de la LED void
setup() { [Link](9600); } void loop() { lightReading = analogRead(lightPin); //Affichage de la
valeur de "lightReading" dans la console [Link]("Lecture analogique = ");
[Link](lightReading); // Affichage de la valeur brute issue de la photorésistance. // Plus il fait
sombre, plus la LED doit être brillante. // Cela signifique qu'il faut inverser la valeur lue de 0-1023 à
1023-0, avec une soustraction. lightReading = 1023 - lightReading; //Enfin il faut faire correspondre
les valeurs lues de 0-1023 à 0-255 qui sont les valeurs utilisées par analogWrite. //Pour cela, on
convertit la valeur de la variable "lightReading" en la divisant par 4. ledBrightness = lightReading / 4;
analogWrite(ledPin, ledBrightness); // On allume enfin la LED avec la luminosité stockée dans la
variable "ledBrightness". delay(100); } La variation de luminosité est souvent inversée. Ainsi, une
radioréveil est très lumineux lorsqu'il fait jour et peu lumineux durant la nuit. Pour simuler cela, il
suffit de supprimer la ligne suivante: lightReading = 1023 - lightReading; Arduino à l'école 86 Code 18:
mappage de données Le mappage des données est l'association des données appartenant à un avec
les données appartenant à un autre ensemble, de manière que l’on puisse passer harmonieusement
des premières aux secondes12. Dans notre cas, nous avons des données inscrites dans une plage
située entre 0 et 1023 que nous devons convertir dans une plage entre 0 et 255, qui correspond à 8
bits. Si on reprend l'exercice précédent, une petite modification permet de faire le mappage des
données. /* Code 18 - [Link], destiné à l'Arduino Objectif: Faire varier la luminosité de la LED
en fonction de la luminosité de la pièce avec mappage de données Source:
[Link] */ int lightPin = 0; // La photorésistance et la résistance pulldown de
1 à 10K sont connectés à A0 int lightReading; // Lecture analogique de la valeur de la photorésistance
avec le diviseur de tension int ledPin = 9; // LED en PWM sur la broche 9 int ledBrightness; // Variable
pour stocker la valeur de luminosité de la LED void setup() { [Link](9600); } void loop()
{ lightReading = analogRead(lightPin); //Affichage de la valeur de "lightReading" dans la console
[Link]("Lecture analogique = "); [Link](lightReading); // Affichage de la valeur brute issue
de la photorésistance. // Plus il fait sombre, plus la LED doit être brillante. // Cela signifique qu'il faut
inverser la valeur lue de 0-1023 à 1023-0, avec une soustraction. lightReading = 1023 -
lightReading; //Enfin il faut faire correspondre avec la fonction "map" les valeurs lues de 0-1023 à 0-
255 qui sont les valeurs utilisées par analogWrite. ledBrightness = map(lightReading, 0, 1023, 0, 255);
analogWrite(ledPin, ledBrightness); // On allume enfin la LED avec la luminosité stockée dans la
variable "ledBrightness". delay(100); } On voit à la ligne suivante le mappage: ledBrightness =
map(lightReading, 0, 1023, 0, 255); la fonction map fonctionne sous la forme suivante: Variable1 est
l'origine des données. Variable2 est la destination des données. 12
[Link] et
[Link] variable2 = map(variable1, 0,
1023, 0, 255); Variable d’arrivée Variable d’origine Données d’origine Données d’arrivée Arduino à
l'école 87 Projet 10: le potentiomètre Le potentiomètre est une résistance variable. Contrairement,
c'est le bouton de réglage du volume sur une radio. La plupart des potentiomètres sont soit rotatifs,
soit linéaires. Potentiomètre rotatif Potentiomètre linéaire Les potentiomètres sont très fréquents
dans les appareils électroniques, par exemple les tables de mixages. Table de mixage du RadioBus13
Voici les symboles électroniques (européen dessus et américain dessous) du potentiomètre: Comme
toute résistance, le potentiomètre modifie la tension d'un circuit. On va donc l'utiliser principalement
comme entrée (input) dans une broche analogique (A0 à A5) de l'Arduino. 13 [Link]
Arduino à l'école 88 Les potentiomètres ont en général trois broches14. Les broches extérieures se
connectent sur l'alimentation +5V et sur la terre, alors que la broche centrale envoie le signal sur la
broche d'entrée analogique de l'Arduino. Il est temps de griller notre première LED (si cela n'est pas
déjà fait)! C'est le passage obligé de tout bon maker ! Pour ce faire, nous allons connecter une LED
sur la broche OUT du potentiomètre et la mettre à la terre. Petit conseil: avant de brancher, tourner
le potentiomètre au minimum, dans le sens inverse des aiguilles d'une montre. Une fois l'Arduino
branché, tourner délicatement le potentiomètre dans le sens des aiguilles d'une montre. La LED va
commencer à s'illuminer, puis de plus en plus, avant de… griller. Circuit 12 Balai Piste résistive +5V
OUT GND vers entrée analogique GND OUT +5V Arduino à l'école 89 Nous venons de le voir: varier le
voltage à l'entrée d'une LED n'est pas la meilleure solution pour faire varier sa luminosité… même si
la LED ne grille pas, au-delà de son voltage de fonctionnement, sa durée de vie sera fortement
réduite. Mais qu'importe, puisque nous avons la fonction PWM15. Nous allons donc coupler le
potentiomètre, en entrée analogique sur A0, avec une LED en PWM sur la broche 9. Concrètement,
au niveau du câblage, cela donne ceci: Circuit 13 15 Voir Projet 7 de ce cours. ARDUINO U1 D0 D1 D2
D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13 GND AREF A5 A4 A3 A2 A1 A0 VIN GND1 GND2 5V 3V RESET
ARDUINO Duemilanove Diecimila UNO R1R2 LED D1 10k R2 Arduino à l'école 90 Le code est très
simple. Comme pour le code 17, on récupère la valeur comprise en 0 et 1023 sur A0, avant de la
diviser par 4, afin de la rendre compatible avec la portée du PWM, comprise entre 0 et 255. Comme
pour le code 18, on pourrait aussi imaginer un mappage au lieu de la division. /* Code 19 -
[Link], destiné à l'Arduino Objectif: Lire la valeur du potentiomètre pour faire varier la
luminosité de la LED en PWM Source: Philippe Krähenbühl */ int ledPin = 9; //On renomme la broche
9 en "ledPin" int analogPin = 0; // Le potentiomètre est connecté à la broche analogue 0 int val = 0; //
la variable qui stocke la valeur lue est mise à 0 void setup() { pinMode(ledPin, OUTPUT); } void loop()
{ val = analogRead(analogPin); //lecture de la valeur analogue (potentiomètre) analogWrite(ledPin,
val / 4); // valeur analogue lue (0 à 1023) divisée par 4 (0 à 255) } ARDUINO U1 D0 D1 D2 D3 D4 D5 D6
D7 D8 D9 D10 D11 D12 D13 GND AREF A5 A4 A3 A2 A1 A0 VIN GND1 GND2 5V 3V RESET ARDUINO
Duemilanove Diecimila UNO R1R2 220 Ω R1 LED D1 10k R2 Arduino à l'école 91 Projet 11 : construire
une station météo Objectif: utiliser un capteur température/humidité et afficher les données sur un
écran LCD Ce projet est la synthèse des input analogiques, avec comme bonus l'utilisation d'un écran
pour l'affichage des données. Connaître la température et l’humidité est une information utile pour
vivre confortablement, pour stocker des aliments ou du matériel, pour des prévisions météo… Avec
ce projet nous apprendrons comment mesurer ces deux données et à les afficher sur un écran LCD.
Avec les projets précédents, nous avons appris à mesurer des valeurs (intensité lumineuse et
température) avec des capteurs analogiques grâce aux entrées analogiques de la carte Arduino qui
sont munies d’un composant qui transforme les valeurs analogiques mesurées en valeurs
numériques. Mais il existe aussi de nombreux capteurs qui transforment eux-mêmes, les valeurs
analogiques mesurées en valeurs digitales exploitables par des moyens informatiques. C’est le cas
d’un capteur de température et d’humidité très répandu et bon marché, le DHT11 que l’on va utiliser
pour ce projet. En bas à droite, de couleur bleue, le capteur DHT11, au-dessus l’afficheur LCD de deux
lignes de 16 caractères qui indique la température et l’humidité actuelle. On remarque aussi un
potentiomètre (résistance variable) sur la partie droite du breadboard dont le rôle est de régler la
luminosité de l’écran. Arduino à l'école 92 Le capteur DHT11 est fourni avec de nombreux kits pour
Arduino, autrement on peut l’acheter pour quelques francs. Le DHT11 ne mesure que des
températures positives, entre 0°C et 50°C avec une précision de ± 2°C et des taux d’humidité relative
de 20 à 80% avec une précision de ± 5%. Pour des besoins plus pointus ou s’il s’agit de mesurer aussi
des températures négatives, il faut se munir de son grand frère, le DHT22, deux fois plus onéreux,
mais dont la plage de mesure s’étend de -50°C à +125°C, avec une précision de 0.5°C et de 0 à 100%
(précision ± 2%) pour la mesure de l’humidité relative. Attention : il existe des versions des capteurs
DHTxx qui ne sont pas prémontés sur un petit circuit comme le modèle de gauche ci-dessus utilisé
dans ce projet. Si c’est le cas, il faut ajouter une résistance de tirage de 5 à 10 kOhms et un
condensateur de 100 nF entre les broches 1 (alimentation 5 V) et 4 (GND). Un schéma du câblage est
disponible par ici : [Link] Circuit 14 Utilisation du capteur de température
et d’humidité Quand on tient le capteur avec la grille en face de nous, la broche centrale est
l’alimentation, elle doit être reliée au 5V de l’Arduino. La broche la plus à droite sera reliée au –
(GND). Quant à la broche la plus à gauche, c’est la broche de données, elle sera connectée à l’entrée
digitale utilisée pour lire les données. Une fois ces données connues, le montage est un jeu d’enfant
et un schéma est ici inutile, nous allons choisir le Pin7 pour les données : Arduino à l'école 93 Code
20: Acquérir les données du capteur et les afficher. L'objectif de ce code est d’acquérir via l’une des
broches digitales de l’Arduino, les données de température et d’humidité transmises par le capteur
DHT11, puis de les afficher sur l’écran de l’ordinateur. Pour communiquer avec le capteur, il faut
dans un premier temps télécharger et installer la bibliothèque spécifique à ce capteur (ou plutôt
l’une des bibliothèques pour ce capteur, car il y en a plusieurs versions). Les bibliothèques sont des
ensembles de fonctions qui s’ajoutent aux fonctions de base du logiciel [Link]. Certaines
bibliothèques sont préinstallées, par exemple celle intitulée LiquidCrystal dont nous aurons besoin
plus tard pour l’affichage sur l’écran LCD, d’autres doivent être installées par l’utilisateur au fur et à
mesure de ses besoins. La bibliothèque DHTLib que nous allons utiliser pour ce projet fait partie de
cette dernière catégorie et doit donc être installée « à la main ». Depuis la version 1.6.0 de l’IDE
Arduino, un gestionnaire de bibliothèque a permis de grandement simplifier l’installation et la mise à
jour des bibliothèques. Le gestionnaire est accessible via le menu Croquis -> Inclure une bibliothèque
-> Gérer les bibliothèques. Une fenêtre de gestion des bibliothèques apparaît dans laquelle il est
possible de rechercher une nouvelle bibliothèque en tapant son nom dans le champ de recherche en
haut à gauche ou de faire des mises à jour des bibliothèques existantes. Ci-dessus, en tapant dht
dans le champ de recherche on obtient en seconde position la bibliothèque DHTLib que nous allons
utiliser. Il ne reste plus qu’à l’installer en cliquant sur le bouton qui apparaît sur la droite quand on la
sélectionne. Une solution alternative pour installer une bibliothèque consiste à télécharger le
fichier .zip de la bibliothèque désirée, puis de l’installer via le menu Croquis -> Inclure une
bibliothèque -> Ajouter une bibliothè[Link]. La bibliothèque DHTLib peut être téléchargée ici :
[Link] Note : sur les postes élèves,
les bibliothèques supplémentaires sont installées dans le dossier personnel de l’utilisateur et ne
seront donc accessibles que pour ce seul utilisateur, il faut disposer d’un accès administrateur pour
installer une bibliothèque pour tous les utilisateurs d’un ordinateur. Attention, pour que la
bibliothèque nouvellement installée soit utilisable, il faut quitter puis relancer Arduino La
bibliothèque ad hoc étant maintenant installée, on peut passer au code : /* Code 20 - [Link],
destiné à l'Arduino Objectif: Afficher la température et l’humidité sur un écran */ //***** EN-TETE
DECLARATIVE ***** #include //on charge la bibliothèque Arduino à l'école 94 dht DHT; //on crée
l’objet du capteur DHT11 #define DHT11_PIN 7 //on définit le Pin qui sera utilisé pour recevoir les
données void setup() // début de la fonction setup() { [Link](9600); //Pour une fois, l’ouverture
du port série et la définition de sa vitesse en bauds est utile, même indispensable puisque l’on va
utiliser ce port pour afficher les valeurs du capteur. } //***** FONCTION LOOP = Code d'initialisation
***** // La fonction setup() est exécutée en premier et une seule fois, au démarrage du programme
void loop() // début de la fonction loop() { int chk = DHT.read11(DHT11_PIN); // on lit l’état du
capteur [Link]("Temperature = "); //on écrit le mot Température sur le moniteur
[Link]([Link]); //on affiche sur la même ligne la température lue
[Link]("Humidite = "); //on écrit le mot Humidité sur le moniteur
[Link]([Link]); //on affiche sur la même ligne l’humidité lue delay(1000); //on fait une
pause de 1 seconde entre 2 interrogations du capteur } Pour visualiser les données transmises par le
capteur, il faut encore ouvrir une fenêtre du moniteur série sur votre ordinateur : Menu Outils ->
Moniteur série. Tant que le moniteur série est ouvert, la température et l’humidité mesurées
s’affichent une fois par seconde Arduino à l'école 95 Circuit 15 Affichage des valeurs mesurées sur un
écran LCD Afficher le résultat des mesures sur le moniteur série est bien sympathique, mais si l’on
veut faire une installation de mesure permanente et autonome, cette solution ne convient pas, car il
faut que l’ordinateur soit en permanence allumé et branché à la carte. L’affichage sur un petit écran
LCD est une solution bien plus élégante et pratique. L’un des écrans LCD les plus répandu dans le
monde Arduino et qui est souvent fourni avec les kits de base est le modèle dit 16x2 LCD (il est
capable d’afficher deux lignes de 16 caractères chacun). A l’achat un tel écran coûte entre 7 et 15€.
Note : le but final étant d’afficher la température et l’humidité transmise par le capteur DHT11, il est
conseillé de laisser le circuit 9 en place (sur un côté ou une extrémité de la breadboard, autrement il
faudra le recâbler plus tard. Les images ci-dessous ne comprennent volontairement pas le DHT11,
toujours branché à la Pin7 afin d’améliorer leur lisibilité. Liste des composants : 1 écran LED 2x12 1
potentiomètre (résistance variable) 1 résistance de 220 Ω 1 capteur DHT11(déjà câblé depuis le
circuit 9) Il existe une grande variété de modèles d’écran LCD, certains forts pratiques ayant déjà des
pins qui dépassent à la face inférieure et qui s’encastrent directement dans la breadboard, d’autres
nécessitant l’usage de connecteurs mâles-mâles pour pouvoir se connecter à la breadboard ou
directement à la carte Arduino via des câbles de liaisons. Arduino à l'école 96 Tous les modèles
d’écran LCD sont dotés de 16 Pins dont le câblage est le suivant : • Les deux premiers pins tout à
gauche servent à l'alimentation de l'écran. Pôle négatif ou GND pour le premier et pôle positif (5V)
pour le 2ème. • Le 3ème pin est connecté à un potentiomètre et sert à régler le contraste de l'écran
LCD. • Le 4ème, noté RS pour Register Select, est connecté au pin 12 de l'Arduino. Il sert à
sélectionner la zone mémoire de l'écran LCD dans laquelle nous allons écrire. • Le 5ème doit être
connecté au ground (GND). • Le 6ème, noté E pour Enable, est connecté au pin 11 de l'Arduino. Il
permet de lancer ou non l'écriture dans les zones mémoires. • Les quatre suivants (7, 8, 9 et 10ème)
sont reliés au ground (GND). • Les quatre qui suivent (11 à 14ème, notés 5, 4, 3, 2 sur le schéma ci-
dessus, car ils se connectent sur les Pins 5, 4, 3, 2 de l'Arduino. Ils servent pour la transmission des
données à afficher. • Les deux pins tout à droite (15 et 16ème) servent pour alimenter la LED du
rétroéclairage de l’écran LCD. Attention l’avant-dernier (pôle positif 5V) doit impérativement être
protégé par une résistance d’environ 220 Ω. Le dernier est relié au pôle négatif (GND). Une fois le
montage effectué et l’Arduino branché au port USB de l’ordinateur, vous pouvez tourner le
potentiomètre et vous verrez le contraste de l’écran se modifier. Code 21: Afficher les données sur
l’écran LCD Contrairement à la bibliothèque «DHTLib» utilisée auparavant, la bibliothèque
«LiquidCrystal»est-elle incluse avec le logiciel Arduino IDE, mais il faut tout de même l’installer avant
de pouvoir l’utiliser. Menu : Croquis -> Inclure une bibliothèque -> Gérer les bibliothèques Dans
l'onglet de recherche, tapez : "LiquidCrystal". Si la bibliothèque est déjà installée, vous verrez noté
"INSTALLED" à côté de son nom, autrement cliquez sur Install Arduino à l'école 97 Attention, pour
que la bibliothèque nouvellement installée soit utilisable, il faut quitter puis relancer Arduino IDE. /*
Code 21 - [Link], destiné à l'Arduino Objectif: Afficher la température et l’humidité sur un
écran LCD */ //***** EN-TETE DECLARATIVE ***** #include //on inclut la bibliothèque pour le
capteur DHT11 #include //on inclut la bibliothèque pour l’écran LCD LiquidCrystal lcd(12, 11, 5, 4, 3,
2);//on crée l’objet LCD et on définit les Pins utilisés dht DHT; // on crée l’objet du capteur DHT11
#define DHT11_PIN 7 //on définit le Pin utilisé pour les données du DHT11 void setup(){ [Link](16,
2); //on initialise la communication avec l’écran LCD } void loop() { int chk = DHT.read11(DHT11_PIN);
//on lit les données du capteur DHT [Link](0,0); //on place le curseur de l'écran LCD au début
de la 1ère ligne [Link]("Temp: "); //on écrit le mot "Temp: " à l'emplacement du curseur
[Link]([Link],1); //on écrit la température lue par le capteur, avec 1 chiffre derrière la
virgule [Link]((char)223); //on ajoute le symbole ° après la valeur de la température
[Link]("C"); //on ajoute la lettre C pour degré Celsius [Link](0,1); //on déplace le curseur de
l'écran LCD au début de la 2èmeligne [Link]("Humidity: "); //on écrit le mot "Hum. rel: " à
l'emplacement du curseur [Link]([Link],1); //on écrit l'humidité relative lue par le capteur,
avec 1 chiffre derrière la virgule [Link]("%"); //on ajoute le symbole "%" après la valeur de
l'humidité delay(1000); //on attend une seconde avant de procéder à la lecture suivante } Arduino à
l'école 98 Projet 12 : Utiliser un servomoteur Les servomoteurs, souvent abrégés en «servo» tout
court par leurs utilisateurs, sont des moteurs d’un type particulier, très appréciés pour faire tourner
quelque chose jusqu’à une position bien précise et capable de maintenir cette position jusqu’à
l’arrivée d’une nouvelle instruction. Ils sont très utilisés dans le modélisme (direction des voitures
télécommandées, commande des gouvernes de dérive et de profondeur sur les avions, etc…), mais
ont aussi leur place dans la robotique et l’industrie par exemple dans des vannes pour réguler des
flux de liquides. Un servomoteur dit «9 grammes» très répandus dans le monde de l’Arduino. Dans ce
chapitre, nous allons apprendre à utiliser le plus répandu des servomoteurs en modélisme et dans la
petite électronique, il s’agit des modèles dits 9g, pour 9 grammes. Extérieurement, il se présente
sous la forme d’un petit rectangle, avec deux petits rebords sur les côtés pour le fixer solidement et
un axe décentré su lequel on peut fixer des bras interchangeables pour assurer la liaison mécanique
avec la pièce qui doit bouger. Même s’il existe de servomoteurs à rotations continue, l’immense
majorité des modèles sont capables de bouger leur bras sur 180° seulement. Vu de l’intérieur, un
servomoteur est un peu plus complexe qu’il n’en a l’air : Arduino à l'école 99 Un petit moteur à
courant continu est relié à un potentiomètre (résistance variable) par l’intermédiaire d’un circuit
électronique ce qui permet de contrôler finement le moteur en fonction de la position du
potentiomètre. Sur l’axe de sortie du moteur, une série d’engrenage permet d’augmenter son couple
(sa force utile) en réduisant sa vitesse de rotation. Quand le moteur tourne, les engrenages
s’animent, le bras bouge et entraîne dans son mouvement le potentiomètre. Si le mouvement
s’arrête, le circuit électronique ajuste en continu la vitesse du moteur pour que le potentiomètre et
donc par extension le bras du moteur reste toujours au même endroit. C’est ce qui permet par
exemple à un bras d’un robot de ne pas retomber sous l’effet de son propre poids lorsque le
mouvement s’arrête ! Utilisation d’un servomoteur avec l’Arduino Pour commander un servomoteur,
il faut lui envoyer un train d’impulsions dont la période (intervalle de temps entre chaque impulsion)
est toujours de 20 ms (millisecondes). Ce qui va varier et qui au final déterminera la position du bras
n’est pas la période, mais bien la durée de l’impulsion : • pour une impulsion de 1 ms, le servomoteur
se met en position 0° • pour une impulsion de 1.5 ms, le servomoteur se met en positon 90° • pour
une impulsion de 2 ms, le servomoteur se met en position 180° Ce schéma rappelle le PWM que l’on
a utilisé pour faire varier l’intensité d’une LED par exemple, le principe en est effectivement très
semblable, avec un train d’ondes rectangulaires puisque les données transmises sont digitales (HIGH
ou LOW) sans valeurs intermédiaires. La connexion d’un servomoteur ne pose pas de difficulté. Le fil
rouge se connecte à l’alimentation (5V), le fil noir se connecte au ground (GND) et le fil jaune
(attention parfois blanc ou orange ou… suivant le matériel dont dispose le fabricant chinois ?) à
n’importe quelle sortie numérique de l’Arduino (pin 0 à 13) Arduino à l'école 100 Circuit 16 Code 22:
Acquérir les données du capteur et les afficher. L'objectif des trois codes ci-dessous est de se
familiariser avec l’utilisation des servomoteurs. Pour les 3 codes, nous aurons besoin de la
bibliothèque Servo qui fait partie d’office du logiciel Arduino, mais qui n’est pas installée par défaut.
Menu : Croquis -> Inclure une bibliothèque -> Servo Attention, pour que la bibliothèque
nouvellement installée soit utilisable, il faut quitter puis relancer Arduino /* Code 22 - [Link],
destiné à l'Arduino Objectif : Faire bouger le bras d'un servomoteur dans un sens puis dans l'autre,
indéfiniment */ //*****EN-TETE DECLARATIVE***** #include //on inclut la bilbliothèque pour
piloter un servomoteur Servo monServo; //on créée l'objet monServo void setup()
{ [Link](9); //on définit le Pin utilisé par le servomoteur } void loop() { for (int position = 0;
position <=180; position ++){ //on crée une variable position qui prend des valeurs entre 0 à 180
degrés [Link](position); //le bras du servomoteur prend la position de la variable position
delay(15); //on attend 15 milliscondes } Arduino à l'école 101 for (int position = 180; position >=0;
position --){ //cette fois la variable position passe de 180 à 0° [Link](position); //le bras du
servomoteur prend la position de la variable position delay(15); //le bras du servomoteur prend la
position de la variable position } } Une fois votre code fonctionnel, n’hésitez pas à tester des délais
d’attente différents, de demander des parcours de 90° seulement ou d’autres valeurs, de varier le
pas des incréments utilisés, par exemple de 5° en 5°, etc.. Et observez à chaque fois le nouveau
résultat. Nous avons dit en parlant des servomoteurs qu’une fois une position atteinte, le moteur,
grâce aux informations maintenant le bras dans la position demandée jusqu’à ce qu’un nouvel ordre
lui parvienne. Cette fonction de maintien est primordiale aussi bien en modélisme qu’en robotique.
Si un bras robotisé saisit quelque chose par exemple, il ne faut pas qu’il retombe juste sous l’effet du
poids de la pièce saisie et de son bras. Pour cela le servomoteur doit donc continuellement continuer
d’ajuster la position à maintenir. La petite variation de code ci-dessous nous prouvera d’une part que
la position demandée est maintenue même quand on demande à l’Arduino d’effectuer une autre
tâche (ici, allumer la diode 13) et vous pouvez aussi essayer de tourner le servo à la main (sans
forcer !) pour sentir la résistance à la rotation qu’exerce le servo qui tente de maintenir sa position.
Code 23: Servomoteur et gestion des tâches /* Code 23 - [Link], destiné à l'Arduino Objectif :
prouver que la bibliothèque Servo permet au servomoteur d'agir et de se maintenir en position
même lorsque l'Arduino effectue une autre tâche. */ //*****EN-TETE DECLARATIVE*****
#include //on inclut la bibliothèque pour piloter un servomoteur Servo monServo; //on créée l'objet
monServo void setup() { [Link](9); //on définit le Pin utilisé par le servomoteur
pinMode(13,OUTPUT); //la Pin13 est mise en mode OUTPUT } void loop() { [Link](0); // on
dit à l'objet de mettre le servo à 0° diode13(); // appel de la fonction diode13 qui est définie plus bas
[Link](180); // on dit à l'objet de mettre le servo à 180° diode13(); // appel de la fonction
diode13 } void diode13() //on va faire clignoter 15 fois la diode 13 { for (int t=0;t //on inclut la
bibliothèque pour piloter un servomoteur Servo monServo; //on créée l'objet monServo int
pinmonServo=9; //on définit la Pin9 liée à la commande du servomoteur int pinPotar=A0; //on définit
la Pin analogique A0 pour la lecture du potentiomètre void setup()
{ [Link](pinmonServo); //on lie l'objet monServo au pin de commande } void loop() { int
valeurPotar=analogRead(pinPotar); // on lit la valeur du potentiomètre int angle=map(valeurPotar,
0,1023,0,180); //on transforme la valeur analogique lue en valeur d'angle entre 0 et 180°
[Link](angle); //on met le bras du servomoteur à la position angle }