Les Fabriques du Ponant - Contributions de l’utilisateur [fr]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T11:27:36Z

Emma : /* Conception des boutons */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton lumineux rouge à disposition, le problème est qu'il faut plusieurs couleurs. Alors nous changeons de couleur de la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons décider de couper du plexiglass en plusieurs formes : bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. Le fichier prototype a été réalisé avec inkscape et la découpe avec une découpeuse laser. 
- Ensuite, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 
- Pour finir, nous allons les pencher à un angle de 45° pour que ce soit plus visible pour les enfants.

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf
</gallery>

== Galère ==

11h50, jeu de lumiere marche pas, on retourne à l'ancienne version

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T11:14:03Z

Emma :

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton lumineux rouge à disposition, le problème est qu'il faut plusieurs couleurs. Alors nous changeons de couleur de la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons décider de couper du plexiglass en plusieurs formes : bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. Le fichier prototype a été réalisé avec inkscape et la découpe avec une découpeuse laser. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf
</gallery>

== Galère ==

11h50, jeu de lumiere marche pas, on retourne à l'ancienne version

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T11:12:48Z

Emma : /* Prototype design bouton */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton lumineux rouge à disposition, le problème est qu'il faut plusieurs couleurs. Alors nous changeons de couleur de la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons décider de couper du plexiglass en plusieurs formes : bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. Le fichier prototype a été réalisé avec inkscape et la découpe avec une découpeuse laser. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf
</gallery>

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T11:09:27Z

Emma :

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton lumineux rouge à disposition, le problème est qu'il faut plusieurs couleurs. Alors nous changeons de couleur de la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons décider de couper du plexiglass en plusieurs formes : bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. Le fichier prototype a été réalisé avec inkscape et la découpe avec une découpeuse laser. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf
</gallery> 

== Galère == 

11h50, jeu de lumiere marche pas, on retourne à l'ancienne version

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T11:07:50Z

Emma : /* Prototype design bouton */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton lumineux rouge à disposition, le problème est qu'il faut plusieurs couleurs. Alors nous changeons de couleur de la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons décider de couper du plexiglass en plusieurs formes : bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. Le fichier prototype a été réalisé avec inkscape et la découpe avec une découpeuse laser. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf
</gallery> 

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:55:13Z

Emma :

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton lumineux rouge à disposition, le problème est qu'il faut plusieurs couleurs. Alors nous changeons de couleur de la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons décider de couper du plexiglass en plusieurs formes : bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. Le fichier prototype a été réalisé avec inkscape et la découpe avec une découpeuse laser. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf
</gallery>

A 11h50, jeu de lumiere marche pas on retourne sur l'ancien.

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:49:59Z

Emma : /* Conception des boutons */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton lumineux rouge à disposition, le problème est qu'il faut plusieurs couleurs. Alors nous changeons de couleur de la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons décider de couper du plexiglass en plusieurs formes : bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. Le fichier prototype a été réalisé avec inkscape et la découpe avec une découpeuse laser. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf
</gallery>

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:43:37Z

Emma : /* Prototype design bouton */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglass en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf
</gallery>

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:42:34Z

Emma : /* Prototype design bouton */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglass en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Trappe.svg|
</gallery>

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:42:11Z

Emma : /* Prototype design bouton */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglass en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf|
</gallery>

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Fichier:Trappe.svg

2025-11-30T10:41:47Z

Emma :

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:40:23Z

Emma : /* Prototype design bouton */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglass en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==
 
<gallery>
Fichier:Prototypes Boutons .pdf|Description 1
</gallery>

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:36:40Z

Emma :

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons ==

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglass en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Prototype design bouton ==

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:30:02Z

Emma :

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons :== 

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglass, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglass en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée. 

==Photo bouton== 
[[Fichier:Prototypes Boutons .pdf|200px|vignette|centré]]

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Fichier:Prototypes Boutons .pdf

2025-11-30T10:29:14Z

Emma :

prototype final des supports en plexiglass pour les boutons

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:17:51Z

Emma : /* Conception des boutons : */

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons : ==

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglace, cependant cela ne se colle pas au bouton. 
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglace en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans. 
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée.

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:17:10Z

Emma :

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)
==banque d'images==
[[Fichier:E3F3D4A8-ECC8-40C8-9B21-032B27D7E458 2.jpg|200Pxpx|vignette|centré]]

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons : ==

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglace, cependant cela ne se colle pas au bouton.
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglace en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans.
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée.

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]

Super Brest 2025 : L'étrange noël de monsieur Simon

2025-11-30T10:00:28Z

Emma :

[[Fichier:SuperBrest2025-BADGE.png|200px]]

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) en l'adaptant spécifiquement pour la fête de Noël de l'école.

Le projet consiste à :

Utiliser une cheminée existante pour le jeu.

Programmer l'électronique Arduino pour simuler les lumières et les sons de Simon.

Intégrer une thématique Noël (couleurs/sons festifs) pour créer une animation ludique et éducative qui met en avant la créativité.

==membres du projet==

Audrey : Ailée créature 

Emma : Magique arc en ciel 

Ewen: Magic flocon 

Syrielle: Espiegle corne 

Nadia : Divinité flamboyante 

==Bibliographie et webographie sur le projet==
[[https://www.wiki.lesfabriquesduponant.net/index.php?title=ENIB_2022_-_groupe_A_:_Simon]]
https://fr.wikipedia.org/wiki/Simon_(jeu)

==prototype qu'on souhaite réaliser ==

[[Fichier:Prototype simon.jpg|vignette|centré]]

==Schema de cablage==

[[Fichier:Capture d’écran 2025-11-29 à 15.42.22.png|vignette|centré|schema de cablage]]

==Programme arduino==

Le code à ete crée par l'IA claude , voici le prompt : 
Crée un jeu Simon pour ESP32 avec : 

- 4 boutons/LEDs (Rouge/GPIO12-25, Jaune/GPIO13-26, Vert/GPIO14-27, Bleu/GPIO15-33) 

- DFPlayer Mini sur GPIO16-17 avec 6 sons Noël (0001-0006.mp3) 

- Ruban LED WS2812B 144 LEDs sur GPIO32 avec effet feu continu 

- Potentiomètre GPIO34 pour 3 difficultés (3/4/6 niveaux) 

- Son 0005.mp3 pour victoire totale, 0006.mp3 pour échec immédiat 

- Bibliothèques : DFRobotDFPlayerMini + FastLED 

<syntaxhighlight lang="Arduino" line>/*
* JEU SIMON COMPLET - ESP32 + DFPlayer Mini + Ruban LED Feu
*
* Câblage:
* ─────────────────────────────────────────────
* DFPlayer Mini:
* - RX → GPIO 17 (TX ESP32) + résistance 1kΩ
* - TX → GPIO 16 (RX ESP32)
* - VCC → 5V
* - GND → GND
* - SPK_1/2 → Haut-parleur 3W (4-8Ω)
*
* 4 Boutons (avec pull-up interne):
* - Bouton ROUGE → GPIO 12 → GND
* - Bouton VERT → GPIO 13 → GND
* - Bouton BLEU → GPIO 14 → GND
* - Bouton JAUNE → GPIO 15 → GND
*
* 4 LEDs (avec résistances 220Ω):
* - LED ROUGE → GPIO 25 → Résistance → GND
* - LED VERTE → GPIO 26 → Résistance → GND
* - LED BLEUE → GPIO 27 → Résistance → GND
* - LED JAUNE → GPIO 33 → Résistance → GND
*
* Ruban LED (WS2812B - 144 LEDs):
* - DATA → GPIO 32
* - VCC → 5V (alimentation externe recommandée si >30 LEDs)
* - GND → GND (commun avec ESP32)
*
* Potentiomètre (sélection difficulté):
* - Broche gauche → GND
* - Broche centrale → GPIO 34 (ADC)
* - Broche droite → 3.3V
*
* Fichiers MP3 sur carte SD (FAT32):
* - 0001.mp3 : Son bouton ROUGE
* - 0002.mp3 : Son bouton JAUNE
* - 0003.mp3 : Son bouton VERT
* - 0004.mp3 : Son bouton BLEU
* - 0005.mp3 : Son VICTOIRE (après 5 niveaux réussis)
* - 0006.mp3 : Son ÉCHEC (erreur dans la séquence)
*
* IMPORTANT: Installez la bibliothèque FastLED
* (Croquis → Inclure une bibliothèque → Gérer les bibliothèques → FastLED)
*/

#include <DFRobotDFPlayerMini.h>
#include <FastLED.h>

// Configuration DFPlayer
HardwareSerial mySoftwareSerial(2);
DFRobotDFPlayerMini myDFPlayer;

// Configuration Ruban LED
#define LED_STRIP_PIN 32
#define NUM_LEDS 144
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

// Configuration Potentiomètre (sélection difficulté)
#define POTENTIOMETER_PIN 34 // GPIO 34 (ADC1_CH6)

// Niveaux de difficulté
enum Difficulty {
EASY = 0, // 3 niveaux
MEDIUM = 1, // 4 niveaux
HARD = 2 // 6 niveaux
};

Difficulty currentDifficulty = MEDIUM;
int maxLevels = 4; // Par défaut moyen

// Configuration des pins boutons et LEDs
const int BUTTON_PINS[4] = {12, 13, 14, 15}; // Rouge, Jaune, Vert, Bleu
const int LED_PINS[4] = {25, 26, 27, 33}; // Rouge, Jaune, Vert, Bleu

// Noms des couleurs pour l'affichage
const char* COLOR_NAMES[4] = {"ROUGE", "JAUNE", "VERT", "BLEU"};

// Correspondance couleur -> numéro de son
const int COLOR_TO_SOUND[4] = {1, 2, 3, 4}; // Rouge=1, Jaune=2, Vert=3, Bleu=4

// Variables du jeu
int sequence[100]; // Séquence à mémoriser (max 100 niveaux)
int sequenceLength = 0; // Longueur actuelle de la séquence
int playerInput[100]; // Saisie du joueur
int playerIndex = 0; // Position dans la saisie
int level = 1; // Niveau actuel
bool gameActive = false; // Jeu en cours
bool waitingForInput = false; // En attente de la saisie du joueur

// Débounce des boutons
unsigned long lastButtonPress[4] = {0, 0, 0, 0};
const unsigned long DEBOUNCE_DELAY = 250;

// Timings du jeu (en millisecondes)
const int FLASH_DURATION = 500; // Durée d'allumage d'une LED
const int PAUSE_BETWEEN_FLASH = 200; // Pause entre deux LEDs
const int DELAY_AFTER_SEQUENCE = 500;// Délai avant que le joueur joue

// Variables pour l'effet feu
byte heat[NUM_LEDS];
unsigned long lastFireUpdate = 0;
const int FIRE_UPDATE_INTERVAL = 50; // Mise à jour toutes les 50ms

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ JEU SIMON - ESP32 ║");
Serial.println("╚═══════════════════════════════════╝\n");

// Configuration des boutons
for (int i = 0; i < 4; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
}
Serial.println("✓ Boutons configurés");

// Configuration des LEDs
for (int i = 0; i < 4; i++) {
pinMode(LED_PINS[i], OUTPUT);
digitalWrite(LED_PINS[i], LOW);
}
Serial.println("✓ LEDs configurées");

// Configuration du ruban LED
FastLED.addLeds<LED_TYPE, LED_STRIP_PIN, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(100); // Luminosité (0-255)
FastLED.clear();
FastLED.show();
Serial.println("✓ Ruban LED configuré (144 LEDs)");

// Configuration du potentiomètre
pinMode(POTENTIOMETER_PIN, INPUT);
Serial.println("✓ Potentiomètre configuré sur GPIO 34");

// Lire la difficulté initiale
readDifficulty();

// Configuration DFPlayer
mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);

Serial.println("\nInitialisation du DFPlayer...");
if (!myDFPlayer.begin(mySoftwareSerial)) {
Serial.println("\n✗ ERREUR DFPlayer!");
Serial.println("Vérifiez:");
Serial.println(" - Carte SD insérée (FAT32)");
Serial.println(" - Fichiers 0001.mp3 à 0006.mp3");
Serial.println(" - Connexions RX/TX");
while(true) { delay(1000); }
}

Serial.println("✓ DFPlayer OK!");
myDFPlayer.volume(25); // Volume (0-30)
delay(100);

// Animation de démarrage
startupAnimation();

// Initialiser le générateur aléatoire
randomSeed(analogRead(0));

Serial.println("\n═══════════════════════════════════");
Serial.println(" DIFFICULTÉ SÉLECTIONNÉE:");
printDifficulty();
Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour");
Serial.println(" commencer le jeu!");
Serial.println("═══════════════════════════════════\n");
}

void loop() {
// Mettre à jour l'effet feu en continu
updateFireEffect();

if (!gameActive) {
// Attendre qu'un bouton soit pressé pour démarrer
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
delay(300);
startNewGame();
break;
}
}
} else if (waitingForInput) {
checkPlayerInput();
}
}

void startNewGame() {
// Lire la difficulté au début de chaque partie
readDifficulty();

Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ NOUVELLE PARTIE ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Difficulté: ");
printDifficulty();
Serial.println();

gameActive = true;
level = 1;
sequenceLength = 0;

delay(1000);
nextLevel();
}

void nextLevel() {
Serial.println("─────────────────────────────────────");
Serial.print(" NIVEAU ");
Serial.print(level);
Serial.print(" / ");
Serial.println(maxLevels);
Serial.println("─────────────────────────────────────\n");

// Ajouter une couleur aléatoire à la séquence
sequence[sequenceLength] = random(0, 4);
sequenceLength++;

delay(1000);

// Afficher la séquence au joueur
playSequence();

// Attendre la saisie du joueur
playerIndex = 0;
waitingForInput = true;
}

void playSequence() {
Serial.println("👀 Mémorisez la séquence:\n");

for (int i = 0; i < sequenceLength; i++) {
int color = sequence[i];

Serial.print(" ");
Serial.print(i + 1);
Serial.print(". ");
Serial.println(COLOR_NAMES[color]);

// Allumer la LED et jouer le son
digitalWrite(LED_PINS[color], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[color]); // Rouge=1, Jaune=2, Vert=3, Bleu=4

delay(FLASH_DURATION);

// Éteindre la LED
digitalWrite(LED_PINS[color], LOW);

// Pause entre les flashs
if (i < sequenceLength - 1) {
delay(PAUSE_BETWEEN_FLASH);
}
}

delay(DELAY_AFTER_SEQUENCE);
Serial.println("\n🎮 À vous de jouer!\n");
}

void checkPlayerInput() {
for (int i = 0; i < 4; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
unsigned long currentTime = millis();

// Débounce
if (currentTime - lastButtonPress[i] > DEBOUNCE_DELAY) {
lastButtonPress[i] = currentTime;

// Feedback visuel et sonore
digitalWrite(LED_PINS[i], HIGH);
myDFPlayer.play(COLOR_TO_SOUND[i]); // Jouer le son correspondant

Serial.print(" → ");
Serial.println(COLOR_NAMES[i]);

// Enregistrer la saisie
playerInput[playerIndex] = i;

delay(300);
digitalWrite(LED_PINS[i], LOW);

// Vérifier si c'est correct
if (playerInput[playerIndex] != sequence[playerIndex]) {
gameLost();
return;
}

playerIndex++;

// Vérifier si la séquence complète est correcte
if (playerIndex >= sequenceLength) {
sequenceComplete();
}
}
}
}
}

void sequenceComplete() {
Serial.println("\n✅ Séquence correcte!\n");
waitingForInput = false;

level++;

// Vérifier si on a atteint le niveau maximum selon la difficulté
if (level > maxLevels) {
gameWon();
} else {
delay(500);

// Animation de succès (rapide entre chaque niveau)
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(100);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(100);
}

delay(1000);
nextLevel();
}
}

void gameLost() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ ❌ ERREUR! ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous étiez au niveau ");
Serial.println(level);
Serial.println();

waitingForInput = false;
gameActive = false;

// Son d'échec (0006.mp3)
myDFPlayer.play(6);

// Animation d'échec (clignotement rapide)
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(150);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(150);
}

Serial.println("═══════════════════════════════════");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void gameWon() {
Serial.println("\n╔═══════════════════════════════════╗");
Serial.println("║ 🎉 VICTOIRE! 🎉 ║");
Serial.println("╚═══════════════════════════════════╝");
Serial.print("\n Vous avez réussi les ");
Serial.print(maxLevels);
Serial.println(" niveaux!");
Serial.print(" Difficulté: ");
printDifficulty();
Serial.println();

gameActive = false;

// Son de victoire (0005.mp3)
myDFPlayer.play(5);

// Animation de victoire spectaculaire
// Vague de lumière rapide
for (int j = 0; j < 8; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(60);
digitalWrite(LED_PINS[i], LOW);
}
}

// Clignotement final toutes ensemble
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(200);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}
delay(200);
}

Serial.println("\n═══════════════════════════════════");
Serial.println(" Ajustez le potentiomètre pour");
Serial.println(" changer de difficulté");
Serial.println(" Appuyez sur un bouton pour rejouer");
Serial.println("═══════════════════════════════════\n");
}

void startupAnimation() {
Serial.println("\nAnimation de démarrage...\n");

// Allumage séquentiel
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(100);
}
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
delay(100);
}
}

// Flash final
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], HIGH);
}
delay(300);
for (int i = 0; i < 4; i++) {
digitalWrite(LED_PINS[i], LOW);
}

delay(500);
}

// Effet feu de bois pour le ruban LED
void updateFireEffect() {
unsigned long currentTime = millis();

// Mettre à jour seulement toutes les FIRE_UPDATE_INTERVAL ms
if (currentTime - lastFireUpdate < FIRE_UPDATE_INTERVAL) {
return;
}
lastFireUpdate = currentTime;

// Refroidissement: chaque cellule perd un peu de chaleur
for (int i = 0; i < NUM_LEDS; i++) {
int cooldown = random(0, ((55 * 10) / NUM_LEDS) + 2);
if (cooldown >= heat[i]) {
heat[i] = 0;
} else {
heat[i] = heat[i] - cooldown;
}
}

// Diffusion de chaleur vers le haut
for (int k = NUM_LEDS - 1; k >= 2; k--) {
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
}

// Ajout de nouvelles étincelles aléatoires en bas
if (random(255) < 120) {
int y = random(7);
heat[y] = heat[y] + random(160, 255);
}

// Conversion de la chaleur en couleurs
for (int j = 0; j < NUM_LEDS; j++) {
// Palette de couleurs feu: noir → rouge → orange → jaune → blanc
byte temperature = heat[j];

// Noir → Rouge foncé
byte t192 = scale8_video(temperature, 191);
byte heatramp = t192 & 0x3F; // 0..63
heatramp <<= 2; // 0..252

if (t192 & 0x80) {
// Partie la plus chaude - jaune vers blanc
leds[j].r = 255;
leds[j].g = 255;
leds[j].b = heatramp;
} else if (t192 & 0x40) {
// Partie chaude - rouge vers jaune
leds[j].r = 255;
leds[j].g = heatramp;
leds[j].b = 0;
} else {
// Partie froide - noir vers rouge
leds[j].r = heatramp;
leds[j].g = 0;
leds[j].b = 0;
}
}

FastLED.show();
}

// Lire le potentiomètre et déterminer la difficulté
void readDifficulty() {
int potValue = analogRead(POTENTIOMETER_PIN); // 0-4095 sur ESP32

// Diviser en 3 zones
if (potValue < 1365) {
// Zone 1: FACILE (0-1365)
currentDifficulty = EASY;
maxLevels = 3;
} else if (potValue < 2730) {
// Zone 2: MOYEN (1365-2730)
currentDifficulty = MEDIUM;
maxLevels = 4;
} else {
// Zone 3: DIFFICILE (2730-4095)
currentDifficulty = HARD;
maxLevels = 6;
}
}

// Afficher la difficulté actuelle
void printDifficulty() {
switch(currentDifficulty) {
case EASY:
Serial.print("FACILE (3 niveaux)");
break;
case MEDIUM:
Serial.print("MOYEN (4 niveaux)");
break;
case HARD:
Serial.print("DIFFICILE (6 niveaux)");
break;
}
}
</syntaxhighlight>

==Conception des boutons : 

- Au départ : Bouton rouge à disposition, le problème est qu'il faut plusieur couleur. Alors nous changeons de couleur la led et voulons remplacer l'opercule rouge par du plexiglace, cependant cela ne se colle pas au bouton.
- Alors : Nous avons pris des boutons plus petit de plusieurs couleur (rouge, bleu, vert et jaune). Pour les rendre plus grands, nous avons decider de couper du plexiglace en plusieur forme, bonhomme de neige, sapin, renne, et pain d'épice, nous avons laissé un trou (de 27mm de diamètre) dans chacune des formes afin de mettre les boutons dedans.
- Pour finir, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée.

==premier diaporama : Alors ? Comment ça se passe ?==
Diaporama type '''Alors ?''': [[media:DiaporamaSuperBrest2024-Alors.odp|Téléchargez et adaptez-le !]]

==second diaporama : Et voilà !==
Diaporama type '''Et Voilà !''' : [[media:DiaporamaSuperBrest2024-EtVoila.odp|Téléchargez et adaptez-le !]]

[[Catégorie:Sciencehackdaybrest]]
[[Catégorie:Super Brest]]
[[Catégorie:Super Brest 2025]]