Dans les fonctions de bases ”setup()” et ”loop()” obligatoires pour tous les programmes ou dans toute autre fonction, on utilisera les structures de langage suivantes :

1. Syntaxe de base

. Le point-virgule ;

Il est obligatoire à la fin de chaque instruction. Pour le compilateur, les sauts de lignes n’ont pas de signification : c’est le point-virgule qui marque la fin de ligne.

Oublier le point-virgule en fin de ligne donnera une erreur de compilation.

Exemple :

int a = 13;      // le point-virgule indique la fin de l’instruction

. Les accolades {}

Les accolades sont un élément majeur de la programmation en langage C.

Toute ouverture d’une accolade d’ouverture « { » doit obligatoirement être accompagnée dans le code d’une accolade de fermeture « } » correspondante. On dit souvent qu’il faut que les accolades soient équilibrées (càd autant de »{ » que de « } »).

L’Arduino IDE inclut une fonctionnalité pratique pour vérifier la correspondance des accolades entre elles. Il suffit de sélectionner une accolade, ou même de cliquer juste après une accolade, et l’accolade d’ouverture ou de fermeture associée sera mise en surbrillance.

Les accolades sont utilisées dans les fonctions, les boucles et les conditions

Exemples :

 – Avec des fonctions :

void myfunction(datatype argument){      // ouverture de la fonction          // instructions }                                                                          // fermeture de la fonction

– Dans des boucles :

while (boolean expression) { // accolade d’ouverture du code de la boucle while       // instructions } // fermeture de la boucle do { // accolade d’ouverture du code de la boucle do       // instructions } while (boolean expression); // fermeture de la boucle for (initialisation; termination condition; incrementing expr) { // ouverture du code de la boucle for      // instructions } // fermeture de la boucle

– Dans des conditions :

if (boolean expression) { // ouverture du code de la condition if      // instructions } // fermeture du code de la condition if else if (boolean expression) { // ouverture du code de l’instruction else if      // instructions } // fermeture du code de l’instruction else if else { // ouverture du code de l’instruction else      // instructions } // fermeture du code de l’instruction else

. // Les commentaires

Lorsqu’on écrit dans le programme derrière un double slash //, c’est pour donner des informations sur le programme. Les commentaires n’ont aucune action sur le programme.

On peut écrire un commentaire sur plusieurs lignes entre /* et */ .

Exemple : /*commentaire sur plusieurs lignes, commentaire sur plusieurs lignes, commentaire sur plusieurs lignes */

2. Les opérateurs arithmétiques

. opérateur d’assignement (signe égal unique) =

Cet opérateur stocke la valeur à droite du signe égal dans la variable à gauche du signe égal.

Le signe égal dans le langage de programmation C est appelé opérateur d’assignement. Il a un sens différent de celui qu’il a en algèbre où il indique une équivalence ou une égalité. L’opérateur d’assignement indique au microcontrôleur d’évaluer la valeur ou l’expression qui se trouve à droite du signe égal et de la stocker dans la variable à gauche du signe égal :

variable = valeur ;

Exemple :

int sensVal;   // déclare une variable entière de 16 bits nommée senVal senVal = analogRead(0);       // mémorise la valeur de la conversion analogique numérique dans la variable

. Addition + , Soustraction – , Multiplication * , et Division /

Ces opérateurs renvoient respectivement la somme, la différence, le produit ou le quotient entre deux opérandes (= entre deux termes).

Cette opération est réalisée en utilisant le type des données des opérandes. Ainsi par exemple, 9 / 4 donne 2 dès lors que 9 et 4 sont de type int.

Si les opérandes sont de deux types de données différents, le plus « grand » est utilisé pour le calcul.

Si un des nombres (opérandes) est du type float ou double, le calcul dit « en virgule flottante » est utilisé pour le calcul (càd que 9/4 donne 2.25).

– Syntaxe :

result = value1 + value2; result = value1 – value2; result = value1 * value2; result = value1 / value2;

– Exemple :

y = y + 3; x = x – 7; i = j * 6; r = r / 5;

1.3. Les opérateurs de comparaison

==, !=, <, >

sont des opérateurs logiques de comparaison :

• x == y (x est égal à y) • x != y (x est différent de 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)

1.4. Les opérateurs booléens

Ces opérateurs peuvent être utilisés à l’intérieur de la condition d’une instruction if pour associer plusieurs conditions (ou opérandes) à tester.

. && (ET LOGIQUE)

VRAI seulement si les deux opérandes sont VRAI, par exemple :

if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { // lit l’état de 2 entrées        // Instructions } // est VRAI seulement si les deux entrées sont à l’état HAUT simultanément.

. || ( OU LOGIQUE)

VRAI si l’un des deux opérandes est VRAI, par exemple :

if (x > 0 || y > 0) { // si x supérieur à 0 ou si y supérieur à 0       // Instructions } // est VRAI si soit x, soit y est supérieur à 0.

. ! (NON LOGIQUE)

VRAI si l’opérande est FAUX, par exemple :

if (!x) {      // Instructions } // VRAI si la variable x est FAUSSE (càd si x = 0)

 

1.5. Les opérateurs composés

. ++ (incrément) / — (décrément)

Ces opérateurs incrémentent ou décrémentent une variable entière de type int ou long (pouvant être unsigned).

– Syntaxe :

x++; // incrémente x de un, sans modifier x ++x; // incrémente x de un et modifie x x– ; // décrément x de un, sans modifier x –x ; // décrémente x de un, et modifie x

– Exemples :

x = 2; // variable x = 2 y = ++x; // x contient 3 et y contient 3 y = x++; // x contient toujours 2, y contient 3

. += , -= , *= , /=

Ces opérateurs réalisent une opération mathématique entre une variable x et une autre variable ou une constante y. Les opérateurs +,– ,* et / sont juste utiles pour raccourcir la forme complète des opérations mathématiques listées ci-dessous :

x += y; // équivaut à l’expression x = x+y x -= y; // équivaut à l’expression x = x- y x *= y; // équivaut à l’expression x = x * y x /= y; // équivaut à l’expression x= x / y

– Exemples :

x = 2; x += 4; // x contient 6 x -= 3; // x contient 3 x *= 10; // x contient 30 x /= 2; // x contient 15

 

1.6. Structures de contrôle

. if (condition)

L’instruction if (« si » en français), utilisée avec un opérateur logique de comparaison, permet de tester si une condition est vraie, par exemple si la mesure d’une entrée analogique est bien supérieure à une certaine valeur.

Le format d’un test if est le suivant :

if (uneVariable > 50) { // Action }

Dans cet exemple, le programme va tester si la variable uneVariable est supérieure à 50. Si c’est le cas, le programme va réaliser une action particulière.

Autrement dit, si l’état du test entre les parenthèses est vrai, les instructions comprises entre les accolades sont exécutées. Sinon, le programme se poursuit sans exécuter ces instructions.

Les accolades peuvent être omises après une instruction if. Dans ce cas, la suite de la ligne (qui se termine par un point-virgule) devient la seule instruction de la condition.

Tous les exemples suivants sont corrects :

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

. if / else

L’instruction if/else (si/sinon en français) permet un meilleur contrôle du déroulement du programme que la simple instruction if, en permettant de grouper plusieurs tests ensemble.

Par exemple, une entrée analogique peut-être testée et une action réalisée si l’entrée est inférieure à 500, et une autre action réalisée si l’entrée est supérieure ou égale à 500. Le code ressemblera à cela :

if (valsensor < 500) { // action A } else { // action B }

L’instruction else peut contenir un autre test if, et donc des tests multiples et exclusifs peuvent être réalisés en même temps.

Chaque test sera réalisé après le suivant jusqu’à ce qu’un test VRAI soit rencontré.
Quand une condition vraie est rencontrée, les instructions associées sont réalisées, puis le programme continue son exécution à la ligne suivant l’ensemble de la construction if/else.
Si aucun test n’est VRAI, le bloc d’instructions par défaut else est exécuté, s’il est présent, déterminant ainsi le comportement par défaut.

Un bloc else if peut être utilisé avec ou sans bloc de conclusion else.

Un nombre illimité de branches else if est autorisé.

if (valsensor < 500) { // action A } else if (valsensor >= 1000) { // action B } else { // action C }

. Boucle for

L’instruction for est utilisée pour répéter l’exécution d’un bloc d’instructions regroupées entre des accolades.
Un compteur incrémental est habituellement utilisé pour incrémenter et finir la boucle.
L’instruction for est très utile pour toutes les opérations répétitives et est souvent utilisées en association avec des tableaux de variables pour agir sur un ensemble de données ou broches.

Il y a 3 parties dans l’entête d’une boucle for :

for (initialisation; condition; incrementation) {       //instructions }

L’initialisation a lieu en premier et une seule fois. A chaque exécution de la boucle, la condition est testée.
Si elle est VRAIE, le bloc d’instructions et l’incrémentation sont exécutés, puis la condition est testée de nouveau. Lorsque la condition devient FAUSSE, la boucle stoppe.

Exemple :

for (int i=0; i <= 255; i++){  // boucle incrémentant la variable i de 0 à 255, de 1 en 1      //instructions } // fin de la boucle for

. Boucle while

Les boucles while (« tant que » en anglais) bouclent sans fin, et indéfiniment, jusqu’à ce que la condition ou l’expression entre les parenthèses ( ) devienne fausse.
Quelque chose doit modifier la variable testée, sinon la boucle while ne se terminera jamais. Cela peut être dans votre code, soit une variable incrémentée, ou également une condition externe comme le test d’un capteur.

while(expression){ // tant que l’expression est vraie      // instructions }

Avec expression, une instruction (booléenne) qui renvoie un résultat VRAI ou FAUX

Exemple :

var = 0; while(var < 200){ // tant que la variable est inférieur à 200 // fait quelque chose 200 fois de suite… var++; // incrémente la variable }

 

. boucle do – while

La boucle do / while (« faire tant que » en anglais) fonctionne de la même façon que la boucle while, à la différence près que la condition est testée à la fin de la boucle, et par conséquent la boucle do sera toujours exécutée au moins une fois.

– Syntaxe :

do // faire… {    // instructions } while (condition); // tant que la condition est vraie

– Exemple :

do // faire… { x = analogRead(A0); // lit la valeur de la tension d’un capteur } while (x < 100); // …tant que x est inférieur à 100

Remarque :

L’instruction break est utilisée pour sortir d’une boucle do, for ou while, en passant outre le déroulement normal de la boucle.

Exemple :

for (int i=0; i <= 100; i++){ // boucle incrémentant la variable i de 0 à 100, de 1 en 1 x = analogRead(A0); // lit la valeur de la tension d’un capteur if (x < 100) { break ; // si la mesure est inférieure à un seuil, on sort de la boucle } } // fin de la boucle for