1.9 Glossaire programmation Arduino

Avant de passer à la suite, je vous propose de vous remémorer tout ce qu’on a vu, voir un peu plus, dans ce glossaire en terme de programmation.

Les bases de la programmation : Les fonctions

Le programme de base ressemble à ceci :

void setup() {
// put your setup code here, to run once:

}

void loop() {
// put your main code here, to run repeatedly:

}

La fonction setup() qui s’exécute qu’une seule fois au démarrage de la carte et la fonction loop() se répète tant que la carte est allumée après que la fonction setup() se soit exécutée. Il vous suffira de remplir ces deux fonctions afin de créer votre programme. Puis vous pourrez aussi créez vos propres fonctions que vous pourrez utiliser n’importe où dans votre programme afin de ne pas avoir à répéter plusieurs fois les mêmes lignes de code et de rendre le programme plus lisible.

Les bases de la programmation : Les variables (et les commentaires)

Comme dans tout langage de programmation, Arduino utilise des variables. Elles peuvent contenir toutes sortes d’informations allant d’un nombre, à une suite de caractère en passant par une variable booléenne. Voici comment sont déclarée ces variables :

int entier = 0; //Déclaration d'une variable de type nombre entier
float decimal = 25,25; //Déclaration d'une variable de type nombre décimal
boolean vrai = true; //Déclaration d'une variable booléenne
int liste[] = {0,1,2}; //Déclaration d'une liste de variable

Vous pouvez déclarez le type de chaque variable avant la fonction setup()(sans forcément leur donner de valeurs) puis de les modifier par la suite dans le programme et de faire opérations mathématiques entre variables d’un même type comme ceci :

int nb = 10;
int nombre;

void setup() {
nombre = 1;
nombre++; //Permet d'ajouter 1 (incrémenter) la variable, fonctionne aussi avec --
}

void loop() {
nb /= nombre; //Equivaut à nb = nb / nombre
}

Si vous voulez plus d’informations sur les variables, vous pouvez consulter le tutoriel de mike118 disponible ici ou aller sur le site officielle d’Arduino contenant toute la doc (en anglais).

Vous verrez que dans certains de vos futurs programmes vous aurez un nombre conséquent d’informations dans le setup() et la partie le précédant. C’est pour évitez de s’y perdre que je vous conseille de structurer votre programme afin de le rendre plus lisible en mettant une sorte de titre en chaque fonction de votre programme (gestion des pins, déclarations de modules, étape dans le programme, …):

// Librairies :

// Pins E/S :

// Variables :

void setup() {

// Déclarations E/S :

// Servomoteur(s) :

// Ecran(s) LCD :

// Connectique :

}
void loop() {

}

N’hésitez pas à retirer les parties que vous n’utiliserez pas, et à commenter chaque partie de votre programme (y compris dans la fonction loop()). D’ailleurs pour créer des commentaires (parties de programme non exécutée) vous pouvez le faire comme ceci :

// Utilisez le // Pour créer un commentaire sur une ligne

/* Ou alors utiliser les balises /* */ et y placer votre commentaire
, celui-ci peut prendre autant de lignes que vous le désirez */

Les bases de la programmation : Utiliser les pins

Les pins sont les endroits sur la carte Arduino où l’on peut brancher les fils qui seront reliés aux composants. Comme on l’a vu dans la description des cartes, il y en a des digitaux et des analogiques et voici comment les utiliser :

int led = 13; //On crée une variable contenant le numéro du pin
//Cette action permet de ne pas avoir à modifier partout dans le programme lorsque l'on change de pins

void setup() {
pinMode(led, OUTPUT) ;//Déclare le pin associé à led comme une sortie
//INPUT Si on avait déclaré une entrée
}

void loop() {
digitalWrite(led, HIGH);
delay(500); //Delay permet de faire une pause dans le programme d'un temps donné en ms
digitalWrite(led, LOW);
delay(500);
/*Si la sortie avait été une sortie analogique on aurait écrit :
analogWrite(pin,255);
Et si l'on aurait souhaité lire une entrée digitale :
digitalRead(pin);
Ou si l'entrée est analogique :
analogRead(pin); */
}

Les instructions permettent de définir l’état d’une sortie (haut/bas pour une digitale, entre 0 et 255 pour une analogique) ou bien de lire une entrée. Elles sont très facile d’utilisation sur Arduino. Pour les lectures n’hésitez pas à les intégrées dans une variable afin de pouvoir l’utiliser facilement.
La déclaration du numéro d’un pin par un nom peut se faire de deux manière, grâce à une variable de type int (ou uint8_t si vous avez lu le tuto à propos de la gestion des variables) ou bien à l’aide de #define qui s’utilisent comme ceci :

#define LED 13

Pour une meilleure compréhension l’ensemble des symboles (valeur définie par un #define) sont écrites en majuscule comme ci-dessus. Car si les #define permettent d’optimiser l’espace utiliser par les variables (le #define intervient lors de la phase de compilation en remplaçant partout dans le programme le nom du symbole par sa valeur), les opérations mathématiques relatives aux variables ne sont pas valables pour les symboles. Les symboles ne sont pas seulement utilisés pour les numéros de pins mais toute valeur amenée à ne pas subir d’opération mathématique.

Les bases de la programmation : Les structures et boucles:

Ici, nous allons aborder les différentes structures et boucles que vous serez amenez à utiliser avec Arduino. On va commencer par la structure « Si…Alors » dont voici la syntaxe :

if (variable == 0) //Si variable est égal à 0
{
//Programme à exécuter si la condition est vérifiée
}
else //Si variable est différent de 0.
{
//Programme à exécuter si la condition n'est pas vérifiée
}

Sachez qu’il n’est pas obligatoire de placer un « else » après un « if » mais toujours obligatoire de mettre un « if » avant un « else ».
Ici la condition utilisée dans la structure « Si » est nommée variable et est testée pour variable égale à 0, mais elle aurait très bien pu être d’une autre forme :

if (variable != 0){} //variable différente de 0
if (variable < 0){} //variable inférieure à 0 if (variable >= 0){} //variable supérieure ou égale à 0

//Si la variable est de type booléenne :
if (variable == true){} //variable égale à vrai

//Si la variable contient du texte :
if (variable == "on"){} //si variable contient le mot on (et seulement ce mot)

De même les conditions peuvent être combinées à l’aide d’opérateurs logiques tel que and, or, not (et, ou, non) :

if (var1 == true AND var2 == true) {} // Si var1 ET var2 valent vrai
if (var1 < 10 OR var2 == 0) {} //Si var1 inférieur à 10 OU var2 égale à 0

Si vous avez beaucoup de conditions, il existe une alternative à la structure « Si…Alors.. » qui permet d’exécuter des lignes en fonction du retour de la variable testée (obligatoirement une variable du type int) dont voici sa syntaxe :

switch (variable)
{
case 0:
//Code à exécuter si variable égale à 0
break; //Marque la fin du cas et permet de sortir de la boucle switch
case 1:
//Code à exécuter si variable égale à 1
break;
default:
//Si aucune des possibilités citées ci-dessus ne sont vérifiées le code dans default s'exécutera.
//Ce cas n'est pas obligatoire si vous n'en avez pas besoin.
break;
}

La structure « Tant que… » qui s’écrit comme ceci :

while (variable == 0) //Tant que variable est égal à 0
{
//Code à exécuter
}

Permet d’exécuter du code tant qu’une condition est vérifiée.
Dans ce type de structure, il ne faut pas oublier de mettre à jour la condition afin d’en sortir au moment voulu.
Mais la structure « Tant que… » peut poser un problème dans certains cas car si la condition n’est pas vérifiée au moment de son exécution, la boucle ne sera pas exécutée. Pour palier à ce problème il existe une petite variante de la boucle nommée « Faire… Tant que… » dont la syntaxe est :

do
{

} while (condition == 0);

La dernière structure que vous devez connaitre est la structure « Pour », c’est une structure d’itération qui permet de répéter plusieurs fois les mêmes lignes de code. Elle pourra servir à lire les valeurs de plusieurs potentiomètre et à les afficher par exemple.La syntaxe de la structure « Pour » est :

int potentiometre[] = {};

for (variable = 0; variable < 5; variable++) //for (initialisation, condition, pas)
{
potentiometre[variable] = analogRead(variable); //Permet de stocker dans une liste les valeurs des potentiomètres connectés au pin A0, A1, A2, A3, A4;
}

Ici le pas est de +1 par itération (nombre de fois que le code s’exécute mais dans d’autres cas il pourra être de 40 voir négatif.

Les bases de la programmation : Les fonctions

A la manière des fonctions setup et loop il vous est possible de créer des fonctions vous permettant de ne pas avoir à récrire plusieurs fois les mêmes lignes (et donc les modifiées plus rapidement). Pour créer une simple fonction qui exécutera son bout de code dans son coin on utilise cette syntaxe :

void votreFonction()
{
  //Vos lignes de codes
}

Il vous suffira d’écrire ceci pour l’appeler où vous le souhaiter dans votre programme :

votreFonction();

Les parenthèses servent à contenir les arguments des fonctions si il y en a. Les arguments sont des valeurs dont la fonction a besoin pour fonctionner, on défini les arguments nécessaires comme ceci lorsque l’on déclare une nouvelle fonction :

void votreFonction(int heures, int minutes)
{
  Serial.print(heures);
  Serial.print(":");
  Serial.println(minutes);
}

Cette fonction par exemple vous permettra d’afficher dans l’interface Série l’heure que vous lui aurez fourni sous cette forme :

votreFonction(20,32) //Affichera 20:32 sur l'interface Série

Mais ce type de fonction n’est pas le seul utile à connaitre, en voici un exemple d’un retournant la valeur au carré du nombre en argument :

int mettreAuCarre(int nombre)
{
  nombre *=  nombre;
  return nombre;
}

Le type int de cette fonction nous permet d’utiliser la fonction return, qui comme son nom l’indique retourne la valeur qui le suit. Ce qui permet d’apeller la fonction sous cette forme:

int nombre = 2;
int nombreAuCarre = mettreAuCarre(nombre);

Donc ici nombreAuCarre sera égal à 4.

Un autre avantage des fonctions est la possibilités qu’une fonction puisse en appeler une autre :

Mais attention à ne pas vous y perdre, le but étant d’avoir toujours un programme explicite, n’hésitez donc pas à expliciter vos noms de fonctions

<- Retourner à la page précédente | Passer au chapitre suivant ->