Sommaire
Présentation de la carte LED & boutons pour Arduino
La carte LED + Boutons, compatible Arduino, ESP32 et Raspberry Pi, est un module simple et polyvalent conçu pour l’apprentissage et les prototypes rapides.
Elle réunit 8 boutons poussoirs et 8 LED, idéale pour des projets ludiques comme un chenillard, un dé électronique ou un jeu de mémoire.
Les boutons sont regroupés sur un connecteur 10 broches comprenant :
- VCC (alimentation)
- GND (masse)
- 8 broches d’entrée distinctes (une par bouton)
Les LED sont accessibles via un connecteur 9 broches :
- GND partagé
- 8 broches de sortie dédiées (une par LED)
Grâce à ce format, la carte se branche facilement sur une carte Arduino (par exemple une Arduino Mega) sans soudure : alimentez la carte, reliez la masse et connectez les lignes de commande — et c’est prêt.
C’est une excellente plateforme pédagogique pour découvrir la gestion des entrées/sorties numériques, la lecture de boutons, le pilotage de LED et la création de petits projets interactifs.
Le Montage
Dans cette section, nous listons le matériel nécessaire et présentons le câblage entre une Arduino Mega 2560 et la carte LED & boutons. Le montage est simple : il suffit de connecter les entrées boutons, les sorties LED, l’alimentation 5V et la masse.
Matériel nécessaire
- 1 Carte Arduino Mega 2560
- 1 carte LED & Boutons
- 1 câble USB Type-C
- Câbles de connexion M-F 20 cm
Lot de 40 Câbles Dupont mâle-femelle de 30cm pour Arduino
3,99 €
Vous économisez
Câble USB Type C pour Arduino et ESP32 – Transfert Fiable et Rapide pour Projets Créatifs
3,99 €
Vous économisez
Carte microcontrôleur Mega 2560 – ATmega2560 pour Arduino et prototypage avancé
22,99 €
Vous économisez
Carte Led et Boutons pour Arduino
8,99 €
Vous économisez
Câblage Arduino Mega → Carte LEDs & Boutons
Le tableau ci-dessous indique la correspondance entre les broches numériques de l’Arduino Mega et les boutons / LEDs de la carte.
| Arduino MEGA | Carte Leds et Boutons |
|---|---|
| D22 | BT1 |
| D23 | BT2 |
| D24 | BT3 |
| D25 | BT4 |
| D26 | BT5 |
| D27 | BT6 |
| D28 | BT7 |
| D29 | BT8 |
| D30 | L8 |
| D31 | L7 |
| D32 | L6 |
| D33 | L5 |
| D34 | L4 |
| D35 | L3 |
| D36 | L2 |
| D37 | L1 |
| 5V | VCC |
| GND | GND |
Programmation Arduino de la carte LEDs & Boutons (Arduino Mega 2560)
Nous allons configurer et programmer la carte LEDs & boutons avec une Arduino Mega 2560 pour réaliser plusieurs applications interactives :
- Mode Instantané : chaque LED s’allume dès que l’on appuie sur son bouton et s’éteint immédiatement lorsqu’on le relâche.
- Mode Bascule : un appui sur un bouton inverse l’état de la LED associée (ON ⇄ OFF).
- Chenillard : un effet lumineux dynamique où les LED s’allument successivement, avec une vitesse réglable grâce aux boutons.
- Simon Game : un jeu de mémoire où l’utilisateur doit reproduire une séquence lumineuse en appuyant sur les bons boutons.
- Dé électronique : un outil pratique pour les jeux de plateau et les jeux de rôle, affichant un résultat aléatoire de 1 à 6 via les LED.
Librairies
Aucune librairie externe n’est nécessaire pour ces exemples — tout fonctionne avec les fonctions standards de l’IDE Arduino.
Mode instantané
Dans ce mode, chaque LED s’allume tant que son bouton est pressé et s’éteint au relâchement.
const int buttonPins[8] = {22, 23, 24, 25, 26, 27, 28, 29};
const int ledPins[8] = {37, 36, 35, 34, 33, 32, 31, 30};
void setup() {
for (int i = 0; i < 8; i++) {
pinMode(buttonPins[i], INPUT); // Boutons en entrée
pinMode(ledPins[i], OUTPUT); // LED en sortie
}
}
void loop() {
for (int i = 0; i < 8; i++) {
int state = digitalRead(buttonPins[i]);
digitalWrite(ledPins[i], state); // LED ON si bouton appuyé
}
}
Mode bascule
Dans le mode bascule, chaque bouton agit comme un interrupteur : la LED change d’état (allumée ou éteinte) à chaque fois qu’on appuie et relâche le bouton qui lui correspond .
const int buttonPins[8] = {22, 23, 24, 25, 26, 27, 28, 29};
const int ledPins[8] = {37, 36, 35, 34, 33, 32, 31, 30};
bool ledState[8] = {0};
bool prev[8] = {0};
void setup() {
for (int i = 0; i < 8; i++) {
pinMode(buttonPins[i], INPUT); // Pull-down externe
pinMode(ledPins[i], OUTPUT);
}
}
void loop() {
for (int i = 0; i < 8; i++) {
bool reading = digitalRead(buttonPins[i]);
if (reading == HIGH && prev[i] == LOW) {
ledState[i] = !ledState[i];
digitalWrite(ledPins[i], ledState[i]);
delay(200); // anti-rebond simple
}
prev[i] = reading;
}
}
Chenillard (vitesse contrôlée par boutons)
Le chenillard est l’un des effets lumineux les plus emblématiques en électronique. Il consiste à faire s’allumer les LEDs l’une après l’autre, créant un mouvement visuel fluide et dynamique.
Dans cette version, chaque bouton joue un rôle précis :
- Il permet de choisir la vitesse de défilement du chenillard.
- Plus le bouton choisi est “haut” (bouton 1 → bouton 8), plus le chenillard défile rapidement.
const int buttonPins[8] = {22, 23, 24, 25, 26, 27, 28, 29};
const int ledPins[8] = {30, 31, 32, 33, 34, 35, 36, 37};
// vitesses associées à chaque bouton (ms)
int speeds[8] = {
400, // bouton 1 : le plus lent
300, // bouton 2
220, // bouton 3
160, // bouton 4
120, // bouton 5
80, // bouton 6
50, // bouton 7
25 // bouton 8 : le plus rapide
};
int speedDelay = 400; // vitesse initiale
int indexLed = 0;
int direction = 1;
void setup() {
for (int i = 0; i < 8; i++) {
pinMode(buttonPins[i], INPUT); // pull-down
pinMode(ledPins[i], OUTPUT);
}
}
void loop() {
// --- Détection du bouton pressé ---
for (int i = 0; i < 8; i++) {
if (digitalRead(buttonPins[i]) == HIGH) {
speedDelay = speeds[i]; // vitesse = bouton
}
}
// --- Chenillard ---
for (int i = 0; i < 8; i++)
digitalWrite(ledPins[i], LOW);
digitalWrite(ledPins[indexLed], HIGH);
indexLed += direction;
// changement de sens aux extrémités
if (indexLed == 7 || indexLed == 0) {
direction = -direction;
}
delay(speedDelay);
}
Simon Game (jeu de mémoire)
Le Simon Game est un grand classique des jeux électroniques de mémoire, popularisé depuis les années 80.
Le principe est simple :
- Le système affiche une séquence lumineuse en allumant certaines LEDs, puis le joueur doit la reproduire en appuyant sur les boutons correspondants.
- À chaque tour, la séquence s’allonge d’un élément, rendant le défi de plus en plus difficile. C’est un jeu idéal pour tester ses réflexes, sa mémoire visuelle et sa concentration.
// ---------------------------------------
// SIMON GAME - Arduino Mega (8 LEDs + 8 boutons)
// ---------------------------------------
const int NB_BUTTONS = 8;
// Pins des boutons (pull-down)
const int buttonPins[NB_BUTTONS] = {22, 23, 24, 25, 26, 27, 28, 29};
// Pins des LEDs
const int ledPins[NB_BUTTONS] = {37, 36, 35, 34, 33, 32, 31, 30};
// Tableau contenant la séquence
int sequence[100];
int sequenceLength = 0;
bool waitRelease = false;
void setup() {
// Initialisation entrées / sorties
for (int i = 0; i < NB_BUTTONS; i++) {
pinMode(buttonPins[i], INPUT); // pull-down externe
pinMode(ledPins[i], OUTPUT);
digitalWrite(ledPins[i], LOW);
}
Serial.begin(9600);
randomSeed(analogRead(A0)); // random vraiment aléatoire
startNewGame();
}
void loop() {
// 1) Montrer la séquence
showSequence();
// 2) Lire la réponse du joueur
if (!playerTurn()) {
// Échec -> animation de perte
loseAnimation();
delay(1000);
startNewGame();
}
// 3) Succès → on ajoute un élément
sequence[sequenceLength] = random(0, NB_BUTTONS);
sequenceLength++;
delay(700);
}
// ---------------------------------------
// Lancer un nouveau jeu
// ---------------------------------------
void startNewGame() {
sequenceLength = 1;
sequence[0] = random(0, NB_BUTTONS);
Serial.println("Nouveau jeu !");
}
// ---------------------------------------
// Affiche la séquence complète
// ---------------------------------------
void showSequence() {
delay(500);
for (int i = 0; i < sequenceLength; i++) {
int idx = sequence[i];
// LED ON
digitalWrite(ledPins[idx], HIGH);
delay(500);
// LED OFF
digitalWrite(ledPins[idx], LOW);
delay(200);
}
}
// ---------------------------------------
// Tour du joueur - Retourne true si correct
// ---------------------------------------
bool playerTurn() {
for (int i = 0; i < sequenceLength; i++) {
int expected = sequence[i];
int pressed = waitForButtonPress();
if (pressed != expected) {
return false; // joueur s'est trompé
}
}
return true; // joueur a tout réussi
}
// ---------------------------------------
// Attend que le joueur appuie sur un bouton
// Retourne l’index du bouton
// ---------------------------------------
int waitForButtonPress() {
while (true) {
for (int i = 0; i < NB_BUTTONS; i++) {
if (digitalRead(buttonPins[i]) == HIGH) {
// Effet visuel : LED s'allume tant qu'on appuie
digitalWrite(ledPins[i], HIGH);
delay(100);
digitalWrite(ledPins[i], LOW);
// Anti-rebond / attente du relâchement
while (digitalRead(buttonPins[i]) == HIGH);
delay(100);
return i;
}
}
}
}
// ---------------------------------------
// Animation d'échec
// ---------------------------------------
void loseAnimation() {
for (int n = 0; n < 3; n++) {
for (int i = 0; i < NB_BUTTONS; i++)
digitalWrite(ledPins[i], HIGH);
delay(200);
for (int i = 0; i < NB_BUTTONS; i++)
digitalWrite(ledPins[i], LOW);
delay(200);
}
}
Dé électronique (1–6)
Le dé électronique réalisé avec votre carte LED + boutons est une excellente alternative aux dés physiques traditionnels pour les jeux de plateau ou de rôles (Monopoly, Risk, Cluedo, Donjon et Dragons, etc…)
Grâce à un simple appui sur un bouton, l’Arduino génère un nombre aléatoire entre 1 et 6 et l’affiche instantanément sous forme de LED allumées :
- 1 LED pour le chiffre 1, 2 LEDs pour le chiffre 2… jusqu’à 6 LEDs pour le chiffre 6.
const int buttonPin = 22; // bouton en pull-down
// 8 LEDs pour l'animation
const int ledPinsAnim[8] = {30, 31, 32, 33, 34, 35, 36, 37};
// 6 LEDs pour afficher le résultat du dé
const int ledPinsResult[6] = {37, 36, 35, 34, 33, 32};
bool lastButton = LOW;
int result = 1;
void setup() {
pinMode(buttonPin, INPUT);
for (int i = 0; i < 8; i++) {
pinMode(ledPinsAnim[i], OUTPUT);
digitalWrite(ledPinsAnim[i], LOW);
}
randomSeed(analogRead(A0));
}
void loop() {
bool reading = digitalRead(buttonPin);
if (reading == HIGH && lastButton == LOW) {
// ---------------------------------------------------
// ANIMATION LONGUE SUR LES 8 LEDS
// ---------------------------------------------------
for (int cycle = 0; cycle < 3; cycle++) { // 3 tours complets
for (int i = 0; i < 8; i++) {
// éteint tout
for (int j = 0; j < 8; j++)
digitalWrite(ledPinsAnim[j], LOW);
// allume une LED à la fois
digitalWrite(ledPinsAnim[i], HIGH);
delay(90 - cycle * 20); // accélère progressivement
}
}
// ---------------------------------------------------
// RÉSULTAT FINAL (1 à 6) — sur les 6 PREMIÈRES LEDs
// ---------------------------------------------------
result = random(1, 7); // 1 à 6
// éteint toutes les LEDs
for (int i = 0; i < 8; i++)
digitalWrite(ledPinsAnim[i], LOW);
// allume *n* LEDS pour représenter la valeur du dé
for (int i = 0; i < result; i++)
digitalWrite(ledPinsResult[i], HIGH);
delay(300); // anti-rebond
}
lastButton = reading;
}
Exploitez la carte LEDs & Boutons avec Arduino Mega 2560
Grâce à la carte LEDs et Boutons associée à une Arduino Mega 2560, nous avons exploré de nombreuses applications interactives : des plus simples (mode instantané, bascule) aux plus ludiques et avancées (chenillard, Simon Game, dé électronique). Ces exemples démontrent la polyvalence de la carte pour apprendre à manipuler les entrées/sorties, développer sa logique de programmation et créer des mini-jeux électroniques.
Mais ce n’est qu’un début ! Cette carte peut servir de base à de nombreux projets, par exemple :
- Le jeu de la taupe (Whack-a-Mole) : appuyer rapidement sur les boutons dont les LEDs s’allument.
- Des quiz ou QCM lumineux.
- Des jeux de réflexes où le joueur doit réagir le plus vite possible.
- Des animations lumineuses avancées : aller-retour, vagues, patterns aléatoires.
- Des interfaces utilisateur simples : sélection de modes, menus, mini-tableaux de bord.
- Des prototypes pédagogiques pour l’enseignement de l’électronique.
La carte LEDs + Boutons est donc un excellent support pour laisser libre cours à sa créativité : expérimenter, apprendre et imaginer de nouveaux jeux ou systèmes interactifs. Avec seulement quelques lignes de code, elle se transforme en console miniature, outil éducatif ou module d’animation.
Il ne vous reste plus qu’à continuer d’explorer, tester et inventer vos propres applications… Les possibilités sont quasiment infinies !




