Skip to content
Learni
Voir tous les tutoriels
Développement Embarqué

Comment débuter avec Arduino en 2026 : projet LED clignotante

Read in English

Introduction

Arduino est une plateforme open-source idéale pour débuter en électronique embarquée et en programmation physique. En 2026, avec l'essor de l'IoT, des makerspaces et des projets DIY intelligents, maîtriser Arduino ouvre des portes vers des applications comme les capteurs connectés, les robots ou les maisons domotiques. Ce tutoriel beginner vous guide pour créer votre premier projet : une LED clignotante évolutive vers un circuit interactif avec bouton et potentiomètre.

Pourquoi ce tuto ? Il est 100% actionnable : codes complets, fonctionnels, copier-collables dans l'IDE Arduino. On part des bases (installation) vers le complexe (gestion non-bloquante). Imaginez Arduino comme un cerveau minuscule : vous lui donnez des instructions en C++ simplifié, et il interagit avec le monde réel via pins. À la fin, vous bookmarked ce guide pour vos futurs projets. Durée estimée : 1h. Prêt ? Allumons cette LED ! (132 mots)

Prérequis

  • Ordinateur avec Windows, macOS ou Linux
  • Carte Arduino Uno (ou compatible, ~10-20€)
  • Câble USB-A vers USB-B (fourni avec la carte)
  • Optionnel : LED, résistance 220Ω, potentiomètre 10kΩ, breadboard et fils jumper pour extensions
  • Connexion internet pour l'installation

Installer l'IDE Arduino

install-ide.sh
#!/bin/bash
# Téléchargez l'IDE depuis arduino.cc (version 2.x recommandée en 2026)
# Linux/Mac : via gestionnaire de paquets ou direct
curl -O https://downloads.arduino.cc/arduino-ide/arduino-ide_latest_Linux_64bit.AppImage
chmod +x arduino-ide_latest_Linux_64bit.AppImage
./arduino-ide_latest_Linux_64bit.AppImage

# Windows : double-cliquez sur le .exe téléchargé
# Ajoutez l'URL de boards : Fichier > Préférences > URLs supplémentaires
# https://downloads.arduino.cc/packages/package_index.json (pour Uno R4 si besoin)

# Installez le support 'Arduino AVR Boards' via Outils > Gestionnaire de cartes

Ce script bash installe l'IDE Arduino sur Linux/Mac (adaptez pour Windows via .exe). Il prépare l'environnement pour compiler et uploader des sketches. Piège : oubliez pas d'ajouter le support de carte Uno dans le gestionnaire, sinon 'port non trouvé'.

Configurer la carte et uploader

Branchez votre Arduino Uno via USB. Ouvrez l'IDE :

  • Outils > Carte : Sélectionnez 'Arduino Uno'
  • Outils > Port : Choisissez le port COM (Windows) ou /dev/ttyUSB* (Linux/Mac)

Cliquez 'Téléverser' (flèche →). La LED intégrée clignote vite pendant l'upload. Vérifiez le moniteur série (Outils > Moniteur série, 9600 bauds) pour debug. Analogie : c'est comme flasher un firmware sur un smartphone.

Premier sketch : LED clignotante

Blink.ino
void setup() {
  // Initialise la pin LED intégrée comme sortie
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // Allume la LED
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);  // Attend 1 seconde

  // Éteint la LED
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);  // Attend 1 seconde
}

Ce sketch classique fait clignoter la LED intégrée (pin 13) toutes les secondes. setup() s'exécute une fois, loop() en boucle infinie. delay() bloque tout : ok pour débuter, mais évitez en projets complexes (bloque serial par ex.). Copiez-collez, upload, et observez !

Évoluer : Ajouter une LED externe

  • Branchez LED + anode (longue) sur pin 8 via résistance 220Ω, cathode (courte) sur GND.
  • Changez pinMode(8, OUTPUT) et digitalWrite(8, ...).
Testez : la LED externe clignote. Prochaine étape : contrôle manuel.

LED contrôlée par bouton

ButtonLED.ino
const int buttonPin = 2;  // Pin bouton
const int ledPin = 8;     // Pin LED

int buttonState = 0;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);  // Résistance pull-up interne
  Serial.begin(9600);
}

void loop() {
  buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) {  // Bouton pressé (LOW car pull-up)
    digitalWrite(ledPin, HIGH);
    Serial.println("LED allumée");
  } else {
    digitalWrite(ledPin, LOW);
    Serial.println("LED éteinte");
  }
  delay(50);  // Anti-rebond
}

Bouton sur pin 2 (INPUT_PULLUP évite résistance externe), LED sur 8. Lecture digitalRead() et condition if. Serial pour debug. Piège : sans delay(50), rebonds multiples ; INPUT_PULLUP simplifie le câblage (bouton entre pin et GND).

Lecture analogique : Potentiomètre

Branchez potentiomètre : extrémités sur 5V/GND, molette sur A0.

Valeur 0-1023 (10 bits). Utilisez pour varier vitesse clignotement.

Clignotement variable avec potar

PotarBlink.ino
const int ledPin = 8;
const int potarPin = A0;

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int potarValue = analogRead(potarPin);  // 0-1023
  int delayTime = map(potarValue, 0, 1023, 100, 2000);  // Mappe en 100-2000ms

  digitalWrite(ledPin, HIGH);
  delay(delayTime);
  digitalWrite(ledPin, LOW);
  delay(delayTime);

  Serial.print("Potar: ");
  Serial.print(potarValue);
  Serial.print(" | Délai: ");
  Serial.println(delayTime);
}

analogRead() lit signal continu. map() convertit plage (utile pour servos). Ouvrez Moniteur série pour voir valeurs. Piège : delay() bloque serial si trop long ; ici ok pour demo.

Communication série avancée

SerialEcho.ino
void setup() {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.println("Arduino prêt ! Tapez 'ON', 'OFF' ou 'BLINK'.");
}

void loop() {
  if (Serial.available() > 0) {
    String command = Serial.readStringUntil('\n');
    command.trim();

    if (command == "ON") {
      digitalWrite(LED_BUILTIN, HIGH);
      Serial.println("LED ON");
    } else if (command == "OFF") {
      digitalWrite(LED_BUILTIN, LOW);
      Serial.println("LED OFF");
    } else if (command == "BLINK") {
      for (int i = 0; i < 5; i++) {
        digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
        delay(200);
      }
      Serial.println("Blink fini");
    }
  }
}

Lit commandes série du PC ('ON/OFF/BLINK'). readStringUntil() pour input propre. Trim() enlève espaces. Idéal pour debug ou interface simple. Piège : oubliez Serial.available() = boucle infinie.

Clignotement non-bloquant (millis)

NonBlockingBlink.ino
const int ledPin = 8;
unsigned long previousMillis = 0;
const long interval = 1000;
int ledState = LOW;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    ledState = !ledState;
    digitalWrite(ledPin, ledState);
  }

  // Ici : code non-bloqué (ex: lire capteurs)
  // analogRead(A0); etc.
}

millis() mesure temps écoulé sans bloquer (comme un chronomètre). Évite delay() pour multitâche. Piège : millis() déborde après 49 jours (unsigned long gère en boucle). Base pour projets réactifs.

Bonnes pratiques

  • Commentez toujours votre code : setup/loop, pins, logique.
  • Utilisez const int pour pins/configs (évite fautes de frappe).
  • Préférez millis() à delay() pour réactivité.
  • Testez serial debug à chaque étape.
  • Breadboard + schémas Fritzing pour câblage clair.

Erreurs courantes à éviter

  • Port/Board mal sélectionné : 'avrdude: stk500_recv() error' → vérifiez Outils.
  • Câble USB défectueux : essayez-en un autre (power only vs data).
  • delay() partout : rend sourd aux inputs (bouton ignoré).
  • Pins non déclarés : compiler échoue ; toujours pinMode().

Pour aller plus loin