Apprendre l’Arduino : le langage Arduino pour commencer à programmer

Vous y êtes, c’est le quatrième article de cette formation sur la création des systèmes électroniques avec Arduino. Avant la fin de cet article, nous mettrons déjà les mains en programmation Arduino car cet article est là pour vous apprendre à programmer en langage Arduino pour commencer en électronique et informatique embarquée. Jusqu’ici, j’ai déjà fait une introduction du langage Arduino et ici, j’essayerai de vous en dire plus.

Apprendre à programmer une carte Arduino

Le microcontroleur est le cerveau de notre carte. Il va recevoir le programme que nous allons créer et va le stocker dans sa mémoire ( stockage) avant de l’exécuter. Grâce à ce programme, il va savoir faire des choses, qui peuvent être : faire clignoter une ampoule, afficher des caractères sur un écran, envoyer des données à un ordinateur, mettre en route ou arrêter un moteur, transmettre des informations via une liaison Wifi,…

En électronique ou informatique embarquée, le grand axe du système est donc le programme que nous écrirons et qui sera executé par notre carte programme une fois envoyé dans celle-ci. Vous êtes donc appelé à apprendre à écrire vos programmes pour piloter vos systèmes électroniques avec Arduino ou autre carte électronique programmable.

Et sans plus tarder, découvrons comment programmer en langage Arduino !

1. Les variables en Arduino

Prenons un exemple simple : imaginons un numéro de téléphone dont nous devons nous souvenir. Ce numéro de téléphone est stocké dans un espace de stockage de la mémoire vive (RAM) du microcontrôleur. Chaque espace de stockage est identifié de manière unique.

Le numéro de téléphone sera stocké en mémoire comme une suite des chiffres qui formeront ensuite un nombre.

Le nombre stocké a la particularité de changer de valeur. En effet, la variable n’est que le conteneur.

Son contenu va donc pouvoir être modifié volontairement par le programme ( ou par le programmeur). Et ce onteneur va être stocké dans une case de la mémoire.

Le nombre sera donc contenu dans une variable et ensuite la variable dans une mémoire de la carte Arduino.

Imaginons que nous stockons le nombre dans un container (la variable). Chaque container est lui, déposé dans un espace bien précis, afin de le retrouver. Chaque container (variable) est aussi identifié par un nom unique.

Voici une illustration que j’ai eu à tirer de l’internet et qui explique au clair la façon dont les variables sont en mémoire :

Le nom d’une variable

Une variable possède un nom et ce nom permet de l’identifier dans le programme. Le nom de variable n’accepte que l’alphabet alphanumérique ([a-z], [A-Z], [0-9]) et _ (underscore). Il est unique;il ne peut donc pas y avoir deux variables portant le même nom.

Comment définir une variable en Arduino

Nous voulons stocker le nombre 9 dans une variable. Il tiendrait dans un petit carton. Mais on pourrait le stocker dans un grand container. Oui… mais non! Un microcontrôleur, ce n’est pas un ordinateur 3GHz multicore, 8Go de RAM ! Ici, il s’agit d’un système qui fonctionne avec un CPU à 16MHz (soit 0,016 GHz) et 2 Ko de SRAM pour la mémoire vive. Il y a donc au moins deux raisons pour choisir ses variables de
manière judicieuse :

1. La RAM n’est pas extensible, quand il y en a plus, y en a plus! Dans un même volume, on peut stocker
   bien plus de petits cartons de que gros containers. Il faut donc optimiser la place en définissant le bon type de variable, on y reviendra !.
2. Le processeur est de type 8 bits (sur un Arduino UNO), donc il est optimisé pour faire des traitements sur
   des variables de taille 8 bits, un traitement sur une variable 32 bits prendra donc (beaucoup) plus de temps.
   Si les variables de la taille d’un container sont sur 32 bits, autant prendre un carton qui n’occupe que 8 bits
   quand la variable tient dedans !

Les types de variables en Arduino

Comme dans tous les langages de programmation, les variables ont des types et comme le langage Arduino est de la liste, nous devons donc en parler aussi.

La notation -3.4e38 signifie tout simplement -3,4 multiplié par 10 puissance 38, c’est une notation scientifique que vous devez maitrisé pour la suite de ce cours.

Prenons donc un exemple pour que vous maitrisiez les notions des variables ci-haut :

Maintenant, prenons une variable que nous allons appeler « valeur_1». Par exemple, si notre variable « valeur_1 » ne prend que des valeurs décimales, on utilisera les types int, long, ou char. Si maintenant la variable « valeur_1 » ne dépasse pas la valeur 64 ou 87, alors on utilisera le type char comme dans le bout de code suivant :

char valeur_1 = 0;
// Ceci est un commentaire qui ne sera pas lu par le programme
// DebutrerPro

• Il ne faut jamais oublier un point virgule à la fin d’une instrcuction
• un commentaire sur une ligne prend la forme suivante :

// commentaire , et n'est pas lu par le compilateur

• pour affecter une valeur à une variable ( ou donner une valeur ou attribuer à une variable une valeur, on utilise le signe égal). Ce qui est différent avec la double égalité ==

Si en revanche valeur_1 = 280, alors on utilisera le type supérieur (qui accepte une plus grande quantité de nombre) à char, autrement dit int ou long :

int valeur_1 = 0;

Si à présent notre variable « valeur_1 » ne prend jamais une valeur négative (-18, -8, …), alors on utilisera un type
non-signé. C’est à dire, dans notre cas, un char dont la valeur n’est plus de -128 à +127, mais de 0 à 255.
Voici le tableau des types non signés, on repère ces types par le mot unsigned (de l’anglais : non-signé) qui
les précède :

Autres types de variable

Une des particularités du langage Arduino est qu’il accepte un nombre plus important de types de variables,
listées dans ce tableau:

2. Comment définir les broches du microcontrôleur ?

Une carte Arduino est une carte programmable qui est physiquement matériel ( quelle expression !!). Mais retenez que le programme est réellement une dépendance du matériel est fait pour commander celui-ci.

Je vais donc vous montrer comment définir les broches du microcontroleur , mais avant cela , voici une carte Arduino physique :

La description est détaillé et claire de la carte . Vous voyez donc les broches qui y sont de partout. Quand vous les exploiterez pour vos systèmes électroniques, vous devez définir s’il s’agit des entrées ou des sorties.

Une broche entrée est différent d’une broche définie en sortie, car lorsque vous définissez une broche en sortie , elle agira comme une source de tension alors que dans le quand d’une entrée, elle se comportera comme un recepeteur. On parle alors des bornes analogiques et numériques, une leçon du prochainn article.

Définir une broche avec pinMode()

La fonction pinMode () permet de définir ou d’indiquer le type d’une broche en entrée ou en sortie. Les fonctions sont indispensables en Arduino et je vous ai mis un article qui detaille cette notion sur ce site via le lien suivant.

C’est une notion indispensable pour continuer avec cette formation, car une notion importante y est expliquée sur les fonctions !

J’ai identifié les broches du microcontrôleur sur l’image en haut, à l’aide de leurs numéros, comme
dans l’exemple suivant: pinMode(13, OUTPUT);. Cela ne pose pas de problème quand on a une ou deux
LEDs connectées. Mais dès qu’on a des montages plus compliqués, cela devient difficile de savoir qui fait
quoi. Il est donc possible de renommer chaque broche du microcontrôleur.

Premièrement, définissons la broche utilisée du microcontrôleur en tant que variable.

const int led1 = 13;

Le terme const en Arduino

Le terme const signifie que l’on définit la variable comme étant constante. Par conséquent, on change la nature
de la variable qui devient alors constante.
Le terme int correspond à un type de variable. Dans une variable de ce type, on peut stocker un nombre allant
de -2147483648 à +2147483647, ce qui sera suffisant! Ainsi, la broche 13 s’appellera led1.
Nous sommes donc en présence d’une variable, nommée led1, qui est en fait une constante, qui peut prendre
une valeur allant de -2147483648 à +2147483647. Dans notre cas, cette constante est assignée au nombre
13.
Concrètement, qu’est-ce que cela signifie? Observons la différence entre les deux codes :

void setup() {
 pinMode(13, OUTPUT);
// Initialise la broche 13 comme sortie
 Serial.begin(9600);
}
void loop() {
 digitalWrite(13, HIGH);
delay(500);
 digitalWrite(13, LOW);
delay(500);
}

const int led1= 13;
//La broche 13 devient led1
void setup() {
 pinMode(led1, OUTPUT);
// Initialise led1 comme broche de sortie
 Serial.begin(9600);
}
void loop() {
 digitalWrite(led1, HIGH);
delay(500);
digitalWrite(led1, LOW);
delay(500);
}

On peut trouver que de définir les broches allonge le code. Mais quand nous aurons de nombreuses broches
en fonction, cela nous permettra de les identifier plus facilement. Ainsi, si nous avons plusieurs LED, nous
pouvons les appeler Led1, Led2, Led3,… et si nous utilisons des LED de plusieurs couleurs, nous pourrons
les appeler rouge, vert, bleu,…
Enfin (et surtout!), si on veut changer la broche utilisée, il suffit de corriger la variable au départ, sans devoir
corriger tout le code. Comme pour les variables, nous pouvons donner n’importe quel nom aux broches.

2. Les boucles et conditions en langage Arduino

Les boucles permettent de re-exécuter un bout de code(snippets) lorsqu’une condition est vérifiée ou non. Une condition est tout simplement un test ou une vérification. Dans cette rubrique, je vais parlé donc de 2 types de structures conditionnelles en langage Arduino. Il s’agit :

• brachement conditionnels
• itérations ou boucles ( ou alors répétitions)

If , en Arduino

Le mot clé If ou Si en français, est une instruction vérifie une condition et exécute l’instruction en cours ou l’ensemble d’instructions si la condition est «vraie». Voici donc la syntaxe d’une instruction if :

if (condition) {
  //instructions à exécuter si la condition est vraie
}

condition: est le nom d’une variable ou une expression booléenne (c’est-à-dire, peut être trueou false). Les crochets peuvent être omis après une instruction if. Si cela est fait, la ligne suivante (définie par le point-virgule) devient la seule instruction conditionnelle.

if (x > 120) digitalWrite(LEDpin, HIGH);
 // ou alors
if (x > 120)
digitalWrite(LEDpin, HIGH);

// ou alors

if (x > 120) {digitalWrite(LEDpin, HIGH);}
// ou alors

if (x > 120) {
  digitalWrite(LEDpin1, HIGH);
  digitalWrite(LEDpin2, HIGH);
}
// ces syntaxes sont correctes

Les instructions évaluées entre parenthèses nécessitent l’utilisation d’un ou plusieurs opérateurs indiqués ci-dessous.

x == y (x est égal à y)
x! = y (x n'est pas égal à y)
x <y (x est inférieur à y)
x> y (x est supérieur à y)
x <= y (x est inférieur ou égal à y)
x> = y (x est supérieur ou égal à y)

Méfiez-vous d’utiliser accidentellement le signe égal unique (par exemple if (x = 10)). Le signe égal unique est l’opérateur d’affectation et prend xla valeur 10 (met la valeur 10 dans la variable x). À la place, utilisez le double signe égal (par exemple if (x == 10)), qui est l’opérateur de comparaison, et teste s’il x est égal à 10 ou non. La dernière déclaration n’est vraie que si elle xest égale à 10, mais la première déclaration sera toujours vraie.

C’est parce que C ++ évalue l’instruction if (x=10)comme suit: 10 est assigné à x(rappelez-vous que le signe égal unique est (l’ opérateur d’affectation )), donc xcontient maintenant 10. Ensuite, le conditionnel ‘if’ évalue 10, qui évalue toujours à TRUE, puisque tout un nombre différent de zéro est évalué à TRUE. Par conséquent, if (x = 10)évaluera toujours à TRUE, ce qui n’est pas le résultat souhaité lors de l’utilisation d’une instruction «if». 

De plus, la variable x sera définie sur 10, ce qui n’est pas non plus une action souhaitée.

else : mot clé en Arduino

Le if…​else permet un meilleur contrôle sur le flux de code que l’ ifinstruction de base , en permettant de regrouper plusieurs tests. Une else clause (si elle existe) sera exécutée si la condition de l’if instruction aboutit false. Le else peut procéder à un autre if test, de sorte que plusieurs tests mutuellement exclusifs puissent être exécutés en même temps.

Chaque test passera au suivant jusqu’à ce qu’un vrai test soit rencontré. Lorsqu’un vrai test est trouvé, son bloc de code associé est exécuté et le programme passe ensuite à la ligne suivant la construction if / else entière. Si aucun test ne s’avère vrai, le elsebloc par défaut est exécuté, s’il en existe un, et définit le comportement par défaut. Notez qu’un else ifbloc peut être utilisé avec ou sans elsebloc de terminaison et vice versa. Un nombre illimité de ces else ifsuccursales est autorisé.

// test_a et test_b sont des variables

if (test_a) {
  // exécuter si la condition test_a est vraie
}
else if (test_b) {
  // exécuter si la condition test_a est fausse, et test_b est vraie

else {
  // exécuter si la condition test_a et test_b sont toutes fausses
}

un exemple plus pratique des conditions if , else if et else

un code pour le système de capteur de température

if (temperature >= 70) {
  // Danger! Arrêter le système
}
else if (temperature >= 60) { // 60 <= temperature < 70
  // Important d'utiliser le système
}
else { // temperature < 60
  // Parfait, tout marche parfaitement
}

La boucle for en Arduino

La boucle  for est une instruction utilisée pour répéter un bloc d’instructions entre accolades. Un compteur d’incrémentation est généralement utilisé pour incrémenter et terminer la boucle. La boucle  forinstruction est utile pour toute opération répétitive et est souvent utilisée en combinaison avec des tableaux pour opérer sur des collections de données / broches.

Voici la syntaxe d’une boucle for , la plus simple :

for (initialisation; condition; incrementation) {
  // instructions à exécuter;
}

initialisation: se produit en premier et exactement une fois, c’est le point de depart .
condition: à chaque fois à travers la boucle, conditionest testé; si c’est le cas true, le bloc d’instructions et l’ incrémentation sont exécutés, la condition est à nouveau testée. Lorsque la condition devient false, la boucle se termine.
incrementation : exécuté à chaque fois dans la boucle quand conditionest true.

La boucle  for en  C ++ est beaucoup plus flexible que les fo rboucles trouvées dans certains autres langages informatiques, y compris BASIC. Tout ou partie des trois éléments d’en-tête peut être omis, bien que les points-virgules soient obligatoires. De même, les instructions d’initialisation, de condition et d’incrémentation peuvent être des instructions C ++ valides avec des variables non liées et utiliser tous les types de données C ++, y compris les flottants. Ces types de boucles for sont des instructions inhabituelles,  peuvent fournir des solutions à certains problèmes de programmation rares.

Par exemple, l’utilisation d’une multiplication dans la ligne d’incrémentation générera une progression logarithmique:

for (int x = 2; x < 100; x = x * 1.5) {
  println(x);
}

Et pour finir avec la boucle for, voici un exemple pratique d’initialisation avec cette instruction :

int sortie_cap;
for(int sortie_cap = 0, sortie==12, sortie_cap++){

// on est dans la boucle en vérifiant notre condition

}

La boucle while en Arduino

La boucle  while bouclera continuellement, et infiniment, jusqu’à ce que l’expression à l’intérieur de la parenthèse, () devienne fausse. Quelque chose doit changer la variable testée, sinon la boucle while ne se terminera jamais. Cela peut être dans votre code, comme une variable incrémentée, ou une condition externe, comme le test d’un capteur.

while (condition) {
  // instructions
// condition est une variable
}

un exemple de code avec la boucle while :

valeur = 0;
while (valeur < 200) {
  // faire quelque chose de répétitif 200 fois
  valeur++;
}

La switch case en Arduino

Comme les instructions if , switch case contrôle le flux des programmes en permettant aux programmeurs de spécifier un code différent qui doit être exécuté dans diverses conditions. En particulier, une instruction switch compare la valeur d’une variable aux valeurs spécifiées dans les instructions case. Lorsqu’une instruction case dont la valeur correspond à celle de la variable est trouvée, le code de cette instruction case est exécuté.

Le mot-clé break quitte l’instruction switch et est généralement utilisé à la fin de chaque cas. Sans une instruction break, l’instruction switch continuera à exécuter les expressions suivantes («fall-through») jusqu’à ce qu’une pause ou la fin de l’instruction switch soit atteinte.

switch (var) {
  case label1:
    // instructions
    break;
  case label2:
    //instructions
    break;
  default:
    // instructions
    break;
}

var: une variable dont la valeur est à comparer avec différents cas. Types de données autorisés: int, char.
label1, label2: constantes. Types de données autorisés: int, char

Le mot clé return

Terminez une fonction et renvoyez une valeur d’une fonction à la fonction appelante, si vous le souhaitez.

C’est ici que je mets un point à cet article sur le langage Arduino, nous découvrirons plus des notions en pratique et en suivant toujours ce cours.

A la prochiane leçon pour réaliser nos premiers montages électroniques avec Arduino !