1.  Survol

2.  L'essentiel

Un programme Arduino nécessite deux fonctions au minimum :

• setup ()
• loop ()

La fonction setup() est la fonction d'initialisation et la fonction loop() est la fonction d'execution.

Dans la fonction setup() vous initialisez la carte. Typiquement vous utiliserez des fonctions comme pinMode, beginSerial, etc.

Dans la fonction loop() vous inscrirez le comportement de votre programme. Cette fonction répète indéfiniment ce qui y est inscrit.

L'extrait de code qui suit, donne la structure minimale d'un programme Arduino:

void setup()
{
}

void loop()
{
}

3.  Commentaires

Un commentaire est une portion de texte destiné à être lu par un humain. Lors de l'évaluation et de la compilation du code, tout commentaire est ignoré par la machine. Les commentaires permettent au développeur de relire une portion de code et de s'en remémorer rapidement l'articulation. De plus, ils indiquent plusieurs informations supplémentaires.

Un commentaire peut-être créé de deux façons:

• en précédent un segment de ligne par //
• en commençant un paragraphe par /* et en le terminant par */

Exemples de commentaires:

//Definir le prix d'un litre d'essence
prixPetroleBrut = 48;
//Definir le cout de la taxe pour un litre d'essence
prixTaxe = 52;

prixPetroleBrut = 48; //Definir le prix d'un litre d'essence
prixTaxe = 52; //Definir le cout de la taxe pour un litre d'essence

/*
Definir le prix d'un litre d'essence
Definir le cout de la taxe pour un litre d'essence
*/

Tout document de code devrait commencer avec une en-tête contenant les informations suivantes:

• l'auteur
• un résumé du code
• la licence
• la date de création
• la version

Exemple:

*/--------------------------------------------------------------------------
interface to native HID (Human Interface Devices) API
Written by Joe Blow <joeblow@hotmail.com>
Copyright (c) 2004-2006 Joe Blow
--------------------------------------------------------------------------*/

4.  Ponctuation

4.1  Accolades {}

Les accolades délimitent des portions de code que l'on appèle des blocs. Ces blocs peuvent servir à définir:

• une fonction,
• une classe,
• les éléments d'un tableau?,
• ou le code à exécuter si une condition est vraie.

Exemple d'une fonction:

void write() {
        digitalWrite (LED1, HIGH);
        digitalWrite (LED2, LOW);
        i = 1;
}

4.2  Points-virgules ;

Les points-virgules servent a séparer des commandes. On les retrouve habituellement à la fin de chaque ligne.

prixPetroleBrut = 48;
prixTaxe = 52;

4.3  Points .

Les points (.) sont employés de diverses façons. Ils permettent principalement de référer à un élément faisant parti d'une hiérarchie: l'élément à droite du point fait parti de l'élément à gauche du point. En programmation orientée objet, le point sert à accéder aux méthodes et aux propriétés d'un objet.

Dans l'exemple suivant «begin()» est une méthode de «Serial»:

function setup() {
        Serial.begin(19200);
}

4.4  Parenthèses ()

Les parenthèses servent entre autres, à:

• définir l'ordre d'exécution d'instructions
• différencier entre un appel à une fonction et à une variable
• passer des arguments une fonction.

Dans l'exemple qui suit, nous savons que « random » est une fonction parce qu'elle est suivie de parenthèses. « quantity » est une variable, et de par sa position, elle est un argument de la fonction « random »:

apples = random( quantity );

4.5  Guillemets "

Les guillemets servent à définir une chaîne de caractères (les strings en anglais) qui ne sont pas interprétés en tant instructions, mais en tant que donnés.

Dans l'exemple suivant, nous créons un tableau qui contient les caractères arduino:

char chaine[ ] = "arduino";

4.6  Apostrophe '

L'apostrophe indique au programme d'emmagasiner un seul caractère dans une variable. Le caractère est encodé en valeur numérique selon la norme ASCII?.

Dans cette exemple, la variable lettre a comme valeur numérique 65 (selon l'ASCII?, la lettre A majuscule correspond au nombre 65):

char lettre = 'A';
lettre == 65;
lettre == 'A';

4.7  Espaces

De façon générale, les espaces sont ignorés par le programme, mails ils contribuent grandement à la lisibilité du code.

Par contre:

• il faut séparer par des espaces les mots clés et les noms de variables et de fonctions;
• il ne faut pas mettre d'espaces dans les mots clés, les noms de variables ou de fonctions;
• il ne faut pas insérer d'espaces avant ou après un point (.).

Les deux lignes suivantes sont équivalentes:

char nomDuRobot[ ] = "astro";
char nomDuRobot [ ]="astro" ;

Par contre, la ligne suivante n'est pas équivalente aux précédentes parce que la chaîne de caractères qui y est définie est différente (elle commence et se termine par des espaces). Dans l'exemple précédent, la chaîne de caractères avait une longueur de 5. Dans celui-ci, elle a une longueur de 7 caractères.

char nomDuRobot[ ] = " astro ";

5.  Variables

Les variables sont des éléments que vous pouvez utiliser dans vos programmes pour stocker des valeurs changeantes. Par exemple la valeur d'un capteur lue sur une entrée analogique. Les variables sont typées. Selon leur type, elles seront interprétées et stockées différemment. Attention, les variables décimales et leurs opérations associées ne sont pas gérées actuellement.

La carte Arduino reconnaît plusieurs types de variables. Les types suivant sont les plus couramment utilisés:

• int (16 bits)
• byte (8 bits)
• char (8 bits)
• unsigned long (32 bits)

D'autres types reconnus:

• unsigned int (16 bits)
• long (32 bits)
• float (32 bits)
• double (32 bits)
• boolean (8 bits)

5.1  int

Le type int définit un espace de stockage de deux octets (16 bits) permettant d'affecter à la variable associée une valeur entière comprise entre -32 768 et 32 767.

Exemple:

int capteur = analogRead(3);

5.2  byte

Le type byte définit un espace de stockage d'un octet (8 bits) permettant d'affecter à la variable associée une valeur entière comprise entre 0 et 255.

Exemple:

byte valeur = 64;

5.3  char

Le type char définit un espace de stockage d'un octet (8 bits) permettant d'affecter à la variable associée une valeur entière comprise entre -128 et 127. Ce type de variable, dont le nom est une abréviation de caractère, est généralement utilisé pour stocker des caractères ASCII?.

Exemple:

char lettre = 'a';

5.4  unsigned long

Le type unsigned long définit un espace de stockage de quatre octets (32 bits) permettant d'affecter à la variable associée une valeur entière comprise entre 0 et 4,294,967,295.

Exemple:

unisgned long temps =  millis();

6.  Constantes

Les constantes sont des variables spéciales dont la valeur ne change pas lors de l'exécution du programme.

6.1  Constantes prédéfinies

Arduino prédéfini les constantes suivantes :

• HIGH (présence de courant, état haut)
• LOW (masse/terre/GND, état bas)
• INPUT (entrée)
• OUTPUT (sortie)
• true (vrai)
• false (faux)

7.  Définition de constantes

En plus de faciliter la lecture et la modification du code, les constantes ne prennent aucun espace mémoire parce que les valeurs sont substituées à leurs noms au moment de la compilation. Vous pouvez définir vos propres constantes grâce à la commande #define. La syntaxe de la commande est la suivante:

#define nomConstante valeur

Contrairement à l'ensemble de la syntaxe Arduino, une commande #define ne doit pas se terminer par un point virgule.

Dans cet exemple, toutes les occurrences de la constante TEMOIN sont remplacées par le chiffre 13 au moment de la compilation:

#define TEMOIN 13


// initialisation
void setup()
{
        pinMode(TEMOIN,OUTPUT);
}

// clignotement du témoin
void loop()
{
        digitalWrite(TEMOIN,HIGH); // allumer le témoin
        delay(1000); // pause 1 seconde
        digitalWrite(TEMOIN,LOW); // éteindre le témoin
        delay(1000); // pause 1 seconde
}

8.  Instructions conditionnelles

L'enchaînement d'instructions conditionnelles permet de réaliser des structure conditionnelles qui contrôlent l'ordre dans lequel les différentes instructions d'un programme sont exécutées.

Arduino permet deux types de structures conditionnelles:

• if... else if... else
• switch... case... default

8.1  if... else if... else

Une structure conditionnelle if... else if... else doit toujours commencer par une instruction if. Cette première instruction peut ensuite être suivie de plusieurs instructions facultatives else if. L'instruction else, aussi facultative, termine la structure.

Le modèle d'une structure conditionnelle if... else if... else est le suivant:

if() { }
else if () {} //facultative
else if () {} //facultative
...
else {} //facultative

If

L'instruction if vérifie une déclaration qui doit être placée entre parenthèses ( ). Si la déclaration s'avère vraie, le bloc de code entre accolades { } est exécuté, sinon, il est ignoré:

if ( //si ce qui est stipulé ici est vrai )
{
        //faire ceci;
}

Dans l'exemple suivant, la fonction quitterLePays() ne s'exécute que si la valeur de la variable harperEstÉlu est vraie:

if ( harperEst�lu )
{
        quitterLePays();
}

Il est possible d'écrire une instruction conditionnelle if sur une seule ligne si le bloc de code à exécuter n'en contient qu'une seule lui aussi:

if ( déclaration ) code;
if  ( harperEst�lu ) quitterLePays();

else

L'instruction else est complémentaire à l'instruction if. Elle exécute un bloc de code si aucune des conditions précédentes ne s'est avérée vraie.

Il ne peut y avoir qu'une seule instruction else par structure conditionnelle et cette instruction doit terminer la structure.

if (//ce qui est stipulé ici est vrai)
{
        //faire ceci
} else {
        //sinon faire ceci
}

Dans l'exemple suivant, si la valeur de la variable pretEtBourse est inférieure à 3000, la fonction allerEnGreve() est exécutée, sinon c'est la fonction etudierArduino() qui l'est:

if (pretEtBourses < 3000)
{
        allerEnGreve();
} else {
        etudierArduino();
}

else if

L'instruction else if est complémentaire à l'instruction if. Elle exécute un bloc de code si:

• aucune des conditions précédentes ne s'est avérée vraie et
• si la déclaration entre parenthèses qui la suit s'avère vraie.

if (//ce qui est stipulé ici est vrai)
{
        //faire ceci
} else if (//ce qui est stipulé ici est vrai) {
//faire cela
}

Dans l'exemple suivant, si la valeur de la variable pretEtBourse est inférieure à 3000, la fonction allerEnGreve() est exécutée. Si la valeur est entre 3000 et 5000, c'est allerTravailler() qui est exécuté:

if (pretEtBourses < 3000)
{
        allerEnGreve();
} else if ( pretEtBourses < 5000) {
        allerTravailler();
}

À éviter

instructions conditionnelles à la queue leu leu

Prenons l'exemple suivant:

if (a == 1) {
        // faire une chose
}
if (a == 2) {
        // ou en faire une autre
}
if (a == 3) {
        // ou en faire une troisième
}

La version suivante est beaucoup plus rapide, simple et réduit la possibilité de bugs parce qu'elle n'utilise qu'une seule instruction conditionnelle:

if (a == 1) {
        // faire une chose
} else if (a == 2) {
        // ou en faire une autre
} else  if (a == 3) {
        // ou en faire une troisième
}

instructions conditionnelles imbriquées

Plutôt que d'utiliser plusieurs instructions conditionnelles( if, if/else,...) imbriquées, il est préférable d'utiliser une seule instruction conditionnelle intégrant plusieurs opérateurs de comparaison.

Suivent deux exemples qui permettent de déterminer si un point (x,y) est à l'intérieur des limites d'un rectangle (gauche,haut,droite,bas).

Même si elle est fonctionnelle, cette première version du code est à éviter:

if (x > gauche ) {
        if (x < droite) {
                if (y < haut) {
                        if  (y > bas) {
                                //le point est à l'intérieur du carré
                        }
                }
        }
}

Voici une solution plus élégante et surtout plus rapide:

if ( (x > gauche ) && (x < droite) && (y < haut) && (y > bas) ) {
        //le point est à l'intérieur du carré
}

8.2  switch... case... default

Une structure conditionnelle switch... case... default doit toujours commencer par une instruction switch. Cette première instruction peut ensuite être suivie de plusieurs instructions facultatives case. L'instruction default, aussi facultative, termine la structure.

Cet type de structure conditionnelle permet de créer une liste de cas. Une valeur sera comparée à chacun des cas et Arduino effectuera les instructions du cas correspondant. Dans le cas ou vous utiliser l'instruction default, les instructions correspondantes seront exécutées si aucun autre cas ne correspond à la valeur de comparaison.

La structure switch... case... default ne fonctionne qu'avec des valeurs numériques.

Le modèle d'une structure conditionnelle switch... case... default est le suivant:

switch() {
        case ... : //facultative
        break; //facultative
        ...
        default: //facultative
}

L'instruction switch commence la structure conditionnelle et définit la valeur de comparaison entre parenthèses.

L'instruction case établit un cas. Si la valeur de comparaison est égale (==) au cas, l'instruction exécute le bloc de code qui suit les deux points (:) jusqu'au premier break. S'il n'y a pas d'instruction break, tout les blocs de code des case suivant le case courant sont aussi exécuté.

Le bloc de code suivant l'instruction default est exécuté si aucun break n'a été rencontré.

switch (var)
{
        case 1:
        // faire quelque chose quand var est égale à 1
        break;
        case 2:
        // faire quelque chose quand var est égale à 2
        break;
        default:
        // si aucun cas ne corespond, faire autre chose
}

9.  Boucles

9.1  while

L'instruction while permet de répéter une bloc de code tant que la déclaration entre parenthèses est évaluée comme étant vraie:

while ( //tant que ceci est vrai ) {
//exécute ceci
}

Dans l'exemple suivant, un compteur augment tant et aussi longtemps que l'entrée numérique 6 est au niveau haut:

int compte = 0;
while ( digitalRead(6) == HIGH ) {
        compte = compte + 1;
}

9.2  do... while

L'instruction do... while est similaire à l'instruction whileavec la différence que l'évaluation de la déclaration est reportée en fin de boucle:

do {
        //exécute ceci (au moins une fois)
} while ( //tant que ceci est vrai );

Cette instruction permet de faire une première itération de la boucle avant d'évaluer la comparaison. Ainsi, la boucle est toujours exécuté au moins une fois!

Dans l'exemple suivant, do... while nous permet d'initialiser la valeur d'element avant d'en faire l'évaluation:

byte[] tableau = {4,5,4,3,7,0,4};
byte index = 0;
byte element;
do {
        element = tableau[index];
        index = index + 1;
} while ( element != 0 )

9.3  for

L'instruction for prend la forme générale suivante:

for ( //initialisation ; //condition ; //transition ) {
// bloc de code
}

Les parenthèses suivant l'instruction contiennent trois parties:

• initialisation: instruction exécutée une seule fois avec le premier passage dans la boucle;
• condition: condition qui est vérifiée avant chaque exécution de la boucle. La boucle ne s'exécute que si la condition est évaluée en tant que vraie.
• transition: instruction a effectuer après chaque exécution de la boucle.

On utilise en général les boucles for lorsque le nombre de passage dans la boucle est connu dès le départ. C'est un compteur (souvent une variable nommée i) qui sert à déterminer le nombre de passages. Ainsi, pour répéter n fois une suite d'instructions, on utilisera le modèle suivant :

for (int i=0; i<n; i=i+1) {
        //instruction1
        //instruction2
        ....
}

Le compteur i part de 0. Grâce à l'instruction i=i+1 il est incrémenté (augmenté d'une unité) avant chaque nouveau passage. La boucle n'est plus exécutée lorsqu'il prend la valeur n. Comme on est parti de 0, le nombre de passage dans la boucle est bien égal à n.

http://b.kostrzewa.free.fr/javascript/td-boucles/bouclefor.html

Dans l'exemple suivant, la boucle for permet de sauvegarder l'état de toutes les broches numériques (broches 2 à 13) de l'Arduino dans un tableau:

int[12] niveaux;
for (int i=2; i < 14; i=i+1) {
        niveaux[i-2] = digitalRead(i);
}