Fondamentaux de la Programmation avec Arduino

Objectifs Pédagogiques

Comprendre le rôle et l’usage des variables dans Arduino.
Savoir utiliser les structures conditionnelles (if, else, switch).
Maîtriser les boucles (for, while, do-while) pour répéter des actions.
Utiliser des instructions de contrôle (break, continue).

Les Variables en Arduino

Les variables permettent de stocker des données en mémoire afin de les réutiliser ou de les modifier pendant l'exécution du programme. Elles jouent un rôle fondamental dans le contrôle des capteurs, actionneurs et traitements de données sur une carte Arduino. Chaque variable a :

un nom unique (identifiant),
un type (définit le genre de données qu'elle contient),
une valeur (le contenu stocké),
une portée (où elle est accessible dans le code).

Types de variables courants

Voici les types les plus utilisés sur Arduino :

Nom (Français)	Type Arduino	Description	Exemple
Entier	`int`	Nombre entier signé (positif ou négatif)	`int a = 10;`
Décimal	`float`	Nombre à virgule (simple précision)	`float x = 3.14;`
Caractère	`char`	Caractère unique ASCII (1 octet)	`char lettre = 'A';`
Booléen (Vrai/Faux)	`bool`	Valeur logique (`true` ou `false`)	`bool led = true;`

Il existe aussi des variantes comme unsigned int, long, ou double, selon la précision ou la plage de valeurs souhaitées.

Déclaration et affectation

Déclarer une variable consiste à indiquer son type et son nom, puis éventuellement à lui attribuer une valeur.

int entier = 10;        // déclaration avec affectation
float decimal = 3.14;   // nombre à virgule
char caractere = 'A';   // caractère unique
bool booleen = true;    // booléen (vrai ou faux)

Une variable non initialisée peut contenir une valeur aléatoire (résidu de mémoire).

Règles de nommage

Le nom doit commencer par une lettre ou un underscore (_).
Il ne doit pas contenir d'espaces ni de caractères spéciaux.
Il est sensible à la casse : maVariable ≠ mavariable.
Éviter les mots réservés (int, for, void, etc.).

Portée des variables

La portée détermine où une variable est utilisable dans le code :

Locale : déclarée à l'intérieur d'une fonction, elle est accessible uniquement dans cette fonction.
Globale : déclarée hors de toute fonction, elle est accessible partout dans le programme.

int entier_global = 0; // variable globale

void setup() {
  entier_global = 10;
}

void loop() {
  Serial.println(entier_global);
}

Constantes

Une constante est une variable dont la valeur ne peut pas changer après sa déclaration. On utilise le mot-clé const pour la définir.

const int LED_PIN = 13;

Utiliser des constantes permet :

de protéger une valeur contre les modifications accidentelles,
de rendre le code plus clair (au lieu d’écrire 13 partout, on écrit LED_PIN).

Toute tentative de modifier une constante génère une erreur de compilation.

Variables `volatile`

Une variable déclarée avec le mot-clé volatile indique au compilateur qu’elle peut changer à tout moment en dehors du programme principal, souvent à cause d’interruptions (ISR).

volatile int compteur = 0;

Sans volatile, le compilateur pourrait optimiser le code en ignorant les changements non détectés par la boucle principale, ce qui peut causer des bugs difficiles à détecter.

Utilisation mémoire (taille et plages)

Chaque type occupe un certain espace mémoire. Sur la plupart des cartes Arduino (comme l’Uno, basée sur l’ATmega328P) :

Type	Taille (octets)	Plage de valeurs
`bool`	1	`true` ou `false`
`char`	1	de -128 à 127
`unsigned char`	1	de 0 à 255
`int`	2	de -32 768 à 32 767
`unsigned int`	2	de 0 à 65 535
`long`	4	de -2 147 483 648 à 2 147 483 647
`unsigned long`	4	de 0 à 4 294 967 295
`float`	4	±3.4E+38, environ 6 à 7 chiffres significatifs

Opérations sur les Variables

Les variables peuvent être manipulées à l’aide d’opérateurs mathématiques, logiques ou d’affectation. Ces opérations sont fondamentales pour effectuer des calculs, prendre des décisions ou modifier des états dans un programme.

Opérations arithmétiques de base

int a = 10, b = 5;
int somme     = a + b; // addition → 15
int difference = a - b; // soustraction → 5
int produit   = a * b; // multiplication → 50
int quotient  = a / b; // division entière → 2
int reste     = a % b; // modulo (reste de la division) → 0

La division entre deux int donne un résultat entier (les décimales sont ignorées). Pour obtenir un résultat décimal, utilise des float :

float x = 10.0, y = 4.0;
float res = x / y; // res vaut 2.5

Incrémentation et décrémentation

Ces opérations permettent d’ajouter ou de retirer 1 unité à une variable :

int compteur = 0;
compteur++; // équivalent à compteur = compteur + 1
compteur--; // équivalent à compteur = compteur - 1

Il existe aussi les formes préfixées :

++compteur; // incrémente AVANT utilisation
--compteur; // décrémente AVANT utilisation

En général, compteur++ et ++compteur ont le même effet sauf dans des expressions complexes.

Opérateurs combinés (affectation modifiée)

Ils permettent d’écrire plus simplement certaines opérations fréquentes :

int a = 5;
a += 3;  // équivalent à a = a + 3 → a vaut 8
a -= 2;  // a = a - 2 → 6
a *= 4;  // a = a * 4 → 24
a /= 6;  // a = a / 6 → 4
a %= 3;  // a = a % 3 → 1

Opérateurs de comparaison

Utilisés dans les conditions (if, while...), ils retournent un booléen (true ou false) :

Opérateur	Signification	Exemple
`==`	égal à	`a == b`
`!=`	différent de	`a != b`
`>`	strictement supérieur	`a > b`
`<`	strictement inférieur	`a < b`
`>=`	supérieur ou égal à	`a >= b`
`<=`	inférieur ou égal à	`a <= b`

Opérateurs logiques

Permettent de combiner des conditions :

Opérateur	Signification	Exemple
`&&`	ET logique (AND)	`(a > 0 && b > 0)`
`		`	OU logique (OR)	`(a > 0	b > 0)`
`!`	NON logique (NOT)	`!(a > 0)` → vrai si `a ≤ 0`

Conversion de types (casting)

Il peut être utile de convertir explicitement une variable d’un type à un autre, surtout entre int et float :

int entier = 7;
float decimal = (float)entier / 2; // donne 3.5

Attention aux débordements

Sur Arduino, dépasser la plage de valeurs autorisée pour un type peut entraîner des erreurs :

byte b = 255;
b++; // b vaut maintenant 0 → débordement (overflow)

Utilise des types adaptés (long, unsigned, etc.) et des tests pour éviter ces cas.

Conditions en Arduino

Les instructions conditionnelles permettent au programme de réagir différemment selon certaines situations. Elles sont indispensables pour programmer un comportement intelligent et adaptatif (par exemple : activer un ventilateur si la température dépasse un seuil).

Structure de base : `if`, `else if`, `else`

La structure conditionnelle classique permet de tester une ou plusieurs conditions.

if (condition) {
  // Code exécuté si la condition est vraie
} else if (autre_condition) {
  // Code exécuté si la première est fausse mais celle-ci est vraie
} else {
  // Code exécuté si aucune des conditions n’est vraie
}

Exemple :

int valeur = 50;

if (valeur > 100) {
  Serial.println("Trop élevé !");
} else if (valeur == 100) {
  Serial.println("Juste !");
} else {
  Serial.println("Trop bas !");
}

Les blocs else if sont optionnels. On peut avoir un if seul, ou un if suivi d’un else.

Exemple concret (contrôle d’un ventilateur)

int temperature = 25;

if (temperature > 30) {
  digitalWrite(ventilateur, HIGH); // Allume le ventilateur
} else {
  digitalWrite(ventilateur, LOW);  // Éteint le ventilateur
}

L'instruction `switch`

L’instruction switch permet de tester plusieurs valeurs possibles d’une même variable, de façon plus lisible que plusieurs if successifs.

switch (mode) {
  case 1:
    digitalWrite(LED1, HIGH);
    break;

  case 2:
    digitalWrite(LED2, HIGH);
    break;

  default:
    digitalWrite(LED1, LOW);
    digitalWrite(LED2, LOW);
    break;
}

Détails importants :

Le mot-clé break empêche d'exécuter les blocs case suivants.
Le bloc default est optionnel et s’exécute si aucun case ne correspond.
La variable testée doit être de type entier (int, byte, char...).

Comparaison entre `if` et `switch`

Situation	Préférence
Conditions complexes (ex : `x > 10 && y < 20`)	`if / else`
Tests d’égalité simples sur une même variable	`switch / case`

Utilisation combinée avec les opérateurs logiques

Les instructions conditionnelles s’utilisent souvent avec les opérateurs && (ET), || (OU) et ! (NON) pour tester plusieurs critères à la fois.

if (temperature > 20 && humidite < 60) {
  activerBrumisateur();
}

Les Boucles

Les boucles permettent de répéter une action.

Boucle `for`

for (int i = 0; i < 10; i++) {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

Boucle `while`

while (digitalRead(boutonPin) == HIGH) {
  // Répète tant que le bouton est appuyé
}

Boucle `do...while`

do {
  // S'exécute au moins une fois
} while (digitalRead(boutonPin) == HIGH);

Contrôle du Flux avec `break` et `continue`

Instruction	Effet
`break`	Interrompt la boucle immédiatement
`continue`	Passe à l’itération suivante de la boucle

Exemple avec `break`

for (int i = 0; i < 10; i++) {
  if (digitalRead(boutonPin) == HIGH) {
    break;
  }
}

Exemple avec `continue`

for (int i = 0; i < 10; i++) {
  if (i % 2 == 0) continue;
  Serial.println(i); // Affiche les impairs
}

Exemples

Allumer une LED si un bouton est appuyé

if (digitalRead(boutonPin) == HIGH) {
  digitalWrite(LED_BUILTIN, HIGH);
} else {
  digitalWrite(LED_BUILTIN, LOW);
}

Clignoter une LED selon la température

if (temperature > 25 && humidite > 60) {
  for (int i = 0; i < 5; i++) {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(200);
    digitalWrite(LED_BUILTIN, LOW);
    delay(200);
  }
}