Introduction
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 couteux 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é inutiles au projet.
Le langage Arduino se distingue des langages utilisés dans l’industrie de l’informatique embarquée de par sa simplicité. En effet, beaucoup de librairies et de fonctionnalités de base occulte 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 de hobby, même au niveau des radioamateurs.
Les possibilités des cartes Arduino sont énormes, un grand nombre d’application ont déjà été réalisé et testées par bon nombre d’internautes. On retrouve par exemple diverse formes de robot ou des stations météos. 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 carte, les plus importantes sont : l’Arduino Uno, Arduino Lenardo, Arduino Mega, Arduino Mega ADK, Arduino Due, Arduino Nano, Arduino Mini Pro et Arduino Yun. Nous nous intéresserons à la carte Arduino UNO mais d’abords 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ôleurs à 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 inévitables dans les domaines de l’informatique embarquée, de l’automation et de l’informatique industrielle.Ils permettent de réduire le nombre de composant 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 simplification d’utilisation.
Elle utilise une puce ATmega328P [1] cadencée à 16Mhz. 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ée 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 à ces 6 entrées analogiques [3]. Chaque broche est capable de délivré 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 alimentation comprise entre 7 V et 12 V grâce à son connecteur Power Jack [5]. Son prix mini est actuellement environ 19.50 € 😉
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 soit 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 shield 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 leurs simplicité d’utilisation. Il suffit de les emboiter sur la carte Arduino pour les connecter, les circuits électronique et les logiciels sont déjà faits et on peut en empiler plusieurs. C’est un atout majeur pour ces cartes pour pouvoir 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, leurs prix peuvent 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/main/software. D’autres alternatives existent pour développer Arduino (extensions pour CodeBlocks, Visual Studio, Eclipse, XCode, etc.) mais nous n’aborderons ici que l’IDE officiel.
Actuellement c’est la version 1.8.8 qui est utilisée. Une fois téléchargé, vous l’installez et jusqu’ici pas de soucis.
Il vous crée une icône sur le bureau, que vous ouvrez …
L’interface de l’IDE Arduino est plutôt simple, il offre une interface minimale et épurée pour développer un programme sur les cartes Arduino ou tout autres microcontrôleur. Il est doté 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, c’est ceux que l’on utilise le plus souvent.
On retrouve aussi une barre de menus [3] plus classique qui est utilisé pour accéder aux fonctions avancées de l’IDE. Enfin, une console [4] affichant les résultats de la compilation du code source, 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, 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 produit, il sera 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 suivant :
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/en/Reference/HomePage. La déclaration des variables suit cette syntaxe : (const) ([]) (= valeur); Voici un exemple :
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 bases. 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.
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 :
struct <nom>{
<type> <nom du champ> ;
} ;
Fonction :
<type de retour> <nom>(<paramètre>) {
<instruction>
}
Classe :
class <nom> {
public :
<attributs et champ publics>
private :
<attributs et champ privés>
protected :
<attribut et champ privés>
} ;
3. Les fonctionnalités de base
A. Les entrées et sorties
Le langage Arduino vient avec un nombre important de fonction de base permettant d’interagir avec son environnement. Les fonctions les plus utilisée 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 :
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é supplémentaire.
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 (comprise entre 0 et 5V) et de le 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 (met 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és 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’il recevait une tension analogique. Cela provient du fait que les composants utilisés dans l’électronique analogique, ne changent pas d’états 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 (compatible 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 (compatible 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 certains nombre de fois. Le langage Arduino fournis 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ère une pause suivant le paramètre passé (en milliseconde pour l’un, en microseconde pour l’autre). Cependant ces fonctions bloquent le microcontrôleur, on ne peut alors plus effectuer aucune 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 milliseconde (respectivement microseconde) depuis le lancement de la carte. Attention, ces fonctions incrémente une variable (interne). Ces variables se remettent à zéro une fois le maximum atteint (overflow). La variable utilisée pour les millisecondes atteint sont 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 longues durées.
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és lorsque qu’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’interruption externe 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 :
void appuiBouton() {
etat =!etat; // Changement d’état
}
void setup() {
pinMode(2,INPUT); // Broche 2 en entrée
attachInterrupt(0,appuiBouton,RISING); // On attache à l’interruption 0 (broche 2) la fonction ‘appuiBouton’ sur un front montant
}
On remarque l’apparition du mot clef volatile avant la déclaration de la variable ‘etat’. Ce mot clef est nécessaire pour toutes les variables qui sont modifiées dans une interruption. Cela à 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 noInetrrupts 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. Ou alors, vous pouvez utiliser la LED directement sur l’Arduino (broche 13 sur la carte Arduino UNO). Pour y arriver il faut aller chercher le nom « Blink » dans le programme installé précédement.
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 à 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 delay() commandes delay() indiquent donc au conseil de ne rien faire pendant 1 000 millisecondes, ou 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 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’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ée est celle implémentant la communication série. La majorité des cartes Arduino possède 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 variablesou simplement afficher la valeur des capteurs.Cette librairie à été directement implémentée dans le langage Arduino. On peut accéder à la communication série (au travers 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 (Electricaly 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 à une durée de vie limitée (environ 100000 cycles d’écritures). 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émoires mortes à 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 toutes fois faire attention à éviter d’alimenter les servomoteurs directement sur une des broches d’alimentation de la carte. En effet, un servomoteur consomme une quantité important de courant (suivant le couple exercé par le moteur). Il est donc fortement conseillé de relier les servomoteurs sur 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
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.
