ENIB 2024 : catch the light : Différence entre versions

De Les Fabriques du Ponant
Aller à : navigation, rechercher
(étapes de fabrication)
(Fichiers à joindre)
 
(47 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
 
Titre de la fiche expérience :
 
Titre de la fiche expérience :
==description (résumé)==
+
==Description==
  
 
Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.
 
Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.
Ligne 7 : Ligne 7 :
  
  
 +
{| class="wikitable"
 +
|-
 +
| [[Fichier:Groupebg.jpg|400px]]
 +
|-
 +
| ''photo du groupe''
 +
|}
  
 +
==Introduction==
  
[[Fichier:Groupebg.jpg|400px]]
+
Voici une démo pour mieux comprendre comment fonctionne le jeu.
  
==Introduction==
+
<html>
 +
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
 +
</html>
  
éventuelle vidéo
+
==Outil et Matériel==
==outil et matériel==
 
 
*  bouton poussoir
 
*  bouton poussoir
 
*  carte D1 mini avec Arduino
 
*  carte D1 mini avec Arduino
 
*  rubans de led
 
*  rubans de led
 
*  une solderless breadboard
 
*  une solderless breadboard
*  appareil a souder
+
*  appareil à souder
*  colle/scotch
+
pistolet à colle
*  petits cables de connexion
+
*  petits câbles de connexion
resistance pour led
+
résistance pour led
 +
*  bois de chêne / scie à bois/ etaux
 +
*  petite vis x6
 +
*  EPI: lunettes / gants
 +
*  perceuse / tournevis
  
==fichiers à joindre==
+
==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
+
[[Media:Decoupeuse.svg|téléchargez le svg]]
===Mettre du code Arduino===
+
==code==
 +
<syntaxhighlight lang="Arduino" line>
 
#include <Adafruit_NeoPixel.h>    //Importer la bibliotèque "Adafruit_NeoPixel"
 
#include <Adafruit_NeoPixel.h>    //Importer la bibliotèque "Adafruit_NeoPixel"
  
#define NUM_TOTAL_LED 15         // Nombres total de led
+
#define NUM_TOTAL_LED 60         // Nombres total de led
 
#define NUM_LED_PER_LEVEL 15      // Nombres de led par level
 
#define NUM_LED_PER_LEVEL 15      // Nombres de led par level
#define NUM_LEVEL 1               // Nombres de level
+
#define NUM_LEVEL 4               // Nombres de level
 
#define PIN_BUTON 3              // Pin bouton sur la carte
 
#define PIN_BUTON 3              // Pin bouton sur la carte
 
#define PIN_LED 2                // Pin led sur la carte
 
#define PIN_LED 2                // Pin led sur la carte
Ligne 37 : Ligne 50 :
  
 
Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800);  // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
 
Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800);  // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
 +
 
int LED_MIDDLE = NUM_LED_PER_LEVEL/2;                                  // Calcul de la led du milieu
 
int LED_MIDDLE = NUM_LED_PER_LEVEL/2;                                  // Calcul de la led du milieu
int level = 0;                                                         // Initialisation du jeu
+
 
 +
int level = 0;                                                         // Initialisation du jeu
 +
 
 +
int lev = 0;                                                            // Variable pour sauter la fin du niveau
 +
 
 
int score = 0;                                                          // Initialisation du score
 
int score = 0;                                                          // Initialisation du score
 +
 
int delay_level = 300;                                                  // Initialisation de la vitesse de jeu
 
int delay_level = 300;                                                  // Initialisation de la vitesse de jeu
 +
 
int led;                                                                // Implémentation de la variable globale "led"
 
int led;                                                                // Implémentation de la variable globale "led"
 +
 +
unsigned long time = 0;                                                // Initialisation de la variable globale "time"
  
  
 
void setup() {                                                          // Fonction d'initialisation du jeu
 
void setup() {                                                          // Fonction d'initialisation du jeu
  Serial.println("Begin");
 
 
   pinMode(PIN_BUTON, INPUT);                                            // Définition de "PIN_BUTON" en tant qu'entrée
 
   pinMode(PIN_BUTON, INPUT);                                            // Définition de "PIN_BUTON" en tant qu'entrée
 
    
 
    
 
   leds.begin();                                                        // Initialisation des leds
 
   leds.begin();                                                        // Initialisation des leds
   leds.setBrightness(255);                                              // Régler la luminosité des leds
+
   leds.setBrightness(10);                                              // Régler la luminosité des leds
 
   leds.show();                                                          // Afficher les leds
 
   leds.show();                                                          // Afficher les leds
 
    
 
    
 
   attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING);    // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
 
   attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING);    // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
 
   Serial.begin(9600);
 
   Serial.begin(9600);
 
 
}
 
}
  
 
void loop() {                                                          // Fonction de boucle du jeu
 
void loop() {                                                          // Fonction de boucle du jeu
   left();
+
   left();                                                               // Fonction left pour déplacer les leds depuis la gauche
  Serial.println("left");                                                              // Fonction left pour déplacer les leds depuis la gauche
+
   right();                                                             // Fonction right pour déplacer les leds depuis la droite
   right();  
+
  //Serial.println(score);
  Serial.println("right");                                                            // Fonction right pour déplacer les leds depuis la droite
 
 
}
 
}
  
void bouton(){                                                                     // Fonction en cas d'appuie sur le bouton
+
void bouton(){                                                                       // Fonction en cas d'appuie sur le bouton
   score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led);  // Modification du score du joueur
+
   if(millis()-time > 100 && level < NUM_LEVEL){                                                            // Vérification du temps d'appuie bouton pour éviter le rebond
 +
    time=millis();                                                                    // Mettre à jour le bouton pour le prochain appuie
 +
    score += (NUM_LED_PER_LEVEL)-2*abs(NUM_LED_PER_LEVEL*level+LED_MIDDLE-led);  // Modification du score du joueur
 
    
 
    
  leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0));      // Éteindre la led du milieu
+
    leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0));      // Éteindre la led du milieu
  leds.setPixelColor(led, leds.Color(0, 0, 255));                                  // Allumer en bleu la led cliquée
+
    leds.show();
  leds.show();                                                                      // Afficher la led allumée
+
    leds.setPixelColor(led, leds.Color(0, 0, 255));                                  // Allumer en bleu la led cliquée
 +
    leds.show();                                                                      // Afficher la led allumée
 
    
 
    
  level++;                                                                          // Passer au level suivant
+
    level++;                                                                          // Passer au level suivant
  delay_level /= 2;                                                                // Accélérer la vitesse de jeu
+
    delay_level /= 2;                                                                // Accélérer la vitesse de jeu
  led = NUM_LED_PER_LEVEL*level;                                                    // Initialiser la led du level suivant
+
    led = NUM_LED_PER_LEVEL*level;                                                    // Initialiser la led du level suivant
  delay(100);                                                                      // Attendre 100 ms
+
   
 +
    delay(100);                                                                      // Attendre 100 ms
 +
  }
 
}
 
}
  
Ligne 81 : Ligne 105 :
 
   leds.fill(leds.Color(255, 0, 0), 0, score);                                      // Afficher le score du joueur
 
   leds.fill(leds.Color(255, 0, 0), 0, score);                                      // Afficher le score du joueur
 
   leds.show();                                                                      // Afficher le score du joueur
 
   leds.show();                                                                      // Afficher le score du joueur
   delay(500);                                                                      // Attendre 500 ms
+
   delay(2000);                                                                      // Attendre 500 ms
   for(int i = 0; i <= 10; i++){                                                    // Boucle d'affichage des leds de fin
+
   for(int i = 0; i <= 3; i++){                                                    // Boucle d'affichage des leds de fin
 
     for(led = 0; led < NUM_TOTAL_LED; led++){                                      // Boucle d'affichage des leds de fin
 
     for(led = 0; led < NUM_TOTAL_LED; led++){                                      // Boucle d'affichage des leds de fin
 
       if(i%2 == 0){                                                                // Si la boucle est pair
 
       if(i%2 == 0){                                                                // Si la boucle est pair
Ligne 94 : Ligne 118 :
 
       }
 
       }
 
       leds.show();                                                                  // Afficher la leds
 
       leds.show();                                                                  // Afficher la leds
 +
      delay(50);
 
     }
 
     }
 
   }
 
   }
 
   level = 0;                                                                        // Réinitialiser le jeu
 
   level = 0;                                                                        // Réinitialiser le jeu
 
   delay_level = 300;                                                                // Réinitialiser la vitesse du jeu
 
   delay_level = 300;                                                                // Réinitialiser la vitesse du jeu
 +
  score = 0;                                                                        // Réinitialiser le score
 +
  leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED);                                // Réinitialiser l'affichage led
 +
  leds.show();                                                                      // Réinitialiser l'affichage led
 
}
 
}
  
void left(){                                                                       // Fonction permettant de déplacer la led en partant de la gauche
+
void left(){      
  for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){  // Boucle d'affichage des leds en partant de la gauche
+
    for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){  // Boucle d'affichage des leds en partant de la gauche
    if(level == NUM_LEVEL){                                                        // Si le level est égal au nombre de level
+
      if(level == NUM_LEVEL){                                                        // Si le level est égal au nombre de level
      end();                                                                        // Fonction de fin du jeu
+
        end();                                                                        // Fonction de fin du jeu
 
     }
 
     }
 +
      if (lev != level){
 +
        lev++;
 +
        break;
 +
      }
 +
    Serial.println(led);
 
     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
 
     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
 
     leds.setPixelColor(led, leds.Color(0, 100, 0));                                // Allumer la led qui se déplace
 
     leds.setPixelColor(led, leds.Color(0, 100, 0));                                // Allumer la led qui se déplace
 
     leds.show();                                                                    // Afficher les leds
 
     leds.show();                                                                    // Afficher les leds
 
     delay(delay_level);                                                            // Attendre un certain temps pour créer la vitesse du jeu
 
     delay(delay_level);                                                            // Attendre un certain temps pour créer la vitesse du jeu
 +
    if (lev != level){
 +
        lev++;
 +
        break;
 +
      }
 
     leds.setPixelColor(led, leds.Color(0, 0, 0));                                  // Éteindre la led qui se déplace
 
     leds.setPixelColor(led, leds.Color(0, 0, 0));                                  // Éteindre la led qui se déplace
 
     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
 
     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
 
     leds.show();                                                                    // Afficher les leds
 
     leds.show();                                                                    // Afficher les leds
 
     delay(delay_level);                                                            // Attendre un certain temps pour créer la vitesse du jeu
 
     delay(delay_level);                                                            // Attendre un certain temps pour créer la vitesse du jeu
   }
+
    }                                                                // Fonction permettant de déplacer la led en partant de la gauche
 +
    
 
}
 
}
  
void right(){                                                                       // Fonction permettant de déplacer la led en partant de la droite
+
void right(){
  for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){  // Boucle d'affichage des leds en partant de la droite
+
    for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){  // Boucle d'affichage des leds en partant de la droite
    if(level == NUM_LEVEL){                                                        // Si le level est égal au nombre de level
+
      if(level == NUM_LEVEL){                                                        // Si le level est égal au nombre de level
      end();                                                                        // Fonction de fin du jeu
+
        end();                                                                        // Fonction de fin du jeu
 
     }
 
     }
 +
    if (lev != level){
 +
        lev++;
 +
        break;
 +
      }
 +
    //Serial.println(led);
 
     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
 
     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
 
     leds.setPixelColor(led, leds.Color(0, 100, 0));                                // Allumer la led qui se déplace
 
     leds.setPixelColor(led, leds.Color(0, 100, 0));                                // Allumer la led qui se déplace
 
     leds.show();                                                                    // Afficher les leds
 
     leds.show();                                                                    // Afficher les leds
 
     delay(delay_level);                                                            // Attendre un certain temps pour créer la vitesse du jeu
 
     delay(delay_level);                                                            // Attendre un certain temps pour créer la vitesse du jeu
 +
    if (lev != level){
 +
        lev++;
 +
        break;
 +
      }
 
     leds.setPixelColor(led, leds.Color(0, 0, 0));                                  // Éteindre la led qui se déplace
 
     leds.setPixelColor(led, leds.Color(0, 0, 0));                                  // Éteindre la led qui se déplace
 
     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
 
     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
 
     leds.show();                                                                    // Afficher les leds
 
     leds.show();                                                                    // Afficher les leds
 
     delay(delay_level);                                                            // Attendre un certain temps pour créer la vitesse du jeu
 
     delay(delay_level);                                                            // Attendre un certain temps pour créer la vitesse du jeu
   }
+
   }                                                                       // Fonction permettant de déplacer la led en partant de la droite
 +
 
 
}
 
}
 +
</syntaxhighlight>
  
==étapes de fabrication==
+
==Etapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (phot, dessins, ...)
 
  
 
===étape 1===
 
===étape 1===
 +
 +
*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.
 +
 +
 +
{| class="wikitable"
 +
|-
 +
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
 +
|-
 +
| ''Soudure de la led'' || ''Sens de la led''
 +
|}
 +
 
===étape 2===
 
===étape 2===
 +
 +
*Faire les branchements sur la plaque et la connecter à l'ordinateur.
 +
 +
 +
 +
{| class="wikitable"
 +
|-
 +
| [[Fichier:Connectique.jpg|400px]]
 +
|-
 +
| ''Montage plaque''
 +
|}
 +
 
===étape 3===
 
===étape 3===
 +
 +
*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.
 +
 +
 +
 +
{| class="wikitable"
 +
|-
 +
|[[Fichier:Test prog.jpg|400px]]
 +
|-
 +
| ''Test du programme''
 +
|}
 +
 
===étape 4===
 
===étape 4===
===étape 5===
 
===étape 6===
 
===étape 7===
 
===étape 8===
 
  
===troubleshouting===
+
*Fabrique de notre support en bois
quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?
 
  
1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
+
 
Carte D1 hors service.
+
 
 +
{| class="wikitable"
 +
|-
 +
| [[Fichier : Decoupe bois.jpg|400px]]
 +
|-
 +
| ''Découpe du bois manuellement''
 +
|}
 +
 
 +
===Problèmes rencontrés et Solutions===
 +
 
 +
 
 +
*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
 +
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
 +
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes
  
 
==Sources et documentation complémentaire==
 
==Sources et documentation complémentaire==
 +
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]
 +
 +
 
[[Catégorie:Enib2024]]
 
[[Catégorie:Enib2024]]

Version actuelle datée du 25 janvier 2024 à 15:31

Titre de la fiche expérience :

Description

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.



Groupebg.jpg
photo du groupe

Introduction

Voici une démo pour mieux comprendre comment fonctionne le jeu.

Outil et Matériel

  • bouton poussoir
  • carte D1 mini avec Arduino
  • rubans de led
  • une solderless breadboard
  • appareil à souder
  • pistolet à colle
  • petits câbles de connexion
  • résistance pour led
  • bois de chêne / scie à bois/ etaux
  • petite vis x6
  • EPI: lunettes / gants
  • perceuse / tournevis

Fichiers à joindre

téléchargez le svg

code

  1 #include <Adafruit_NeoPixel.h>    //Importer la bibliotèque "Adafruit_NeoPixel"
  2 
  3 #define NUM_TOTAL_LED 60          // Nombres total de led
  4 #define NUM_LED_PER_LEVEL 15      // Nombres de led par level
  5 #define NUM_LEVEL 4               // Nombres de level
  6 #define PIN_BUTON 3               // Pin bouton sur la carte
  7 #define PIN_LED 2                 // Pin led sur la carte
  8 
  9 
 10 Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800);   // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
 11 
 12 int LED_MIDDLE = NUM_LED_PER_LEVEL/2;                                   // Calcul de la led du milieu
 13 
 14 int level = 0;                                                         // Initialisation du jeu
 15 
 16 int lev = 0;                                                            // Variable pour sauter la fin du niveau
 17 
 18 int score = 0;                                                          // Initialisation du score
 19 
 20 int delay_level = 300;                                                  // Initialisation de la vitesse de jeu
 21 
 22 int led;                                                                // Implémentation de la variable globale "led"
 23 
 24 unsigned long time = 0;                                                 // Initialisation de la variable globale "time"
 25 
 26 
 27 void setup() {                                                          // Fonction d'initialisation du jeu
 28   pinMode(PIN_BUTON, INPUT);                                            // Définition de "PIN_BUTON" en tant qu'entrée
 29   
 30   leds.begin();                                                         // Initialisation des leds
 31   leds.setBrightness(10);                                              // Régler la luminosité des leds
 32   leds.show();                                                          // Afficher les leds
 33   
 34   attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING);    // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
 35   Serial.begin(9600);
 36 }
 37 
 38 void loop() {                                                           // Fonction de boucle du jeu
 39   left();                                                               // Fonction left pour déplacer les leds depuis la gauche
 40   right();                                                              // Fonction right pour déplacer les leds depuis la droite
 41   //Serial.println(score);
 42 }
 43 
 44 void bouton(){                                                                        // Fonction en cas d'appuie sur le bouton
 45   if(millis()-time > 100 && level < NUM_LEVEL){                                                             // Vérification du temps d'appuie bouton pour éviter le rebond
 46     time=millis();                                                                    // Mettre à jour le bouton pour le prochain appuie
 47     score += (NUM_LED_PER_LEVEL)-2*abs(NUM_LED_PER_LEVEL*level+LED_MIDDLE-led);  // Modification du score du joueur
 48   
 49     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0));      // Éteindre la led du milieu
 50     leds.show();
 51     leds.setPixelColor(led, leds.Color(0, 0, 255));                                   // Allumer en bleu la led cliquée
 52     leds.show();                                                                      // Afficher la led allumée
 53   
 54     level++;                                                                          // Passer au level suivant
 55     delay_level /= 2;                                                                 // Accélérer la vitesse de jeu
 56     led = NUM_LED_PER_LEVEL*level;                                                    // Initialiser la led du level suivant
 57     
 58     delay(100);                                                                       // Attendre 100 ms
 59   }
 60 }
 61 
 62 void end(){                                                                         // Fonction de fin du jeu
 63   leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED);                                 // Éteindre toutes les leds
 64   leds.fill(leds.Color(255, 0, 0), 0, score);                                       // Afficher le score du joueur
 65   leds.show();                                                                      // Afficher le score du joueur
 66   delay(2000);                                                                       // Attendre 500 ms
 67   for(int i = 0; i <= 3; i++){                                                     // Boucle d'affichage des leds de fin
 68     for(led = 0; led < NUM_TOTAL_LED; led++){                                       // Boucle d'affichage des leds de fin
 69       if(i%2 == 0){                                                                 // Si la boucle est pair
 70         leds.setPixelColor(led, leds.Color(0, 0, 0));                               // Afficher la led en blanc
 71       }
 72       else{                                                                         // Sinon
 73         int couleur_1 = random(0, 255);                                             // Valeur aléatoire de rouge
 74         int couleur_2 = random(0, 255);                                             // Valeur aléatoire de vert
 75         int couleur_3 = random(0, 255);                                             // Valeur aléatoire de bleu
 76         leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3));       // Afficher la led en fonction des couleurs aléatoires
 77       }
 78       leds.show();                                                                  // Afficher la leds
 79       delay(50);
 80     }
 81   }
 82   level = 0;                                                                        // Réinitialiser le jeu
 83   delay_level = 300;                                                                // Réinitialiser la vitesse du jeu
 84   score = 0;                                                                        // Réinitialiser le score
 85   leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED);                                 // Réinitialiser l'affichage led
 86   leds.show();                                                                      // Réinitialiser l'affichage led
 87 }
 88 
 89 void left(){       
 90     for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){   // Boucle d'affichage des leds en partant de la gauche
 91       if(level == NUM_LEVEL){                                                         // Si le level est égal au nombre de level
 92         end();                                                                        // Fonction de fin du jeu
 93     }
 94       if (lev != level){
 95         lev++;
 96         break;
 97       }
 98     Serial.println(led);
 99     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
100     leds.setPixelColor(led, leds.Color(0, 100, 0));                                 // Allumer la led qui se déplace
101     leds.show();                                                                    // Afficher les leds
102     delay(delay_level);                                                             // Attendre un certain temps pour créer la vitesse du jeu
103     if (lev != level){
104         lev++;
105         break;
106       }
107     leds.setPixelColor(led, leds.Color(0, 0, 0));                                   // Éteindre la led qui se déplace
108     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
109     leds.show();                                                                    // Afficher les leds
110     delay(delay_level);                                                             // Attendre un certain temps pour créer la vitesse du jeu
111     }                                                                 // Fonction permettant de déplacer la led en partant de la gauche
112   
113 }
114 
115 void right(){
116     for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){   // Boucle d'affichage des leds en partant de la droite
117       if(level == NUM_LEVEL){                                                         // Si le level est égal au nombre de level
118         end();                                                                        // Fonction de fin du jeu
119     }
120     if (lev != level){
121         lev++;
122         break;
123       }
124     //Serial.println(led);
125     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
126     leds.setPixelColor(led, leds.Color(0, 100, 0));                                 // Allumer la led qui se déplace
127     leds.show();                                                                    // Afficher les leds
128     delay(delay_level);                                                             // Attendre un certain temps pour créer la vitesse du jeu
129     if (lev != level){
130         lev++;
131         break;
132       }
133     leds.setPixelColor(led, leds.Color(0, 0, 0));                                   // Éteindre la led qui se déplace
134     leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0));  // Allumer la led du milieu
135     leds.show();                                                                    // Afficher les leds
136     delay(delay_level);                                                             // Attendre un certain temps pour créer la vitesse du jeu
137   }                                                                       // Fonction permettant de déplacer la led en partant de la droite
138   
139 }

Etapes de fabrication

étape 1

  • Souder les bandeaux de leds en série en faisant attention au sens de fléchage.


Soudure led.jpg Sens led.jpg
Soudure de la led Sens de la led

étape 2

  • Faire les branchements sur la plaque et la connecter à l'ordinateur.


Connectique.jpg
Montage plaque

étape 3

  • Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.


Test prog.jpg
Test du programme

étape 4

  • Fabrique de notre support en bois


Decoupe bois.jpg
Découpe du bois manuellement

Problèmes rencontrés et Solutions

  • 1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
  • Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
  • Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

Sources et documentation complémentaire