Introduction

Le mot « Arduino »

Le mot « Arduino » est utilisé un peu dans tous les sens. Il peut désigner à la fois un IDE, une carte, un langage de programmation …
Arduino est une marque, elle met en libre service des schémas de carte de prototypages (ces fameuses cartes Arduino).
« Arduino » c’est donc à la fois des cartes de développement, un IDE pour programmer les microcontrôleurs embarqués dans ces cartes. Étant open-source les schémas et le routage des cartes Arduino sont donc publiques.

Le microcontrôleur

Ce qui caractérise une carte Arduino, c’est le microcontrôleur utilisé, c’est lui qui défini les « fonctionnalités » de chaque la carte.
Pour la plus part des cas nous utilisons un Uno ou une Nano (c’est le même microcontrôleur Atmega328P), ce microcontrôleur possède 14 GPIO digitaux, dont 6 PWM et 6 GPIO analogique.
Sur une carte Arduino, il y a plusieurs ports et type de port, ces ports servent à interagir avec des capteurs, des LED, ou autre composants électroniques.
Les ports digitaux peuvent avoir seulement 2 états, haut ou bas, ce qui électriquement correspond respectivement à 5 V ou 0 V.
Les ports analogiques servent à mesurer la tension d’un signal (cette tension ne doit pas dépasser 5 V).
Une autre fonctionnalité importante, c’est les ports de communications disponibles. Il y a plusieurs type de communication (SPI, I2C, Série), ici la Uno possède 1 liaison Serial (TX & RX), SPI (MOSI & MISO) et I2C (SDA & SCL). Ces protocoles sont utilisés par certains capteurs, et peuvent être utilisés pour faire interagir plusieurs cartes entre elles.
Les autres cartes Arduino ont des spécifications différentes, par exemple la Leonardo qui permet plus facilement d’utiliser un capteur comme sourie ou clavier d’ordinateur, ou encore, la Mega qui offre beaucoup plus de GPIO que la Uno ou Nano.

L’alimentation

Pour faire « cramer » une carte Arduino, il y a 2 raisons récurrentes :

• Demander trop de courant à la carte (mauvaise utilisation d’actionneurs)
• L’alimentation d’une carte Arduino
  Pour l’alimentation, il y a le classique USB qui délivre 5 V, mais lorsqu’on veut rendre le projet portable, il y a souvent besoin d’un fonctionnement sur batterie, on peut donc utiliser une pile 9 V (sur jack in), ou alors une batterie 12 V sur Vin.

L’IDE

L’IDE Arduino est le logiciel qui est utilisé pour coder, compiler et téléverser sur une carte Arduino. (Remarque : il y a d’autre logiciels qui permettent de faire la même chose, comme PlatformIO qui est sur VS-Code ou CLion).
Pour commencer je conseille d’ajuster la taille de la police à sa convenance et sur tout d’afficher les numéros de lignes ainsi que le repli de code pour ceux qui aime cette fonctionnalité.
Souvent, on dit « codé en Arduino », le langage utilisé pour coder une Arduino est le C++.

Dans l’IDE il y a donc plusieurs fonctionnalités :

• Compilation du code (1er bouton sur la gauche)
• Compilation et téléversement du code (2ème bouton sur la gauche)
• Moniteur Série & Traceur série

Les variables

Il y a plusieurs type de variables :

• valeurs entières (byte/char, int, long)
• valeurs réelles (float, double)
• chaîne de caractères (string)
  Les variables entières et réelles ont une taille sur la mémoire du microcontrôleur, cette taille détermine aussi les valeurs possibles que peuvent contenir ce type de variable.
  Par exemple, pour un int de -32 768 à 32 767, si nous n’utilisons pas les valeurs négatives (pour un compteur strictement positif par exemple), on peut utiliser le mot clef unsigned pour préciser que l’entier est non signé et donc nous pouvons aller de 0 à 65 535 (soit 2^16 – 1).
  Un autre mot clef important est const qui permet de s’assurer que la valeur de la variable restera constante, en cas de modification le compilateur relèvera une erreur.
  volatile et static sont des mots plus rarement utilisés. volatile sert principalement pour les interruptions, sur une Arduino Uno le pin 2 et 3 sont muni d’une possibilité d’interruption externe, c’est-à-dire qu’une variation ou un changement d’état met le programme en arrêt et lance l’exécution d’un programme d’interruption (ISR), les variables modifiées dans cette ISR doivent être déclarer en volatile (source).
  Il y a des caractères pour l’utilisation de la logique, il y a la logique bit à bit et la logique booléenne (sur le type bool). Les plus souvent utilisés sont : le ET logique (&&) et le OU logique (||).

Fonctions usuelles

Les principales fonctions qu’on utilise dans un programme Arduino, sont listées dans la diapositive numéro 10.

• pinMode : permet de définir, pour un pin, la manière dont on va l’utiliser, la question c’est : est-ce que du point de vue de la carte Arduino est ce que ce pin est une entrée (INPUT) ou une sortie (OUTPUT) ?
  Pour les entrée, on a besoin de fonction de « lecture » de ces pins
• analogRead : lit la tension du signal appliqué sur la pin. Renvoie un entier sur 10 bits (donc de 0 à 1023)
• digitalRead : lit la valeur logique (0 V ou 5 V) sur la pin. Renvoie un booléen
  Pour les sortie, on a besoin de fonction pour configurer ce qu’on peut appliquer sur nos sorties:
• digitalWrite : écrit 0 ou 1 (0 V ou 5 V) sur la pin sélectionnée.
• analogWrite : permet de faire varier la tension de sortie en 0 V et 5 V, en utilisant la PWM (ou MLI en français) qui consiste à faire varier sur une période, le temps pour lequel la sortie est à 5 V par rapport au temps à 0 V, en faisant ceci assez rapidement (pour la Uno 490 Hz ou 980 Hz), la tension de sortie est alors diminuer proportionnellement à l’argument entre 0 et 255 (8 bits), 0 étant 0 V et 255 étant 5 V. (analogWrite)
  Pour gérer la temporalité, il y a quelques fonctions utiles :
• millis et micros : mesure le temps écoulé depuis le début du programme en millisecondes ou en microsecondes
• delay et delayMicroseconds : permettent de bloquer le programme pendant le temps donné en argument, en millisecondes ou en microsecondes

Pour écrire les fonctions, c’est comme en C ou en C++ car c’est le langage de programmation utilisé.

Structuture d’un programme

Un programme Arduino est constitué de 2 fonctions obligatoires :

• setup : cette fonction sera exécutée seulement au début du programme, c’est une fonction d’initialisation.
• loop : cette fonction sera exécutée continuellement, à l’infini (jusqu’au RESET du programme)

On peut mettre les variables globales, les constantes, les librairies et tout ce qui est utilisé en global dans le programme.

Électronique

Breadboard

Pour utiliser convenablement les composants de base en Arduino, voici comment on utilise une breadboard (ou platine d’essai en français), les lignes rouges montrent des points qui sont reliés entre eux, on peut donc prototyper rapidement un circuit grâce à ces platines d’essais.

LED

Pour utiliser un avertisseur lumineux, typiquement une LED, nous avons besoin de limiter le courant qui la traverse, pour cela nous utilisons une résistance qui se dimensionne de la manière suivante :
$$R = \frac{5 – V_{LED}}{I_{LED}} $$
Ici : $R = \frac{3}{5 \times 10^{-3}} = 600 \approx 560 \ohm \text{ (valeur normée)}$

Bouton

Un autre composant utile c’est le bouton, pour lire sa valeur, il faut utiliser soit un montage pull up, ou un montage pull down. Ces montages utilisent des résistances dites de tirages, elles vont servir à appliquer soit 5 V (pull up), soit 0 V (pull down) lorsque le bouton est dans son état ouvert. Ces résistances sont souvent de l’ordre de la dizaine de ㏀
Pour une Arduino Uno, il y a possibilité d’utiliser n’importe quel pin comme entrée dite INPUT_PULLUP, entrée qui, en interne, place une résistance de tirage « vers le haut », ce qui permet de faire des tests avec un interrupteur sans forcément utiliser de résistance.

Moniteur série

Le moniteur série est l’outil de débogage de l’IDE. Lors de la compilation le programme qui est écrit dans l’IDE est stocké sur la carte et est exécuté comme le programme le décrit. Dans ce programme, on peut utiliser le port Série de la carte Arduino Uno (pin 0 et 1) pour échanger des informations avec le protocole UART/USART (source).
L’outil moniteur série sur votre ordinateur permet de récupérer ces informations.
Pour ce faire il faut configurer la vitesse de communication, ça doit être une vitesse de communication à laquelle l’outil moniteur série de l’IDE peut fonctionner, souvent 9600 ou 115 200 baud sont des valeurs utilisées.
Pour envoyé de l’Arduino vers l’ordinateur on utilise la méthode print ou println sur l’objet Serial, le détaille de leurs actions :

• print : envoie sous forme de chaîne de caractère le message que vous voulez envoyer
• println : la même chose que print mais avec un saut de ligne en plus à la fin
  Pour lire ce qui est envoyé de l’ordinateur les méthodes read, available sont utiles.

Traceur série

Un autre outil sur la communication série est le traceur série. il permet comme le moniteur série de réceptionner les données envoyées par l’Arduino mais cette fois si pour vous afficher un graphique.
Néanmoins, il faut utiliser un certain format, le format « CSV » (comma separated values).
Lorsqu’on veut visualiser 1 seule variable, on peut « juste » utiliser Serial.println(variable); ce qui rentre dans le format CSV sans le nom de la grandeur.
Si on veut visualiser plus de variables, il faut utiliser print et intercaler une virgule après chaque envoie de variable, puis finir par une println ce qui permet de sauter un ligne à la fin.

Librairies

Les libraires ou bibliothèques sont très utiles lorsqu’on programme. Cela permet de s’affranchir de beaucoup d’étapes laborieuse de lecture de documentation technique de capteurs, de composants. Par exemple, pour utiliser un afficheur LCD, il y a tout un protocole pour la configuration (1 ou 2 lignes, nombre de caractères …), de la transmission d’ordre, tout ça avec une temporisation plutôt exigeante, la librairies vous permet d’utiliser des fonctions qui font ça à votre place, vous aurez juste à comprendre le fonctionnement de la fonction soit avec les exemples, soit avec le détail du créateur de la librairie.

Traitement périodique & Multitâches

Un problème qu’on peut rencontrer c’est que la fonction delay bloque le programme pendant X millisecondes, il n’y a donc aucune actions possible (1 seule exception c’est les interruptions).
La solution est donc de formuler une condition qui a pour but de faire tourner le un routine durant un certain temps, puis lorsque le temps est écoulé va reprendre le dérouler du programme.
Une bonne manière de raisonner lorsqu’on écrit un code c’est de voir le voir comme un couloir avec des trappes, le déroulement du programme « court » dans ce couloir, les trappes sont l’analogie des conditions dans lesquelles le déroulement du programme peut « tomber ».
Il y a une manière particulière d’écrire ces conditions pour que la trappe s’ouvre toutes les X millisecondes (ou microsecondes).
À condition que le processus périodique exécuté toutes ces X secondes ait un temps d’exécution moins long que sa période.
Ceci permet de faire un traitement périodique, si nous en faisons plusieurs, s’il y a plusieurs trappes, on peut imaginer plusieurs routines périodique, toujours avec un soucis de temps d’exécution inférieur à la période, et s’il y en a plusieurs, un notion de priorité qui peut s’avérer nécessaire.
Un exemple qui se prête bien pour comprendre comment tout cela fonctionne, c’est blink (Basics/) et blinkWithOutDelay (Digital/).