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

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

==résumé du projet==
Ce hackathon a pour objectif d'adapter le jeu Simon (mémoire des couleurs/sons) 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 <br>

Emma : Magique arc en ciel <br>

Ewen: Magic flocon <br>

Syrielle: Espiègle corne <br>

Nadia : Divinité flamboyante <br>

[[Fichier:WhatsApp Image 2025-11-30 at 13.39.13 (10).jpeg|400px|centré]]] <br>

==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|200px|vignette|centré]]

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

[[Fichier:Prototype simon.jpg|vignette|centré]] [[Fichier:WhatsApp Image 2025-11-30 at 13.39.10.jpeg]]

==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 : <br>
Crée un jeu Simon pour ESP32 avec :<br>

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

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

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

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

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

- Bibliothèques : DFRobotDFPlayerMini + FastLED<br>

<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 <br> ==

- 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. <br>
- 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. <br>
- Ensuite, nous avons rajouté du vinyl de la même couleur que les boutons pour les rendre plus visible sur la cheminée.<br>
- Pour finir, nous allons les pencher à un angle de 45° pour que ce soit plus visible pour les enfants.

==fichier pour la decoupe de la boite et des boutons <br> ==

[[Media:Prototypes Boutons .pdf|les differents boutons]]<br>

[[Media:Jonction.svg|interieur de la boite]]<br>

[[Media:SupportBoutons.svg|boite des boutons]]<br>

[[Fichier:Les boutons du jeu simons.jpg|vignette|centré]]

== Galère (non exhaustif) <br>== 

Après avoir passé une bonne partie de la soirée à finaliser le câblage et à le rendre propre, malheureusement, il va falloir repasser à la version prototypage. Nadia pas contente.

Le téléversement des photos sur le wiki, Emma n'as pas du tout adhéré à la philosophie wiki !!

Le fichier de la flamme a dû être retravaillé pur permettre une gravure plus rapide, Pour Audrey le visuel n'est pas celui attendu, mais c'est OK. 

Ewen a conçu la trappe pour les cadeaux, il a fallu adapte le principe au fonctionnement, Ewen pas content.


== Le vrai KIFF(non exhaustif) <br>== 

Le résultat est cool, les boutons sont finalisés et utilisable par des enfants. <br>

Le travail de groupe a été efficace, <br>

le fablab est cool, c'est bien de voir des machines plus grandes avec un usage différent<br>

==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]]