Bienvenue sur l'espace de ressources et tutoriels des Conseillers Numériques de la Labomedia !
Vous pouvez également nous retrouver dans le monde non-numérique, les mercredis de 13H à 19H, au 108 rue de Bourgogne.
Skip to main content

Débuter l'électronique et la programmation avec l'Arduino

 

Le but de cet article est de vous familiariser avec l’utilisation de la carte Arduino. Il vous présente la carte, l’interface qui vous permet de le programmer, ainsi qu’une méthodologie qui vous permettra de créer de petits projets adaptables et modulables.

L’Arduino est une petite carte électronique conçue pour favoriser l’apprentissage des technologies électroniques et numériques. D’un prix abordable ( 1€ pour les premiers prix ), elle permet un usage polyvalent et notamment le prototypage d’un certain nombre de montages. Elle est très utilisée dans le domaine artistique du fait de sa facilité de manipulation.

arduino_board.jpgla carte Arduino

 

La carte est en fait entièrement basée sur un composant plus petit : l’ATMega. Cette puce est l’un des plus petits composants programmable. Il s’agit donc d’un microcontrôleur. L’utilisation de l’ATMega seule est assez fastidieuse : il faut, pour la programmer, savoir envoyer des informations électriques sur la bonne broche selon un protocole de communication compliqué… L’Arduino permet de faciliter la programmation de l’ATMega. En effet, un programme informatique a été conçu pour faire l’interface entre l’ATMega et l’utilisateur. De plus, les entrées/sorties de l’Arduino ont été conçues pour faciliter les câblages : aucune soudure n’est nécessaire. Enfin, un quartz a été ajouté à la carte afin de doter le circuit d’une horloge interne.

ATMega.jpgl’ATMega, un des plus petits composants programmables

 

Afin de pouvoir programmer l’Arduino, nous utilisons un IDE, c’est-à-dire un logiciel permettant de programmer le plus facilement possible. Celui-ci permet d’indiquer les instructions que l’on veut voir l’Arduino effectuer.

Vous pourrez le télécharger sur le site officiel de l’Arduino.

Pour programmer l’Arduino, un langage de programmation est utilisé. Nous allons voir comment celui-ci fonctionne. Vous pouvez, via le menu de l’IDE, ouvrir des fichiers d’exemples.

En ouvrant Fichier > Exemples > 01.Basics > BareMinimum, nous allons ouvrir le plus petit programme valide de l’Arduino, qui ressemble à ceci :

void setup() {
  // put your setup code here, to run once
}

void loop() {
  // put your main code here, to run repeatedly
}

Ce programme ne sert à rien ! Ce n’est en effet qu’un exemple afin de montrer les étapes que devra contenir votre code pour pouvoir fonctionner. Les phrases commençant par « // » ne sont d’ailleurs pas des phrases de codes. On les appelle des commentaires, elles sont destinées à l’humain, afin de lui fournir des indications sur le code. Pour l’Arduino, c’est comme si elles n’existaient pas.

Ce code contient deux fonctions vides. Nous ne nous attarderons pas longtemps sur cette notion, car ce n’est pas la plus fondamentale. On reconnaît une fonction dans l’IDE à cette forme-ci :

void nom_de_la_fonction() {

}

Une fonction commence par un mot indiquant le type de valeur qu’elle génère. Cette notion importe peu pour ce tutoriel, nous dirons donc simplement qu’ici, elle n’en génère aucune, c’est donc le mot ‘void’ qui la débute.

Vient ensuite le nom de la fonction, suivi de deux parenthèses. C’est en général le programmateur qui décide comment il doit l’appeler, sauf exception (que nous allons justement voir). Ensuite, une accolade est ouverte, puis, plus loin celle-ci est fermée. La fonction permet d’exécuter le code contenu dans ses accolades lorsqu’on utilise son nom. Autrement dit, au lieu de réécrire un long code à chaque fois, l’inclure dans une fonction permet d’utiliser le nom de la fonction à la place.

Nous sommes en fait ici en présence de deux fonctions spéciales. Celles-ci se nomment « setup » et « loop ». N’importe quel programme Arduino devra contenir ces deux fonctions spéciales pour pouvoir fonctionner.

La première, « setup », permet de préparer l’Arduino. Le code contenu entre ses accolades indiquera à l’Arduino dans quel état se mettre pour fonctionner correctement. Le code sera exécuté une seule fois, lors de l’allumage de l’Arduino.

La seconde, « loop », indiquera à l’Arduino quelle action il doit effectuer une fois que « setup » est fini. Loop signifie boucle en anglais : le code entre les accolades sera répété indéfiniment tant que l’Arduino est alimenté en électricité !

Laissons le code de côté pour l’instant pour nous intéresser à des questions bassement matérielles. Par essence, l’Arduino est un circuit électronique, et utilise donc du courant. Mieux encore, il nous permet en fait de manipuler le courant qui le traverse. Lorsque celui-ci est branché à l’ordinateur via un port USB, une LED s’allume, témoin de l’activité électrique interne de la carte.

Une caractéristique de ce courant nous intéresse tout particulièrement lorsque nous manipulons l’Arduino : il s’agit de la tension, mesurée en Volt. Lorsque l’Arduino est branché à l’ordinateur, le courant qui entre et sort de l’Arduino a une tension de 5V. Prenez garde si vous alimentez l’Arduino par une autre source qu’un ordinateur : si la tension est inférieure à 5V, il est possible que l’Arduino n’ait pas assez de puissance pour fonctionner. Cela n’est pas très grave. À l’inverse, une tension supérieure à 5V risque de détruire l’Arduino ! Prudence !

Nous voilà au cœur de l’utilisation de l’Arduino. Vous pouvez remarquer, des deux côtés de la carte, de petits trous permettant d’insérer des câbles. Il s’agit des entrées et sorties de l’Arduino, qui permettront de distribuer l’électricité en fonction du montage réalisé :

arduino_io.jpgles trous de l'Arduino

 

Chaque trou peut être utilisé en entrée ou en sortie, mais pas les deux à la fois. Il en existe deux types, qui permettent trois utilisations différences. Dans ce tutoriel, nous n’aborderons que l’utilisation la plus simple des trois.

Les entrées/sorties situées sur la droite de la carte, nommées 0 à 13, sont les plus simples à utiliser : elles obéissent à une logique binaire redoutable : soit il y a du courant, soit il n’ y en a pas ! On les appelles sorties (ou entrées) numériques ( en anglais digitals ). Deux états différents sont possibles, selon le diagramme suivant :

Arduino_Digital_Output.png

 

En rouge, vous pouvez voir la tension de la sortie. À gauche, elle est à zéro, c’est à dire qu’il n’y a pas de courant. À droite, il y a du courant, la tension est à 5V. Cette logique est la base du numérique.

Nous avons ici deux états possibles : tension basse ou tension haute, ce qui correspond à un bit d’information. Nous pouvons ainsi traduire cela en 0 ou 1. Ci-dessous un tableau d’équivalence :

Equivalence_bit.jpg

 

Bon, et en pratique ? Nous allons maintenant voir comment envoyer du courant dans une sortie digitale de l’Arduino. Pour cela, deux étapes sont nécessaires. D’abord, indiquer à l’Arduino que nous voulons utiliser la broche en sortie, puis demander à l’Arduino d’y activer le courant. En code, cela ce traduit comme suit :

void setup() {
  // Broche digitale 5 en sortie :
  pinMode( 5, OUTPUT );
  // Tension de 5V sur la broche 5 :
  digitalWrite( 5, HIGH ) ;
}

void loop() {
  // Pas besoin de boucle pour l’instant.
}

Comme vous pouvez l’imaginer, nous n’avons pas besoin de répéter ces instructions, une seule activation suffit : les instructions ont donc été codées dans la fonction « setup ».

Une fois votre code rédigé, deux étapes sont nécessaires pour mettre-à-jour l’Arduino.

Il est d’abord de bon ton de vérifier son code afin de repérer d’éventuelles erreurs. Il s’agit du bouton en haut à gauche de l’IDE :

check.jpg

 

Ensuite, on peut le téléverser à l’aide du bouton immédiatement à côté :

upload.jpg

 

S’il y a une erreur ( visible en bas de l’IDE ), il est probable que le mauvais port série ( c’est-à-dire le mauvais port USB ) soit sélectionné. Celui-ci devrait apparaître dans Outils > Port > Nom_du_port_série.

Revenons maintenant au code : nous trouvons ici deux nouvelles fonctions :

pinMode( numero_de_broche, état ); : permet d’indiquer à l’Arduino que la broche numero_de_broche ( 0, 1, 2, etc pour les broches digitales, A0, A1, etc pour les broches analogiques ) doit se comporter selon l’état demandé ( INPUT pour une broche en
entrée, OUTPUT pour une broche en sortie ).

digitalWrite( numero_de_broche, état ); permet de mettre la broche numero_de_broche dans l’état sélectionné si cette broche a été configurée comme sortie. L’état peut être LOW pour une tension de 0V, ou HIGH pour une tension de 5V.

Vous retrouverez l’ensemble des fonctions abordées à la fin de cet article. Celles-ci sont également disponibles dans la documentation du site officiel.

Ainsi, ce simple code permet d’indiquer à l’Arduino :

  • Tout d’abord, que nous souhaitons que la broche 5 soit utilisée comme un sortie.
  • Puis, que nous souhaitons que cette sortie ait une tension de 5V.

Ce que vous pourriez vérifier en reliant un voltmètre entre la broche 3 de l’Arduino et une de ses broches GND.

Comme vous pouvez vous en douter, pour désactiver la tension de la broche trois, il faut téléverser le code suivant :

void setup() {
  // Broche digitale 5 en sortie :
  pinMode( 5, OUTPUT );
  // Tension de 0V sur la broche 5 :
  digitalWrite( 5, LOW ) ;
}

void loop() {
  // Pas besoin de boucle pour l’instant.
}

 

C’est l’heure de notre premier montage, intitulé Clignotement, ou Blink, en anglais. Comme son nom l’indique, il s’agit tout simplement de faire clignoter une LED à l’aide de l’Arduino. Rien de bien compliqué.

Vous remarquerez que nous avons un peu fait les choses à l’envers, puisque l’Arduino est déjà presque configuré pour accepter le montage ! Peu importe, nous brancherons simplement les composants en ayant débranché l’alimentation de l’Arduino.

Voici le matériel dont nous aurons besoin :

  • un Arduino
  • une LED
  • une résistance de 220 ohms
  • une breadboard
  • des câbles pour Arduino

Présentons un peu ces composants :

L’Arduino : héhéhé, je plaisante.

La LED : acronyme de Light Emitting Diode ( ou diode émettrice de lumière ), un composant passif et polarisé émettant de la lumière. Attention, polarisé signifie qu’il ne peut pas se brancher dans les deux sens ! De tels composants ont deux pattes différentes : l’anode et la cathode, respectivement pôle positif et négatif. Sur la LED, sauf indication contraire, la branche la plus longue est l’anode, elle est donc située du côté de l’alimentation ( le côté positif, c’est-à-dire la broche de sortie ). La branche plus courte, la cathode, est située du côté de la terre ( sur l’Arduino, vers la
broche GND ).

La Résistance : la LED, grand bien lui en fasse, est un composant gourmand. Elle drainera ainsi la totalité du courant que vous lui enverrez. Malheureusement pour elle, c’est également un poids plume, et le courant de l’Arduino la fera griller si vous la branchez
telle quelle. Il vous faudra donc utiliser un composant nommé Résistance pour réguler le courant avant d’alimenter la LED. Les résistances n’ont pas toutes les mêmes valeurs. Exprimée en Ohm, celle-ci est indiquée par de petites bagues colorées sur le corps du composant. Nous avons ici besoin d’une résistance de 220 Ohms. Le code couleur correspondant est Rouge – Rouge – Marron. Une résistance de 440 Ohms fonctionnera également.

La Breadboard : en français planche à pain. Composant optionnel mais pratique, c’est un petit outil en plastique permettant de relier des composants entre eux plus facilement. Des trous reliés entre eux par une lamelle métallique permettent de créer des circuits électroniques sans avoir à effectuer de soudure. Attention à la connectivité !

Les câbles : en anglais wire jumper, de petits câbles prévus pour se connecter facilement à l’Arduino et aux Breadboards. Il en existe trois types, en fonction des formes des embouts : Femelle/Femelle, Mâle/Femelle et Mâle/Mâle. Ils sont généralement constitués
de cuivre et protégés par une gaîne isolante.

Pour rappel, avant de réaliser le montage suivant, veillez à déconnecter l’Arduino de l’ordinateur. Prendre un coup de jus ne serait pas douloureux à cette tension, mais vous risqueriez d’abîmer un composant en le branchement mal lorsque l’Arduino est alimenté.

Voici un schéma du montage, réalisé avec le logiciel Fritzing :

simpleblink.jpg

 

Une fois le montage réalisé, vous pouvez utiliser les deux bouts de codes ci-dessus pour allumer ou éteindre la LED.

Pour schématiser, la tension de 5V sort de la broche digitale n°5. Le courant est freiné par la résistance, ce qui baisse l’ampérage, soit la quantité d’électrons qui traverse le fil, pour éviter de griller la LED. Le courant rentre ensuite dans la LED par la patte positive, et une partie de ce courant est converti par la LED en lumière. Le courant restant est évacué par la broche GND de l’Arduino. Veuillez noter que cette description est en fait largement erronée, mais qu’elle correspond à une bonne manière de se représenter le fonctionnement du circuit lorsque l’on débute.

Voici le code qui permettra de faire clignoter la LED :

void setup() {
  // Broche digitale 5 en sortie :
  pinMode( 5, OUTPUT );
}

void loop() {
  // Tension de 5V sur la broche 5 :
  digitalWrite( 5, HIGH );
  // Attendre une demi-seconde :
  delay( 500 );
  // Tension de 0V sur la broche 5 :
  digitalWrite( 5, LOW );
  // Attendre une demi-seconde :
  delay( 500 );
}

Premièrement, une nouvelle fonction est utilisée ici :

delay( x ); met l’Arduino en pause pendant x millisecondes. x est exprimé en nombre entier ( integer ).

Ainsi, le code est relativement simple. Nous mettons la broche 5 en sortie, puis, par alternance d’une demi-seconde, nous activons et désactivons le courant. Je rappelle que le code contenu dans la fonction « loop » s’exécute en boucle une fois l’Arduino initialisé.

Nous allons maintenant aborder un concept important de la programmation : la déclaration de variable. Une variable, en informatique, est une information stockée dans la mémoire de l’ordinateur. La plupart du temps, on peut soit lire cette information, soit la modifier. Pour mieux comprendre ce que cela implique voyons comment créer une variable dans l’IDE Arduino. On appelle cette opération ‘déclarer une variable’ :

int ma_variable = 12;

Malgré son apparente simplicité, on peut identifier 5 instructions distinctes dans cette ligne de code.

Le premier mot, int, indique quel type de variable nous allons créer. Certains langages de programmation modernes ne demandent pas cette étape, mais ici, nous y sommes contraints. Plusieurs types de variables existent :

// Créer un nombre entier :
int nombre_entier = 12;
// Créer un nombre à virgule :
float nombre_a_virgule = 2.7;
// Créer une suite de caractères :
string mot = "blablabla";
// Créer une information binaire :
bool information_binaire = true;

La deuxième instruction, ma_variable, est le nom donné à cette information. Attention, il ne s’agit pas de l’information en elle-même ! Il s’agit d’une sorte d’adresse, immuable, qui permet de se référer à son contenu.

Le signe « = », en langage informatique, permet d’assigner un contenu à un nom de variable.

La quatrième instruction est l’information elle-même, celle qui est stockée et sera manipulée au cours du programme. Ici, nous avons donc un mot « ma_variable » qui fait référence à l’information « 12 », et qui est un nombre entier.

Enfin, le « ; » permet d’indiquer la fin de l’instruction. Si vous l’omettez, le programme ne fonctionne tout simplement pas.

Voici une mise-à-jour du code de clignotement utilisant à bon escient les variables :

int broche_de_la_led = 5;
int temps_entre_les_clignotements = 500;

void setup() {
  // Broche digitale 5 en sortie
  pinMode( broche_de_la_led, OUTPUT );
}

void loop() {
  // Tension de 5V sur la broche 5
  digitalWrite( broche_de_la_led, HIGH );
  // Attendre une demi-seconde :
  delay( temps_entre_les_clignotements );
  // Tension de 0V sur la broche 5
  digitalWrite( broche_de_la_led, LOW );
  // Attendre une demi-seconde :
  delay( temps_entre_les_clignotements );
}

 

Les variables, utilisées partout dans le programme et pouvant varier, sont déclarées en tout premier.

Comme vous pouvez le voir, l’utilisation de variables permet d’être plus modulaire dans la programmation. Nous faisons référence à nos paramètres dans les fonctions en utilisant les noms des variables. Ainsi, il n’y a plus qu’une seule valeur à modifier si nous voulons faire clignoter la LED à une fréquence différente, ou si nous voulons changer la broche sur laquelle elle est connectée : la valeur stockée dans la variable, en haut du programme.

Le code ci-dessus est dit paramétrique. Cela veut dire qu’il est constitué en deux parties :

En premier, les différents paramètres ( temps entre les clignotement et broche de la LED ) sont stockés dans des variables. Il n’y a que des déclarations de variable dans cette première partie.

Ensuite, l’algorithme est programmé. Ici, il est constitué des fonctions « setup » et « loop ». Cet algorithme ne contient que des invariants, c’est-à-dire qu’aucune modification n’est nécessaire à cette partie du code pour qu’il continue de fonctionner si l’on change uniquement ses valeurs (et non sa structure).

En d’autres termes, une fois l’algorithme rédigé, il n’y a plus qu’à changer les valeurs des variables en début de programme pour l’adapter à une situation donnée.

 

Voici qui conclut la présentation de l’Arduino. Malgré tout, les concepts abordés ne sont pas si évidents que ça, n’hésitez pas à prendre votre temps et à relire l’article si besoin.

Pour aller plus loin, je vous propose un challenge : à l’aide d’une nouvelle variable, et du fait qu’il est possible d’augmenter la valeur quelle contient en utilisant cette ligne de code :

mon_nombre_entier = mon_nombre_entier + 1;

sauriez-vous faire clignoter la LED sur un intervalle de temps de plus en plus grand ?

Amusez-vous bien !

 

Les fonctions abordées dans cet article :

pinMode( numero_de_broche, état ); : permet d’indiquer à l’Arduino que la broche numero_de_broche ( 0, 1, 2, etc pour les broches digitales, A0, A1, etc pour les broches analogiques ) doit se comporter selon l’état demandé ( INPUT pour une broche en
entrée, OUTPUT pour une broche en sortie ).

digitalWrite( numero_de_broche, état ); permet de mettre la broche numero_de_broche dans l’état sélectionné si cette broche a été configurée comme sortie. L’état peut être LOW pour une tension de 0V, ou HIGH pour une tension de 5V.

delay( x ); met l’Arduino en pause pendant x millisecondes. x est exprimé en nombre entier ( integer ).

Back to top