Enregistrer

Arduino C — types, variables et constantes (20 exercices)

Types Arduino utiles au robot : int, unsigned long, float, bool et constantes. Vingt exercices corrigés pour choisir la variable qui convient au robot.

Illustration : carte microcontrôleur entourée de boîtes transparentes de composants triés, comme des types de données

Illustration générée par IA

Réponse directe (novembre 2026) — Sur Arduino, déclarez le type (int, float, bool, char[]) avant usage ; const pour les broches ; unsigned long pour millis() (millisecondes depuis le démarrage). Les noms sont sensibles à la casse ; un ; manquant bloque toute la compilation.

Cette leçon est la partie 2 du parcours Arduino C (robotique et capteurs). Après la leçon 1 — structure du sketch et Serial, vous manipulez les variables qui stockent vitesses, distances et états.

Kit Arduino Starter — photo produit

Arduino Starter Kit — illustration matériel atelier (usage éditorial).

1) Les types les plus utiles

  • int : entier (compteur, vitesse, seuil).
  • unsigned long : temps millis() (important : millis() renvoie ce type).
  • float : nombre à virgule (mesure “réelle”, moyenne, calcul).
  • bool : vrai/faux (état, drapeau).
  • char : un caractère (ex. 'A').
  • const char* : texte (chaîne) constant, pratique pour afficher un message.

Bon réflexe : si tu comptes des intrusions, c’est un entier → int, pas float.

2) Variables globales vs locales (portée)

  • Globale : déclarée en dehors des fonctions → visible partout (ex. compteur).
  • Locale : déclarée dans une fonction → visible seulement dans ce bloc.

Schéma :

int global;        ← visible dans setup() et loop()

void loop() {
  int local;       ← visible seulement dans loop()
}

3) Constantes : éviter les “nombres magiques”

const int LED_PIN = 13;
const int BAUD = 9600;
const int DELAI_MS = 100;

Bonne pratique : mets des noms qui disent pourquoi ce nombre existe.

4) Conversions fréquentes

  • int n = 3; float f = n; OK (3 → 3.0)
  • float f = 3.7; int n = (int)f; tronque (3.7 → 3)

Pour des textes, on affiche souvent sans stocker de String global : on garde des nombres en int, et on affiche avec Serial.print.


Exercices (20)

Niveau simple

Exercice 1 — Déclare une constante const int BAUD = 9600; et utilise-la dans Serial.begin. Simple

Afficher la solution
const int BAUD = 9600;
void setup() { Serial.begin(BAUD); }
void loop() {}

Exercice 2 — Déclare int compteur = 0; et incrémente-le dans loop(). Simple

Afficher la solution
int compteur = 0;
void setup() {}
void loop() { compteur++; }

Exercice 3 — Déclare bool alarme = false; puis mets-la à true dans setup(). Simple

Afficher la solution
bool alarme = false;
void setup() { alarme = true; }
void loop() {}

Exercice 4 — Déclare unsigned long t0 = 0; et stocke millis() dans setup(). Simple

Afficher la solution
unsigned long t0 = 0;
void setup() { t0 = millis(); }
void loop() {}

Exercice 5 — Affiche le type “implicite” : affiche une phrase avec un int et un float (avec Serial.print). Simple

Afficher la solution
int n = 7;
float f = 3.5;
void setup() {
  Serial.begin(9600);
  Serial.print("n=");
  Serial.print(n);
  Serial.print(" f=");
  Serial.println(f);
}
void loop() {}

Niveau intermédiaire

Exercice 6 — Évite les nombres magiques : remplace delay(250) par const int DELAI_MS = 250;. Intermédiaire

Afficher la solution
const int DELAI_MS = 250;
void setup() {}
void loop() { delay(DELAI_MS); }

Exercice 7 — Portée : déclare une variable locale int x dans loop() et essaye (mentalement) de l’utiliser dans setup() : explique pourquoi ça ne marche pas (commentaire). Intermédiaire

Afficher la solution
void setup() {
  // int x; ici n'existe pas si x est déclaré dans loop()
  // Portée : une variable locale n'est visible que dans son bloc.
}
void loop() {
  int x = 0;
  x++;
}

Exercice 8 — Déclare un texte : const char* msg = \"OK\"; et affiche-le au démarrage. Intermédiaire

Afficher la solution
const char* msg = "OK";
void setup() {
  Serial.begin(9600);
  Serial.println(msg);
}
void loop() {}

Exercice 9 — Conversion : avec float d = 12.9; calcule int n = (int)d; et affiche n (doit afficher 12). Intermédiaire

Afficher la solution
void setup() {
  Serial.begin(9600);
  float d = 12.9;
  int n = (int)d;
  Serial.println(n); // 12
}
void loop() {}

Exercice 10 — Écris une fonction int clampInt(int v, int minV, int maxV) qui force v à rester entre min et max. Intermédiaire

Afficher la solution
int clampInt(int v, int minV, int maxV) {
  if (v < minV) return minV;
  if (v > maxV) return maxV;
  return v;
}

Niveau avancé (débutant + rigueur)

Exercice 11 — Corrige un mauvais type : un compteur d’événements ne doit pas être un float. Remplace par int et affiche-le. Avancé

Afficher la solution
int intrusions = 0;
void setup() { Serial.begin(9600); }
void loop() {
  intrusions++;
  Serial.println(intrusions);
  delay(1000);
}

Exercice 12 — Explique pourquoi millis() doit être stocké dans unsigned long (commentaire + exemple). Avancé

Afficher la solution
void setup() {
  // millis() renvoie un grand nombre positif (ms depuis le démarrage)
  // => unsigned long évite les débordements signés et garde la bonne plage.
  unsigned long t = millis();
  Serial.begin(9600);
  Serial.println(t);
}
void loop() {}

Exercice 13 — Écris une fonction bool isNear(int distanceCm, int seuil) qui renvoie true si distanceCm est <= seuil. Avancé

Afficher la solution
bool isNear(int distanceCm, int seuil) {
  return distanceCm <= seuil;
}

Exercice 14 — Constantes nommées : crée const int DIST_STOP_CM = 15; et utilise-la dans un test. Avancé

Afficher la solution
const int DIST_STOP_CM = 15;
int distance_cm = 12;
void setup() {
  Serial.begin(9600);
  if (distance_cm <= DIST_STOP_CM) Serial.println("STOP");
}
void loop() {}

Exercice 15 — Texte + DRY : déclare const char* message = "MBOT"; et affiche-le 3 fois sans recopier “MBOT” en dur. Avancé

Afficher la solution
const char* message = "MBOT";
void setup() {
  Serial.begin(9600);
  for (int i = 0; i < 3; i++) Serial.println(message);
}
void loop() {}

Exercice 16 — Crée deux variables : int vitesse = 80; et int vitesse_min = 30; puis calcule int v = vitesse - vitesse_min; et affiche v. Avancé

Afficher la solution
void setup() {
  Serial.begin(9600);
  int vitesse = 80;
  int vitesse_min = 30;
  int v = vitesse - vitesse_min;
  Serial.println(v);
}
void loop() {}

Exercice 17 — static : crée une fonction qui compte combien de fois elle a été appelée (retourne un int). Avancé

Afficher la solution
int countCalls() {
  static int c = 0;
  c++;
  return c;
}

Exercice 18 — Écris un petit “état” : bool enVeille = true; puis passe en false après 5 secondes (avec millis()). Avancé

Afficher la solution
bool enVeille = true;
unsigned long t0 = 0;

void setup() { Serial.begin(9600); t0 = millis(); }

void loop() { if (enVeille && millis() - t0 >= 5000) { enVeille = false; Serial.println(“GO”); } }

Exercice 19 — Écris une fonction float toM(float cm) qui convertit des cm en mètres. Avancé

Afficher la solution
float toM(float cm) {
  return cm / 100.0;
}

Exercice 20 — Mini-projet : fais une variable int distance_cm = 42; et affiche Distance: 42 cm (formatage simple). Avancé

Afficher la solution
void setup() {
  Serial.begin(9600);
  int distance_cm = 42;
  Serial.print("Distance: ");
  Serial.print(distance_cm);
  Serial.println(" cm");
}
void loop() {}

Tableau récapitulatif des types (Arduino UNO)

TypeExempleUsage robotique
intint vitesse = 120;PWM moteur, compteur d’impulsions
unsigned longunsigned long t0 = millis();Délai non bloquant, chronomètre
floatfloat dist = 12.4;Distance ultrason, moyenne capteur
boolbool obstacle = true;État bouton ou seuil binaire

Suite du parcours

→ Leçon 3 — conditions, capteurs et actionneurs · Leçon 4 — fonctions et modularité · Hub Arduino C

FAQ

Quelle différence entre int et unsigned long ?
int pour compteurs et vitesses entières ; unsigned long pour stocker le résultat de millis() sans débordement prématuré.

Puis-je utiliser String partout ?
Sur Arduino UNO (2 Ko de RAM), préférez Serial.print avec des int plutôt que des objets String globaux qui fragmentent la mémoire.

Et sur mBot / mBlock ?
Même logique en mode Arduino C — voir mon premier programme mBot.

const int ou #define pour une broche ?
Préférez const int LED_PIN = 13; : le compilateur vérifie le type, contrairement à #define qui fait un simple remplacement texte sans contrôle.

Cette page vous a-t-elle été utile ?

Une question sur cet article ou besoin d'un conseil ? Posez-la ici

Vous hésitez entre deux modèles ou vous avez besoin d'aide sur un montage ? Écrivez-nous, nous vous répondons rapidement par e-mail.