Initiation à l’Arduino

Cette approche a pour but de présenter et d’initier à l’utilisation d’Arduino. Les cartes Arduino sont conçues pour réaliser des prototypes et des maquettes de cartes électroniques pour l’informatique embarquée.
Elles permettent un accès simple et peu coûteux. De plus, elles sont entièrement libres de droit, autant sur l’aspect du code source (Open Source) que sur l’aspect matériel (Open Hardware). Ainsi, il est possible de refaire sa propre carte Arduino dans le but de l’améliorer ou d’enlever des fonctionnalités inutiles au projet.
Le langage Arduino se distingue des langages utilisés dans l’industrie de l’informatique embarquée par sa simplicité. En effet, beaucoup de librairies et de fonctionnalités de base occultent certains aspects afin de gagner en simplicité. Cela en fait un langage parfait pour réaliser des prototypes ou des petites applications dans le cadre d’un hobby, même au niveau des radioamateurs.
Les possibilités des cartes Arduino sont énormes, un grand nombre d’applications ont déjà été réalisées et testées par bon nombre d’internautes. On retrouve par exemple diverses formes de robots ou des stations météo. D’autres exemples d’applications sont disponibles sur le web aux adresses suivantes : hackaday.com/category/arduino-hacks/
instructables.com/technology/arduino/

Le site référence est sans aucun doute celui de la marque www.arduino.cc

1. Présentation de la carte

Il existe actuellement beaucoup de types de cartes, les plus importantes sont : l’Arduino Uno, l’Arduino Leonardo, l’Arduino Mega, l’Arduino Mega ADK, l’Arduino Due, l’Arduino Nano, l’Arduino Mini Pro et l’Arduino Yún. Nous nous intéresserons à la carte Arduino UNO mais d’abord un tour du propriétaire :

A. La carte est composée d’un microcontrôleur

Les cartes Arduino font partie de la famille des microcontrôleurs. Les microcontrôleurs (en notation abrégée µc, ou uc ou encore MCU en anglais) sont des composants intégrés qui contiennent dans un même boîtier un microprocesseur, de la mémoire, et des périphériques courants, tels que timer, liaison série asynchrone, liaison série synchrone, ports d’entrée sortie logiques, contrôleur de bus CAN, convertisseur analogique numérique, etc. On peut comparer un microcontrôleur à un ordinateur classique, mais avec un système d’exploitation réduit et avec une puissance de calcul considérablement plus faible.
Les microcontrôleurs sont incontournables dans les domaines de l’informatique embarquée, de l’automation et de l’informatique industrielle. Ils permettent de réduire le nombre de composants et de simplifier la création de cartes électroniques logiques.

B. Caractéristiques techniques de l’Arduino UNO

C’est la première version stable de carte Arduino. Elle possède toutes les fonctionnalités d’un microcontrôleur classique en plus de sa simplicité d’utilisation.

Elle utilise une puce ATmega328P [1] cadencée à 16 MHz. Elle possède 32 KB de mémoire flash destinée à recevoir le programme, 2 KB de SRAM (mémoire vive) et 1 KB d’EEPROM (mémoire morte destinée aux données). Elle offre 14 pins (broches) d’entrées/sorties numériques (données acceptées 0 ou 1) [2] dont 6 pouvant générer des PWM (Pulse Width Modulation). Elle permet aussi de mesurer des grandeurs analogiques grâce à ses 6 entrées analogiques [3]. Chaque broche est capable de délivrer un courant de 40 mA pour une tension de 5V.
Cette carte Arduino peut aussi s’alimenter et communiquer avec un ordinateur grâce à son port USB [4]. On peut aussi l’alimenter avec une tension comprise entre 7 V et 12 V grâce à son connecteur Power Jack [5]. Son prix mini est actuellement d’environ 29 € pour l’Uno R3 😉

C. Un atout : les shields

Pour la plupart des projets, il est souvent nécessaire d’ajouter des fonctionnalités aux cartes Arduino. Plutôt que d’ajouter soi-même des composants extérieurs (sur une platine d’essai, circuit imprimé, etc.), il est possible d’ajouter des shields. Un shield est une carte que l’on connecte directement sur la carte Arduino, qui a pour but d’ajouter des composants sur la carte. Ces shields viennent généralement avec une librairie permettant de les contrôler.

Photo du site randomnerdtutorials.com

On retrouve par exemple des shields Ethernet, de contrôle de moteur, lecteur de carte SD, etc.
Le principal avantage de ces shields est leur simplicité d’utilisation. Il suffit de les emboîter sur la carte Arduino pour les connecter, les circuits électroniques et les logiciels sont déjà faits et on peut en empiler plusieurs. C’est un atout majeur pour ces cartes qui permet de tester facilement de nouvelles fonctionnalités. Cependant il faut bien garder à l’esprit que les shields ont un prix. Suivant les composants qu’ils apportent, leur prix peut aller de 5 à 100 € !

Pour faire fonctionner ces cartes nous avons besoin d’un logiciel.

2. Présentation du logiciel

A. IDE Arduino

Un IDE (environnement de développement) libre et gratuit est distribué sur le site d’Arduino (compatible Windows, Linux et Mac) à l’adresse arduino.cc/en/software. D’autres alternatives existent pour développer sur Arduino (extensions pour CodeBlocks, Visual Studio, Eclipse, XCode, etc.) mais nous n’aborderons ici que l’IDE officiel.

L’interface de l’IDE Arduino est plutôt simple, elle offre une interface minimale et épurée pour développer un programme sur les cartes Arduino ou tout autre microcontrôleur. Elle est dotée d’un éditeur de code avec coloration syntaxique [1] et d’une barre d’outils rapide [2]. Ce sont les deux éléments les plus importants de l’interface, ce sont ceux que l’on utilise le plus souvent.
On retrouve aussi une barre de menus [3] plus classique qui est utilisée pour accéder aux fonctions avancées de l’IDE. Enfin, une console [4] affiche les résultats de la compilation du code source et des opérations sur la carte, c’est le débogueur.

B. Langage Arduino

Le langage Arduino est inspiré de plusieurs langages. On retrouve notamment des similarités avec le C, le C++, le Java et le Processing. Le langage impose une structure particulière typique de l’informatique embarquée. La fonction setup contiendra toutes les opérations nécessaires à la configuration de la carte (directions des entrées sorties, débits de communications série, etc.).
La fonction loop, elle, est exécutée en boucle après l’exécution de la fonction setup. Elle continuera de boucler tant que la carte n’est pas mise hors tension ou redémarrée (par le bouton ‘reset’). Cette boucle est absolument nécessaire sur les microcontrôleurs étant donné qu’ils n’ont pas de système d’exploitation. En effet, si l’on omettait cette boucle, à la fin du code exécuté, il serait impossible de reprendre la main sur la carte Arduino, qui exécuterait alors du code aléatoire.
Au niveau de la syntaxe, on retrouve des similarités avec les langages précédemment cités. La déclaration des variables se fait généralement dans l’espace global (de façon à partager les variables les plus importantes entre les deux fonctions principales). On retrouve les types de base suivants :

Il existe d’autres types de base mais ils ne sont qu’un alias de ceux cités précédemment, la liste des types est disponible sur la page des références du site Arduino arduino.cc/reference/en/. La déclaration des variables suit cette syntaxe : (const) <type> <nom> ([taille]) (= valeur); Voici un exemple :

const int constante = 12;
float univers = 42.0;
char lettre = 'b';
String chaine = "Hello World";
long tableau[12];
boolean vrai = true;

On retrouve les opérateurs les plus courants pour les types de base. Parmi eux, = (affectation), == (comparaison), != (différence), <, >, <=, >=, && (et logique), || (ou logique), ! (non logique). On retrouve aussi les opérateurs mathématiques (+, -, *, /, %) et les opérateurs logiques bit à bit (^ XOR, & et, | ou, ~ non, << décalage logique à gauche, >> décalage logique à droite).

Voici quelques exemples d’utilisation de structure de contrôle.

if (variable < 2) {
    switch (variable) {
        case 1:
            doSomething(10);
            break;
        case 0:
            doSomething(1);
        default:
            doSomething(0);
    }
} else if (variable > 4) {
    while (variable != 10) {
        variable = doSomethingElse(variable - 1);
    }
} else {
    for (int i = 0; i < 10; i++) {
        variable = variable * 2;
    }
}

Les fonctions, les structures et les classes se déclarent de la même façon qu’en C++. Elles se déclarent sous cette forme :

// Structure :
struct  {
     ;
};

// Fonction :
 () {
    
}

// Classe :
class  {
public:
    
private:
    
protected:
    
};

3. Les fonctionnalités de base

A. Les entrées et sorties

Le langage Arduino vient avec un nombre important de fonctions de base permettant d’interagir avec son environnement. Les fonctions les plus utilisées sont les fonctions d’entrée/sortie. Ce sont elles qui permettent d’envoyer ou de mesurer une tension sur une des broches de la carte.
Dans un premier temps, avant d’effectuer une mesure ou d’envoyer une commande, il est nécessaire de définir la direction des broches utilisées. Pour cela on fait appel à la fonction pinMode en lui donnant d’une part la broche concernée, et d’autre part la direction. Cela se traduit comme ceci :

void setup() {
    pinMode(1, OUTPUT); // Broche 1 en sortie
    pinMode(2, INPUT);  // Broche 2 en entrée
}

Cette configuration faite, on peut procéder à l’utilisation des broches. Toutes les broches sont capables d’écrire et de lire des données numériques, c’est-à-dire des 0 (0V) ou des 1 (5V). Mais certaines disposent de fonctionnalités supplémentaires.
Tout d’abord, toutes les cartes Arduino possèdent des entrées analogiques. Ce sont les broches A0-A1-A2 etc. Elles permettent de lire des tensions analogiques (comprises entre 0 et 5V) et de les convertir en entier (compris entre 0 et 1023) proportionnellement à la tension mesurée. Certaines cartes Arduino possèdent des sorties analogiques faisant l’opération inverse (mettre une tension sur la broche proportionnellement à l’entier donné), mais ce n’est pas le cas pour l’Arduino UNO.

Pour pouvoir tout de même contrôler des composants autrement qu’en « tout ou rien » il est possible d’utiliser des broches PWM. Ce sont les broches annotées par un tilde ~ sur la carte.

Les PWM (Pulse Width Modulation) sont utilisées pour synthétiser des signaux analogiques en modulant le temps passé à l’état 1 (5V).

En utilisant une fréquence relativement élevée, les PWM permettent de commander certains composants comme s’ils recevaient une tension analogique. Cela provient du fait que les composants utilisés dans l’électronique analogique ne changent pas d’état instantanément. Par exemple, une ampoule à incandescence reste chaude un court instant après avoir été éteinte. Ce phénomène est généralement invisible à l’œil nu. Grâce à elles, on pourra par exemple faire varier l’intensité d’une LED. La plupart des cartes Arduino utilisent des PWM cadencées à 490 Hz environ.
Toutes ces fonctionnalités sur les broches d’entrées/sorties sont utilisables par le biais de quatre fonctions :

• digitalRead(pin) : mesure une donnée numérique sur une des broches, la broche en question doit être réglée « en entrée »
• digitalWrite(pin, value) : écrit une donnée numérique sur une des broches, la broche concernée doit être réglée « en sortie ». Le paramètre value doit être égal à HIGH (état 1 soit 5V) ou LOW (état 0 soit 0V)
• analogRead(pin) : mesure une donnée analogique sur une des broches (compatibles seulement), la broche doit être réglée sur « entrée »
• analogWrite(pin, value) : écrit une donnée sous forme de PWM sur une des broches (compatibles uniquement), la broche doit être réglée « en sortie ». Le paramètre value doit être compris dans l’intervalle [0;255]

B. La gestion du temps

Pour la plupart des applications de domotique, il est nécessaire de faire intervenir des intervalles de temps. Par exemple, pour gérer le temps d’appui sur un bouton ou pour faire une sonnerie qui se répète un certain nombre de fois. Le langage Arduino fournit quelques fonctions permettant de gérer ce temps.

Il est possible d’insérer une pause dans son programme pendant un instant. Pour cela, on utilise les fonctions delay et delayMicroseconds qui insèrent une pause suivant le paramètre passé (en millisecondes pour l’une, en microsecondes pour l’autre). Cependant ces fonctions bloquent le microcontrôleur, on ne peut alors plus effectuer aucune autre action.

En plus d’insérer une pause, il est possible de mesurer le temps. De la même manière que les fonctions de délai, on utilise les fonctions millis et micros qui donnent le nombre de millisecondes (respectivement microsecondes) depuis le lancement de la carte. Attention, ces fonctions incrémentent une variable interne. Ces variables se remettent à zéro une fois le maximum atteint (overflow). La variable utilisée pour les millisecondes atteint son maximum au bout de 49 jours et 17 heures, et la variable utilisée pour les microsecondes au bout de 71 minutes et 34 secondes environ. Il faut donc faire attention lors de l’utilisation de ces fonctions pour des utilisations de longue durée.

C. Les interruptions

Il est parfois nécessaire en informatique embarquée d’attendre un événement externe (appui sur un bouton, données d’un capteur, etc.) pour effectuer une action. Pour ce type de problème, on utilise les interruptions. Les interruptions sont des portions de code (fonctions) appelées lorsqu’un événement (interne ou externe) survient et a besoin d’être traité sur-le-champ.
Il faut cependant faire attention : ce mécanisme interrompt le code exécuté, il est prioritaire par rapport au reste du code. Vu qu’il est possible de mesurer les événements ponctuellement (via les fonctions d’entrées/sorties), on utilise généralement les interruptions pour du code critique (arrêt d’urgence par exemple) ou des événements non ponctuels (transmissions de données depuis un ordinateur par exemple).

Aussi, le nombre d’interruptions externes est limité à 2 sur la plupart des cartes Arduino. Les interruptions sont utilisables sur les broches compatibles seulement (broches 2 et 3 sur l’Arduino UNO). Pour choisir la fonction et la broche utilisée pour l’interruption, on utilise la fonction attachInterrupt. On peut utiliser detachInterrupt pour supprimer l’interruption. Il est possible de partir en interruption sur 4 types d’événements :

• LOW : lorsque la broche est à l’état 0 (0V)
• RISING : lorsque la broche passe de l’état 0 (0V) à l’état 1 (5V) (front montant)
• FALLING : lorsque la broche passe de l’état 1 (5V) à l’état 0 (0V) (front descendant)
• CHANGE : lorsque la broche change d’état (front montant et front descendant)

Voici un exemple d’utilisation :

volatile boolean etat = false;

void appuiBouton() {
    etat = !etat; // Changement d'état
}

void setup() {
    pinMode(2, INPUT); // Broche 2 en entrée
    // On attache à l'interruption 0 (broche 2) la fonction 'appuiBouton' sur un front montant
    attachInterrupt(0, appuiBouton, RISING);
}

On remarque l’apparition du mot-clé volatile avant la déclaration de la variable etat. Ce mot-clé est nécessaire pour toutes les variables qui sont modifiées dans une interruption. Cela a une incidence sur la manière dont le compilateur traite l’accès à la variable.

Il est parfois nécessaire de désactiver temporairement les interruptions, par exemple lorsque l’on exécute du code critique (activation d’un moteur, etc.). Deux fonctions permettent de changer l’activation des interruptions, interrupts() et noInterrupts(), pour activer (respectivement désactiver) les interruptions.

4. Un peu de pratique …

A. Hello Led

Nous allons maintenant passer à la pratique (c’est quand même le plus amusant). Pour cette première manipulation, il est demandé de faire clignoter une LED de façon régulière. Vous pouvez soit utiliser une LED avec une résistance en série sur une breadboard, soit utiliser la LED directement sur l’Arduino (broche 13 sur la carte Arduino UNO). Pour y arriver il faut aller chercher l’exemple « Blink » dans le programme installé précédemment.

Une fois que vous avez cliqué sur « Blink », une nouvelle fenêtre va apparaître. Elle va contenir le programme « Blink ».

Quelques explications s’imposent

La première chose à faire est d’initialiser la broche LED_BUILTIN en tant que broche de sortie avec la ligne :

pinMode(LED_BUILTIN, OUTPUT);

Dans la boucle principale, vous allumez le voyant avec la ligne :

digitalWrite(LED_BUILTIN, HIGH);

Cela fournit 5 volts à l’anode de la LED. Cela crée une différence de tension entre les broches de la LED qui s’éclaire. Ensuite, vous l’éteignez avec la ligne :

digitalWrite(LED_BUILTIN, LOW);

Cela ramène la broche LED_BUILTIN à 0 volt et éteint le voyant. Entre l’activation et la désactivation, vous souhaitez disposer de suffisamment de temps pour permettre à une personne de voir le changement. Les commandes delay() indiquent donc à la carte de ne rien faire pendant 1000 millisecondes, soit une seconde. Lorsque vous utilisez la commande delay(), rien d’autre ne se produit pendant cette période. Une fois que vous avez compris les exemples de base, consultez d’autres exemples pour savoir comment créer un délai tout en effectuant d’autres tâches.

Si vous désirez envoyer le programme « Blink » vers la carte et voir ce que vous avez réalisé, il faut dire au logiciel quel est le type de carte que vous avez. C’est assez simple jusqu’ici. Vous sélectionnez le nom de votre carte, pour notre exemple il s’agit de la carte « Arduino/Genuino Uno ». Allez dans le menu « Outils » puis dans « Type de carte » comme sur la capture.

Choisissez maintenant le port de connexion de la carte. Allez dans le menu « Outils » puis « Port ». Là, vous choisissez le port COM de votre ordinateur dédié à votre carte.

À présent, il va falloir envoyer le programme dans la carte. Pour ce faire, il suffit de cliquer sur le bouton « Téléverser », en jaune-orangé sur la capture :

En bas [4], dans la partie affichant les résultats de la compilation du code source, vous voyez le texte : « Compilation du croquis » puis « Téléversement… », cela signifie que le logiciel est en train d’envoyer le programme dans la carte. En même temps, une barre d’avancement du téléchargement (voir flèche orange) montre aussi l’avancement de l’opération. Une fois terminé, il s’affiche « Téléversement terminé » et signale ainsi que le programme a bien été chargé.

Et la lumière jaillit YESSS 🙂

Si vous souhaitez expérimenter, essayez de faire ce même programme en utilisant la fonction millis plutôt que delay.

5. Quelques librairies

En plus de la simplicité du langage et des nombreuses fonctionnalités qu’il offre, l’IDE vient avec un nombre important de librairies évitant ainsi d’implémenter des fonctions courantes dans l’informatique embarquée.
Une des librairies les plus utilisées est celle implémentant la communication série. La majorité des cartes Arduino possèdent un émulateur de connexion série pour communiquer au travers de l’USB. Ainsi, on peut communiquer avec l’ordinateur sur lequel la carte Arduino est connectée. Cela permet, par exemple, de déboguer un programme en affichant la valeur des variables ou simplement afficher la valeur des capteurs. Cette librairie a été directement implémentée dans le langage Arduino. On peut accéder à la communication série (au travers de l’USB) grâce à l’objet Serial. Une autre librairie existe pour communiquer par liaison série via une des broches de la carte.
Il est parfois nécessaire de stocker des informations même après l’arrêt de la carte. Il est possible de stocker une petite quantité d’information sur la mémoire EEPROM (Electrically Erasable Programmable Read Only Memory) intégrée. Une librairie est aussi fournie pour dialoguer avec cette mémoire. Il est possible de lire et d’écrire sur cette mémoire sans rien ajouter sur la carte. Cette mémoire est accessible via l’objet EEPROM et en ajoutant la librairie du même nom.
Attention, la mémoire EEPROM a une durée de vie limitée (environ 100 000 cycles d’écriture). Il faut donc veiller à ne pas écrire répétitivement les données.
D’autres alternatives existent pour ajouter de plus grandes quantités de mémoire morte à l’Arduino (carte SD notamment) mais cela demande l’ajout de composants externes.

Pour terminer, il existe aussi des librairies permettant de contrôler des composants externes. Parmi ces librairies, une des plus populaires est celle contrôlant des servomoteurs. Un servomoteur est un composant électronique composé d’un moteur et d’une carte d’asservissement. On peut le contrôler en position (c’est-à-dire choisir l’angle du moteur) grâce aux PWM. Une librairie Arduino est implémentée pour contrôler simplement ces moteurs : la librairie Servo. Il faut toutefois faire attention à éviter d’alimenter les servomoteurs directement sur une des broches d’alimentation de la carte. En effet, un servomoteur consomme une quantité importante de courant (selon le couple exercé par le moteur). Il est donc fortement conseillé de relier les servomoteurs à des alimentations externes (batteries, piles de 9V, etc.).

Et vous voilà fin prêt pour le monde fabuleux de l’ARDUINO

Avec les remerciements de Julien Lechalupé pour l’inspiration de son cours, dont vous pouvez retrouver l’original à cette adresse fablab.univ-tlse3.fr/wiki/images/9/92/Cours_arduino_v0.2.pdf

À propos

Albert ON5AM

100almu@gmail.com

Licencié Harec depuis 1990, après une pause de quelques années, j'ai renouvelé mon intérêt pour la radio, je suis particulièrement actif en HF, appréciant le FT8, les contest et la chasse au Dx. Passionné d'informatique, je suis convaincu que le monde des radioamateurs doit évoluer avec les avancées technologiques, notamment avec l'émergence de l'IA dans nos shack.