ARDUINO:
LE MICROCONTRÔTNUR
AVR POUR TOUS
Arduino
est un projet d'open
hardware
destiné
à démocratiser
le développement
sur microcontrôleurs.
Il existe
plusieurs
kits Arduino,
mais tous se basent
sur des composants
AVR d'Atmel. L'un des objectifs principaux du projet
est de faciliter l'accès
aux débutants
et fournir une plateforme complète,
matérielle
et logicielle,
multiplateforme.
rduino est l'un des plus impor-tants projets open hardware existants. Le d e sign matériel, des kits Arduino est distribué sous licence Creative Commons Attïibution Share-Alike 2.5. Les schémas ainsi que certains des circuits (typons) sont
également mis à disposition sur le site
officiel. Enfin, le code source de
l'en-vironnement de développement et les
bibliothèques pour le microcontrôleur
sont dlsponibles sous licence LGPL.
Cependant, bien qu'une grande partie
de ce que fait Arduino soit sous licence copyleft, les créateurs ont décidé que le nom Arduino et ses dérivés soient
réservés aux kits officiels. Ils ne peuvent
donc pas être utilisés pour des projets dérivés sans accord préalable. Cette politique de marque déposée sur des projets open source n'est pas récente et peut être vue comme quelque chose de légitime (ou non). C'est une question de
point de vue. Pour les développeurs, 1l
s'agit généraiement de limiter et contrôier
I'image du projet et éviter d'endosser 1a
responsabilité, en termes d'image et de
réputation, de projets qui ne seraient pas
liés directement au leur. On retrouve ce
type de politique avec Mozllla Firefox, par exemple.
En réponse à cette restriction, d'autres
projets compatibles ont été lancés sous
les noms Freeduino, Seeduino, Uduino,
etc. Ces modules sont généralement
tota-lement compatibles avec I'environnement
de développement et les bibliothèques
Arduino. Il s'agit de clones parfaitement légaux et légitimes de l'Arduino ne pouvant, tout simplement, pas utiliser la même appellation.
Mais de quoise compose effectivement
une carte Ardulno ?
E f" matériel
Un kit ou module Arduino est construit avec un microcontrôleur AVR (Atme-ga328, Atmega168 ou AtmegaS) et uncertain nombre de composants satellites
destinés à faciliter la prise en main et
minimiser I'investissement personnel de
I'utilisateur (temps, matérie1, etc.). Ainsi,
un kit Arduino possède généralement
les éléments suivants :
- Un régulateur de tension 5 Volts
fournissant une alimentation stable
et régulée pour le reste du module. - Un oscillateur à quartz (ou céra-mique) de i6 MHz fournissant une
fréquence d'horloge plus stable que
l'oscillateur interne de IAVR.
- Une interface série ou USB/série permettant la connexion à la ma-chine de développement (Mac et PC Windows/Linux).
- Une série de connecteurs en liaison
directe avec les lignes d'E/S du microcontrôleur. Ceci permet la connexion à d'autres modules ou à des montages personnels, mais rend aussi possible 1'utilisation de sh ie I d s manufacturés spécialement
pour s'empiler au-dessus du kit.
- Un circuit fabriqué industriellement
et sérigraphié permettant le repérage
rapide des lignes d'E/S référencées, non pas avec les libellés dAtmel, mais ceux utilisés par I'environnement de développement.
Parmi les quelque 13 modèles déve-loppés à cejour, les plus populaires et les plus récents sont :
- Arduino Duemilanove, qui utilise
un Atmega328 (anciennement un
Atmega168) alimenté soit
direcre-ment en USB, soit par le régulateur
de tension intégré (commutation
automatique). Ce kit est équipé d'un
convertisseur USB/série FTDI, de quelques LED sur la carte et d'un b o u t o n p o u s s o i r . C'est 1à, sans
Le monstrueux Arduino Mega 2560 et son AVR Atmega2560 foumissant 54 E/S dont 14 pour la PWM, 256 Ko de flash, B Ko de SRAM et 4 Ko d'EEPROM. Ce module est équipé d'un AtmegaBIJ2 en guise d'intefface USB/série par défaut, tout comme le nouveau Arduino Uno.
itaiii,
tr:!** ;1i i:1
]:
lit f'lt}ill: ii ii: :.lUnpostrécent de Caleb Kraft sur Hack
A Day (II /02 /201 1), en réponse à 1'article
de Phillip Torrone sur 1e blog de Makezine,
résume bien 1'état des lieux concernant la
perception dArduino et de la communauté
Arduino par les électroniciens chevronnés.
Phillip Torrone tente d'expiiquer pourquoi
Arduino est une réussite et précise que les
100 000 unités distribuées démontrent
blen cette réusslte.
11 convient cependant de relativiser les
choses, 1es 100 000 kits Arduino ne pèsent
pas lourd face au nombre de projets et de
microcontrôleurs AVR utillsés en globalité.
La perception de Caleb Kraft est qu'i1 s'agit
en réalité de 100 000 kits utilisés par des
hackers débutants. La piupart des projets
à base dArduino sont généralement
sur-dimensionnés. En effet, en grande partie,
les réalisations n'utilisent pas le potentiel
d'unAtmega et, très souvent, une poignée
de circuits logiques feraient le travall pour
20 fois moins cher et avec 20 fois plus de
satlsfaction personnelle.
Le fait est qu'i1n'y a ainsi que très peu
de liens entre les communautés Arduino et
celles des développeurs sur, entre autres,
AVR. Par voie de conséquence, des
utili-sateurs qui débutent avec Arduino (,1a
plupart > diront certains) n'envisagent pas
1'utilisation du microcontrôleur sans les
bibliothèques Arduino et ne cherchent
pas à découvrir plus avant le monde d e l ' e i e c t r o n i q u e . C e s t e n c e l a q u e le s
hackers considèrent Arduino comme
une plateforme finalement peu éducative
et peu intéressante, elle ne pousse pas
à 1'expérimentation, à la recherche des
limites ou à l'exploration des
fonction-nalités. Elle encapsule et masque une
technologie fascinante qui ne tfouve
finalement, selon eux, sa vraie valeur
que lorsqu'e11e est exploitée pleinement.
U n m a g n i f i q u e e t d é m o n s t r a t i f
exemple de cet état de faits résulte de 1a
simple comparaison de projets. Prenons,
11;1r:;'f ':.Èi;]'r'l
commandes est, pour le projet Arduino,
un avantage, car i1 simplif,e le dévelop
pement. < Question de point de vue ,, diront certains...
Le développement pour Arduino repose
s u r u n e b i b l i o r h è q u e C / C - + s p e c i f i q u e
initialement basée sur Wirlng. Celle-ci
e s t . c o m m e l e r e s t e d e s s p e c i f i c i t e s de l'Ardulno, destinée à simplifier le
développement. Cette bibliothèque est
issue du projet du même nom (wiring. org.co) ayant pour objectif de fournir
une plateforme de développement
ba-sée sur... un AtMega1281. On se rend
rapidement compte que la carte Wiring
est très similaire aux kits Arduino, y
compris dans les motivations du projet:
" [...]exploring the electronic arts, tangible
media, teaching and learning computer
n r n o r a m m i n o [ ] .
r . e ô , 4 . _ , . . . , , . ô t , , J
Cette bibliothèque et les macros
as-sociées enrobent complètement la base
C/C++ et fournissent à 1'utillsateur une
interface de programmation si spéciflque
qu'i1 est presque difficile de parler de C ou
de C++ (la documentation officielle parle
du langage Arduino). Les programmes a d e s t i n a r i o n d e s k i t s r e p o s e n t g é n é
-ralement sur f implémentation de deux
fonctions principales que sont ::,'e i:ri r"; r ,, pour f initialisation du programme et le code exécuté à la mise sous tension (ou après un reset) et . r rl ir , , 1a boucle
principale exécutée de manière répétitive
jusqu'à 1'arrêt du kit.
V o i c i u n p r o g r a m m Ê s i m p l i s t e te l q u e décrlt dans 1a documentation officielle :
v o i d s e t u o r r { , p i n l 4 o d e ( 1 3 . 0 U ï P U T ) ;
)
v o ' o lo o p { r { ; d l g l t a l l l i r l i e ( 1 3 , | 1 I 0 H ) ; d e l a y ( 1 0 0 0 ) ; r d i q i t a l l , l r i t e ( 1 3 , L 0 | l ) ; d e l a y ( 1 0 0 0 ) ;)
C e c o d e p e r m e t d e s i m p l e m e n t f a i r eclignoter une LED sur 1a broche 13 d'un
kit. La fonction n â r 2 m ê l r ê
l a l i g n e 1 3 e n s o r t i e , e t r . " i , i . passe
alternatlvement son état à haut puis bas
avec un délai de 1000 millisecondes. Ce programme n'est pas un code valide
pour un compilateur C/C++, bien que
l a c h a î n e d e c o m p i l a t i o n G N U G C C
soit utilisée en compagnie de 1a AVR
Libc. L'ensemble des déclarations et
d e s i n c l u s i o n s s o n t m a s q u é e s a i n s i
que les initlalisations propres au
mi-crocontôleur. Nous sommes très loin
du développement classique pour AVR.
Onnotera que les fichiers sources Arduino,
appelés sftefch, utllisent généralement une
extension " i=:qle afin de 1es distinguer des
sources C/C++. Ceux-ci sont utilisables en
ligne de commandes moyennant
1'utilisa-r i o n d e , : " ' s s n é c i f i o u e s , m a i s l ' e f f o 1'utilisa-r t
nécessaire est disproportlonné par rapport
à l'utilisation d'un véritable code en C en lieu et place du sketch Arduino.
Arduino n'est pas le seul kit basé sur Atmel AVR. lci, une breakout board d'Evil Mad Scienflsf facilitant le développement surAtmega**8. Arduino, cependant, est plus complet en foumissant
circuit d'alimentation, interface USB/série, bootloader et environnement de développement.
doute, la carte la plus populaire, car très puissante tout en gardant un coût réduit.
A r d u i n o N a n o e s t u n e v e r s i o n
miniature (1.9 x 4.3 cm) dArduino
a l i m e n t é e u n i q u e m e n t p a r U S B e t r e p o s a n t s u r u n A t m e g a 3 2 8
version CMS. Celle-ci dispose d'un
connecteur mâle au pas de 0.25 et
est destinée à être enf,chée sur une
^ l ^ r : . . ^ À ^^^^: P r d r i l l t r d t r ù ) d l .
LilyPad Arduino est une version encore plus réduite et minimallste de
iArduino destinée à une application
portable et autonome. Elle est mue
par un Atmega168 CMS.
Arduino Mega est équipé du
mons-trueux Atmegal 280 en CMS (1 28 Ko
flash, 8 Ko SRAM, 4 Ko EEPROM). il
est 1à lntéressant de préciser qu'une
partie de 1a gamme AVR n'est pas disponible en boîtier PDIP Ces
mi-crocontrôleurs sont plus difficiles à
mettre en ceuvre pour 1'utilisateur
ne disposant pas de 1'équipement et
d e I e x p é r i e n c e n é c e s s a i r e s . A u l a n t
la soudure de CMS et de SOIC reste
accessible pour 1e plus soigneux des
électroniciens, autant les boîtiers BGA
sont tout simplement inutilisables
e n d e h o r s d ' u n e n v i r o n n e m e n t i n d u s t r i e l . L ' u t i l i s a t i o n d e k i t s , comme les Arduino, permet ainsi
de rendre accessibles ces AVR au
plus grand nombre.
- Arduino Uno est une conception n a r t i c r r l i è r e c a r c e k i t u t i l i s e d e u x
AVR. Le premier, unAtmega328, est
identique à celui équipant Arduino
Duemilanove, mais un Atmega8U2
- ^ * ^ 1 ^ ^ ^ I ^ - . . . ^ ^ ' - S B / s é r i e F T D I .
r t r l r r P l é ! ç 1 4 PULç U
LAtmegaBU2 est équivalant a un
Atmega8 (8 Ko flash, 512 octets
de SRAM et 512 d'EEPROM), mais
i n t è p r e u n c o n t r ô l e u r U S B . I l e s r programmé par défautpour servir de
convertisseur USB/série (ou comme
interface de programmation DFU à
1'aide d'un simple pointde soudure),
m a i s p o u r r a ê t r e r e p r o g r a m m é d e façon àtransformer le kit Arduino en n'importe quel type de périphérlque U S B . U n c o n n e c t e u r I S P (p r o g r a m
-mation In Sltu) peut être soudé pour
r e n r o p r a m m e r c e t A V R .
Dernier élément important concernant
I'aspect matériel des kits Arduino, leur
programmation se faitvia laliaison USB/
Série. Un bootloader spécifique (et open
source) est, en effet, préchargé dans
L'Arduino Mini, utilisant un Atmegal68,
est Ie plus petit kit officiel Arduino
existant à ce jour.
les AVR des kits. Un connecteur ISP 6
broches est également disponible sur la
quasi-totalité des modèles. On pourra
donc très simplement se passer du
boot-loader même si celui-ci est initialement destiné à simplifier la programmation
du microcontrôieur. Dans 1a démarche
initiale de simplification pour I utilisateur/
développeur débutant, ii est plus facile
de programmer ainsl 1e kit, directement
depuis I'IDE Arduino et avec un simple câble USB. Lutilisation du booloader évite d'avoir recours à un programmeur
ISP et un logiciel comme AVRdude, qui
n'est pas nécessairement disponible en
version la plus récente pour le système d e x p l o i t a t i o n d e s o n c h o i x .
ww
F 4
f , Ë e - ,
, = ' i ''ir'."1
ffffiR3Ë -h_r\ I \ P {; d iv 0.4_. {
Le bootloader est l'un des éléments
logiciels intégrés dans 1e kit, mais le
déve-loppement s'étend bien au-de1à. Le projet
Arduino met à disposition deux éléments
importants pour le développement :
Un environnement de développement
i n t é g r é c o m p r e n a n t u n é d l t e u r d e
code. Cet IDE est développé en Java et
fonctionnera donc, théorlquement, sur
n'importe quel système d'exploltatlon
supportant ce langage. Léditeur de code
est relativement avancé et comprend la
colorisation syntaxique, Ie repérage des
portées de fonctions, 1'auto-indentation,
etc. La compilation et le chargement du
code dans le microcontrôleur du kit se font directement depuis I'IDE. Le fait
de n'avoir pas à édlter un ll'leLc,ni:.Lil e et
de ne pas utiliser d'outils en ligne de
it;;.:âll
:"r,:
a:l
iiji13;!11 :i irr!: :;r '. i.. t:t irÂ:l
;,t
"l.itjl.l tl..r I t il
Le monstrueux Arduino Mega 2560 et son AVR Atmega2560 foumissant 54 flS dont 14 pour Ia PWM, 256 Ko de flash, B Ko de SRAM et 4 Ko d'EEPROM. Ce module est équipé d'un Atmega9U2 en guise d'interface USB/série par défaut, tout comme le nouveau Arduino Uno.
Unposfrécent de Caleb Kraftsur Hack
A Day (11 /02 /201 1), en réponse à 1'article
de PhillipTorrone surle blog de Makezine,
résume bien l'état des lieux concernant la
perception dArduino et de la communauté
Arduino par les électroniciens chevronnés.
Phillip Torrone tente d'expliquer pourquoi
Arduino est une réussite et précise que les
100 000 unités distribuées démontrent
bien cette réussite.
11 convient cependant de relativiser 1es
choses, les 100 000 kits Arduino ne pèsent
pas lourd face au nombre de projets et de
microcontrôleurs AVR utilisés en globalité.
La perception de Caleb Kraft est qu'il s'agit
en réalité de 100 000 kits utilisés par des
fiackers débutants. La plupart des projets
à base dArduino sont généralement
sur-dimensionnés. En effet, en grande partie,
les réalisations n'utilisent pas le potentiel
d'un Atmega et, très souvent, une poignée
de circuits logiques feraient 1e travail pour
20 fois moins cher et avec 20 fois plus de
satisfaction personnelle.
Le fait est qu il ny a ainsi que très peu
de liens entre les communautés Ardulno et
celles des développeurs sur, entre autres,
AVR. Par voie de conséquence, des utili
sateurs qui débutent avec Arduino (, la
plupart > diront certains) n'envisagent pas
1'utillsation du microcontrôleur sans les
bibliothèques Arduino et ne cherchent
pas à découvrir plus avant 1e monde
de 1'électronique. C'est en cela que les
hackers considèrent Arduino comme
une plateforme finalement peu éducative
et peu intéressante, e11e ne pousse pas
à l'expérimentation, à 1a recherche des
limites ou à I'exploration des
fonction-naiités. E11e encapsule et masque une
technologie fascinante qul ne trouve finalement, selon eux, sa vraie valeur
que lorsqu'e11e est exploitée pleinement.
U n m a g n i f i q u e e t d é m o n s t r a t i f
exemple de cet état de faits résulte de 1a
simple comparaison de projets. Prenons,
commandes est, pour le projet Arduino,
un avantage, car i1 simplifie le
dévelop-pement. < Question de point de vue ,, diront certains...
Le développement pour Arduino repose
sur une bibliothèque C,/C++ spécifique
initialement basée sur Wiring. Ce1le-ci
e s r . c o m m e l e r e s r e d e s s p e c i f i c i t é s de l'Ardulno, destinée à simplifier le
développement. Cette bibliothèque est
lssue du projet du même nom (wiring. org.co) ayant pour objectlf de fournir
une plateforme de développement
ba-sée sur... un AtMega1281. On se rend
rapidement compte que 1a carte Wiring
est très similaire aux kits Arduino, y
compris dans les motivations du projet:
< [.,]exploring the electronic arts, tangible media, teaching and learning computer
n r n o r a m m i n o [ | , ,
r ' e ô ' - " " " - " ô L " l
Cette bibliothèque et les macros
as-sociées enrobent complètement la base
C/C++ et fournissent à l'utilisateur une
interface de programmation si spécifique
qu'il est presque diffic11e de parler de C ou
de C++ (la documentation officie1le parle
du langage Arduino). Les programmes
à d e s t i n a t l o n d e s k i t s r e p o s e n l g e n e
ralement sur I'implémentation de deux
fonctions principales que sont s ir ,:,i !1 r j
pour I'initialisation du programme et
le code exécuté à la mise sous tension
(ou après un resef) et it,urr:rl ;, ia boucie
principale exécutée de manière répétitive
jusqu'à 1'arrêt du kit.
Voici un programme simpliste tel que
décrit dans la documentatlon officielle :
, v o j d s e t u p 0 { , p i n f 4 o d e ( 1 3 , O U T P U T ) ; , ) : v 0 r 0 r 0 0 p U t ; d i g i t a l l l r i t e ( 1 3 , | ] I G H ) ; d e l a y ( 1 0 0 0 ) ; d 1 g 1 t a l l l 1 r l t e t 1 3 , L 0 l , i ) ; del ay ( 1ûû0 ) ; ] C e c o d e p e r m e t d e s i m p l e m e n t f a i r e clignoter une LED sur la broche 13 d'un
k i t . L a f o n c t i o n p a r a m è t r e
1a ligne 13 en sortie, et -it:rrti:r ' i passe
alternativement son état à haut puis bas
avec un dé1al de 1000 millisecondes.
Ce programme n'est pas un code valide p o u r u n c o m p i l a t e u r C / C + - . b i e n q u e l a c h a î n e d e c o m p i l a t i o n G N U G C C
soit utilisée en compagnie de la AVR
Libc. Lensembie des déclarations et d e s i n c l u s i o n s s o n t m a s q u é e s a i n s i
que 1es initlalisations propres au
mi-crocontôleur. Nous sommes très loin
du développement classique pour AVR.
On notera que 1es flchiers sources Arduino,
appelés skefch, utilisent généralement une
extension .,1r,::: afin de les distinguer des
sources C/C++. Ceux-ci sont utillsables en
ligne de commandes moyennant l'utilisa
r i o n d e " . s n e c i f i o u e s , m a i s l e f f o r t
nécessaire est disproportionné par rapport
à 1'utilisation d'un véritable code en C en
1leu et place du sketch Arduino.
1:.r.:,,..,L.1,-rlri',':'l t |,,
',1:i.r..-f.:Ërill.,i...:
-par exemple, 1e sujet de l'éclairage d'am-biance en fonction de la diffusion d'une
vidéo (type Ambilight de Philips). Nous
avons d'une part le projet Atmolight te1
que, par exemple, décrit sur r;iir-'.,,'iki.d','.
On trouve 1à des explications complètes,
un détail du protocole, un pluginYLC,
des typons, des schémas et des
discus-sions sur les problèmes de performances.
Bref, un projet complet, bien travaillé re-posant sur un modeste mais suffisant
At-mega8. Le circult est conçu pour
contrô-ler une ou deux sources lumineuses et
peut être couplé à un second clrcuit. La
conception prévoie de base cette
confi-guration,/extension qui s'opère par un
simple agencement de cavaliers.
D'un autre côté, nous avons le < projet >
de Silicon Republic, un site Blogspot/
Blogger, se composant d'un Ardulno
Duemllanove (Atmega328 + FTDI), d'un
ruban de LED RVB de SparkFun et d'un
ULN2003A, 1e tout monté sur une platine
à essai. Côté logiciel, un code reposant sur
Processing (donc traduit du u Processing
language > enJava puis exécuté) effectue
des captures d'écran répétées et calcule
la couleur moyenne avant d'envoyer f information à l'Arduino. Le code du
microcontrô1eur tient en 25 lignes et se
contente de recevoir les valeurs RVB et
les applique sur 1es broches adéquates.
On comprend alors pourquoi certains
parlent de < solutions démesurées , :
une poignée de lignes de C pour un AVR
disposant de 32 Ko de Flash, un code
Le design open source de l'Arduino permet à n'impofte qui de créer des ktfs ef /es modules compatibles. Ici, un module disponible sur eBay en provenance de Singapour coûtant moins de 1 3 euros.
traduit en Java et un traitement d'image reposant sur des captures d'écran. Les motivations des deux projets sont
différentes. Le premier vise la création
d'un périphérique complet, configurable et optlmisé. Le second projet vise
1'ex-périence, 1'aspect ludique et le résuitat
fonctionnel.
C'est assez paradoxal, car cette fracture
entre l'électronique et le monde de
1Ar-duino estparfois considérée comme étant
à 1'origine de la popularité du projet open
source (dixit Phillip Torrone). Lattitude
hostile ou dédaigneuse des électroniciens
de longue date serait bloquante pour les nouveaux arrivants qui se seraient alorsjetés sur Arduino. De leur côté, 1es hackers considèrent des désignations
du type u le langage Arduino >) comme
un abus, car i1 s'agit tout bonnement de
C ou de C++ et quelques macros. Les
différents commentaires sur les forums
dAVRfreaks découlant de questions sur
l A r d u i n o s o n t ta n t o t t r è s a g r e s s i f s .
Un commentai r e sw Hack A D ayrésume
pourtant la situation et fait sejoindre les
deux mondes : < The point of Arduino is to give people who aren't hackers yet a way to experiment >. Le mot important est ( yet >, car en effet, Arduino est une
excellente façon de mettre le pied à l'étrier,
mais il ne faut pas s'arrêter 1à. Un vaste
domaine s'étend au-delà du kit et de son SDK, mais il faut lire \es datasheets, développer ses bibliothèques et réaliser
d p r r r a i c n r n i p t c
F . n é l p c t r o n i n r r e h e a u
-coup d'amateurs ont débuté
e n a s s e m b l a n t d e s k i t s e t en soudant slmplement les
composants à I'emplacement
indiqué par la documentation.
Ce n'est qu'ensuite qu'ils se
sont tournés vers la réalisation
d e c i r c u i t s e t l a c o n c e p t i o n . motlvés par la soif de créer et de laisser libre cours à l e u r im a g i n a t i o n p o u r a i n s i
dépasser le simples puzzles
électroniques proposés par
l e s k i t s . ll e n v a d e m è m e pour les microcontrôleurs.
E utt Arduino pour
quelle utilisation ?
Arduino est une excellente plateforme
pour s'initler au monde des kits et des microcontrôleurs. Lutilisateur pourra
ainsi faire connaissance avec quelques
concepts de base et réaliser des montages
simples et démonstratifs. Lenvironnement
d e d e v e l o p p e m e n t i n t é g r e o f f r e u n e
accessibilité sans pareil avec une mise
en application très rapide. LArduino est
recommandé pour des réalisations oir Ia
technicité n'est pas au cæur des
préoc-cupations de 1'utilisateur et où 1e résultat
seul est important.
Le contre.coup de la simplicité est, blen entendu, le fait que les spécifications du
microcontrôleur sont totalement masquées
ainsi que la démarche courante/classique/
recommandée de développement.
Lutilisa-teur pourra basculer, par la suite, avec son
kitArduino, vers des techniques de
dévelop-pement plus poussées en créant des codes C
et C++. Ceux-ci devront alors être compilés
selon une méthode plus standard et chargés
dans le kit soit via le bootloader Arduino,
soit via le connecteur ISP. Le kit devient
alors une plateforme d'expérimentation oùr
1es avantages de lArduino résideront
prin-cipalement dans le caractère manufacturé du module et le fait qu'il intègre un certain nombre de composants utiles (régulateur,
convertisseur, connecteur, etc).
Nous avons choisi, dans ce numéro, de
vous présenter lArduino et, bien sûr, vous
donner l occasion de faire vos premiers pas
avec le SDK standard. Mais nous avons ega
lement souhaité vous montrer qu'il existe,
pour quelques efforts supplémentaires, un champ d'expérimentation bien plus
vaste. Un microcontrôleur AVR n'est pas,
et ne serajamais, un ordinateur. Chaque
modèle répond à des caractéristiques bien
spécifiques et possède des limitations
flxes. Avec un peu de persévérance et de
curlosité, vous vous rendrez compte qu'il
n'est pas nécessaire d'acheter un kit avec un
AVR < plus gros ) pour vos projets et que, dans bien des cas, vous serez en mesure
de donner vie à vos réalisations pour un
nÉnurnR AVEC
soN ARDUINo
:
DES
PREMIERS
PAS
AU BORD
DE L'ENVIRONNEMENT
ARDUINO
par Denis BodorComme
nous I'avons
dit précédemment,
Arduino est une plateforme
idéale
pour s'initier au développement
sur microcontrôleur.
Cet article a pour but
de vous faire débuter
avec
le matériel et l'lDE Arduino,
mais aussi
et surtout
de vous montrer
qu'il ne s'agit
pas d'un ensemble
statique
et immuable.
Plus
qu'une
plateforme
de découverte,
un module
Arduino
peut s'adapter
à votre
expérience
et est capable
de vous
apporter
bien plus qu'un
simple
kit électronique.
o u s c o m m e n c e r o n s n o t r e
découverte de lArduino très
classiquement à la manière des
tutoriels présents sur le Wiki (playgroundl officiel. Ce n'est qu'ensuite que nous
nous approcherons de la frontière avec
le développement sur Atmel AVR et des
beautés de ce monde, différent mais non sans lien (heureusement).
T
II Arduino ?
Comme nous 1'avons vu dans l'article
précédent, Arduino désigne non pas
une carte mais différents modèles.
Ce-lui ayant servi de base de travail pour nos articles est lArduino Duemilanove
(<< 2009 > en itallen). Cette carte ou
module utilise le format standard Ar-duino et intègre une connectique USB fournissant I'alimentation ainsi qu'un
biais de communication à deux usages.
À la mise sous tension du module, le bootloader attend une suite d'octets
valides correspondant à un firmwareà
copier dans la mémoire flash de IAVR. Si. dans le temps imparti, rien n'est
À propos du resefautomatique
LArduino Duemilanove, contrairement à d'autres modèles, n'utilise pas
de bouton poussoir pour procéder à un reset du microncôtroleur et donc à
son redémarrage avec exécution du bootloader. Notez que ceci est toutefois
possible, le bouton présent sur le module étant bien relié au reset. Comme la
connexion USB est le fait d'un convertisseur USR/Série, une ligne spéciflque
appelée DTR (Data Terminal Ready) permet au terminal (le PClMac) de
contrôier logiciellement 1e reset car la ligne DTR est reliée à la ligne de reset
de I'AVR. Ainsi, I'IDE Arduino peut rebooter le module et charger ie code en
flash par simpie clic de l'utilisateur sur f icône tJpload.
Malheureusement, cela signifie aussi qu'une application communiquant via
le port USB/série du module provoquera un reset si la ligne DTR est activée à
la connexion. C'est un problème rencontré par quelques utilisateurs dArduino
et en particulier avec des applications dont ils ne possèdent pas ]es sources
et ne sont pas conflgurables. C'est également le cas, sous GNU/Linux, du moniteur série intégré à I'IDE Arduino qui procédera à un reset du module
dès son lancement. Si cela s'avère gênant dans votre utilisation de la platine,
il faudra modifier le module Arduino. Un strap placé entre la puce FTDI et
le connecteur USB est présent sur le circuit, marqué ( RESET-EN >. Il faudra
couper ce strap pour déconnecter la ligne DTR du reset. Dès lors, le problème
ne se posera plus, mais il faudra procéder au reset manuellement, avec un
parfait timing, pour rebooter 1e module juste avant le chargement du nouveau
code en flash. C'est l'une des limitations imposées et l'une des concessions
obligatoires lorsqu'on souhalte simplifrer 1'utilisation d'une plateforme pour
1e plus grand nombre. Un emplacement pour un cavalier aurait été préférable
r ê a r l ê Ê r m u l : r p - r . n r ê q ê - - . l l l u t r J d i " u d l l ) l - - - l ^ l d l l d ) l l f l ^ L r \ l t r \ H t l l l r . T\
ce stade, le code exécute peut faire usage du port série du
mlcrocontrôleur. C'est 1e composant FTDI, un convertisseur
USB/sérle placéjuste à côté du connecteur USB, qui permet
1a connectivité. LAVR utilisé, un Atmega32SP ne dispose en
effet pas de fonctionnalités USB par lui-même. contrairement
à quelques autres modèles d'AVR.
i
' , ' ^
A p r o p o s d e I A t m e g a 3 2 S P i l i a u t s a \ o i r q u e c e n e s t p a s
1à un petit mlcrocontrô1eur. Au contraire, c'est 1'un des pius
( gros > Atmega disponibles au format PDIP (Plastlc Dual
Inline Package). La Duemilanove peut ainsi proposer :
- Une communication sérle via 1es broches 0 et 1 qui s o n r e g a l e m e n t d i r e c t e m e n t r e l i e e s a u c o m p o s a n ' F T D I F T 2 3 2 R .
- Deux lignes d'interruption externes (broche 2 et3).
- Six sorties PWM (voir ci après) sur ies broches 3, 5, 6, 9 , 1 0 , e t 1 1 .
- Un bus de communication SPi via les broches 10 (SS), 11
(MOSD, 12 (MISO) et 13 (SCK).
- Six entrees analogiques sur les broches ANALOC IN 0 à
5. Certaines de ces broches peuvent avoir une r-rtilisation
alternative, comme la 4 (SDA/data) et la 5 (SCliclock)
p e r m e l l a n t u n e c o n r m u n i r - a t i o n T \ \ ' l f r - o t t r p a r i h l e il r - ) .
- La broche 13 directement reliée sur la carte à une ré
5 i 5 t a n c e e L u n e L F D .
- Des entrées/sorties (E/S) standards aux broches 12, 8,
7 , 4 e t 2 .
- Quelques broches permettant l'obtention de 3,3 V et 5 V 1a masse et une entrée pour une tension de référence p o u r le s m e s u r e s a n a l o g i q u e s .
I1 faut savoir que 1es lignes/broches spécialisees peuvent
être utilisées comme E/S standards. Le module Arduino utilise
au mieux les fonctionnalités disponibies sur I'Atmega328P
et facilite les premlers pas de I'utillsateur en établissant une
relation entre 1es désignations utilisées dans 1e code et 1a
nomenclature sérigraphiée sur 1e circuit. 11 faut cependant
sarder en tete cue la littérature du fabricant, Atmel, utilise
ô _ _ * . - _ _ , ' ' . ' ' _ f * . - ' * _ " '
d'autres dénominations qul, elles, sont utilisees dans 1a
bibliothèque AVR Libc.
Le microcontrôleur Atmega328P équipant 1e module
Duemila-nove dispose de 32 Ko de mémoire flashpermettantle stockage
de votre code. En réalité, seuls 30 Ko sont disponibles du fait
de 1'utillsation du bootloader occupant les deux autres Ko. Là
encore, c'est une concession obligatoire pour permettre l accès
au plus grand nombre d'utilisateurs. Les quelque 6 % de flash
perdus évitent de devoir avoir recours à un programmeur In
Situ pour charger le code. De 1a même manlère, 1es lignes d'E/S
PB6 et PB7 de 1Atmega328P sont inutilisables car connectées
en lieu et place de I'osclllateur interne de 8 Mhz qui, avec un diviseur de fréquence
interne configuré d'usine, fait flnalement
fonctionner 1AVR à 1 Mhz pour 1 MIPS.
La fréquence est donc 16 fois plus élevée avec notre module, mais nous perdons deux lignes d'E/S. Toujours en rapport
avec 1'horloge, le choix d'un quartz de
16 Mhz permet de simplifier les calculs
concernant les délais en plus de réduire
1es coûts de production. Cependant, en
regardant la documentation Atmel, on se
rend compte que cela implique un léger taux d'erreur dans les communications
séries, de l'ordre deO,2o/o à 19200 bps
(taux qui grimpera à 8,5 o/o à 230400 bps).
Dans certains cas précis, l'utilisation
d'un quartz à 14,7456 Mhz permettant
un taux d'erreur nu1 en communication
sériejusqu'à 230400 bps est nécessaire.
Il faudra alors dessouder 1e quartz et le
remplacer, mais dans ce cas, on préférera
sans doute utiliser autre chose qu'un module Arduino, comme une platine
pour AVR de chez Evil Mad Scientist ou
un circuit < maison >.
T e r m i n o n s c e t t e s e c t i o n a v e c l a
connectique. Pour programmer et
utili-ser votre Arduino Duemilanove, il vous
suffira d'un câble reiiant 1e connecteur
type B du module avec un port USB type
A du PC ou du Mac. Ce genre de câble
est très courant. 11 s'achètera au détail
en même temps que ie module Arduino ou sera réutilisé d'un hub USB, d'une imprimante ou un disque dur externe.
Pour la plupart des applications, 1e port
USB d'une machine hôte fournira assez
de courant. Lalternative consistera à
faire usage d'un adaptateur secteur 5V
1A qu'on trouve facilement sur le Web
pour quelques euros.
Installation et
IDE
Lenvironnement de développement Arduino complet est disponible au
té-1échargement sur le site officiel aussi
bien pour Windows, GNU/Linux et Mac OS X. La dernière version en date est la
0022, disponible depuis le 24/12/2OIO.
Les sources complètes sont également
té1échargeables. Linstallation est très
s i m p l e e t s e f e r a c o m m e n ' i m p o r t e q u e l l e a p p l i c a t i o n . E n c e q u i c o n c e r n e Windows et Mac OS X, il est possible que vous soyez obligé d'installer les pilotes FTDI disponibles sur le site du
constructeur. Une machine virtuelle
J a v a e s t e g a l e m e n t n é c e s s a i r e . m a j s
celie-ci est généralement installée par
défaut. Sous GNU/Linux et avec Debian
et Ubuntu en particulier, vous pouvez o p t e r p o u r 1 ' l n s t a l l a t i o n d u p a q u e t
arduino via le système de gestion de
paquets. Ce paquet installera également
arduino- core et les dépendances Java.
LIDE Arduino sur GNU/Linux est divisé en deux paquets afin de séparer
les dépendances Java. Ainsi, c'est le
paquet arduino qui intègre I'IDE alors
q u e a r d u i n o - c o r e e s t d é p e n d a n t d e g c c - a v r , avrdude, gcc et avr-libc. Il en résulte que, si vous souhaitez vous
passer de l'IDE pour utiliser votre propre
environnement de développement et
votre éditeur de code préféré, 1e paquet
a rduino - core sera suffisant.
L'environnement de développement de I'Arduino est relativement simple mais complet pour un usage ponctuel. Il intègre un éditeur de code et des raccourcis permettant la
compilation du code et le chargement sur le module.
À propos de l'éditeur de code
Si vous n'avez pas l'habitude de développer et de rédiger du code, il est probable
que l'éditeur intégré dans l'Arduino soit suffisant, du moins un certain temps.
Les développeurs préfèrent généralement des éditeurs plus complets et plus
spécialisés, comme Emacs, Vim ou encore l'environnement Eclipse. Léditeur
par défaut de I'IDE Arduino propose des fonctionnalités basiques comme 1a
colorisation syntaxique, l'indentation automatique ou le repérage de 1a portée
des fonctions et des parenthèses. Lutilisation d'un éditeur de code classique
vous apportera la compiétion, f indexation du code, la personnalisation de la
colorisation, 1'utilisation de < plis
" (folding), etc. Si vous commencez à
active-ment développer du code pour Arduino ou AVR, il est généralement admis que
l'utilisation d'un éditeur de code plus performant est une bonne idée.
Filê Edit skêtch Tools Help
r r r d s r t u p 0 { Ë1rl'1rrdû (13, tL|TFtrT] j
]
r r r d l n c p { } { ,iigrt;1t{rite (L3, HIt-lH} ; iiÊ1à!r (25) j d i I i t n i f r i t Ê ( 1 3 , L0d] j ,iehI (1000) ;]
Linterface de développement est simple
et concise. Le lancement se fera par
l'ap-pel de l'application Java Arduino. Mais
avant de développer 1e moindre code, il
convient de configurer l'environnement.
Commencez donc par connectervotre kit
Arduino. Ceci aura pour effet d'ajouter un
port série à votre machine. Rendez-vous
ensuite dans le menu Iools/Boards pour
déflnir le module que vous possédez,
puis dans Tools/Serial Port polJr choisir
le port série correspondant. Dès 1ors,
vous êtes prêt à développer.
Lenvironnement graphique de
déve-loppement se divise en 4 parties : - L a b a r r e d e m e n u p e r m e t t a n t
I'accès aux fonctions habituelles d e c h a r g e m e n t e t s a u v e g a r d e d e
flchiers (les skerchs), fonctions de
copier,/co1ler, formatage du code et
c o n f i o r r r : t i o n
. - " " _ _ ô * ' - _ ' " . . '
- L a barre d icone permetlant. de
gauche à droite, de compiler et véri
fier le code, d'arrêter I'opération en
cours, de créer un nouveau sketch,
d'ouvrir un sketch, d'enregistrer le
sketch courant, de charger le code
dans le module (après compilation si
nécessaire) et d'ouvrir le moniteur
série. Ce dernier est un mini terminal
série permettant d'envoyer et
rece-voir des données vers et depuis le
module. 11 est relativement simpliste
et on nrélérera péneralement . : * ô"- un
outil plus complet, les besoins du
développeur évoluant généralement
r a p i d e m e n t a p r è s l a p r i s e e n m a i n s du module.
-La zone d'édition du code. Celle-ci permet I'utilisatlon d'onglets n e r m c i l a n r d e d i v i s e r l e s c o d e s
complexes en plusieurs fichiers.
Lors de Ia compilation du code, les
données des différents onglets sont
r e s r o r r n é e s a v a n t d ê t r e t r a i t é e s . Sur la droite est placée une icône permettant la gestion des onglets. - Enfln, Iazone du bas regroupe les
informations sur les opérations en
cours (compilation, chargement, etc.)
avec dans 1'ordre : les messages de
1'lDE, les messages détai11és et, tout
e n b a s . la l i g n e d ' é t a t d e I é d i t e u r de code.
Plusieurs fonctionnalités didactiques
sont intégrées dans 1'IDE. Nous avons,
entre autres, les exemples livrés avec
1'environnement, qui sont directement
accessibles via le menu Fite/Exemptes.
Les sources sont organisées sous la
forme de sketchs avec une notion de projets. Vos différents sketchs sont
automatiquement regroupés dans votre
sketchb o ok elsont également accessibles
rapidement depuls le menu Fire. Un autre
exemple consiste en la possibillté de
sélectionner un morceau de code (nom
de fonction, macro, etc.) et de cliquer avec 1e bouton droit de la souris pour afficher directement la documentation
(si elle existe) du mot-clé sélectionné. Le
navigateur par défaut est utllisé pour visiter 1a page correspondante sur le site Arduino. Encore une fois, ce sont là des ajouts destinés aux utilisateurs
débutants. Les développeurs confirmés
(que vous deviendrez sans doute) préfé
reront utiliser leur propre organisation
de projets et consulter l'implémentation
d'une fonction ou d'une macro plutôt que sa documentation.
Précisons, enfin, que 1es préférences
de I'environnement sont mémorisées et
stockées dans un fichier preferences.txt
(dans -,/,arduino/ sous GNU/Linux et dans -/Library,/Arduino/ avec Mac OS X). Lédition de ce fichier permet un réglage plus fin de la conflguration. C'est
1à que, par exemple, vous choisirez
d'uti-liser une entrée /dev,/se riat/by-id/* plutôt que /dev/ttyUSB* sous GNU/ Linux (à condition de ne pas retourner
dans le menu). Encore une fois, pour une
utilisation avancée, on auravite fait de faire
sans I'IDE et sans les dépendances àJava.
E nt si on faisait
du code ?
Vous ne m'avezsans doute pas attendu
pour parcourir les menus et les
diffé-rents exemples. Nous ailons cependant
ici faire une petlt introduction au déve-loppement Arduino. Pour respecter la tradition voulant qu'un premier code soit toujours un < Hello World ,, nous allons en premier lieu étudier 1'exemple Blink.pde. Ce typique premier code a pour objectif de faire découvrir un
langage, sa syntaxe et la structure d'un
programme. Lorsqu'il s'agit de micro-contrôleurs, il est plus difficile d'afficher u Hello World , que de faire clignoter une LED. Et ça tombe bien, 1'Arduino
Duemilanove, comme la piupart des
modules Arduino, dispose d'une LED
(marquée L) soudée sur le circuit,
per-mettant de faire ses premiers pas sans
avoir recours à des composants externes.
Cette LED est connectée à la broche 13 de
la platine.
3.1 Premier code,
activer une sortie
V o i c i 1 e c o d e d e B l i n k . p d e : v o i d s e t u p O i p i n l 4 o d e ( 1 3 , 0 U ï P U ï ) ; ] v o i d 1 o o p 0 { d i g i ta 1 l , { r i t e ( 1 3 , | l I G | | ) ; del ay ( 1000 ) ; d i g i t a l i , l r i t e ( 1 3 , L 0 ! l ) ; d e l a y ( 1 0 0 0 ) ;
]
Un sketch Arduino se compose au m i n i m u m d e d e u x fo n c t i o n s :
- setupO est appelée automatique en premier lieu lorsque votre code
est exécuté par 1e microcontrôleur. Il
permet. entre autres. de configurer
les broches (E/S), 1a communication
série, etc.
- loopO est 1a boucle principale, 1 à o u v o u s a l i e z p r o v o q u e r l e s
choses et faire réagir votre module
à des événements externes, par
exemple.
Un programme C classique dispose
d une fonction appelée lors de l'exécution
du code, c'est mainO. Ici, mainO est
masquée etprise en charge par les
la fonction est termlnée, le programm€ s ârre te \i t
un ordinateur classique. le programme quitte mais ie systelll'
d'exploitation fonctionne toujours' Avec un microcontrÔieu r'
c'est différent, votre code est le seul à fonctionner' il n-v a
pas de système d'exploitation pour, par exemple' relancer le
p.og.u--". Si votre code s'arrête, 1e microcontrÔleur est
àrrêté et ne répondra plus. Vous ne 1e voyez pas avec votre
ordinateur, mals celuici exécute TOUJOURS un code ll doit
en être de même avec un microcontrÔ1eur' Voilà pourquoi
nous avons une boucle sans fin appelant de manière répétée
Que fait notfe présent code ? Dans la fonction
,rous .o.tfigurons 1e port 1 3 en sortie en utilisant la fonction
qui prend deux arguments : le numéro de la
broche et le mode' Par défaut, 1es lignes d'E/S de i'Arduino
sont configurées en entrée afin de pouvoir y lire un état'
Deux modes sont disponibles et leur nom est suffisamment
explicite : et Dès 1'exécution de notre fonction
la broche 13 peut soit fournir une tension de +5V, soit être à OV (masse).
La fbnction p r e m i è r e ,
utllise deux fonction distinctes La , prend en arguments un
nu-méro de broche et un état pour haut et donc +5V et
pour bas et une mise à la masse' La première ligne de
notre fbnction active donc la broche 13 Celle-ci est
reliée à une LED via une résistance CMS de 1 K Ohm et à la
masse. El1e va donc s'aliumer' La seconde fonction utilisée
est , prenant en argument une valeur en millisecondes'
Ici. nous spéciflons 1000' nous marquons donc une pause
c l u n e s e c o n d e . L e r e s t e d u c o c l e e s t m a i n t e n a n t l i m p i d e :
ciésactiration de la broche 13 et nouveau déiai Notre LED
va dolic crlignoter doucement'
\''oilà lc B A BA de I'Arduino Une chose lmportante à savoir
sur rient clans ie fait que certe fonction
peut être utilisée aussi bien avec une broche conf,gurée en
sortie qu'en entrée. Si 1a broche est configurée en entrée
( ), 1e fait de mettre 1a broche en
active une résistance de rappel au +5V'
Modifions notre code afin de ne provoquer le
clignote-ment que si un bouton est enfoncé 11 n'est pas nécessaire
ici de disposer d'un bouton poussoir' Idéalement' on rellera
1a broche 12 de l'Arduino avec un bouton poussoir (du type
présent sur 1e module), qu'on connec-tera à la masse du
circult. Lidée est de mettre la broche I2 àIa masse lorsque
le bouton est enfoncé' Bien entendu, ceci fonctionnera tout
aussi bien en utilisant un simple câbie pour faire la liaison
manuellement entre le broche 12 etla broche GND sltuée
deux broches Pius 1oin.
i n t v a l e u r = 0; v o i d s e t u p ( ) { p i n M o d e ( 1 3 , 0 U T P U T ) ; d i g i t a l l , J r i t e ( 1 2 , H I G H ) ; ) v o i d 1 o o p O { v a l e u r = digitalRead(12); i f ( v a l e u r = = 1 0 ! i ) i d i g i T a l t t l r i t e ( 1 3 , t | I G H ) ; d e l a y ( 2 5 ) ; d i g i t a l | . l r j t e ( 1 3 , L 0 l i ) ; d e 1 a y ( 2 5 0 ) ; ] i
Nous avons ici une nouveauté, une
déclaration de variable. Son nom est valeur et son type est int pour entier
(integer). Notre variable est dite globale
car accessible à l'ensemble du code et
donc à f intérieur de toutes 1es fonctions
que nous utilisons. Il est important de
bien comprendre le fonctionnement de
la portée des variables. Si une variable
e s t l o c a l e ( p r o p r e à u n e f o n c t i o n ) ,
cel1e-ci n'existe tout simplement pas en
dehors de la portée de la fonction. E1le ne peut donc pas servir à transporter une donnée d'une fonction à une autre.
De plus, loop( ) est appelée de manière
répétitive. Une déclaration de variable locale dans la fonction loopO et son initialisation signifie une chose : la variable sera initialisée à chaque appel de la fonction. E1le ne peut donc pas être utilisée pour stocker une donnée qui doit survivre au frl des invocations de la fonction, pour stocker un état, par exemple.
Notre fonction setup( ) a également été modifiée. Nous activons la résistance d e r a p p e l s u r l a b r o c h e l 2 ( c f . b o î t e explicative sur le sujet). Nous n'avons pas besoin de définir le mode en INPUT, puisque c'est le mode par défaut.
Mais le principal changement se situe
dans toop0. Toutd'abord, nous utilisons
la fonction digitalReadO pour lire l'état d'une broche. Largument passé en paramètre est simplement le numéro de la broche. La fonction retourne un
entier décrivant l'état, LOW pour bas,
HIGH pour haut. Notez que nous utilisons
les constantes définies par Arduino,
oir 1a valeur 0 correspond à LOW et 1
à HIGH. Nous aurions tout aussi bien
pu utiliser ces valeurs en lieu et place
des constantes. mais c'est une bonne
habitude à prendre que de reposer sur
ces constantes. Cela permet de clarifler
1e code, d'éviter ies confusions et de conserver une certaine portabilité au c o d e . D è s I ' a p p e l à d i g i t a l R e a d O , valeu r contiendra I une ou I'autre valeur.
La dernière étape consiste à tester la
valeur de valeur à l'aide d'une simple
condition if. Si valeur est égale à LOW,
nous exécutons le code dans la portée
de la condition, sinon, nous ne faisons rien. Nous avons légèrement changé les délais utilisés pour le clignotement
pour avoir quelque chose d'un peu plus
rapide et de plus sexy. valeur==LOW n'est pas la seule syntaxe utilisable. Le
Iangage Arduino est du C. Le C, comme
d'autres langages, considère qu'une
variable entière est vrai lorsqu'elle est
supérieure à zéro et fausse quand elle
vaut zéro. Nous aurions donc tout aussi
bien pu écrlre if ( | valeu r) , en d'autres t e r m e s . s i v a l e u r n ' e s t p a s v r a i . J e ! slgnifiant 1a négation.
Après compilation et chargement d a n s le m o d u l e D u e m i l a n o v e , r i e n n e
semble se passer. En effet, en l'absence
de connexion de 1a broche 12 à la masse,
la résistance de rappel fait son office ;
valeur est donc égale à HIGH. Si nous
poussons 1e bouton ou connectons la broche à la masse, 1a LED clignote.
valeur est égale à LOW et le code dans
la portée du if est exécuté.
3.3 Communication série
La communication entre le PC (ou Mac) et le module est quelque chose de très travalllé avec Arduino. il faut savoir, en effet, qu'en développement AVR en C, il vous faudrait gérer toutes les opérations manuellement ou, du
molns, développer vous-même le code
qui s'en chargera. Faire communiquer votre Arduino est donc quelque chose de très facile. Nous n'allons pas consommer
de la place pour rien dans cet article et je vous fais grâce d'une troisième version du code exemple pour cette simple modification.
Pour faire communiquer notre pro-gramme, nous allons le retoucher en ajoutant simplement deux petites lignes. La première doit être placée dans la fonction setupO :
5 e r i a 1 , b e g i n ( 9 6 0 0 ) ;
Ceci aura pour effet de configurer la
communication série à 9600 bps 8 bits
de données, pas de parité et un bit de
stop (9600 SNi). Dès que cette fonction
est appelée, le port série de lArduino est
prêt à être utllisé à la vitesse spéciflée. Plus loin dans notre code, à la fin de la
fonction loop( ), mais dans 1a portée de
la condition if, nous ajoutons :
S e r i a l . p r i n t ( "b 1 j nk\n" ) ;
La fonction print( ) prend en argu-ment une valeur à envoyer par le port série. Cette fonction est très complète
et permet, comme ici, d'envoyer une
chaîne de caractères (le \n de fln est une
nouvelle ligne), une valeur numérique
entière, un nombre à virgule ou encore
un simple caractère. Chargez le code dans
votre module, puis ouvrez le moniteur série vla I'icône dans f iDE Java. Celui-ci est conflguré par défaut en 9600 bps. En gardant sous les yeux le moniteur, mettez la broche 12 à Ia masse. En même temps que le clignotement de Ia LED, lArduino vous envoie la chaîne de
caractères blink et retourne à la ligne.
Débranchez la broche 12 dela masse,
le clignotement cesse et l'émission de
caractères aussi.
À présent, voyons comment lire un caractère avec une nouvelle version du code : i n t v a l e u r = 0; b o o l e a n c l i g n o t e = true; v o i d s e t u p 0 { pi nl4ode( 13, 0UTPl.JT) ; d l g i t a l l , l r i t e ( 1 2 , H I G H ) ; S e r i a 1 . b e g i n ( 9 6 0 0 ) ;
]
v o i d l o o p o i b y t e l e c t u r e ; v a l e u r = dlgilalRead(12); i f ( S e r i a l , a v a 1 1 a b 1 e 0 ) { l e c t u r e = Serial.read0; i f ( I e c r u r e = = 7 8 ) c l i g n o t e = O ' i f ( l e c r u r e = = 7 9 ) c l i g n o t e = 1 ' ] i f ( v a l e u r = = 1 0 1 , { & & c l i g n o t e ) { d i g i t a l i , l r i t e ( 1 3 , H I G H ) ; d e l a y ( 2 5 ) ; d i g i t a l i , l r i t e ( 1 3 , L O l l ) ; d e l a y ( 2 5 0 ) ; S e r i a l , p r i n t ( " b l i n k \ n " ) ; ) )
Nous avons ajouté une nouvelle v a r i a b l e g l o b a l e , c l i g n o t e , q u i e s t t e s t e e d a n s la c o n d i t i o n i f . A p r é s e n t . i1 faut non seulement que 1a broche
1 2 s o i t à l a m a s s e , m a i s é g a l e m e n t q u e c l i g n o t e s o i t v r a i ( t r u e ) p o u r n r r e l e c l i p n o f e m e n t e t l e n v o i d e b l i n k a i e n t l i e u . L e & & e s t u n E T logique permettant de lier les deux c o n d i t i o n s . P o u r c o n t r ô l e r la v a l e u r d e c t i g n o t e . n o u s li s o n s l e p o r t s é r i e . Avant de lire le port, nous utilisons la fonction availabte pour connaître l e n o m b r e d e c a r a c t è r e s q u i o n t e l e r e ç u s p a r 1 e m o d u l e e t q u i s o n t d o n c d i s p o n l b l e s p o u r 1 a le c t u r e . I c i , 1 e nombre nous importe peu en réa11té, d u m o m e n t q u ' i l e s t s u p e r i e u r à z e r o
et donc que 1a condition if à la même
ligne soit vérifiée. Nous procédons ensuite à la lecture en utilisant read, nous retournant le premier caractère disponible. Nous comparons ensuite sa valeur, si c'est 78 (lettre < N > en
ASCII), nous passons clignote à faux,
s i c ' e s t 7 9 ( . O > e n A S C I I ) , c l i g n o t e devient vrai.
Nous pouvons maintenant contrôler 1e clignotement via le moniteur série. Par défaut, une mise à 1a masse de 1a broche 12 fait clignoter la LED, mais si nous envoyons < N >, le clignotement
cesse. Pour le remettre en marche, il
suffit d'envoyer < O >. Vous venez de communiquer pour la première fois avec votre Arduino.
3.4 Lecture analogique
Les cartes Ardulno sont équipées d'entrées permettant la lecture de
va-leurs analogiques. Plus exactement, un
AVR peut être conflguré de manière à
ce que certalnes de ses entrées utilisent
un convertisseur analogique/numérique
(ADC en anglais) présent dans 1e mi-crocontrôleur. Une valeur analogique est une tension entre 0V (la masse) et la tension de référence, par défaut Vcc et donc +5V. Pour expérimenter la
lecture analogique, il vous faudra plus
qu'un simple câble en plus du module
Arduino. 11 vous faudra idéalement un
potentiomètre linéaire de 10 K Ohms.
Une autre solution consiste à utiliser des
résistances, et enfin, 1'ultime solution
broulllon consiste à ne rien utillser du
t n r r t { r i n i r e i - a n r è s l
Un potentiomètre est un composant disposant de trois broches. Deux per-mettant une connexion respective à Vcc et à la masse et une broche centrale qui fournira une tenslon variable entre Vcc et la masse. Le principe utilisé est celui du pont diviseur de tension :
Vcc - résistance - mesure - resistance
-masse. Si 1'on tourne le potentiomètre
vers Vcc, la tension mesurée augmente,
inversement, en tournant vers la masse,
celle-ci diminue.
N o u s a 1 1 o n s c o n n e c t e r la b r o c h e
centrale à la broche 0 des connecteurs
situés à côté de la sérigraphie n ANA LOG IN > sur le module Arduino. Nous pourrions continuer de modifier notre
code exemple, mais nous préférons ici
f e i r e s i m n l e e r r e e ' v o l d s e t u p 0 { S e r j a I . b e g i n ( 9 6 0 0 ) ; ] v o i d 1 o o p 0 { i n t v a l e u r ; v a l e u r = analogRead(A0); S e r l a l . p r i n t ( " n e s u r e : " ) ; S e r i a l . p r l n t l n ( v a l e u r . D E C ) ; d e l a y ( 5 0 0 ) ; )
La fonction utilisée pour 1a mesure
sur la broche 0 est analogReadO, qui
prend en argument le numéro de la broche qui nous intéresse. Notez que
dans la nomenclature Arduino. les entrées
analogiques sont préfixées d'un A. Cette
fonction retourne directement la valeur
lue que nous stockons dans vateur. Nous
utilisons ensuite printO et delayO,
que nous connaissons déjà. Une petite
nouveauté ici avec println ( ), qui prend
en arguments non seulement la valeur
o u l a v a r i a b l e à e n v o y e r s u r l e p o r t
série, mais également un identificateur
de format optionnel. Ici, DEC demande
un formatage de vateur en décimale et
donc un affichage de la valeur lisible par
un humain en lieu et place d'un octet ayant valeur comme valeur. Notez que
println ajoute tout seul les caractères
\r (retour chariot) et \n (nouvelle ligne)
en fln de ligne. Une fois le code chargé d a n s le m o d u l e , v o u s d e v r i e z p o u v o i r
voir s'afficher, dans ie moniteur série, une
valeur toutes 1es demi-secondes. Jouez
avec le potentiomètre pour faire varier
la valeur entre 0 (masse) et 1024 (Vcc).
Comme 1'entrée analogique n'a pas de
résistance de rappel activée, en 1'absence
de potentiomètre connecté, vous aurez
une belle représentation de ce qu'on entend par < état indéterminé > :
Une succession de valeurs mesurées
qui semble complètement aléatoire et
qui, en réa1ité, est due à 1'environnement
électrique amblant.
Nous arrêterons là notre tour d'horizon
du langage Arduino ou plus exactement
de 1'utilisation des fonctionnalités mises
à disposition par la bibliothèque Wiring
modif,ée pour le projet Arduino. Le site officiei regorge littéralement d'exemples
détaillés et commentés. Je ne saurais que
trop vous en recommander la lecture
et, si possible, la mise en æuvre
collez pas 1es exemples et n'utilisez pas
les codes accessibles depuis le menu de
1'lnterface. Recopiez-1es ligne par 1igne.
Les incontournables fautes de frappe que
vous ferez et les messages d'erreur en
découlant vous offriront 1'occasion de
chercher les erreurs et donc de mieux comprendre le code.
Plus vous utiliserez ce langage, plus
votre niveau de competence en C
aug-mentera naturellement. Car 90 % du
langage Arduino est du C et il vous sera
de plus en plus facile de vous détacher
des blbliothèques pour appréhender le
C sur microcontrô1eur AVR.
À
Él Comprendre
le processus
de
construction et de
compilation
Avant d'a11er plus loin avec lArduino,
i l e s t im p e r a t i f d e c o m p r e n d r e c e q u e
1'environnement de développement
fourni falt réellement. Les fichiers
sources, appelés sketchs dans Arduino,
ne sont pas des sources C ou C++ valides
d'un point de vue du compilateur GCC. Voilà pourquoi les fichiers sources, les sketchs Arduino, possèdent géné-ralement une extension spécifique, . p d e , p e r m e t t a n t d e 1 e s id e n t i f i e r facilement.
Pour obtenir un fichier susceptible d'être exécuté par le module Arduino,
I'environnement commence par intégrer
Ies éléments spécifiques à Arduino dans votre code. Ceci prend la forme de f inclusion du fichier WProgram.h.
Ceiui-ci, généralement placé dans 1e
répertoire hardware/cores de 1'envi-ronnement installé sur votre système, comprend les déf,nitions de fonctions, de macros et de pseudo-constantes de la bibllothèque princlpale Arduino.
Ensuite, votre code sera analysé et les
prototypes de fonctions que vous aurez
définis seront ajoutés. Tout ceci formera
les sources C++ de votre code.
v o i d s e t u p O { pi nl4ode ( 13 , 0UTPUT ) ; ) v o i d l o o p 0 { d i q i t a l i , l r i t e ( 1 3 , H I G H ) ; d e l a y ( 2 5 ) ; d i g i t a l i { r i t e ( 1 3 , 1 0 i l ) ; del ay ( 10û0 ) ; )
voici ce cue produira I'environnement
# i n c l u d e " l i P r o g r a m . h " v o i d s e t u p 0 ; v o i d 1 o o p 0 ; v o i d s e t u p O { pi nl'1ode( 13, 0UTPUT) ;
]
v o l d lo o p 0 { d l g l t a l l l r i t e ( 1 3 , H I G H ) ; d e l a y ( 2 5 ) ; d i q i t a l l , l r i t e ( 1 3 , t0 l , l ) ; d e 1 a y ( 1 0 0 0 ) ;]
Si nous prenons l'exemple Blink et en
faisons un sketch spécifique :
On retrouve l'lnclusion deWProgram.h,
1es prototypes des fbnctions setup( ) et
loopO et notre code, dans un fichier appelé du nom du sketch avec l'extension
.cpp. Tout ceci, sous GNU/Linux, est
placé dans un sous-répertoire de ,/tmp.
Qu'avons-nous d'autre à cet endroit ?
c 0 r e . a c 0 u c 0 u . c p p c 0 u c 0 u . c p p . e e p c o u c o u . c p p , e 1 f c o u c o u . c p p . h e x c 0 u c 0 u . c p p . 0 H a r d w a r e S e r l a l , c p p . o m a i n . c p p . o p i n s _ a r d u i n o . c , o P r i n t . c p p . o T o n e . c p p . o ù l T n i ê r r r n t ( . ô w l r l n g _ a n a 1 o g , c , o l . / l r i n g . c . o w i r i n g _ d i g i t a l . c , o w i r i n g _ p u 1 s e . c . o w i r i n g _ s h i f t . c . o l,ll'4ath . cpp. o liStri ng . cpp. o c o u c o u . c p p e s t l e s o u r c e C + + d e
notre sketch u coucou.pde >. cor.rcou.
cpp.o est le fichier objet généré par
la compilation par GCC. Ce fichier ne contient que le code de notre source et non des éléments de l'environnement Arduino. Vous remarquerez un grand nombre de .o. Il s'agit des fichiers objets des sources de I'environnement (la bibliothèque Wiring sur laquelle est
T ) a n s c e r t e n a r r i e n o u s n e couvri
rons que I'utilisation dArduino avec
un environnement GNU/Linux et les
d i s t r i b u t i o n s D e b i a n e t U b u n t u e n n a rt ic r r l i e r F n e f f e t c e s l e n r a is o n
des mæurs des développeurs GNU,/
Linux que ce type d'utilisations des
m e c a n i s m e s d e c o m n i l a t i o n d A r
-duino est possible. Debian et Ubuntu
séparent I'environnement Arduino en
d e u x p a r t i e s s o u s l a lo r m e d e p a q u e r s
et Le second
ne contient que les éléments dépendant
d e Java er donc l lDE en tanl que iel.
De plus, le paquet de base,
, est étoffé d'un é1ément ayant
disparu des éléments téléchargeables
Arduino : le flchier version 0017.
Un fichier
d e l a
F q l r n < , a r i n l. - ' - - " . - _ ' r '
utilisable par 1a commande , Celle-ci
p Ê r m e l d a u { o m a r i s e r l a t o m p i l a r i o n d u n c o d e e t d e p e r e r * _ ô_'.-'' .^' .-r_d e ' o n e r a t i o n s a l l a n t
i r r s c r r r ' a r r c h a r s e m e n t d u c o d e b i n a i r e
. l _ " f * * . ^ " * _ ô . " ' . " '
-d a n s le m o -d u l e A r -d u i n o . C o n s u l t e z
1'article sur CNU Make dans le présent
magazine à la rubrique < Répère > pour
en apprendre plus sur Make.
Il est parfaitement possible de com
piler un code/sketch en ligne de
commandes. Ceci vous sera sans doute
plus naturel que 1e chargement du code
dans 1'lDE Java après édltion avec un
outil comme Vim ou Emacs. Et force
est de constater que 1'éditeur intégré
e c t r c l : t i v c m p n t ' _ - " ' " " ' " ô . - ^ 'l é o p r
P o u r p r o d u i r e u n b i n a i r e e t 1 e c h a r g e r d a n s r o t r e À r d u i n o d e p u i s l a l i g n e d e c o m m a n d e t . r o u s d i s p o s e z
de deux solutions :
Utiliser 1e présent dans
en le
copiant dans 1e répertoife où1 se
trouve votre sketch et en
I ' ^ l ^ ^ + ^ ^ + ^ i L ^ ^ i -r d u d P L d l -r L > 1 u t r ) u r l t .
- Créer un Makefile réduit contenant 1a configura-tion de votre environnement et en incluant le fichier / us r / shar e /a rd uino/Arduino. mk.
C'est cette seconde solution qui sera détaillée ici, car
elle est la plus simple et 1a plus efficace. Lutilisation d'un
Makefile complet, 1ocal (au répertoire où se trouvent les sketchs) est bien trop proche de l'utilisation directe de
sources C classiques. Autant alors se composer son
envi-ronnement et utiliser des bibliothèques équivalentes à celle
dArduino, mais plus polyvalentes car génériques à tous
développements AVR.
Soit le répertoire coucou contenant le source/sketch
Blink,pde. Pour présenter correctement la solution, nous
ajoutons un fichler toto.pde équivalent au contenu d'un
onglet (sans extension spéciflée) dans 1'IDE Java. Tout ce que
nous avons à faire est de créer un petit Makefite déflnissant
les éléments en présence :
- ARDUINO-DIR = ,/usr/share/arduino precise
I'empla-cement des sources et des éléments de I'environnement.
Ce répertoire est determiné par le paquet a rduino- core
et ne changera pas de projet en projet.
- Selon la verslon utilisée, il peut être nécessaire d'ajouter
une iigne AVR_TOOLS_PATH = /usr/bin précisant oir
se trouvent 1es outils de compilation. Ce n'est pas le cas
avec la version intégrée à I'heure actuelle dans le paquet arduino-core. Mais une version plus àjour, directement
recupéree sur http:,/,/mjo.tc, demandera cet ajout.
- TARGET = Btink est notre sketch principal. I1 s'agit de
l'équivalent du premier onglet de I'IDE Java qui déter-mine 1e nom du sketch. Notez que nous ne spéclfions pas I'extension.
- MCU = atmega323p définit le processeur selon 1a syntaxe
AVR GCC te11e que renseignée par i'option -mmcu.
- F_CPU = 16000000 renseigne sur la fréquence d'horloge.
Ceci est important pour le ca1cu1 des délais, par exemple.
- ARDUINo_PoRT = ,/dev/ttyUSB0 définit le port où est
connecté le module Arduino. Le Makef ite en question, en
effet, sera en mesure de charger 1e code dans le module.
Vous pouvez également utiliser un chemin plus explicite,
comme /dev/serial/by-id/usb - FTDI_FT232R_USB_
UART_A700e0cF-if 00- po rt0.
- AVRDUDE_ARD_PROGRAMMER = arduino précise le type
de programmeur AVR à utiliser. AVRdude est, en effet, en
mesure de se servir de bon nombre de programmeurs différents et de bootloaders préchargés dans les AVR.
arduino correspond à 1'ensemble des modules Arduino
disposant d'une connectivité série ou USB/série.
- AVRDUDE_ARD_BAUDRATE = 57600, enfin, définit la viressc
de communication avec le bootloader série Arduino. Ceci
est la valeur par défaut.
Nous n'oublions pas de terminer notre Makef ile en
ajou-tant une ligne include /u s r,/s ha rela rd uino/Arduin o, m k
permettant d'inclure automatiquement ie contenu du fichier
spécifié et donc les différentes cibles utilisables. 11 nous
suffit alors d'enregistrer le fichier et d'utiliser la commande
make pour compiler notre sketch. Toutes les étapes décrites
précédemment seront exécutées. Nous obtenons alors un
répertoire build-cli contenant tous les fichlers produits.
Ce contenu est équivalent à celui du répertoire temporaire que nous avons exploré. S'y trouve donc, bien entendu, 1e
fichier Blink. hex. On reconnaîtra aussi les différents fichiers
découlant du traitement de toto. pde. Le nom du programme
produit est issu de ce que nous avons spéciflé avec TARGET= dans le Makefite, mais les autres fichiers .pde sont auto-matiquement traités et intégrés.
Mais nous ne sommes pas obligés d'utiliser avrdude directement pour uploader le code, le Makefile prend en
charge 1'opération de chargement dans le module. Un slmple
make raw_uptoad chargera le code.
Notez qu'il existe également une cible upload, mais
celle-ci n'est pas à jour. Nous l'avons détaillé en début d'artlcle,
le reset nécessaire à I'exécution du booloader est contrôlé
de manière logicielle via la ligne DTR de ia liaison série. Jusqu'à la version 5.8 dAVRdude, ce reset logiciel n'était pas pris en charge et 1a commande stty devait être utilisée avant avrdude pour modifier l'état de 1a ligne DTR. La clble
uptoad invoque ainsi stty puis avrdude. Avec les versions
récentes dAVRdude, le reset pris en charge par défaut et
stty ne sont plus nécessaires. Ce comportement est celui
d e la c i b l e ra w _ u p l o a d .
Bien entendu, si les options utilisées par défaut par
Arduino.mk pour 1a commande avrdude ne vous satisfont
pas, rlen ne vous empêche de composer la votre et d'ajouter
une clble, myupload, par exemple, ainsi que d'autres. Parmi
les choses intéressantes à propos de ce Makefile, nous
avons le fait que les sources C et C++ sont prises en charge
ainsi que les sources assembleurs (. s). De plus, vous pouvez
utiliser make clean pour nettoyer les sources. Encore une
fois, reportez-vous à I'article sur GNU Make pour améliorer
votre Makefile et ajouter des cibles permettant de
visuali-ser 1'état des fuses AVR, par exemple, ou d'afficher la taille
du code binaire obtenu avec avr-size -C suivi du nom du
fichier ELF. Exemple :
s t z e :
a v r - s i z e -C - -mcu=$ ( l i l C U ) b u i I d - c l i / $ ( T A R G E T ) . e l f
Ceci ajouté en fin de Makefile vous permettra de faire m a k e s i z e :
