Vous êtes sur la page 1sur 16

Base de programmation et entrées/sorties

Accueil  »  Arduino  »  Bases  »  Base de programmation et entrées/sorties

 30/11/2013  Sébastien Sougnez

Introduction
Dans les articles précédents, nous avons vu ce qu'était l'Arduino, de quoi elle était composée et les outils
à installer pour pouvoir développer des programmes électroniques compatibles. Maintenant que nous
avons toutes ces informations, nous allons voir comment utiliser les broches d'entrée et de sortie de
l'Arduino. Ces broches permettent à  l'Arduino  d'envoyer des données à vos programmes mais c'est
également celles-ci qui permettent  à vos programmes d'envoyer des impulsions électriques vers vos
circuits afin d'en modifier le comportement.

Signal analogique vs signal digital


Avant de parler des entrées/sorties de l'Arduino, il est important d'avoir une idée de la différence entre un
signal analogique et un signal digital car l'Arduino  possède aussi bien des entrées/sorties digitales
qu'analogiques, il est donc important de savoir quand utiliser les unes et quand utiliser les autres. Nous
n'allons évidemment pas rentrer dans les détails car ce n'est pas le sujet de cet article.
Un signal analogique est un signal pouvant être représenté  par un intervalle de valeur relativement
grand. Vous avez par exemple la luminosité de l'écran de votre "smartphone" qui peut être représentée
par une valeur allant de 0 à 100%.
Un signal digital, ou numérique, au contraire, est un signal pouvant être représenté par un intervalle de
valeur extrêmement restreint. Par exemple, vous avez l'état de la l'éclairage chez vous: vos lampes sont
soit allumées (1) ou éteintes (0).
La différence entre l'analogique et le numérique réside donc dans l'intervalle de valeurs acceptées pour
représenter un signal. Bien entendu, ceci est très simplifié, mais vous n'avez pas besoin d'en savoir plus
actuellement pour comprendre la suite de cet article.

Structure d'un programme Arduino


Un peu de patience, nous y arrivons... Cependant, nous ne pouvons pas foncer tête baissée vers les
explications des entrées/sorties sans même voir la structure basique d'un programme  Arduino. Tout
d'abord, nous tenons à préciser que la série d'articles Arduino de ce site ont pour but de vous apprendre à
développer des programmes électroniques. Dans le cas de l'Arduino, le langage utilisé est le C++, nous ne
pouvons cependant pas vous expliquer toute la programmation en C++, nous ne nous pencherons donc
que sur les fonctions et structures spécifiques au développement  Arduino. Pour ce qui est de
l'apprentissage du  C++, je vous propose de faire un tour du côté d'Amazon  pour trouver un livre
correspondant à vos attentes.
Lorsque vous créez un programme, vous devez respecter une structure définie par deux fonctions
importantes : "setup" et "loop". Voici à quoi ressemblerait donc le code minimal pouvant être compilé par
le programme Arduino :
 
void setup() 

   

 
void loop() 

   
}

Lorsque le "bootloader" du microcontrôleur de l'Arduino va exécuter votre programme, c'est la fonction


"setup" qui sera le point d'entrée de ce dernier. Cette méthode est en fait l'équivalent de la méthode
"main" dans une application console, c'est le point d'entrée de votre programme. C'est par exemple dans
cette méthode que vous définirez si une broche de l'Arduino est utilisée en tant qu'entrée ou en tant que
sortie. Bien entendu, vous pouvez faire absolument tout ce que vous voulez dans cette méthode, mais
l'important est de savoir qu'une fois votre programme lancé, celle-ci sera exécutée une fois et c'est tout.
En effet, une fois la méthode "setup" exécutée, c'est la méthode "loop" qui l'est. La différence entre ces
deux méthodes est que la méthode "loop" ne sera pas executée qu'une seule fois, mais un nombre
"inifini" de fois. Infini étant forcément influencé par un problème quelconque (panne de courant coupant
l'alimentation de votre carte, un bug dans votre programme, l'appui sur le bouton "reset" de
votre Arduino, etc...). 
L'exécution d'un programme  Arduino  commence donc par un appel à la fonction "setup" et se
poursuit par un appel infini à la fonction "loop".

Les entrées/sorties digitales


L'Arduino UNO  possède 14 broches d'entrée/sortie digitale, cependant, la "0" et la "1" étant reliées
aux  LED  internes  RX  et  TX, nous vous déconseillons fortement de les utiliser. Si vous regardez
votre  Arduino, vous remarquerez que ces broches sont numérotées et que certaines d'entre elles sont
précédées du signe "~". Cela signifique que ces broches peuvent émettre un signal "PWM" équivalent à un
signal analogique (nous verrons comment cela fonctionne un peu plus loin). Comme nous l'avons vu
précédemment, ces différentes broches vont permettre d'émettre un signal digital égal à "0" ou à "1".
Dans le cadre de la programmation Arduino, nous parlerons plutôt de HIGH (1) et LOW (0).
Pour illustrer cela, nous allons faire un circuit extrêmement simple permettant d'allumer une LED et de
l'éteindre toutes les 2 secondes. Nous allons tout d'abord vous expliquer comment réaliser ce circuit,
vous donner le code du programme et enfin, nous fournirons une vidéo vous permettant de suivre le
montage "en direct" au cas où votre circuit ne fonctionnerait pas comme prévu.

Le circuit

Notre circuit est le suivant :


Nous branchons donc une  LED  dans notre "breadboard" et relions son anode à la broche "GND"
(représentant la masse) de l'Arduino et sa cathode à une résistance 220 ohms que nous relions enfin à la
broche "8". Nous avons utiliser la loi d'Ohm pour déterminer la valeur de la résistance. Pour rappel, nous
devons utiliser le "forward voltage" de la LED afin de pouvoir calculer la valeur de la résistance. Celui-ci
étant de 2 volts, nous pouvons appliquer la loi d'Ohm pour trouver la valeur de la résistance à appliquer
pour obtenir une intensité de 20 mA ("forward current") :
 
5−2
R= 0,02
R=5−20,02

R = 150Ω R=150Ω

Nous soustrayons ici le "forward voltage" à "5" car c'est la tension qui sera délivrée par la broche "8" de
l'Arduino. Pour plus d'informations sur la loi d'Ohm et sur la façon de calculer la résistance à appliquer
pour une ou plusieurs LED, nous vous conseillons de lire cet article (si vous connaissez déjà la loi d'Ohm,
vous pouvez vous rendre dans le bas de l'article à la section "informations complémentaires" pour avoir
plus d'informations sur l'utilisation de cette loi pour l'utilisation de LED).
Nous allons maintenant passer au programme permettant d'allumer et d'éteindre cette  LED  toutes les
deux secondes.

Le programme

Le code de notre programme est le suivant :


 

char pinLed = 8; 
boolean ledState = LOW; 
 
void setup() 

  pinMode(pinLed, OUTPUT);   
  digitalWrite(pinLed, LOW); 

 
void loop() 

  ledState = ledState == LOW ? HIGH : LOW; 
  digitalWrite(pinLed, ledState); 
   
  delay(2000); 
}

Tout d'abord, nous déclarons une variable de type "char" permettant de contenir l'identifiant de  la
broche que notre programme va utiliser. Nous aurions pu stocker cette valeur dans un entier ("int"), mais
une chose importante à prendre en compte dans la programmation Arduino, c'est que cette dernière n'a
pas une mémoire de 16 Go comme votre ordinateur, il est donc nécessaire d'utiliser le moins de mémoire
possible dans vos programmes. Nous avons également déclaré une variable booléenne qui permettra de
retenir l'état actuel de la LED (allumée ou éteinte). Par défaut, nous définissons cette variable à "LOW",
nous allons voir dans quelques phrases ce que cela signifie.
Ensuite, via la méthode "setup", nous indiquons que la  broche  identifiée  par notre variable
sera configurée en tant que broche de sortie. Cette configuration se fait à l'aide de la méthode "pinMode".
Celle-ci attend comme premier paramètre le numéro de la broche à configurer, nous utilisons donc la
valeur de notre variable pour ce paramètre. Comme vous vous en doutez, si nous faisons passer "8"
comme premier paramètre à cette méthode, c'est que nous voulons configurer la broche numérotée "8"
sur votre Arduino. Le deuxième paramètre de cette méthode permet de savoir si cette broche permettra
de lire des données "INPUT" ou d'en envoyer "OUTPUT". En l'occurrence, nous utilisons "OUTPUT" car la
broche va devoir envoyer un signal pour allumer ou éteindre la LED. Nous utilisons également la méthode
"digitalWrite" pour indiquer que la LED devra être éteinte lors du démarrage du programme. De la même
manière que "pinMode", la fonction "digitalWrite" attend comme premier paramètre l'idenfiant de la
broche sur laquelle nous voulons envoyer (ou non) un signal électrique. Ce signal électrique est, quant à
lui, indiqué dans le deuxième paramètre de cette méthode et peut prendre deux valeurs : "LOW" pour
n'envoyer aucun signal (la tension sera donc de 0 volt) ou "HIGH" pour envoyer un signal (la tension sera
donc de 5 volts). Nous l'avons vu, le signal étant digital, nous n'envoyons que deux valeurs différentes.
Nous verrons cependant que nous pouvons envoyer plus de signaux différents dans le cas des broches
"PWM".
Enfin, la fonction "loop" va permettre d'allumer ou d'éteindre la LED toutes les deux secondes. Pour ce
faire, nous utilisons simplement la fonction "digitalWrite" comme précédemment. Bien entendu, avant,
nous devons définir si nous allons allumer ou éteindre la LED, nous faisons donc cela en plaçant dans
"ledState" la valeur opposée à celle que cette variable contient déjà. Nous faisons ensuite passer cette
variable à la méthode "digitalWrite" pour allumer ou éteindre la LED. Pour finir, nous utilisons la méthode
"delay" qui, comme nous le verrons dans un autre article, permet "d'endormir" le programme pendant le
nombre de millisecondes passé en paramètre. En passant "2000", nous mettons donc notre programme
en pause pendant 2 secondes.
Et voilà, il ne vous reste plus qu'à connecter votre Arduino à votre pc et transférer le programme sur celle-
ci, normalement, votre LED devrait s'allumer et s'éteindre toutes les 2 secondes. Si ce n'est pas le cas,
regardez la vidéo suivante pour voir où votre erreur se situe.

Vidéo

Impossible de charger le plug­in.

Amélioration du circuit

Maintenant que nous avons vu comment configurer et utiliser une broche de l'Arduino  en sortie, nous
allons voir comment les utiliser en entrée. Pour cela, nous allons légéremment modifier le circuit
précédent en y ajoutant un bouton qui permettra d'allumer la LED lorsqu'il est enfoncé. Bien entendu, il
serait tout à fait possible de faire cela sans Arduino, mais l'intêret ici est surtout de montrer comment lire
une information sur une broche de celle-ci. Le schéma de notre circuit est donc le suivant :
En ce qui concerne la  LED, le schéma n'a pas changé, nous avons juste ajouter un bouton poussoir à
gauche. Comme nous devons alimenter celui-ci, nous relions ce bouton à la broche nommée "5V" sur
l'Arduino. Cette broche permet simplement d'envoyer un signal continu possédant une tension  de  5
volts. Pour être précis, nous avons connecté cette broche à la "ligne positive" du "breaboard" que nous
avons connectée avec notre bouton. Nous relions ensuite la sortie de ce bouton à la broche "12" de
l'Arduino. Enfin, nous plaçons une résistance  1 Kohm  derrière le fil reliant le bouton à la broche "12".
Ce type de résistance est nommé "résistance de rappel" et est très utilisé en électronique. Nous n'allons
pas rentrer dans les détails, mais sachez qu'autour de nous se trouve ce que l'on appelle du "bruit
électromagnétique". Pour faire simple, c'est une sorte de de champ électromagnétique pouvant créer une
tension dans votre "breadboard". Si vous ne placiez pas cette résistance, le bruit rentrerait dans le fil
reliant votre "breadboard" à la broche "12" et donnerait l'impression à votre programme que le bouton a
été enfoncé alors qu'il ne l'est pas. Grâce à cette résistance, ce bruit est neutralisé (nous verrons dans un
autre article comment cela fonctionne et j'incluerai le lien vers celui-ci lorsqu'il sera rédigé).
Le principe va être relativement simple : tant que ce bouton n'est pas appuyé, la tension de la broche "8"
sera de 0 volt. Par contre, si le bouton est enfoncé, nous enverrons une tension de 5 volts sur cette même
broche pour allumer la LED.

Le programme
Modifiez le code précédent de cette façon :
 

char pinLed = 8; 
char pinButton = 12; 
 
void setup() 

  pinMode(pinLed, OUTPUT); 
  pinMode(pinButton, INPUT); 
   
  digitalWrite(pinLed, LOW); 

 
void loop() 

  boolean buttonState = digitalRead(pinButton); 
  digitalWrite(pinLed, buttonState); 
}

Nous déclarons cette fois deux variables : "pinLed", toujours pour contenir l'identifiant de la broche à
laquelle la LED est reliée et "pinButton" contenant le numéro de la broche à laquelle le bouton est relié.
Dans la fonction "setup", nous définissons toujours la broche "8" comme étant une broche de sortie, mais
nous définissons la broche "12" comme étant une broche d'entrée. Pour ce faire, nous utilisons
simplement la fonction "pinMode" de la même manière que pour la broche liée à la LED sauf que nous
indiquons que cette broche sera une entrée ("INPUT").
Enfin, dans la fonction "loop", nous commeçons par récupérer l'état du bouton. En fait, nous utilisons la
méthode "digitalRead" pour voir si une tension est appliquée à la broche ou non. Si c'est le cas, la valeur
renvoyée sera "HIGH", dans le cas contraire, elle vaudra "LOW". Etant donné que nous devons allumer
la LED ("HIGH") lorsque le bouton est enfoncé ("HIGH"), il suffit de faire passer la valeur lue en paramètre à
la fonction "digitalWrite" pour allumer ou éteindre la LED en fonction de l'état du bouton.

Vidéo

Impossible de charger le plug­in.
Les entrées analogues
Bien que certains composants peuvent fonctionner correctement avec des signaux digitaux, il existe
certains composants qui ne pourraient pas fonctionner si les seuls signaux qu'ils pouvaient envoyer ou
recevoir étaient soit "HIGH" soit "LOW", tout ou rien. Ces différents composants fonctionnent donc avec
des signaux analogiques permettant de représenter  des valeurs  contenues dans un intervalle plus
important. Nous allons voir cela avec un composant appelé "temperature sensor" permettant de donner
la température ambiante. Ce dernier renvoie des signaux analogiques dont la valeur varie de "0" à "1023".
Penchons-nous d'abord sur le circuit que nous allons mettre en place.

Le circuit

Le circuit utilisé est le suivant :

Dans ce circuit, nous utilisons le modèle "TMP36" du  composant nommé "temperature sensor".
L'utilisation de ce composant est assez simple, nous devons envoyer une tension sur la branche de
gauche et cette tension ressort sur la branche du milieu avec une valeur dépendant de la température. La
dernière branche de ce composant doit être reliée à la masse de l'Arduino. S'il vous arrive d'oublier à quoi
correspondent les différentes branches, nous vous conseille de regarder le schéma suivant présent dans
le "datasheet" fourni précédemment :

Faites bien attention au côté arrondi de ce dessin car il correspond au côté arrondi de votre composant.
La branche "1" (celle de gauche) correspond donc à  VS VS, la tension d'entrée. La branche "2" (celle du
milieu) correspond à  VOUT VOUT, la tension de sortie définissant la température. Enfin, la branche "3"
(celle de droite) correspond à la masse ("GND"). Regardons maintenant le programme utilisé par ce
circuit.

Le programme

Le programme utilisé est le suivant :


 

char sensorPin = A0; 
 
float GetTemperature(char pin) 

  float sensorValue = (analogRead(pin) / 1024.0) * 5.0; 
 
  return (sensorValue ‐ 0.5) * 100; 

 
void setup() 

  Serial.begin(9600); 
  pinMode(sensorPin, INPUT); 

 
void loop() 

  Serial.println(GetTemperature(sensorPin)); 
   
  delay(5); 
}

Nous commeçons tout d'abord par créer une variable contenant l'identifiant de la broche analogique
utilisée ("A0"). Nous déclarons également une méthode permettant de traduire la tension reçue sur cette
broche en température (degré celsius). Nous n'expliquerons pas ici ce calcul car cela fera partie d'un autre
article. Dans la fonction "setup", nous commeçons par ouvrir une voie de communication sur le port 9600.
Ceci permet en fait de faire communiquer l'ordinateur  et l'Arduino  (nous verrons un peu plus tard
comment en tirer profit). Ensuite, nous définissons que la broche "A0" est une broche d'entrée. Enfin,
dans la fonction "loop", nous imprimons un message sur la voie de communication ouverte
précédemment grâce à la fonction "println". La valeur imprimée est celle renvoyée par la fonction
"GetTemperature". Celle-ci prend en paramètre l'identifiant de la broche sur laquelle la température doit
être lue, la convertit en degré et renvoie le résultat. La valeur imprimée correspond donc à la température
ambiante.
Pour voir cette valeur en question, uploadez le programme sur votre Arduino et pressez "Ctrl + Maj + M"
pour afficher la fenêtre de communication. Dans cette fenêtre, vous devriez obtenir quelque chose
comme ceci, dépendamment de la température de la pièce dans laquelle vous vous trouvez :

Bien que ces broches analogiques fonctionnent très bien, elles ne peuvent pas être utilisées pour envoyer
des données analogiques, cela doit être fait grâce aux broches "PWM".

PWM
Comme nous venons de le voir, il semblerait que l'Arduino  ne possède pas de sorties analogiques,
effectivement, les broches "A0" à "A5" sont des entrées et non des sorties analogues. A vrai dire,
l'Arduino possède bel et bien des sorties analogiques mais celles-ci ne se trouvent pas au même entrées
que les entrées, effectivement, elles se trouvent au même endroit  que les entrées/sorties digitales.
Cependant, il est important de comprendre que toutes les broches digitales peuvent envoyer des signaux
digitaux, mais certaines d'entre elles peuvent également envoyer des signaux analogiques. Ces broches
sont reconnaissables sur l'Arduino  grâce au symbole "~" présent à gauche du nombre identifiant la
broche.
"PWM" signifie "pulse width modification", ou en français "modulation de largeur d'impulsion" et consiste
en une technologie permettant de transformer des signaux digitaux en signaux analogiques. Voyons un
peu comment cela fonctionne... Lorsque vous branchez un composant à une broche digitale de l'Arduino,
deux sortes de signaux peuvent être envoyés : "HIGH" ou "LOW". D'un point de vue graphique, ces deux
valeurs pourraient se représenter comme ceci en ce qui concerne "HIGH" :

Et comme ceci pour "LOW" :

Sur ces deux graphiques, la ligne rouge représente la valeur du signal (inexistant dans le cas de "LOW")
alors que les lignes grises représentent des cycles. Un cycle est une période de temps, donc ici, c'est une
période de temps pendant laquelle le signal vaudra une certaine valeur. Ces deux graphiques
représentent des signaux  digitaux car la valeur  représentée  est soit "LOW", soit "HIGH". Imaginons
maintenant que nous soyons en mesure de faire ceci :
Nous envoyons donc une valeur "HIGH" un cycle sur deux (la valeur pendant l'autre cycle étant "LOW").
Bien sur, si nous imaginons qu'un cycle vaut dix secondes, cela ne changerait pas grand chose, nous
obtiendrons une valeur "HIGH" pendant dix secondes et une valeur "LOW" pendant dix autres secondes.
Par contre, si nous imaginons que les cycles représentent une période de temps extrêmement petite, le
signal donnera l'impression d'être le suivant :

Nous obtenons donc une valeur intermédiaire pour notre signal digital, le transformant ainsi en signal
analogique. Nous ne disons pas cela car nous sommes passé d'un intervalle de deux valeurs à un
intervalle de trois valeurs mais bien parce qu'il est possible de faire varier le signal entre "HIGH" et "LOW"
comme nous le voulons, il suffit de réduire ou d'augmenter le nombre de cycles pendant lesquels la
valeur sera "HIGH" :

Nous allons maintenant voir comment tirer profit de ces broches "PWM" pour envoyer des signaux
analogiques vers une LED "RGB" : 
Ce type de LED est en fait constitué de trois petites LED de couleurs différentes (rouge, verte et bleue). La
manière d'utiliser ce composant consiste à envoyer des valeurs contenues entre "0" et "256" sur les
branches correspondant à une des LED de lumière. La branche la plus longue de cette LED correspond à la
cathode, la branche à sa gauche correspond à la LED rouge, celle à sa droite correspond à la LED bleue et
enfin, la branche à l'extrême droite correspond à la LED verte. Nous allons donc utiliser cette LED  pour
créer le circuit suivant.

Le circuit
Nous branchons donc notre "RGB LED" dans le "breadboard" et relions sa cathode à la masse de
l'Arduino. Nous relions ensuite les différentes branches de la LED à des résistances réliées elles-même aux
sorties "PWM" "9", "10" et "11" de l'Arduino. Si vous jetez un oeil du côté de la "datasheet" de ce
composant, vous remarquerez que bien que les trois LED (rouge, verte et bleue) requièrent une intensité
de  20 mA  ("forward current"), elles ne produisent pas toutes la même chute de tension ("forward
voltage"). Effectivement, la LED rouge produit une chute de tension d'approximativement 2 volts  alors
que les deux autres branches produisent une chute de tension d'approximativement 3,2 volts. Grâce à
ces chiffres et la loi d'Ohm, il est simple de calculer les résistances à utiliser :

5−2
R rouge = 0,02
Rrouge=5−20,02
3
R rouge = 0,02
Rrouge=30,02

R rouge = 150Ω Rrouge=150Ω


 

5−3,2
=
5−3,2
R bleueetverte = 0,02
Rbleueetverte=5−3,20,02
1,8
R bleueetverte = 0,02
Rbleueetverte=1,80,02

R bleueetverte = 90Ω Rbleueetverte=90Ω

Comme il est toujours préférable de prendre des résistances plus élevées que celles calculées lorsque l'on
ne possède pas la résistance exacte, nous utilisons une résistance de 220 Ohms pour la LED rouge et deux
résistances de 100 Ohms pour les deux autres LED.

Le programme

Le programme utilisé par notre circuit est le suivant :


 

char pinGreen = 9; 
char pinBlue = 10; 
char pinRed = 11; 
 
void setup() 

  pinMode(pinRed, OUTPUT); 
  pinMode(pinBlue, OUTPUT); 
  pinMode(pinGreen, OUTPUT); 
   
  analogWrite(pinRed, LOW); 
  analogWrite(pinBlue, LOW); 
  analogWrite(pinGreen, LOW); 

 
void loop() 

  analogWrite(pinGreen, random(0, 256)); 
  analogWrite(pinBlue, random(0, 256)); 
  analogWrite(pinRed, random(0, 256)); 
   
  delay(200); 
}

Il y a un peu plus de lignes de code que précédemment mais au final, c'est souvent 3 fois la même ligne
qui se répète. Effectivement, nous commençons par créer trois variables permettant  de contenir les
identifiants des broches que nous utilisons. Nous employons ensuite la fonction "setup" pour configurer
ces broches en tant que broches de sortie ("OUTPUT") et nous indiquons qu'au démarrage du
programme, la tension dans ces broches devra être de 0 volt. Enfin, nous utilisons la fonction "loop" pour
envoyer sur ces trois broches des valeurs aléatoires comprises entre "0" et "256". Nous mettons
également le programme en pause pendant 200 millisecondes.
L'exécution de ce programme devrait produire un effet similaire à celui présenté dans la vidéo ci-dessous.

Vidéo
Impossible de charger le plug­in.

Conclusion
Maintenant que vous connaissez les bases de la programmation  Arduino  et que vous savez comment
utiliser les broches d'entrées/sorties digitales, analogiques et "PWM", nous allons pouvoir passer à l'étude
de composants électroniques et voir comment les utiliser avec l'Arduino. Nous verrons également dans la
partie "développement" les fonctions spéciales liées à l'Arduino telles que "delay", "millis", etc...

Vous aimerez peut-être aussi