Outils pour utilisateurs


Introduction à la programmation dans Arduino

La syntaxe

Les langages de programmation diffèrent des langages dits 'naturels' : dans un échange entre deux personnes, outre les règles d'une langue, les approximations verbales, les gestes ou l'intonation qui sont de nature culturelles, permettent de détecter et suivre le sens d'une conversation (ou encore d'y introduire de l'humour, des erreurs et des inadéquations).

Dans les langages informatiques un programme est régit par une syntaxe rigide. Elle se compose de définitions, de règles et de structures. Voici quelques règles générales du langage de programmation Arduino.

Chaque ligne est terminée par un ';' (sauf pour les fonctions)
Le code d'une fonction s'inscrit à l'intérieur d'accolades '{}'
Les arguments d'une fonction sont placés entre parenthèses '()'

La structure de base

Chaque programme Arduino se divise en trois parties :

1. Déclaration de variables

int uneVariable = 42; // une déclaration de variable de type 'int' (nombre entier), portant le nom 'uneVariable' et avec la valeur 42

2. Initialisation des entrées et des sorties

void setup() { // fonction d'initialisation, s'exécute une seule fois
// les broches sont déclarées ici en entrées ou en sortie 
// ou encore la communication sérielle est établie 

}

3. La fonction loop

void loop() {
// Le code placé à l'intérieur des accolades se répète en boucle.
}
exemple: communication_serielle

Les variables

Définition

Un espace réservé dans la mémoire de l'ordinateur pour y stocker de l'information on y réfère par un nom. Les noms des variables peuvent être de simples lettres (comme x ou y) ou être plus descriptifs (moyenne, vitesse, joltCola). La casse doit être respectée (y et Y sont des variables différentes) les noms de variables doivent débuter par une lettre et ne pas contenir d'accents, d'espaces, de points, de virgules et de noms réservés du langage Arduino.

Types de variables les plus courants :

int x = 42;     // le plus courant, nombre entier qui peut varier de -32,768 à 32,767
boolean merciBoole = TRUE;  // Peut garder une valeur soit vraie ou fausse
float  = 6.66; // un nombre fractionnaire 

Autres types de variables

La déclaration de variables

La création d'une variable est appelé “déclaration”. La déclaration d'une variable se fait en précédent le nom de la variable de son type.

int vitesseMoteur; // À sa création, la variable est indéfinie (undefined), elle ne contient aucune valeur. 
// Pour lui assigner une valeur nous utilisons l'opérateur d'affectation '='.

L'affectation d'une variable

L'opérateur d'affectation le plus simple est le signe “=”. Le premier réflexe est de penser que ce signe veut dire “égal à”. Ce n'est pas le cas. Contrairement à l'algèbre, il signifie que l'opérande de gauche se voit affecter la valeur de l'expression qui est à droite du signe égal.

On peut donc affecter une valeur à une variable comme ceci :

int x = 5; //  la variable type 'nombre entier' et portant le nom 'x' se voit affecter la valeur 5

Les variables peuvent être re-affectée comme ceci :

int vitesseMoteur = 42;
int vitesseMoteur = vitesseMoteur+624; // Dans ce cas la nouvelle valeur de vitesseMoteur est 666

Le cycle des variables (roll-over)

Lorsque les valeurs des variables dépassent leur borne maximale ou minimale (définie par le type de variable), elles 'cyclent'. Par exemple, pour un type de variable 'int' qui se nomme 'x' la borne maximale est de 32 767, si on ajoute '1' à cette valeur, la nouvelle valeur de x sera -32 768. Ceci est une source d'erreur fréquente.

   int x = 32 768;  // crée une variable x de type int (avec des bornes de -32 768 et 32 768)
   x = x + 1;       // x a maintenant une valeur de -32,768 et non 32769
   

Les fonctions

Introduction

Lorsque nous programmons, il arrive régulièrement que nous devions répéter une suite d'opérations à plusieurs reprises dans notre programme. Si la répétition s'exécute un nombre de fois déterminées, nous pourrions nous contenter de faire un copier coller. Par contre, si la répétition est dépendante de facteurs externes ou qu'elle peut varier à chaque exécution, le copier coller ne suffira plus. La plupart des langages nous permettent de regrouper ces opérations dans une structure que nous pouvons faire rouler lorsque nous en avons besoin. Dans l'environnement Arduino, cette structure s'appelle une fonction.

Déclaration de fonction

int maFonctionMultiplicatrice(int x, int y){ // une fonction portant le nom "maFonction" qui accepte deux arguments (x et y)
  int resultat; // déclaration de variable de type nombre entier
  resultat = x * y; // multiplication de x et y et assignation de la valeur résultante dans la variable 'resultat'
  return resultat; // pour retourner la valeur au reste du programme
}

  • Le type de données qui sera retournée par la fonction, dans ce cas, ce sera un nombre entier “int”. Si la fonction ne retourne rien au reste du programme, nous inscrivons “void”.
  • le nom de la fonction, ici “maFonction”, ce nom doit respecter les mêmes règles que les variables et ne doit pas être un mot réservé du langage Arduino.
  • Les parenthèses, toujours présentes. Elles nous permettent d'envoyer de l'information à la fonction lors de l'exécution. Elles doivent toujours être présentes, même lorsqu'il n'y a rien à transmettre elles restent alors vides.
  • le code de la fonction s'inscrit à l'intérieur des accolades '{}'

Appel de fonction

uneNouvelleVariable = maFonctionMultiplicatrice(6, 7);

Lorsque la fonction est ainsi appelée, elle est exécutée immédiatement et lorsqu'elle est complétée, l'exécution du programme reprend à partir du point d'appel de la fonction et l'énoncé suivant sera exécuté.

Valeur de retour

Avec le mot réservé “result”, la fonction est capable de renvoyer une valeur au programme appelant. Cette valeur est contenue dans une donnée en tout point comparable à une variable typée.


{
    ...
    return monResultat;                // renvoyer le résultat
}

Les énoncés conditionnels

Il existe quatre types d'énoncés conditionnels : les boucles 'for' et 'while' et les conditions 'if…else' et 'switch/case'. Ils servent à exécuter une section de code lorsqu'une certaine condition est vraie.

boucle for

// Le code entre accolades sera exécuté à répétition tant que 
// la valeur de 'i' reste inférieure à 100.  Cette structure est 
// utile comme compteur.

for(int i=0;i<100;i++)
 {
 Serial.println(i); // afficher la valeur de 'i' dans la console
 delay(1000);       // pause de 1 seconde
 }

boucle while

Le code entre accolades est exécuté tant que la condition est vraie. Cette structure est utile pour des événements comme des interrupteurs ou pour exécuter du code tant que la valeur d'un senseur est inférieure ou supérieure à un seuil donné.

// le code sera exécuté tant que la valeur d'un interrupteur est 'HIGH'
  while (digitalRead(monBouton) == HIGH) {
    executeCetteFonction(); 
  }
  

if

// Si la valeur de monSenseur est plus grande que 42 alors 
// le code entre les accolades sera exécuté.  

if(monSenseur==42)
 {
    //allume une DEL!
    digitalWrite(13,HIGH);
 }

switch/case

Comme un 'if' avec plusieurs conditions.


  switch (maVariable) 
  {
    case 42:
      //exécuter cette partie lorsque maVariable est égale à '42'
      break;
    case 666:
      //exécuter cette partie lorsque maVariable est égale à '666'
      break;
    default: 
      // si aucune condition n'est vraie, cette partie est exécutée
      // cette partie est optionnelle
  }

Sources