Bases de programmation

L'environnement Arduino

L'environnement de développement (IDE) permet d'écrire son programme en faisant un peu de coloration syntaxique sur les mots-clés, les noms de fonctions, ... spécifiques à Arduino. Mais plus intéressant, il permet de compiler (c'est à dire, transformer le code écrit par un humain en une version compréhensible par le micro-contrôleur) notre programme en s'adaptant au type de carte Arduino que l'on possède. Pour cela, il faut aller renseigner cette information dans le menu Outils / Carte.

Si des erreurs de programmation sont détectées, elles sont affichées en bas de la fenêtre, dans la zone noire. Il faut toujours commencer par corriger la première erreur avant même de tenir compte des autres. Souvent, cette première erreur en engendre d'autres qui ne sont pas réellement des erreurs. Il faut donc la corriger et recompiler. Bien entendu, une relecture attentive de votre code vous permettra d'éviter ces erreurs à la compilation.

Une fois le programme mis au point et compilant sans erreur, il est temps de le téléverser. Pour cela, il faut commencer par sélectionner le port série qui a été affecté à notre carte Arduino lorsqu'elle a été branchée à un port USB de notre ordinateur. Cette affectation se fait par le système d'exploitation et le nom, l'ordre, ou tout autre considération à propos de ce port, va dépendre du dit système. Sous Windows, vous aurez des ports COM, sous MacOS et Linux, ils auront des noms un peu plus compliqués comme tty.usbxxxxxxx ou /dev/usbxxxx. Le plus délicat est de choisir le bon. Pour ce faire, le mieux est de regarder la liste avant de brancher la carte Arduino sur le port USB et de choisir celui qui est apparu une fois la carte branchée.

À l'aide !

En plus de proposer un environnement pour écrire, compiler et téléverser les programmes, l'environnement Arduino dispose d'une aide en ligne (que vous soyez connecté à l'Internet ou pas) pour chacune des fonctions qu'il propose. Elle est accessible soit via le menu Aide / référence, soit en sélectionnant le nom d'une fonction et en faisant un clic droit dessus.

L'avantage de la documentation trouvée via les moyens décrits ci-dessus est que vous obtenez des explications pour les fonctions installées sur votre système. Aller chercher celles disponible sur le site Arduino est également possible, mais vous n'aurez les informations que pour la toute dernière version des bibliothèques.

setup() et loop()

Tout d'abord, les passages obligés. Vous allez écrire dans un langage de programmation spécifique qui, comme tout langage de programmation, a des règles strictes d'écriture.

Dans le cadre d'Arduino, ces règles se limitent à l'utilisation de deux fonctions : setup() et loop(). La première n'est exécutée qu'une seule fois à chaque démarrage du micro-contrôleur et a pour vocation de configurer les différents ports d'entrée/sortie, d'initialiser les différentes variables que l'on va utiliser. Ensuite, la seconde est exécutée en boucle, à l'infini, tant que le micro-contrôleur n'est pas mis hors tension. C'est le cœur de notre programme, là où tout va se faire.

Ci-dessous, vous est présenté un code Arduino minimal.

void setup()
{ }

void loop()
{ }

Vous remarquerez que nos deux fonctions sont précédées d'un mon clé particulier (void), qui signifie que cette fonction ne produit pas de valeur de retour. Nous verrons ça plus en détail dans la section suivante.

Vous remarquerez également que chacune de ces fonctions est suivi d'un couple de parenthèses. C'est ce qui défini que ce sont effectivement des fonctions. Parfois ces parenthèses sont vides, parfois elles contiennent des noms qui sont les arguments de la fonction (les données sur lesquelles notre fonction va travailler).

Enfin, en plus du couple de parenthèses, il y a un couple d'accolades. Elles aussi sont obligatoires. Elles définissent les limites des instructions qui font la fonction. On appelle ça un bloc d'instruction, c'est à dire l'ensemble des instructions qui vont être exécutées à chaque fois que ma fonction sera appelée.

Mais où est main() ?

Les personnes ayant déjà programmées en C/C++ se demanderont pourquoi il n'y a pas la seule fonction obligatoire dans ces langages, c'est à dire la fonction main().

En réalité, cette fonction est présente, mais elle est entièrement prise en charge par l'environnement Arduino. Le réel code qui sera compilé est en fait le suivant :

void setup()	// fonction définie par l'utilisateur
{ }

void loop()	// fonction définie par l'utilisateur
{ }

void main()	// fonction définie par l'IDE Arduino
{
	setup() ;

	for (;;) loop() ;
}

Commentaires

Il est possible d'ajouter des commentaires dans le code. C'est à dire des phrases, des paragraphes, des bouts de texte, qui ne seront jamais pris en compte par le compilateur, mais qui servent de pense-bête, de moyen de communication entre différents programmeurs.

Ces commentaires, pour être différenciés du code environnant, doivent avoir une syntaxe particulière. Ici, il y a deux façons de faire.

Soit le commentaire concerne une ligne et une seule, alors il suffit de le faire commencer par le couple de caractères //. Tout ce qui est entre ces caractères et la fin de la ligne n'est pas pris en compte.

Soit ils concernent plusieurs lignes et il faudra marquer le début et la fin du bloc de commentaire, respectivement par /* et */. Tout ce qui se trouve entre ces deux couples de caractères sera ignoré.

Il est possible de mettre autant de commentaire que l'on désire, où on le désire, dans la langue que l'on désire. C'est une aide précieuse et une mémoire à ne pas négliger quand on devra revenir sur un programme quelques mois plus tard.

/**
 * Programme ne servant à rien si ce
 * n'est à montrer comment écrire des
 * commentaires.
 */

#define LED 11	// ma LED sera branchée sur le port 11
const int serial_speed = 9600 ;	// ne pas oublier de régler le moniteur série à ma même vitesse

/**
 * Cette fonction n'est exécutée qu'une seule
 * fois au début du programme.
 */
void setup()
{ 
	// Faire toutes les initialisations
}

/**
 * Cette fonction est exécutée en boucle
 * tant que le micro-contrôleur n'est pas mis
 * hors tension.
 */
void loop()
{
	// Ici c'est la boucle principale où tout se passe
}

Variables et types

Une variable, dans un programme informatique, c'est une zones dans la mémoire de l'ordinateur, qui est nommée et dans lesquelles il est possible de lire et d'écrire des valeurs. Ces zones nommées sont crées par le programmeur en définissant de nouvelles variables qui lui permettront de résoudre son problème.

Le langage que nous utilisons est un langage typé, c'est à dire qu'il est obligatoire de donner un type aux variables que nous définissons.

Une variable a donc, pour être correctement formée, un type et un nom.

Les nom d'une variable peut être presque n'importe quoi à partir du moment où :

• le nom n'est pas déjà utilisé ;
• le nom ne commence pas par un chiffre ;
• le nom ne contient pas d'autres caractère que : des lettres de l'alphabet (majuscules et minuscules), le caractère _ et des chiffres.

Le type dépend de l'utilisation que l'on va faire de la variable et il est à choisir dans la liste suivante :

• void, le type qui représente le fait qu'il n'y a pas de type. Rarement utilisé tel quel pour des variables, il sera plus utile pour les fonctions.
• byte, c'est une valeur entière représentée sur un octet, soit sur 8 bits. Les valeur possibles varient entre 0 et 255.
• char, c'est une valeur entière représentée sur un octet, soit sur 8 bits. Les valeur possibles varient entre -128 et 127.
• int, c'est une valeur entière représentée sur deux octets, soit sur 16 bits (sur la plupart des Arduino). Les valeur possibles varient entre -32 768 et 32 767.
• long, c'est une valeur entière représentée sur quatre octets, soit sur 32 bits. Les valeur possibles varient entre -2 147 483 648 et 2 147 483 647.
• float, double, ce sont des valeurs décimales représentées sur quatre octets, soit 32 bits. Les valeurs représentables varient de -3,4028235E+38 à 3,4028235E+38. Mais attention, la représentation informatique des nombres à virgule flottante est complexe et ne permet pas de représenter tous les nombres dans cet intervalle (il serait magique de pouvoir représenter un nombre infini de valeur sur un nombre fini de bits). Les calculs faits avec des flottants sont rarement justes, mais ne le sont qu'à une décimale près. La précision est de 6 à 7 nombres, partie entière et partie décimale comprise.

Les types entiers (char,int, long) peuvent être qualifiés par le mot-clé unsigned. Il ne pourront alors plus prendre de valeur négative, mais en compensation, la valeur maximale représentable dans les positifs sera doublée (respectivement 255, 65 535 et 4 295 967 295).

D'autres types existent, hérités du C++ ou crées pour Arduino. Vous les retrouverez sur l'aide en ligne et nous ne les détaillerons pas ici. En effet, les types précédents suffisent pour résoudre les problèmes courants que l'on pourra rencontrer.

Par contre, il existe d'autres types, hérité de l'environnement wiring duquel est tiré le langage utilisé par l'Arduino, qui n'ont rien de nouveau, mais qui sont pratiques en ce sens qu'ils explicitent leur occupation mémoire.

• int8_t, uint8_t, un entier sur 8 bits, signé et non signé.
• int16_t, uint16_t, un entier sur 16 bits, signé et non signé.
• int32_t, uint32_t, un entier sur 16 bits, signé et non signé.

La figure suivante donne un exemple de déclaration de variables. Vous remarquerez également à cette occasion la présence du caractère ; à la fin de cette ligne. Le caractère ; est obligatoire à la fin de toute instruction en C/C++. Déclarer une variable est une instruction.

int compteur ;	// une variable globale
float moyenne ;	// une autre variable globale

void setup()
{ }

void loop()
{ }

int compteur ;	// une variable globale
int valeurs[10] ; // un tableau de 10 valeurs entières
float moyenne ;	// une autre variable globale

void setup()
{
  valeurs[0] = 0 ;
  valeurs[1] = 76 ;
  valeurs[2] = 121 ;
  valeurs[3] = 153 ;
  valeurs[4] = 178 ;
  valeurs[5] = 198 ;
  valeurs[6] = 215 ;
  valeurs[7] = 230 ;
  valeurs[8] = 243 ;
  valeurs[9] = 255 ;
}

void loop()
{ }

Constantes

En plus des variables, il est possible de définir des constantes, c'est à dire des entités dont la valeur ne pourra pas être modifiée.

#define LED 11

void setup()
{ }

void loop()
{ }

const int speed = 9600 ;

void setup()
{ }

void loop()
{ }

Opérateurs de test

Un test revient à se poser la question « est-ce qu'une valeur est inférieure, égale, ou supérieure à une autre valeur ? ». Il faut pour cela disposer des opérateur adéquats et il se trouve que l'environnement Arduino nous propose les principaux qui sont <, <=, ==, !=, >= et >. Soit respectivement, inférieur, inférieur ou égal, égal, différent, supérieur ou égal et supérieur.

Condition de réussite

Ces opérateurs retournent tous une valeur en fonction du résultat du test. Si l'expression est fausse, une valeur nulle (0) est retournée. C'est donc le code pour dire « c'est faux ». Toute autre valeur est considérée comme étant vraie, ou un synonyme de « c'est vrai ».

Grouper les tests

Enfin, il est possible de faire des groupes de tests en reliant chacun des sous-tests par des opérateurs logiques. Il existe principalement trois opérateurs logiques utilisables pour cascader les tests :

• le ET (symbole &&) qui veut que le test soit vrai si tous les sous-tests de l'expression sont vrais ;
• le OU (symbole ||) qui veut que le test soit vrai si au moins un des sous-tests de l'expression est vrai ;
• le NON (symbole !) qui inverse le résultat d'un test.

Vous pouvez voir un exemple d'utilisation des groupes de tests dans l'exemple complet, plus bas.

Réagir selon le résultat du test

Une fois que l'on a une condition, il faut pouvoir réagir en fonction du résultat. Pour cela, il existe un mot clé réservé, qui est la structure de test if. Un exemple d'utilisation est donné ci-dessous.

#define LED 11

const int serial_speed = 9600 ;

int compteur ;
float moyenne ;

void setup()
{
  Serial.begin(serial_speed) ;	// Initialisation de la ligne série

  Serial.println("Compte des tours de loop()") ;	// Impression d'un message
  
  compteur = 1 ;

  Serial.println("C'est parti !") ;
}

void loop()
{
  /* Impression d'un message composé d'un texte,
   * de la valeur d'une variable et d'un autre texte.
   */
  Serial.print("Je suis dans la boucle pour la ") ;
  Serial.print(compteur) ;
  if ( compteur == 1 ) {
    // On vient ici si la condition est vraie
    Serial.println("ere fois") ;
  } else {
    // On vient ici si la condition est fausse
    Serial.println("eme fois") ;
  }

  compteur = compteur + 1 ;
}

Ce qu'il faut retenir c'est la syntaxe du if dont le test est obligatoirement entre parenthèses et qui est éventuellement suivi d'un else qui indique la suite d'instructions à exécuter dans le cas où le test serait faut.

Des constructions plus complexes peuvent exister, du type

if ( test )
{
  instructions
}
else if ( test )
{
  instructions
}
else
{
  instructions
}

où il peut y avoir autant de blocs else if que nécessaire et éventuellement (il n'est pas obligatoire) un unique bloc else pour terminer la structure.

Les tests permettent donc d'altérer le comportement séquentiel d'un programme en sautant éventuellement des blocs d'instructions.

Base 2 (binaire)

La base 2 ne comprend que deux valeurs pour représenter ses nombres : 0 et 1. Pourtant, grâce à cela il est possible de représenter tous les nombres entier que l'on désire. Par exemple :

Le nombre en base 2 est représenté comme un polynôme dont les facteurs sont les valeurs binaires et dont les termes sont les puissances de 2 consécutives. Par exemple, pour représenter 6_base 2, on a :
110_base 2 = 1 × 2² + 1 × 2¹ + 0 × 2⁰ = 6_base 10.

La représentation binaire est celle réellement utilisée dans le cœur des ordinateurs. Ils calculent comme ça et tous les nombres que nous écrivons sont automatiquement transformés en base 2.

Il est bien entendu possible de représenter les nombres négatifs. Pour cela, un mécanisme appelé le complément à deux est utilisé.

Base 16 (hexadécimale)

La base hexadécimale fonctionne sur le même principe que la base 2, mais nous disposons à présent de 16 signes (base 16) pour représenter les nombres : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

Là encore, il est possible de représenter tous les nombres entier grâce à la base 16. Par exemple :

Le nombre en base 16 est représenté comme un polynôme dont les facteurs sont les valeurs de la représentation hexadécimale et dont les termes sont les puissances de 16 consécutives. Par exemple, pour représenter 12345_base 10, on a :
3039_base 16 = 3 × 16³ + 0 × 16² + 3 × 16¹ + 9 × 16⁰ = 12345_base 10.

On peut remarquer que la représentation de 255_base 10 est 11111111_base 2 mais aussi FF_base 16. C'est la valeur maximale que peut prendre 1 octet (un groupe de 8 bits).

Autant la notation en base 2 est rarement utilisée directement dans les programmes, autant il est fréquent de devoir écrire des nombres en base 16. Pour que notre compilateur s'y retrouve, nous devons lui préciser que la base est différente. Les nombres en base 16 seront pour cela, toujours préfixés des deux caractères 0x. Le bout de code suivant donne des exemples d'initialisation de variables entières.

int a = 1 ;	// valeur 1, quelle que soit la base
int b = 0x10 ;	// valeur 16 exprimée en base 10
int o = 0xFF ;	// valeur 255 exprimée en base 10