S’APPROPRIER LE LANGAGE ARDUINO

Une carte Arduino étant programmer en C++ il est important de connaître les principes de bases de ce
langage de programmation.

CHAPITRE 1 : DEFINITION DES VARIABLES

Le mieux pour comprendre la notion de variable est de

commencer avec une métaphore, ainsi nous allons
imaginer une commode vide disposant de plusieurs tiroirs
nommés chacun par une lettre. Nous avons alors le tiroirs
A, puis le B, puis le C, etc…

Figure 1 : Illustration de la métaphore

Maintenant imaginons que nous ayons besoin de ranger 6 chaussettes, 3 pulls et 2 pantalons. Cependant
nous ne sommes autorisées à mettre qu’un seul type de vêtement par tiroirs. Nous rangeons donc les
chaussettes dans le tiroir A, les pulls dans le B et les pantalons dans le C.

La mémoire d’un ordinateur fonctionne de la même manière, elle est composée d’une multitude de
« tiroirs » ne pouvant accueillir qu’un seul type de variables. Plus concrètement en informatique il existe
une variété de types de variables permettant de sauvegarder une multitude de types données. Voici les plus
communes même si cette liste n’est pas exhaustive elle est largement suffisante.

Tableau 1 : Les différents types de variables

Type de
Signification
variable

Représente un entier naturel.

int
Compris entre −32 768 à 32 767

Représente un entier naturel.

long
Compris entre −2 147 483 648 à 2 147 483 647

Représente un nombre à virgule.

float
Compris entre −3.4 ∙ 10−38 et 3.4 ∙ 1038

Représente un nombre à virgule.

double
Compris entre −3.4 ∙ 10−308 et 3.4 ∙ 10308

char Représente un caractère.

 bool Stocke une valeur true ou false.

Si nous revenons à notre métaphore les types de variables sont les vêtements et les tiroirs sont les variables.
Cela explique pourquoi il n’est pas possible de mettre des vêtements différents dans le même tiroir, cela
reviendrait à mélanger les types de données différentes entre elles.

Une fois cette notion claire il nous faut désormais définir nos variables dans un code. Pour cela notre
métaphore nous donne tous les éléments. Un tiroir étant une variable, celui-ci dispose d’un nom, d’un type
(type de vêtements ranger dedans) et d’une valeur par défaut (dans notre cas il est vide).

Informatiquement parlent tous ces éléments se combine de la façon suivante :

𝑡𝑦𝑝𝑒 𝑛𝑜𝑚 = 𝑣𝑎𝑙𝑒𝑢𝑟 ;

Le type, il définit donc quel type de données sont attendu dans la variable.
Le nom, permet d’appeler (ou de désigner) la variable.
La valeur, est donc le contenu de la variable.

Nous pouvons remarquer la présence de deux nouveaux éléments :

- « = » qui est l’opérateur d’assignement qui permet d’indiquer que nous assignons une valeur à une
variable.
- « ; » qui indique une fin de ligne. Cet élément est d’ailleurs obligatoire à chaque fin de ligne sauf si
celle-ci finit par une accolade.

CHAPITRE 2 : LES OPERATEURS

Les variables étant maintenant correctement définies nous pouvons introduire les différents opérateurs
utilisés pour manipuler les variables seuls ou entres elles.

OPERATEURS DE COMPARAISON
Les opérateurs de comparaison aux nombres de six permettent de comparer deux variables entre elles et
renvoie une valeur booléenne.

Tableau 2 : Les opérateurs de comparaison

Opérateur Dénomination Signification

== Opérateur d’égalité Compare deux valeurs et vérifie leur égalité

 Opérateur d'infériorité
< Vérifie qu'une variable est strictement inférieure à une valeur
stricte

<= Opérateur d'infériorité Vérifie qu'une variable est inférieure ou égale à une valeur

Opérateur de supériorité Vérifie qu'une variable est strictement supérieure à une

>
stricte valeur

>= Opérateur de supériorité Vérifie qu'une variable est supérieure ou égale à une valeur

!= Opérateur de différence Vérifie qu'une variable est différente d'une valeur

OPERATEURS DE CALCUL

Les opérateurs de calcul permettent de modifier mathématiquement la valeur d'une variable.

Tableau 3 : Les opérateurs de calcul

Opérateur Dénomination Signification

+ Opérateur d'addition Ajoute deux valeurs

- Opérateur de soustraction Soustrait deux valeurs

* Opérateur de multiplication Multiplie deux valeurs

/ Opérateur de division Divise deux valeurs

= Opérateur d'affectation Affecte une valeur à une variable

LES OPERATEURS D'ASSIGNATION

Ces opérateurs permettent de simplifier des opérations.

Par exemple si nous voulons ajouter une valeur dans une variable et stocker le résultat dans cette même
variable. Nous utilisons habituellement la façon suivante : variable = variable + valeur ;
Avec les opérateurs d'assignation il est possible d'écrire cette opération sous la forme variable += valeur ;
 Tableau 4 : Les opérateurs d'assignation

Opérateur Signification

+= Additionne deux valeurs et stocke le résultat dans la variable (à gauche)

-= Soustrait deux valeurs et stocke le résultat dans la variable

*= Multiplie deux valeurs et stocke le résultat dans la variable

/= Divise deux valeurs et stocke le résultat dans la variable

LES OPERATEURS D'INCREMENTATION

Ce type d'opérateur permet de facilement augmenter ou diminuer d'une unité une variable. Ces opérateurs
sont très utiles pour des structures telles que des boucles, qui ont besoin d'un compteur (variable qui
augmente d’un en un).

Un opérateur de type x++ permet de remplacer des notations lourdes telles que x=x+1 ou bien x+=1.

Tableau 5 : Les opérateurs d'incrémentation

Opérateur Dénomination Signification

++ Incrémentation Augmente d'une unité la variable

-- Décrémentation Diminue d'une unité la variable

LES OPERATEURS LOGIQUES

Ce type d'opérateur permet d’établir la valeur d’une équation booléenne.

Tableau 6 : Les opérateurs logiques

Opérateur Dénomination Signification

|| OU logique Vérifie qu'au moins une des conditions est réalisée

^ XOU logique Vérifie qu’exactement une des conditions est réalisée

&& Vérifie que toutes les conditions sont réalisées

ET logique
 Inverse l'état d'une variable booléenne (retourne la valeur 1 si
! NON logique
la variable vaut 0, 0 si elle vaut 1)

LES PRIORITES

Lorsque l'on associe plusieurs opérateurs, il faut que le compilateur sache dans quel ordre les traiter (ou plus
exactement dans quel ordre il doit disposer les instructions), voici donc dans l'ordre décroissant les priorités
de tous les opérateurs.

Tableau 7 : Priorité des opérateurs

Ordre de Opérateurs
priorité
1 () []

2 -- ++ !

3 * / %
4 + -

5 < <= >= >

6 == !=
7 ^

8 && ||
9 = += -=

CHAPITRE 3 : STRUCTURES CONDITIONNELLES

On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou
non.

Une expression suivie d'un point-virgule est appelée instruction. Par exemple « a++ ; » est une instruction.
Lorsque l'on veut regrouper plusieurs instructions, on peut créer ce que l'on appelle un bloc, c'est-à-dire un
ensemble d'instructions comprises entre accolades « { instructions } ».
LA STRUCTURE « IF »

L’instruction « if » est la structure de test la plus basique, on la retrouve dans tous les langages (avec une
syntaxe différente...). Elle permet d'exécuter une série d'instructions si jamais une condition est réalisée.
Cette condition est construite grâce aux opérateurs décrit précédemment. La syntaxe de cette expression
est la suivante.

if (condition) {
...
Instructions exécuter si la condition est vraie(true)
...

Dans le cas où il n’y a qu’une seule instruction les accolades ne sont pas obligatoire, la structure peut alors
s’écrire de la façon suivante.

if (condition) Instruction ;

L'instruction « if » dans sa forme basique ne permet de tester qu'une condition, or la plupart du temps on
aimerait pouvoir choisir les instructions à exécuter en cas de non-réalisation de la condition. Pour cela il
existe l'expression « if ... else » qui permet d'exécuter une autre série d'instructions en cas de non-réalisation
de la condition. La syntaxe de cette expression est la suivante.

if (condition) {
...
Instructions exécuter si la condition est vraie(true)
...

} else {
...
Instructions exécuter si la condition est fausse(false)
...

Dans le cas où il n’y a qu’une seule instruction une syntaxe moins lourde existe, elle est construite de la
façon suivante.

(condition) ? Instruction si vraie(true) : Instruction si faux(false) ;

Il est possible d’enchaîner plusieurs « if…else » afin de pouvoir vérifier plusieurs conditions dépendamment
de conditions précédentes. La syntaxe de cette expression est la suivante.
 if (condition 1) {
...
Instructions exécuter si la condition 1 est vraie(true)
...

} else if (condition 2){

...
Instructions exécuter si la condition 1 est fausse(false) et que la condition 2 est
vraie(true)
...

} else {
...
Instructions exécuter si la condition 1 est fausse(false) et que la condition 2 est
fausse(false)
...

LA STRUCTURE « SWITCH »

L'instruction « switch » permet de faire plusieurs tests de valeurs sur le contenu d'une même variable. Cette
structure conditionnelle simplifie le test de plusieurs valeurs d'une variable, car cette opération aurait été
compliquée (mais possible) avec des if imbriqués. Sa syntaxe est la suivante.

switch (Variable) {

case Valeur1 :
Liste d'instructions
break;

case Valeur2 :
Liste d'instructions
break;

case Valeurs... :
Liste d'instructions
break;

default:

Liste d'instructions
break;

Les parenthèses qui suivent le mot clé « switch » indiquent une expression dont la valeur est testée
successivement par chacun des « case ». Lorsque l'expression testée est égale à une des valeurs suivant
un « case », la liste d'instructions qui suit celui-ci est exécuté.
Le mot clé « break » permet de sortir de la structure conditionnelle.
Le mot clé « default » précède la liste d'instructions qui sera exécutée si l'expression n'est jamais égale à une
des valeurs.
CHAPITRE 4 : STRUCTURE DE BOUCLE

Les structures conditionnelles peuvent être associées à des structures qui se répètent suivant la réalisation
de la condition, on les appelle alors des structures de boucle.

A noter que le mot clé « break » vu précédemment permet également de sortir de n’importe qu’elle
structure de boucle.

Une fois qu’un programme sort d’une structure de boucle, le programme ne s’interrompt pas pour autant et
continue le reste des instructions.

LA BOUCLE « WHILE »
La boucle « while » exécute une liste d’instructions tant que la condition qui lui est imposée est vraie(true),
celle-ci est définit par la syntaxe suivante.

while (condition) {
...
Instructions exécuter tant que la condition est vraie(true)
...

Il est important de notée qu’avec ce type de structure les risques qu’une boucle ne s’arrête jamais car la
condition est toujours vraie sont important, ce phénomène est appelé boucle infinie.

LA BOUCLE « DO…WHILE »
Proche de la boucle « while » celle-ci dispose d’une propriété supplémentaire simple, que sa condition soit
fausse ou non elle exécutera une liste d’instructions au minimum une fois. Sa syntaxe est la suivante.

do {
...
Instructions exécuter une fois puis tant que la condition est vraie(true)
...

} while (condition);

LA BOUCLE « FOR »
La boucle « for » permet d’exécuter plusieurs fois la même série d’instruction suivant une condition
dépendante d’une forme de conteur. Sa syntaxe est la suivante.

for (compteur; condition; modification du compteur) {

...
Instructions exécuter tant que la condition est vraie(true)
...

}
« compteur » correspond à une variable qui permettra de définir la « condition ». La modification du
compteur, souvent une incrémentation de celui-ci, permet d’éviter de finir dans une boucle infinie (même si
ce cas reste possibilité elle en est fortement réduite).

Le C++ permet notamment de déclarer la variable du compteur directement dans la boucle elle-même de la
façon suivante.

for (type nom_De_Variable = valeur_Par_Défaut; condition; modification de la variable){

...
Instructions exécuter tant que la condition est vraie(true)
...

Les boucle « for » peuvent toute s’écrire sous la forme d’une boucle « while » de la façon suivante. Attention
la réciproque est fausse.

type nom_De_Variable = valeur_Par_Défaut ;

while (condition) {
...
Instructions exécuter tant que la condition est vraie(true)
...
modification de la variable
}

CHAPITRE 5 : LES FONCTIONS

La notion de fonction en informatique est fondamentale, il s’agit d’un sous-programme qui permet
d'effectuer un ensemble d'instructions par simple appel de celle-ci dans le corps du programme principal.
Les fonctions permettent d'exécuter dans plusieurs parties du programme une série d'instructions, cela
permet une simplicité du code et donc une taille de programme minimale.

DECLARATION D’UNE FONCTION

Avant d'être utilisée, une fonction doit être définie car pour l'appeler dans le corps du programme il faut que
le compilateur la connaisse, c'est-à-dire qu'il connaisse son nom, ses arguments et les instructions qu'elle
contient. La définition d'une fonction s'appelle « déclaration ». La déclaration d'une fonction se fait selon la
syntaxe suivante :
 type Nom_De_La_Fonction(type1 argument1, type2 argument2, ...) {

...
Instructions
...

return valeur_du_type_de_la_fonction

Le type indiquer ici correspond au type de la valeur que renvoie la fonction, il faut savoir qu’en plus des
types de variables classique il existe le type « void » permettant de ne rien renvoyer. Tenant compte de cette
particularité le mot clé « return » suivis d’une valeur correspondant au type de la fonction est nécessaire
pour terminer une fonction, sauf dans le cas d’une fonction de type « void ».

Il est possible de définir une valeur par défaut pour les arguments d’une fonction de la manière suivante.

type Nom_De_La_Fonction(type1 argument1, type2 argument2 = Valeur_Par_Défaut, ...) {

...
Instructions
...

return valeur_du_type_de_la_fonction

Il est cependant obligatoire que les arguments ayant une valeur par défaut soit définit en dernier.

APPEL D’UNE FONCTION

Une fois la fonction déclarer celle-ci ne seras pas exécuter tant qu’elle n’est pas appelée dans le corps du
programme principale.

Pour exécuter une fonction, il suffit de faire appel à elle en écrivant son nom suivi d'une parenthèse ouverte
(éventuellement des arguments) puis d'une parenthèse fermée.

Nom_De_La_Fonction(argument1, argument2, ...);

D'autre part, une fonction peut faire appel à elle-même, on parle alors de fonction récursive (il ne faut pas
oublier de mettre une condition de sortie au risque sinon de ne pas pouvoir arrêter le programme...).