LES BASES DE LA

PROGRAMMATION SUR ARDUINO

Introduction
Arduino est un constructeur de cartes électroniques matériellement libres (les plans et les
schémas des cartes sont disponibles gratuitement, vous pouvez même en fabriquer une
vous-même), sur lesquelles se trouve un microcontrôleur programmable. Le but d’un
projet à base d'Arduino est de programmer celui-ci pour qu’il analyse et qu’il produise des
signaux électriques. Tout simplement. Vous pouvez par exemple brancher toutes sortes
de capteurs sur les entrées (capteurs de température, capteur capacitif, capteur de
lumière..) et définir l’état des sorties en fonction de l’état des entrées (par exemple
allumer une lampe quand on appuie sur un bouton, activer un moteur en fonction d’un
capteur de lumière etc…) Vous l’aurez compris, une carte Arduino est souvent utilisée
pour automatiser ou simplifier des processus. Les Arduino sont de ce fait souvent utilisés
pour faire de la domotique.
Voici comme exemple la carte Arduino Due :

Les cartes Arduino sont donc des microcontrôleurs, possèdant un nombre

d'entrées/sorties variables en fonction des modèles. Pour les broches numériques par
exemple (à droite sur le schéma), on peut définir chacunes des broches comme une
entrées ou comme une sortie dans notre programme en fonction de ce qu'on a besoin.
Chaque broche est reconnu par le logiciel grâce à un numéro unique. On pourra donc, en
fonction de ce qu'on a définit dans le programme, utiliser chacune des broches soit pour
envoyer un signal électrique, soit pour analyser la présence celui-ci sur ladite broche.
Dans cet article, une bref présentation des cartes sera faite, suivie d'une partie
informatique uniquement.

Les différentes cartes :

La première chose à savoir avant de se lancer, c’est le type de carte nécessaire en
fonction de l’utilisation qu’on souhaite en faire. En effet, il existe une multitude de cartes
Arduino différentes, toutes faites pour une plage d’utilisation spécifique. Voici les
catégories principales, ainsi que les cartes les plus utilisées dans chacune de ces
catégories (pour avoir la liste complète des cartes et faire un choix plus précis, le mieux
est d’aller se renseigner sur le site officiel Arduino, ou sur les nombreux forums qui
existent à ce sujet).

Cartes pour débuter

Si vous débutez dans le monde de l'Arduino, voici une petite liste des cartes les plus
utilisées :
1. Arduino Uno : la carte "Uno" est la meilleure carte pour commencer. Elle possède
14 entrées sorties digitales et 6 entrées analogiques. Elle est facile d'utilisation et
a un très bon rapport qualité/prix.
2. Arduino Micro : cette carte est la plus petite de la marque. Elle est très utile pour
faire des projets qui nécessitent d’avoir un microcontrôleur de petite taille, et
malgré celle-ci, cette carte possède plus d’entrées/sorties que la carte Uno.
3. Arduino Mini : la carte "Mini" a les mêmes caractéristique que la carte "Uno", mais
est proposé dans un format plus petit. Elle est donc très utilisée dans des projets
qui nécessitent un encombrement minimal tout en gardant un nombre
d'entrées/sorties raisonnable.

Cartes pour des projets complexes

Il existe aussi d'autres cartes qui peuvent être utilisées lors de projets qui nécessitent un
nombre plus important d'entrées/sorties ou une puissance plus élevée. En voici quelques-
unes :
1. Arduino Mega : cette carte est l'une des cartes possédant le plus de connecteurs
(54 entrées/sorties numériques et 16 entrées analogiques).
2. Arduino Zero : la carte "Zero" possède un peu plus d'entrées/sorties que les cartes
basiques vues au-dessus. Elle est donc utilisée dans les projets qui nécessitent
d'avoir plus d'éléments à gérer sans pour autant avoir besoin d'une puissance plus
accrue.
3. Arduino Due : la carte "Due" présente exactement les mêmes caractéristiques que
la carte Mega, sauf que celle-ci possède en plus deux sorties analogiques. Cette
 carte est donc indispensable s'il vous est nécessaire de générer des signaux qui
ne sont pas continus.

Cartes avec accès internet

Pour certaine utilisation, il est très utile de pouvoir récupérer des informations ou de
commander notre microcontrôleur à distance (surtout en domotique). Voici quelques
contrôleurs qui intègrent des cartes réseaux :
1. Arduino MKR1000 : cette carte est un puissant contrôleur qui possède les mêmes
caractéristiques que la carte "Zero", avec la fonctionnalité Wi-Fi en plus.
2. Arduino Ethernet : elle possède les mêmes carctéristiques que la carte Uno, avec
une carte ethernet intégrée.

Cartes pour textiles :

Ces cartes ont étés spécialement conçues dans le but d’intégrer de l’électronique dans
des vêtements ou autres objets portatifs.
1. Arduino Gemma : la carte Gemma est une carte miniature, qui se présente sous la
forme d’un cercle, et qui est faite pour être portée. Du fait de sa petite taille, elle
possède seulement 3 entrées/sorties numériques et une entrée analogique.
2. Lilypad Arduino : cette carte se présente comme la carte Gemma, en un peu plus
imposante, et avec des fonctionnalités en plus : 14 entrées/sorties numériques et
6 entrées analogiques. La forme circulaire est conservée par rapport à sa
prédécétrice.
Il existe évidemment encore beaucoup d'autre microcontrôlleurs, certains fait pour le jeux,
d'autres possédant un processeur intel pour avoir plus de puissance, etc.

Programmation
La langage de programmation Arduino est basé sur les langages C et C++. Si vous
connaissez déjà ceux-ci, vous n'aurez aucun mal à vous familiariser avec l'environnement
Arduino.
Si vous débutez, il est préférable d’utiliser le logiciel officiel Arduino. Il est téléchargeable
gratuitement sur internet (à cette adresse : https://www.arduino.cc/en/Main/Software ).
Sachez néanmoins qu’il existe de nombreuses alternatives viables pour programmer votre
Arduino depuis un autre logiciel.

Création du projet
Une fois le logiciel téléchargé et installé, vous pouvez créer votre premier projet. Il suffit
simplement de cliquer sur Fichier, puis sur Nouveau, ou utiliser le raccourci clavier ctrl+N.
A la création d'un projet, voici ce qu'on obtient :
On peut remarquer que deux fonctions se génèrent automatiquement. Voici leurs utilités :
- Setup() : la fonction setup est une fonction qui s’exécute une seule fois à chaque
démarrage du programme. C’est dans cette fonction qu’on initialise les variables, qu’on
définit la fonction de chaque broche (entrée ou sortie), l’initialisation de l’état des sorties,
des fonctions d’initialisation personnalisées ou tout autre partie de code que l'on souhaite
exécuter qu’une seule fois.
- Loop() : la fonction loop est la fonction principale de l’Arduino : une fois la fonction setup
exécutée, la fonction loop s’exécutera et se répètera à l’infini.
Le logiciel est très simple d’utilisation. Dans la barre d’icônes (visible en haut sur l’image
précédente), on peut voir cinq boutons en haut à gauche. Le premier (vérifier) sert à
compiler le code et vérifier qu’il n’y a pas d’erreurs dans celui-ci. Le deuxième
(téléverser) sert à envoyer le programme sur l’Arduino pour que celui-ci l’exécute. Les
trois icônes restants servent à créer (nouveau), ouvrir ou enregistrer un projet.
L’icône en haut à droite sert à ouvrir le moniteur série. L’utilisation de celui-ci sera
détaillée plus loin.
Une autre chose très importante à savoir, c’est que lorsque l’on connecte une carte en
USB, il faut aller dans le menu « outils » et sélectionner le type de carte sur laquelle on
veut transférer notre projet ainsi que le port COM sur lequel l’Arduino est branché. Il est
nécessaire de faire cette manipulation à chaque fois pour que la carte soit reconnue par
le logiciel Arduino et que le téléversement se fasse correctement. Si le type de notre
carte n’existe pas dans le logiciel, il faut simplement le rajouter à l’aide du gestionnaire
de carte (Outils > Type de carte > Gestionnaire de carte).
Fonctions
Comme dans tout langage, le système de fonction est présent dans le langage Arduino.
Toutes les fonctions de bases et les opérateurs tels que "if", "else", "switch case", "==", "!
=", etc. sont communs à beaucoup de langages, et ne seront donc pas présentés dans
cet article. Si ces fonctions ne vous sont pas familières, je vous conseille de commencer
votre apprentissage par un tutoriel du langage C.

Fonction de gestion d'I/O numériques

1. pinMode(broche, mode) : cette fonction sert à définir une broche spécifique de
l’Arduino (par le biais de son numéro) comme étant une entrée ou une sortie.
2. digitalWrite(broche, valeur) : sert à définir l’état d’une sortie à un temps donné.
Par exemple, si on a défini qu’une LED est branchées sur le pin 4 ( pinMode(4,
OUTPUT); ), on peut par la suite envoyer ou non du courant dans cette broche,
pour que la LED s’allume ou s’éteigne :
a. sert à envoyer un signal électrique, et donc à allumer la
LED.digitalWrite(4, HIGH) ;
b. sert à mettre la broche 4 au potentiel de masse, et donc à éteindre la
LED.digitalWrite(4, LOW) ;
3. int digitalRead(broche) : sert à lire l’état d’une broche. Si celle-ci est reliée à un
potentiel 5V, le résultat de la lecture sera 1, et si elle est reliée à un potentiel nul,
le résultat sera 0.
Grâce à ces fonctions et à quelques composant électronique, on peut par exemple
allumer des lampes, faire fonctionner des moteurs ou encore vérifier l’état d’un élément
relié à un capteur en lisant son état.

Fonction de gestion d'I/O analogiques

Beaucoup d'Arduino possèdent des entrées analogiques, mais très peu (comme le Due)
possèdent des sorties analogiques.
1. int anlogRead(broche) : la fonction analogRead permet de lire l’état d’une broche
analogique. La différence entre une borche analogique et une broche numérique,
c’est que contrairement à une broche numérique qui ne renvoi qu’un 1 ou un 0, la
broche analogique envoie un nombre compris entre 1 et 256 le 1 étant 0V et 256
étant 5V. On peut donc avoir un chiffre qui correspond à un voltage, et donc savoir
le potentiel d’une broche à un instant ‘T’. On peut également augmenter la
précision de l'Arduino pour avoir plus de précision. Les entrées analogiques sont
très utilisées pour les capteurs qui renvoient une multitude de valeurs différentes,
comme les capteurs de température, par exemple.
2. analogWrite(broche, valeur) : peu de cartes ont cette fonction. Celle-ci sert à
envoyer comme précédemment une tension proportionnelle à un delta, qu'on peut
modifier si besoin pour accroitre la précision.
Fonctions de temporisation
Etant donné que les Arduino possèdent une horloge, on peut effectuer des temporisations
entre différents bloc de code. Voici les fonctions qui permettent de manier le temps :
1. Delay() : La fonction Delay(ms) sert à effectuer une pause d’une certaine durée
fixée par un entier passé dans la fonction à son appel. Cet entier correspond au
nombre de millisecondes pendant lesquelles on veut stopper le programme. Cette
fonction est une fonction bloquante, et donc pendant qu’elle se déroule, toutes les
autres actions sont ignorées.
2. DelayMicroseconds() : Identique à la fonction delay(), sauf que l’entier passé en
paramètre est prit en compte comme des microsecondes et non plus comme des
millisecondes.
3. Unsigned long millis() : permet de retourner un nombre de millisecondes qui
correspond au temps depuis lequel le programme a été démarré. Cette fonction se
remet à zéro après environ 50 jours, à la suite d’un dépassement mémoire
(overflow).
4. Unsigned long micro() : exactement la même fonctino que millis(), sauf que micro()
renvoi un entier qui correspond à des microsecondes et non plus à des
millisecondes.
5. Long random(max) : retourne un entier aléatoire compris entre 0 et le nombre
passé en paramètre.
6. Long random(min, max) : retourne un entier aléatoire compris entre les deux
nombres passés en paramètres.

Fonction Scheduler
La fonction scheduler est l’une des plus importante fonction de l’Arduino, car celle-ci nous
permet d’effectuer des tâches asynchrones. En effet, de base, un Arduino ne peut pas
gérer plusieurs tâches en même temps. Par exemple, si vous utiliser la fonction delay()
pour faire clignoter une LED, et que vous souhaitez lire l’état d’une entrée de l’Arduino en
même temps, cela vous sera impossible, car pendant que le délai s’écoule, le programme
est bloqué, et attend la fin de celui-ci. Comme on a pu le voir au début, le programme est
composé de seulement deux fonctions : « setup() » et « loop() ». On a évidemment la
possibilité de créer d’autres fonctions, mais celle-ci s’exécuterons de manière synchrone
après leur appel. La fonction Scheduler nous permet de créer plusieurs boucle infinie
( identiques à la fonction loop() déjà existante ) et de les lancer en même temps. Voici un
exemple :
Etant donné que le microprocesseur de l'Arduino n'est pas conçu pour faire de
l'asynchrone, la fonction Scheduler lui permet d'en faire comme on l’a vu précédemment,
mais de façon un peu détournée. En effet, lorsque que la fonction Scheduler est utilisée,
l’Arduino n’exécute pas vraiment les deux boucles en mêmes temps ; la première boucle
va exécuter une toute petite partie de son code, passer le relai à la deuxième boucle qui
va elle aussi exécuter une partie de code, puis repasser la main à la première boucle, et
ainsi de suite. En général, pour les petits projets, cela n’est pas du tout dérangeant.
Néanmoins, pour ceux qui souhaitent exécuter du code dans un temps précis, cette
fonction est à proscrire, car le passage d’une boucle à l’autre augmente le temps de
calcul de l’Arduino.
De plus, il est impératif d'utiliser la fonction "yield()" à la fin de chaque boucle, car c'est
elle qui permet la gestion du passage de l'une à l'autre.

Fonctions personnalisées
On peut bien évidemment créer des fonctions personnalisées qui correspondent à nos
besoins. Plutôt que de longs discours, voici un exemple de code qui permet de faire
clignoter une LED un nombre de fois précis lorsqu’on appuie sur un bouton, le nombre de
répétitions étant spécifié lors de l’appel :
L'utilisation des fonctions personnalisées est identique aux langages C et C++.

Moniteur série
Grâce au moniteur série (le petit icône loupe en haut à droite) vous avez la possibilité
d’afficher des informations provenant du code. Celui-ci est souvent utilisées pour le
débogage, ou simplement pour logger des informations renvoyées par l'Arduino, en
direct. Dans le code qu’on écrit, on peut spécifier à l’Arduino que nous souhaitons afficher
certaines informations, ou variables. Voici un exemple :
Ce programme nous permet de voir l’état d’un bouton en direct. Quand on se trouve dans
la fenêtre du moniteur série et que le programme est lancé sur l’Arduino, on peut voir
s’afficher les mots « Bouton Appuyé » quand celui-ci est pressé.
La ligne « Serial.begin(9600) » qui se trouve dans le setup est obligatoire, et sert à
initialiser la liaison série de l’Arduino, en lui affectant une vitesse de transmission. Cette
vitesse peut évidemment être changée, mais il faudra donc aussi modifier cette valeur
dans le moniteur série pour que la lecture des informations se fasse à la même fréquence
que leurs envois.

Conclusion
Cet article présente les bases de la programmation en Arduino. Si vous aimez ce
domaine, que vous avez quelques connaissances en électronique et que vous fourmilliez
d'idées géniales, lancez-vous! Et si vous souhaitez continuer, et que vous avez besoin
d'aide, sachez qu'internet regorge de sites en tout genre qui traitent de ce sujet et qui
vous permettront de faire tout ce que vous souhaitez.