🔌 Arduino — De zéro à héros

Arduino, c'est une carte électronique programmable. En gros : un mini-ordinateur qui peut interagir avec le monde réel. Tu écris du code, tu le téléverses sur la carte, et elle exécute tes instructions en boucle.

Concrètement, un Arduino Uno c'est :

Un microcontrôleur ATmega328P — le cerveau, 16 MHz
14 pins digitaux — signaux ON/OFF
6 pins analogiques — valeurs entre 0 et 1023
Un port USB — pour programmer et alimenter
Un régulateur de tension — accepte 5V à 12V

Le meilleur ? La carte coûte ~25€, le logiciel est gratuit et open-source, et la communauté est gigantesque.

💡

Arduino vs Raspberry Pi ?

Le Pi c'est un vrai ordinateur (Linux, Python). L'Arduino c'est un microcontrôleur : il fait UNE chose, instantanément, et consomme quasi rien. Contrôler des moteurs, lire des capteurs → Arduino. Serveur web, machine learning → Pi.

🌍 Qui utilise Arduino ?

Makers — Drones DIY, stations météo, arrosage automatique
Artistes — Installations lumineuses interactives
Ingénieurs — Prototypage rapide industriel
Étudiants — Toi, là, maintenant 😎

🛠️ Le Setup

Étape 1 : Télécharger l'IDE Arduino

L'IDE (Integrated Development Environment), c'est le logiciel où tu écris ton code et où tu l'envoies sur la carte.

👉 Va sur arduino.cc/en/software et télécharge la version pour ton OS.

Étape 2 : Brancher la carte

Câble USB-B (gros connecteur carré). Branche l'Arduino sur ton PC. La LED verte "ON" doit s'allumer.

Étape 3 : Configurer l'IDE

Outils → Type de carte → Arduino Uno
Outils → Port → sélectionne le port COM (COM3 ou /dev/ttyACM0)
Clique sur ✓ Vérifier pour compiler
Clique sur → Téléverser pour envoyer le code

⚠️

Le port n'apparaît pas ?

Windows : installe les drivers CH340 (clone chinois) ou FTDI. Linux : sudo usermod -a -G dialout $USER puis redémarre.

// Structure de base d'un sketch Arduino

void setup() {
  // Exécuté UNE SEULE FOIS au démarrage
  // Configure les pins, initialise la comm
}

void loop() {
  // Exécuté EN BOUCLE INFINIE après setup()
  // C'est ici que vit ton programme
}

💻 Les Bases du C++

Arduino utilise du C++ simplifié. Voici les fondamentaux qui couvrent 90% de ce que tu feras.

📦 Les Variables

Une variable, c'est une boîte qui stocke une valeur. En C++, tu dois dire le type de la boîte.

int age = 15;              // Nombre entier (-32768 à 32767)
long distance = 100000;    // Entier plus grand
float temperature = 23.5;  // Nombre à virgule
bool ledOn = true;         // Vrai ou faux
char lettre = 'A';         // Un caractère
String nom = "Arduino";    // Texte

const int LED_PIN = 13;    // Constante (ne change jamais)

int resultat = 5 / 2;     // = 2 (division entière !)
float exact = 5.0 / 2.0;  // = 2.5 (division flottante)

🔀 Les Conditions

Le programme prend des décisions.

int capteur = analogRead(A0);  // Lit 0-1023

if (capteur > 500) {
  digitalWrite(LED_PIN, HIGH);
} else if (capteur > 200) {
  Serial.println("Valeur moyenne");
} else {
  digitalWrite(LED_PIN, LOW);
}

// Opérateurs : == != > < >= <=
// Logique : && (ET)  || (OU)  ! (NON)
if (capteur > 100 && capteur < 900) {
  Serial.println("Plage normale");
}

🔁 Les Boucles

Répéter des actions sans copier-coller.

// FOR — nombre de répétitions connu
for (int i = 0; i < 10; i++) {
  Serial.println(i);  // Affiche 0 à 9
  delay(100);
}

// WHILE — tant que c'est vrai
int compteur = 0;
while (compteur < 5) {
  Serial.println(compteur);
  compteur++;  // IMPORTANT sinon boucle infinie !
}

// Fade progressif d'une LED (PWM)
for (int lum = 0; lum <= 255; lum += 5) {
  analogWrite(9, lum);
  delay(30);
}

⚡ Les Fonctions

Un bloc de code réutilisable.

// Fonction sans retour (void)
void faireClignoter(int pin, int duree) {
  digitalWrite(pin, HIGH);
  delay(duree);
  digitalWrite(pin, LOW);
  delay(duree);
}

// Fonction avec retour
float celsiusVsFahrenheit(float c) {
  return c * 9.0 / 5.0 + 32.0;
}

void loop() {
  faireClignoter(13, 500);
  float f = celsiusVsFahrenheit(22.5);
  Serial.println(f);
}

🧠

Règle d'or : DRY — Don't Repeat Yourself

Si tu copies-colles du code plus de 2 fois, fais-en une fonction. Ton futur toi te remerciera quand il faudra débugger à 23h.

💡 Projet 1 : Blink

Le "Hello World" de l'électronique

Faire clignoter une LED. Si ça marche, ton setup fonctionne.

Matériel : Arduino Uno, 1 LED, 1 résistance 220Ω, breadboard, fils

🔌 Câblage

     Arduino Uno
    ┌──────────────┐
    │          [13] ├────[220Ω]────(LED+)────(LED-)────┐
    │          [GND]├──────────────────────────────────┘
    └──────────────┘
  Pin 13 → Résistance → LED (anode +) → LED (cathode -) → GND

⚡

Pourquoi la résistance ?

LED sans résistance = LED morte. L'Arduino envoie 5V, la LED supporte ~2V. La résistance 220Ω limite le courant.

/*
 * PROJET 1 : BLINK
 * Fait clignoter une LED sur la pin 13
 */
const int LED = 13;

void setup() {
  // pinMode configure une pin : INPUT ou OUTPUT
  pinMode(LED, OUTPUT);
}

void loop() {
  // digitalWrite envoie HIGH (5V) ou LOW (0V)
  digitalWrite(LED, HIGH);  // Allumer
  delay(1000);              // Attendre 1 seconde
  digitalWrite(LED, LOW);   // Éteindre
  delay(1000);              // Attendre 1 seconde
  // loop() recommence → clignotement infini
}

🎯

Défi : Code un SOS en morse ! 3 courts (200ms), 3 longs (600ms), 3 courts. Pause de 2s entre chaque séquence.

🚦 Projet 2 : Feu Tricolore

Simule un vrai feu de circulation

3 LEDs, une séquence réaliste. Tu apprends à contrôler plusieurs pins et gérer le timing.

Matériel : Arduino, LED rouge + orange + verte, 3× 220Ω, breadboard, fils

🔌 Câblage

     Arduino         Breadboard
    ┌──────────┐
    │      [4] ├──[220Ω]── 🔴 Rouge ── GND
    │      [3] ├──[220Ω]── 🟡 Orange ── GND
    │      [2] ├──[220Ω]── 🟢 Verte ── GND
    │    [GND] ├── Rail GND commun
    └──────────┘

/*
 * PROJET 2 : FEU TRICOLORE
 * Séquence : Vert → Orange → Rouge → Vert...
 */
const int ROUGE  = 4;
const int ORANGE = 3;
const int VERT   = 2;

void setup() {
  pinMode(ROUGE, OUTPUT);
  pinMode(ORANGE, OUTPUT);
  pinMode(VERT, OUTPUT);
}

void toutEteindre() {
  digitalWrite(ROUGE, LOW);
  digitalWrite(ORANGE, LOW);
  digitalWrite(VERT, LOW);
}

void loop() {
  toutEteindre();
  digitalWrite(VERT, HIGH);    // 🟢 Vert - 5s
  delay(5000);

  toutEteindre();
  digitalWrite(ORANGE, HIGH);  // 🟡 Orange - 2s
  delay(2000);

  toutEteindre();
  digitalWrite(ROUGE, HIGH);   // 🔴 Rouge - 5s
  delay(5000);

  digitalWrite(ORANGE, HIGH);  // 🔴+🟡 Prêt à démarrer
  delay(1000);
}

🚀

Niveau suivant : Ajoute un bouton-poussoir pour un passage piéton ! Utilise digitalRead() pour lire le bouton.

📡 Projet 3 : Capteur Ultrason

Mesure la distance comme un sonar 🦇

Le HC-SR04 envoie un son ultrasonique, attend l'écho, et calcule la distance. Coûte ~2€, mesure de 2cm à 4m.

Matériel : Arduino, capteur HC-SR04, breadboard, fils

🔌 Câblage

      HC-SR04          Arduino
    ┌──────────┐
    │ VCC      ├──── 5V
    │ TRIG     ├──── Pin 9
    │ ECHO     ├──── Pin 10
    │ GND      ├──── GND
    └──────────┘

🧪 Comment ça marche ?

Impulsion de 10µs sur TRIG
Le capteur émet 8 salves à 40 kHz
Le son rebondit et revient
ECHO reste HIGH pendant le trajet aller-retour
distance = durée × 0.0343 / 2 (en cm)

/*
 * PROJET 3 : CAPTEUR ULTRASON HC-SR04
 * Affiche la distance dans le Moniteur Série
 */
const int TRIG = 9;
const int ECHO = 10;

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  Serial.begin(9600);
  Serial.println("=== Capteur Ultrason ===");
}

float mesurerDistance() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);      // Impulsion de 10µs
  digitalWrite(TRIG, LOW);

  long duree = pulseIn(ECHO, HIGH);  // Durée en µs
  float distance = duree * 0.0343 / 2.0;
  return distance;
}

void loop() {
  float dist = mesurerDistance();

  Serial.print("Distance : ");
  Serial.print(dist);
  Serial.println(" cm");

  if (dist < 10) {
    Serial.println("⚠️  OBJET TRES PROCHE !");
  } else if (dist < 30) {
    Serial.println("🟡 Objet détecté");
  }

  delay(250);  // Mesure 4 fois par seconde
}

📺

Moniteur Série : Dans l'IDE Arduino, clique sur la loupe en haut à droite (ou Ctrl+Shift+M). Mets le baudrate à 9600. Tu verras les distances s'afficher en temps réel !

⚙️ Projet 4 : Servo Moteur

Contrôle un moteur avec un potentiomètre

Un servo moteur peut tourner à un angle précis (0° à 180°). Avec un potentiomètre (bouton rotatif), tu contrôles l'angle en temps réel. C'est la base de la robotique : bras articulés, tourelles, direction de véhicule.

Matériel : Arduino, servo SG90 (ou MG996R), potentiomètre 10kΩ, fils

🔌 Câblage

  Potentiomètre              Arduino              Servo SG90
  ┌─────────┐                                    ┌─────────┐
  │ Gauche  ├──── GND                            │ Marron  ├── GND
  │ Centre  ├──── A0 (analogique)                │ Rouge   ├── 5V
  │ Droite  ├──── 5V                             │ Orange  ├── Pin 9
  └─────────┘                                    └─────────┘

  Le potentiomètre envoie 0-1023 sur A0
  On convertit en 0-180° pour le servo

⚠️

Alimentation : Un servo SG90 (petit bleu) marche sur le 5V de l'Arduino. Mais un gros servo (MG996R) consomme trop de courant — il faut une alimentation externe 5V-6V. Sinon ton Arduino va redémarrer en boucle.

/*
 * PROJET 4 : SERVO + POTENTIOMÈTRE
 * Tourne le potentiomètre → le servo suit
 */
#include <Servo.h>  // Bibliothèque incluse dans l'IDE

Servo monServo;           // Crée un objet Servo
const int POTPIN = A0;    // Pin analogique du potentiomètre
const int SERVOPIN = 9;   // Pin du servo (doit être PWM ~)

void setup() {
  monServo.attach(SERVOPIN);  // Connecte le servo à la pin
  Serial.begin(9600);
}

void loop() {
  int valeur = analogRead(POTPIN);  // Lit 0-1023

  // map() convertit une plage en une autre
  // 0-1023 → 0-180 degrés
  int angle = map(valeur, 0, 1023, 0, 180);

  monServo.write(angle);  // Envoie l'angle au servo
  
  Serial.print("Potentiomètre: ");
  Serial.print(valeur);
  Serial.print(" → Angle: ");
  Serial.print(angle);
  Serial.println("°");

  delay(15);  // Le servo a besoin d'un petit délai
}

🧠

La fonction map() est super utile. Elle convertit une valeur d'une plage à une autre. Syntaxe : map(valeur, min_entrée, max_entrée, min_sortie, max_sortie). Tu l'utiliseras partout.

🎯 Défi bonus : Balayage automatique

Fais balayer le servo de 0° à 180° et retour, automatiquement. C'est exactement ce qu'on utilise pour le radar du robot !

// Balayage automatique du servo
#include <Servo.h>
Servo monServo;

void setup() {
  monServo.attach(9);
}

void loop() {
  // Aller : 0° → 180°
  for (int angle = 0; angle <= 180; angle++) {
    monServo.write(angle);
    delay(15);
  }
  // Retour : 180° → 0°
  for (int angle = 180; angle >= 0; angle--) {
    monServo.write(angle);
    delay(15);
  }
}

🤖 Projet Final : Robot Éviteur d'Obstacles

Le boss final 🏆

On combine TOUT ce qu'on a appris : un capteur ultrason monté sur un servo, deux moteurs DC, et un châssis. Le robot avance, détecte un obstacle, regarde à gauche et à droite, et choisit la meilleure direction. Autonome.

📋 Liste de matériel

Arduino Uno — Le cerveau
Châssis robot 2WD — Kit avec 2 roues motrices + roue folle (~8€)
2× moteurs DC — Généralement inclus dans le kit châssis
Driver moteur L298N — Pont en H pour contrôler les moteurs (~3€)
Capteur HC-SR04 — Pour détecter les obstacles (~2€)
Servo SG90 — Pour tourner le capteur (~3€)
Support de piles — 4× AA (6V) ou batterie LiPo 7.4V
Fils dupont — Mâle-mâle et mâle-femelle
Interrupteur — Pour couper l'alimentation facilement

Budget total : ~25-35€ (en plus de l'Arduino)

🔌 Câblage complet

  ALIMENTATION (piles 6V-9V)
  ├── + → Interrupteur → L298N 12V IN
  └── - → L298N GND → Arduino GND

  L298N (Driver Moteur)
  ├── ENA → Arduino Pin 5  (PWM vitesse moteur A)
  ├── IN1 → Arduino Pin 7  (direction moteur A)
  ├── IN2 → Arduino Pin 8  (direction moteur A)
  ├── IN3 → Arduino Pin 12 (direction moteur B)
  ├── IN4 → Arduino Pin 13 (direction moteur B)
  ├── ENB → Arduino Pin 6  (PWM vitesse moteur B)
  ├── OUT1/OUT2 → Moteur gauche
  ├── OUT3/OUT4 → Moteur droit
  └── 5V OUT → Arduino VIN (le L298N alimente l'Arduino !)

  HC-SR04 (Capteur)
  ├── VCC → Arduino 5V
  ├── TRIG → Arduino Pin 9
  ├── ECHO → Arduino Pin 10
  └── GND → Arduino GND

  Servo SG90
  ├── Orange (signal) → Arduino Pin 11
  ├── Rouge (+) → Arduino 5V
  └── Marron (-) → Arduino GND

⚠️

Alimentation séparée OBLIGATOIRE !

Les moteurs consomment beaucoup de courant. Ne les alimente JAMAIS via le USB ou le 5V de l'Arduino. Utilise des piles ou une batterie via le L298N. Le régulateur 5V du L298N peut alimenter l'Arduino via VIN.

/*
 * PROJET FINAL : ROBOT ÉVITEUR D'OBSTACLES
 * Le robot avance, détecte un mur, scanne gauche/droite,
 * et tourne du côté le plus dégagé.
 */
#include <Servo.h>

// === PINS ===
// Moteur A (gauche)
const int ENA = 5;   // Vitesse (PWM)
const int IN1 = 7;   // Direction
const int IN2 = 8;
// Moteur B (droit)
const int ENB = 6;   // Vitesse (PWM)
const int IN3 = 12;  // Direction
const int IN4 = 13;
// Capteur ultrason
const int TRIG = 9;
const int ECHO = 10;
// Servo
const int SERVO_PIN = 11;

// === CONSTANTES ===
const int VITESSE = 180;      // 0-255 (ne mets pas trop fort)
const int DIST_DANGER = 25;   // Distance en cm avant obstacle

Servo radar;

void setup() {
  // Config moteurs
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENB, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  // Config capteur
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  // Servo
  radar.attach(SERVO_PIN);
  radar.write(90);  // Centre
  Serial.begin(9600);
  delay(2000);  // Attendre 2s au démarrage
  Serial.println("🤖 Robot prêt !");
}

// --- Fonctions capteur ---
float mesurerDistance() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  long duree = pulseIn(ECHO, HIGH, 25000);
  if (duree == 0) return 999;  // Pas d'écho = loin
  return duree * 0.0343 / 2.0;
}

// --- Fonctions moteur ---
void avancer() {
  analogWrite(ENA, VITESSE);
  analogWrite(ENB, VITESSE);
  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
  digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
}

void reculer() {
  analogWrite(ENA, VITESSE);
  analogWrite(ENB, VITESSE);
  digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH);
  digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH);
}

void tournerGauche() {
  analogWrite(ENA, VITESSE);
  analogWrite(ENB, VITESSE);
  digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH);
  digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
}

void tournerDroite() {
  analogWrite(ENA, VITESSE);
  analogWrite(ENB, VITESSE);
  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH);
}

void stop() {
  analogWrite(ENA, 0);
  analogWrite(ENB, 0);
}

// --- Scanner gauche/droite ---
void scannerEtTourner() {
  stop();
  reculer();
  delay(300);
  stop();

  // Regarder à droite
  radar.write(20);
  delay(500);
  float distDroite = mesurerDistance();
  Serial.print("Droite: "); Serial.println(distDroite);

  // Regarder à gauche
  radar.write(160);
  delay(500);
  float distGauche = mesurerDistance();
  Serial.print("Gauche: "); Serial.println(distGauche);

  // Recentrer le servo
  radar.write(90);
  delay(300);

  // Choisir la meilleure direction
  if (distDroite > distGauche) {
    Serial.println("→ Je tourne à droite");
    tournerDroite();
    delay(400);
  } else {
    Serial.println("← Je tourne à gauche");
    tournerGauche();
    delay(400);
  }
  stop();
}

void loop() {
  float dist = mesurerDistance();
  Serial.print("Distance: ");
  Serial.print(dist);
  Serial.println(" cm");

  if (dist < DIST_DANGER) {
    Serial.println("⚠️ OBSTACLE !");
    scannerEtTourner();
  } else {
    avancer();
  }
  delay(100);
}

🔧

Calibration :

Les deux moteurs ne tournent jamais exactement à la même vitesse. Si ton robot tire à gauche, augmente la vitesse du moteur gauche (ou baisse celle du droit). Ajoute un offset dans la fonction avancer().

🧪 Tips de pro

Teste chaque partie séparément — D'abord les moteurs seuls, puis le capteur seul, puis le servo. Assemble le tout une fois que chaque morceau marche.
Le Moniteur Série est ton meilleur ami — Mets des Serial.println() partout pour débugger. Tu verras exactement ce que le robot "pense".
Vitesse progressive — Ne démarre pas les moteurs à fond d'un coup. Augmente progressivement la PWM de 0 à ta vitesse cible.
Piles chargées — Des piles faibles = un robot incohérent. Si les moteurs "grognent" sans tourner, change les piles.
Fixe bien le capteur — Si le HC-SR04 bouge ou vibre, les mesures seront fausses. Utilise de la pâte adhésive, du scotch double face, ou imprime un support 3D.

🏆

Tu as fini ? GG !

Tu as un robot autonome qui évite les obstacles. Ça te met devant 99% des gens de ton âge en robotique. Prochaines étapes : ajoute un suiveur de ligne (capteur IR), un Bluetooth HC-05 pour le contrôler depuis ton téléphone, ou un écran OLED pour afficher les infos. Le monde est à toi.

Arduino : De Zéro à Robot

🗺️ Sommaire

C'est quoi Arduino ?

Le Setup

Les Bases du C++

Projet 1 : Blink

Projet 2 : Feu Tricolore

Projet 3 : Capteur Ultrason

Projet 4 : Servo Moteur

Projet Final : Robot

🤔 C'est quoi Arduino ?

🌍 Qui utilise Arduino ?

🛠️ Le Setup

Étape 1 : Télécharger l'IDE Arduino

Étape 2 : Brancher la carte

Étape 3 : Configurer l'IDE

💻 Les Bases du C++

📦 Les Variables

🔀 Les Conditions

🔁 Les Boucles

⚡ Les Fonctions

💡 Projet 1 : Blink

Le "Hello World" de l'électronique

🔌 Câblage

🚦 Projet 2 : Feu Tricolore

Simule un vrai feu de circulation

🔌 Câblage

📡 Projet 3 : Capteur Ultrason

Mesure la distance comme un sonar 🦇

🔌 Câblage

🧪 Comment ça marche ?

⚙️ Projet 4 : Servo Moteur

Contrôle un moteur avec un potentiomètre

🔌 Câblage

🎯 Défi bonus : Balayage automatique

🤖 Projet Final : Robot Éviteur d'Obstacles

Le boss final 🏆

📋 Liste de matériel

🔌 Câblage complet

🧪 Tips de pro