Atelier Arduino — Programmation de 8 LEDs NeoPixel

Cet atelier Arduino a été conçu et animé dans le cadre de mes activités de formatrice.

L’objectif était de proposer une première approche concrète de la programmation embarquée à travers le pilotage d’un module de huit LEDs NeoPixel. Les participants ont pu manipuler des couleurs RGB, créer des séquences lumineuses et organiser leur programme avec des boucles et une fonction personnalisée.

Présentation de l’atelier

Le montage repose sur une carte Arduino reliée à un module circulaire composé de huit LEDs RGB adressables.

Chaque LED NeoPixel peut être contrôlée individuellement. Il est ainsi possible de définir sa couleur à partir de trois valeurs correspondant aux composantes rouge, verte et bleue.

Le programme réalisé pendant l’atelier enchaîne plusieurs animations :

• allumage progressif des quatre premières LEDs en rouge ;
• allumage progressif des quatre dernières LEDs en bleu ;
• passage de l’ensemble des LEDs au vert ;
• affichage d’un motif rouge, jaune et rouge inspiré du drapeau espagnol.

Démonstration

Ce GIF présente le résultat obtenu après téléversement du programme sur la carte Arduino.

Information composant

Schéma du montage

Connexions utilisées

Module NeoPixel	Carte Arduino
DIN ou entrée de données	Broche numérique 2
5V	Broche 5V
GND	Broche GND

La broche numérique 2 est utilisée pour transmettre les instructions au module NeoPixel.

Pour un montage comportant un plus grand nombre de LEDs, une alimentation externe adaptée est recommandée. La masse de cette alimentation doit alors être reliée à celle de la carte Arduino.

Matériel utilisé

• Une carte Arduino
• Un module de 8 LEDs NeoPixel
• Des câbles Dupont
• Une plaque d’essai selon le montage
• Un câble USB
• La bibliothèque Adafruit_NeoPixel

Objectifs pédagogiques

Cet atelier permettait d’aborder plusieurs notions fondamentales :

• découvrir la structure d’un programme Arduino ;
• comprendre le rôle des fonctions setup() et loop() ;
• utiliser une bibliothèque externe ;
• piloter individuellement des LEDs adressables ;
• manipuler les couleurs avec le modèle RGB ;
• utiliser des boucles for ;
• créer une fonction personnalisée ;
• distinguer un affichage progressif d’un affichage simultané.

Bibliothèque utilisée

Le programme s’appuie sur la bibliothèque Adafruit_NeoPixel, qui facilite le contrôle des LEDs adressables.

Elle est importée au début du programme :

#include <Adafruit_NeoPixel.h>

Configuration du module

Le nombre de LEDs et la broche de données sont définis avec deux constantes :

#define sortie 2
#define nb_led 8

L’objet représentant le module est ensuite créé :

Adafruit_NeoPixel module = Adafruit_NeoPixel(
  nb_led,
  sortie,
  NEO_GRB + NEO_KHZ800
);

Cette configuration précise :

• le nombre total de LEDs ;
• la broche utilisée par la carte Arduino ;
• l’ordre des composantes de couleur ;
• la fréquence de communication du module.

Programme Arduino

// ========================================
// ATELIER ARDUINO - 8 LEDS NEOPIXEL
// ========================================

#include <Adafruit_NeoPixel.h>

// Configuration
#define sortie 2
#define nb_led 8

// Création de l'objet module
Adafruit_NeoPixel module = Adafruit_NeoPixel(
  nb_led,
  sortie,
  NEO_GRB + NEO_KHZ800
);

// Déclaration préalable de la fonction personnalisée
void drapeauEspagne();

// ===== SETUP =====
void setup()
{
  module.begin();
  module.clear();
  module.show();
}

// ===== PALETTE DE COULEURS =====
// Rouge   : {255, 0, 0}
// Vert    : {0, 255, 0}
// Cyan    : {0, 255, 255}
// Jaune   : {255, 255, 0}
// Orange  : {255, 125, 0}
// Violet  : {255, 0, 255}
// Rose    : {255, 0, 100}
// Bleu    : {0, 0, 255}
// Blanc   : {255, 255, 255}

// ===== LOOP =====
void loop()
{
  // ÉTAPE 1 : les quatre premières LEDs en rouge
  for (int i = 0; i < 4; i++)
  {
    module.setPixelColor(i, 255, 0, 0);
    module.show();
    delay(100);
  }

  delay(100);

  // ÉTAPE 2 : les quatre dernières LEDs en bleu
  for (int i = 4; i < 8; i++)
  {
    module.setPixelColor(i, 0, 0, 255);
    module.show();
    delay(100);
  }

  delay(100);

  // ÉTAPE 3 : les huit LEDs en vert
  for (int i = 0; i < 8; i++)
  {
    module.setPixelColor(i, 0, 255, 0);
    module.show();
    delay(100);
  }

  delay(100);

  // ÉTAPE 4 : affichage du drapeau espagnol
  drapeauEspagne();
  delay(2000);
}

// ===== FONCTION : DRAPEAU ESPAGNOL =====
void drapeauEspagne()
{
  // Rouge : LEDs 0 et 1
  for (int i = 0; i < 2; i++)
  {
    module.setPixelColor(i, 255, 0, 0);
  }

  // Jaune : LEDs 2 à 5
  for (int i = 2; i < 6; i++)
  {
    module.setPixelColor(i, 255, 255, 0);
  }

  // Rouge : LEDs 6 et 7
  for (int i = 6; i < 8; i++)
  {
    module.setPixelColor(i, 255, 0, 0);
  }

  module.show();
}

Déroulement de l’atelier

L’atelier était organisé autour d’une progression simple et visuelle.

Initialisation du module

La fonction setup() prépare le module NeoPixel au démarrage :

module.begin();
module.clear();
module.show();

Le module est initialisé, les LEDs sont éteintes, puis l’état initial est envoyé au ruban.

Manipulation des couleurs RGB

Chaque couleur est définie grâce à trois valeurs comprises entre 0 et 255 :

module.setPixelColor(index, rouge, vert, bleu);

Par exemple, cette instruction configure une LED en rouge :

module.setPixelColor(0, 255, 0, 0);

Création de séquences lumineuses

Les boucles for permettent de parcourir plusieurs LEDs et de créer un effet progressif :

for (int i = 0; i < 4; i++)
{
  module.setPixelColor(i, 255, 0, 0);
  module.show();
  delay(100);
}

L’appel à module.show() après chaque modification rend l’animation visible LED par LED.

Création d’un motif personnalisé

La fonction drapeauEspagne() regroupe la logique d’un motif rouge, jaune et rouge.

Elle permet d’introduire l’organisation du code en fonctions et de montrer comment préparer plusieurs couleurs avant de les afficher simultanément avec un seul appel à module.show().

Prolongements possibles

Cet atelier peut être enrichi avec de nombreuses variantes :

• création d’un effet arc-en-ciel ;
• modification progressive de la luminosité ;
• ajout d’un bouton pour changer d’animation ;
• utilisation d’un potentiomètre pour régler la vitesse ;
• création de nouveaux motifs colorés ;
• remplacement de delay() par une gestion basée sur millis() ;
• pilotage du module avec une carte ESP32 ;
• contrôle des animations depuis une interface web.

Bilan

Cet atelier propose une introduction ludique et accessible à la programmation Arduino.

Le retour visuel immédiat des LEDs facilite la compréhension du code et permet d’aborder progressivement les variables, les boucles, les fonctions et les couleurs RGB à travers une réalisation concrète.