ENIB 2024 : GNOP : Différence entre versions

De Les Fabriques du Ponant
Aller à : navigation, rechercher
(→‎Outil et matériel)
(→‎Mettre du code Arduino)
Ligne 31 : Ligne 31 :
 
===Mettre du code Arduino===
 
===Mettre du code Arduino===
 
<syntaxhighlight lang="Arduino" line>  
 
<syntaxhighlight lang="Arduino" line>  
−
#define PIN 9
+
/*
−
#include <Arduino_GFX_Library.h>
+
  Code de fonctionnement pour le jeu PONG.
 +
  Par les petits débrouillards.
 +
*/
  
 +
#include <FastLED.h>
 +
 +
// Definition des couleurs
 +
const CRGB NOIR  = CRGB(0,  0,  0  );
 +
const CRGB BLANC = CRGB(255, 255, 255);
 +
const CRGB ROUGE = CRGB(255, 0,  0  );
 +
const CRGB VERT  = CRGB(0,  255, 0  );
 +
const CRGB BLEU  = CRGB(0,  0,  255);
 +
const CRGB JAUNE = CRGB(255, 255, 0  );
 +
const CRGB ROSE  = CRGB(255, 0,  255);
 +
const CRGB CYAN  = CRGB(0,  255, 255);
 +
 +
// Definition des notes de musique
 +
const int NOTE_DO_1 = 33;
 +
 +
 +
/******************************
 +
  PARAMETRES DE BRANCHEMENTS
 +
******************************/
 +
 +
const int LED_PIN = 8;          // Numero de branchement de la bande de LEDs
 +
const int BUTTON1_PIN = 3;      // Numero de branchement du premier bouton
 +
const int BUTTON2_PIN = 2;      // Numero de branchement du deuxieme bouton
 +
const int HAUT_PARLEUR_PIN = 6; // Numero de branchement du haut parleur (optionnel)
 +
 +
 +
/******************************
 +
  PARAMETRES GENERAUX DU JEU
 +
******************************/
 +
const int  NUM_LEDS = 40;      // Nombre de LEDs sur la bande
 +
const float SPEED = 0.5;        // Vitesse de la balle
 +
const float ACCELERATION = 8;  // Accelleration de la balle a chaque tir, si ACCELERATION = 10 on augmente la vitesse de 10 pourcent a chaque tir
 +
const int  HIT_ZONE = 5;      // Nombre de LED pendant lesquelles on peut renvoyer la balle
 +
const int  MAX_SCORE = 3;
 +
 +
const CRGB  PLAYER1_COLOR = CYAN;    // Couleur player 1
 +
const CRGB  PLAYER2_COLOR = ROSE;    // Couleur player 2
 +
const CRGB  BALL_COLOR = BLANC;      // Couleur de la balle
 +
 +
 +
// LEDs
 +
CRGB leds[NUM_LEDS];
 +
 +
// Players
 +
enum Player
 +
{
 +
  PERSONNE,
 +
  PLAYER1,
 +
  PLAYER2
 +
};
 +
 +
// Etats du jeu
 +
enum GameState
 +
{
 +
  START,
 +
  GAME
 +
};
 +
GameState gameState = START;
 +
 +
 +
// Fonctions de fonctionnement du jeu
 +
 +
// Fonction permettant de changer la couleur d'une LED relativement au player 1 ou 2
 +
void ledColor(Player player, int pos, CRGB color)
 +
{
 +
  if (player == PLAYER1)
 +
  {
 +
    leds[pos] = color;
 +
  }
 +
  else // player == PLAYER2
 +
  {
 +
    leds[NUM_LEDS - pos - 1] = color;
 +
  }
 +
}
 +
 +
// Fonction permettant de changer la couleur d'une LED
 +
void ledColor(int pos, CRGB color)
 +
{
 +
  leds[pos] = color;
 +
}
 +
 +
// Variables de fonctionnement du jeu
 +
Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
 +
float ballSpeed = SPEED;  // Vitesse de la balle
 +
float ballPosition = 1; // Position de la balle sur la bande de led (Si ballPosition = 0, la balle est devant le player 1. Si ballPosition = 1, la balle est devant le player 2)
 +
int player1Score = 0;  // Score du player 1
 +
int player2Score = 0;  // Score du player 2
 +
Player lastWinner = PERSONNE;
 +
 +
unsigned long lastMillis = 0;
 +
unsigned long gameBegin = 0;
 +
unsigned int counter = 0;
 +
 +
 +
// Fonction servant à afficher les scores
 +
void showScore()
 +
{
 +
  // On commence par effacer toutes les couleurs de led
 +
  FastLED.clear();
 +
 +
  // On allume le nombre de led correspondant au score du player 1
 +
  for (int i = 0; i < player1Score; i++)
 +
  {
 +
    ledColor(PLAYER1, NUM_LEDS / 2 - (i + 1), PLAYER1_COLOR);
 +
  }
 +
 +
  // On allume le nombre de led correspondant au score du player 2
 +
  for (int i = 0; i < player2Score; i++)
 +
  {
 +
    ledColor(PLAYER2, NUM_LEDS / 2 - (i + 1), PLAYER2_COLOR);
 +
  }
 +
 +
  // On envoie les nouvelles couleurs a la bande de led
 +
  FastLED.show();
 +
 +
  // On fait clignotter trois fois
 +
  if (lastWinner == PLAYER1)
 +
  {
 +
    for (int i = 0; i < 3; i++)
 +
    {
 +
      // On eteint la derniere LED pendant 0.5s
 +
      delay(500);
 +
      ledColor(PLAYER1, NUM_LEDS / 2 - player1Score, NOIR);
 +
      FastLED.show();
 +
 +
      // On allume la derniere LED pendant 0.5s
 +
      delay(500);
 +
      ledColor(PLAYER1, NUM_LEDS / 2 - player1Score, PLAYER1_COLOR);
 +
      FastLED.show();
 +
    }
 +
  }
 +
  else // lastWinner == PLAYER2
 +
  {
 +
    for (int i = 0; i < 3; i++)
 +
    {
 +
      // On eteint la derniere LED pendant 0.5s
 +
      delay(500);
 +
      ledColor(PLAYER2, NUM_LEDS / 2 - player2Score, NOIR);
 +
      FastLED.show();
 +
 +
      // On allume la derniere LED pendant 0.5s
 +
      delay(500);
 +
      ledColor(PLAYER2, NUM_LEDS / 2 - player2Score, PLAYER2_COLOR);
 +
      FastLED.show();
 +
    }
 +
  }
 +
 +
  // Si la partie est terminée on va a l'affichage de fin
 +
  if (player1Score == MAX_SCORE || player2Score == MAX_SCORE)
 +
  {
 +
    gameState = START;
 +
 +
    // On reinitialise les scores
 +
    player1Score = 0;
 +
    player2Score = 0;
 +
 +
    // On reinitialise la vitesse
 +
    ballSpeed = SPEED;
 +
 +
    // On reinitialise les leds
 +
    FastLED.clear();
 +
  }
 +
  // Sinon on reprend le jeu
 +
  else
 +
  {
 +
    gameState = GAME;
 +
    ballSpeed = SPEED;
 +
  }
 +
}
 +
 +
 +
 +
/****************************************************************
 +
  Cette fonction s'execute une fois lorsque la carte s'allume.
 +
****************************************************************/
 
void setup() {
 
void setup() {
−
   // put your setup code here, to run once:
+
  Serial.begin(115200);
 +
   // Initialisation des LEDs
 +
  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
 +
 
 +
  // Initialisations des boutons
 +
  pinMode(BUTTON1_PIN, INPUT_PULLUP);
 +
  pinMode(BUTTON2_PIN, INPUT_PULLUP);
 +
 
 +
  // Initialisation du haut parleur
 +
  pinMode(HAUT_PARLEUR_PIN, OUTPUT);
  
 +
  // COULEUR DES LEDS EN DEBUT DE PARTIE
 +
  FastLED.clear();
 +
  // Couleurs player 1
 +
  ledColor(PLAYER1, 0, PLAYER1_COLOR);
 +
  ledColor(PLAYER1, 1, PLAYER1_COLOR);
 +
  ledColor(PLAYER1, 2, PLAYER1_COLOR);
 +
  ledColor(PLAYER1, 3, PLAYER1_COLOR);
 +
  ledColor(PLAYER1, 4, PLAYER1_COLOR);
 +
 +
  // Couleurs player 2
 +
  ledColor(PLAYER2, 0, PLAYER2_COLOR);
 +
  ledColor(PLAYER2, 1, PLAYER2_COLOR);
 +
  ledColor(PLAYER2, 2, PLAYER2_COLOR);
 +
  ledColor(PLAYER2, 3, PLAYER2_COLOR);
 +
  ledColor(PLAYER2, 4, PLAYER2_COLOR);
 +
 +
  // On envoie les changements a la bande de leds
 +
  FastLED.show();
 
}
 
}
  
 +
/*************************************************************
 +
  Cette fonction s'execute en continue tout au long du jeu.
 +
*************************************************************/
 
void loop() {
 
void loop() {
−
  // put your main code here, to run repeatedly:
 
  
 +
  switch (gameState)
 +
  {
 +
    case START:
 +
      // Si un player a gagne, on affiche l'arc en ciel du cote du vainqueur
 +
      if (lastWinner == PLAYER1)
 +
      {
 +
        fill_rainbow(leds, NUM_LEDS / 2, counter++, 7);
 +
        FastLED.show();
 +
      }
 +
      else if (lastWinner == PLAYER2)
 +
      {
 +
        fill_rainbow(leds + NUM_LEDS / 2, NUM_LEDS / 2, counter++, 7);
 +
        FastLED.show();
 +
      }
 +
 +
      // On regarde si un des boutons est appuye
 +
      if (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW)
 +
      {
 +
        // La partie commence
 +
        gameState = GAME;
 +
 +
        // Initialisation de la varable lastMillis
 +
        lastMillis = millis();
 +
 +
        // Initialisation du temps de début de jeu
 +
        gameBegin = millis();
 +
      }
 +
      break;
 +
 +
    case GAME:
 +
      // Calcul du temps ecoule entre deux boucles
 +
      unsigned long currentMillis = millis();
 +
 +
      // On calcule le numero de la LED allumee
 +
      int ballLed = int(ballPosition * NUM_LEDS);
 +
 +
      // On s'assure que la position de la balle ne dépasse pas la taille de la bande de LED
 +
      ballLed = min(ballLed, NUM_LEDS - 1);
 +
 +
      // On regarde qui est en train de jouer
 +
      if (player == PLAYER1)
 +
      {
 +
        // On regarde si le player a appuye sur son bouton et si le délai de début de jeu est passé
 +
        if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - gameBegin > 500)
 +
        {
 +
          // Si la balle est hors de la zone de tir, l'autre player marque un point
 +
          if (ballLed >= HIT_ZONE)
 +
          {
 +
            player2Score += 1;
 +
            lastWinner = PLAYER2;
 +
            ballPosition = 0;
 +
 +
            // On passe en mode affichage des scores
 +
            showScore();
 +
 +
            // C'est a l'autre player de jouer
 +
            player = PLAYER2;
 +
 +
            // Actualisation de la variable lastMillis
 +
            lastMillis = millis();
 +
          }
 +
          else
 +
          {
 +
            // On accelere la balle
 +
            ballSpeed *= 1.0 + ACCELERATION / 100;
 +
 +
            // C'est a l'autre player de jouer
 +
            player = PLAYER2;
 +
 +
            // On joue la note de musique
 +
            tone(HAUT_PARLEUR_PIN, NOTE_DO_1, 300);
 +
          }
 +
 +
          break;
 +
        }
 +
 +
        // On fait avancer la balle
 +
        ballPosition -= ballSpeed * (currentMillis - lastMillis) * 0.001f;
 +
 +
        // On regarde si la balle est sortie de la zone
 +
        if (ballPosition < 0.0f)
 +
        {
 +
          // Si oui le player 2 marque un point
 +
          player2Score += 1;
 +
          lastWinner = PLAYER2;
 +
          ballPosition = 0;
 +
 +
          // On passe en mode affichage des scores
 +
          showScore();
 +
 +
          // C'est a l'autre player de jouer
 +
          player = PLAYER2;
 +
 +
          // Actualisation de la variable lastMillis
 +
          lastMillis = millis();
 +
          break;
 +
        }
 +
      }
 +
      else // player == PLAYER2
 +
      {
 +
        // On regarde si le player a appuye sur son bouton et si le délai de début de jeu est passé
 +
        if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - gameBegin > 500)
 +
        {
 +
          // Si la balle est hors de la zone de tir, l'autre player marque un point
 +
          if (ballLed < NUM_LEDS - HIT_ZONE)
 +
          {
 +
            player1Score += 1;
 +
            lastWinner = PLAYER1;
 +
            ballPosition = 1;
 +
 +
            // On passe en mode affichage des scores
 +
            showScore();
 +
 +
            // C'est a l'autre player de jouer
 +
            player = PLAYER1;
 +
 +
            // Actualisation de la variable lastMillis
 +
            lastMillis = millis();
 +
          }
 +
          else
 +
          {
 +
            // On accelere la balle
 +
            ballSpeed *= 1.1;
 +
 +
            // C'est a l'autre player de jouer
 +
            player = PLAYER1;
 +
          }
 +
 +
          break;
 +
        }
 +
 +
        // On fait avancer la balle dans l'autre sens
 +
        ballPosition += ballSpeed * (currentMillis - lastMillis) * 0.001f;
 +
 +
        // On regarde si la balle est sortie de la zone
 +
        if (ballPosition >= 1)
 +
        {
 +
          // Si oui le player 1 marque un point
 +
          player1Score += 1;
 +
          lastWinner = PLAYER1;
 +
          ballPosition = 1;
 +
 +
          // On passe en mode affichage des scores
 +
          showScore();
 +
          // C'est a l'autre player de jouer
 +
          player = PLAYER1;
 +
 +
          // Actualisation de la variable lastMillis
 +
          lastMillis = millis();
 +
          break;
 +
        }
 +
      }
 +
 +
      ///// AFFICHAGE BANDE DE LEDs /////
 +
      // Premierement on efface toutes les couleurs precedentes
 +
      FastLED.clear();
 +
 +
      // Ensuite on allume faiblement les LEDs correspondant a la zone de chaque cote
 +
      for (int i = 0; i < HIT_ZONE; i++)
 +
      {
 +
        // On allume de chaque cote
 +
        ledColor(PLAYER1, i, PLAYER1_COLOR / 10);  // On divise la couleur par 10 pour la rendre 10 fois moins puissante
 +
        ledColor(PLAYER2, i, PLAYER2_COLOR / 10);
 +
      }
 +
 +
      // Ensuite on allume faiblement les LEDs correspondant aux scores
 +
      // Pour le player 1
 +
      for (int i = 0; i < player1Score; i++)
 +
      {
 +
        ledColor(PLAYER1, NUM_LEDS / 2 - (i + 1), PLAYER1_COLOR / 15);
 +
      }
 +
      // Pour le player 2
 +
      for (int i = 0; i < player2Score; i++)
 +
      {
 +
        ledColor(PLAYER2, NUM_LEDS / 2 - (i + 1), PLAYER2_COLOR / 15);
 +
      }
 +
 +
      // Ensuite on actualise la position de la balle
 +
      // On donne la couleur de la led en fonction de si la balle est dans la zone d'un player ou non
 +
 +
      // Si la balle est dans le camp d'un des player, elle est rouge.
 +
      if (ballLed < HIT_ZONE || ballLed >= NUM_LEDS - HIT_ZONE)
 +
      {
 +
        ledColor(ballLed, ROUGE);
 +
      }
 +
      // Si elle en est proche, elle est jaune
 +
      else if (ballLed < 2 * HIT_ZONE || ballLed >= NUM_LEDS - 2 * HIT_ZONE)
 +
      {
 +
        ledColor(ballLed, JAUNE);
 +
      }
 +
      // Sinon la balle a sa couleur par defaut
 +
      else
 +
      {
 +
        ledColor(ballLed, BALL_COLOR);
 +
      }
 +
 +
      // On envoie la couleur des leds a la bande de leds
 +
      FastLED.show();
 +
 +
      // On actualise la variable lastMillis pour la boucle suivante
 +
      lastMillis = currentMillis;
 +
      break;
 +
  }
 
}
 
}
  

Version du 24 janvier 2024 à 16:14

Titre de la fiche expérience :

Description

Le projet est de fabriquer un jeu ludique à l'aide d'une carte Arduino, notre jeu est le D1-Pong. Inspiré du sport du tennis de table, il reprend le même principe mais avec des LEDS, la balle se déplace sur les LEDS et dès qu'elle arrive à une extrémité, le joueur en question appuie sur son bouton pour que la balle parte dans l'autre sens et ainsi de suite.
​ Voici notre équipe :
LAVRAITEAM.jpg

Introduction

Éventuelle vidéo

Outil et matériel

Pour fabriquer ce jeu, nous avons eut besoin de :

  • Carte Arduino D1 Mini
  • 2 boutons d'arcade
  • Carton
  • Fils électriques
  • Interupteur
  • Batterie
  • Ruban de LEDS
  • Haut-parleur


Nous nous sommes servis de plusieurs outils :

  • Fer à souder
  • Pistolet à colle
  • Cutter

fichiers à joindre

Fichier:AZAD.zip code, ficher d'impression 3D, de découpe laser ou vinyle, ...

Mettre du code Arduino

  1  
  2 /*
  3    Code de fonctionnement pour le jeu PONG.
  4    Par les petits débrouillards.
  5 */
  6 
  7 #include <FastLED.h>
  8 
  9 // Definition des couleurs
 10 const CRGB NOIR  = CRGB(0,   0,   0  );
 11 const CRGB BLANC = CRGB(255, 255, 255);
 12 const CRGB ROUGE = CRGB(255, 0,   0  );
 13 const CRGB VERT  = CRGB(0,   255, 0  );
 14 const CRGB BLEU  = CRGB(0,   0,   255);
 15 const CRGB JAUNE = CRGB(255, 255, 0  );
 16 const CRGB ROSE  = CRGB(255, 0,   255);
 17 const CRGB CYAN  = CRGB(0,   255, 255);
 18 
 19 // Definition des notes de musique
 20 const int NOTE_DO_1 = 33;
 21 
 22 
 23 /******************************
 24    PARAMETRES DE BRANCHEMENTS
 25  ******************************/
 26 
 27 const int LED_PIN = 8;          // Numero de branchement de la bande de LEDs
 28 const int BUTTON1_PIN = 3;      // Numero de branchement du premier bouton
 29 const int BUTTON2_PIN = 2;      // Numero de branchement du deuxieme bouton
 30 const int HAUT_PARLEUR_PIN = 6; // Numero de branchement du haut parleur (optionnel)
 31 
 32 
 33 /******************************
 34    PARAMETRES GENERAUX DU JEU
 35  ******************************/
 36 const int   NUM_LEDS = 40;      // Nombre de LEDs sur la bande
 37 const float SPEED = 0.5;        // Vitesse de la balle
 38 const float ACCELERATION = 8;  // Accelleration de la balle a chaque tir, si ACCELERATION = 10 on augmente la vitesse de 10 pourcent a chaque tir
 39 const int   HIT_ZONE = 5;       // Nombre de LED pendant lesquelles on peut renvoyer la balle
 40 const int   MAX_SCORE = 3;
 41 
 42 const CRGB  PLAYER1_COLOR = CYAN;    // Couleur player 1
 43 const CRGB  PLAYER2_COLOR = ROSE;    // Couleur player 2
 44 const CRGB  BALL_COLOR = BLANC;      // Couleur de la balle
 45 
 46 
 47 // LEDs
 48 CRGB leds[NUM_LEDS];
 49 
 50 // Players
 51 enum Player
 52 {
 53   PERSONNE,
 54   PLAYER1,
 55   PLAYER2
 56 };
 57 
 58 // Etats du jeu
 59 enum GameState
 60 {
 61   START,
 62   GAME
 63 };
 64 GameState gameState = START;
 65 
 66 
 67 // Fonctions de fonctionnement du jeu
 68 
 69 // Fonction permettant de changer la couleur d'une LED relativement au player 1 ou 2
 70 void ledColor(Player player, int pos, CRGB color)
 71 {
 72   if (player == PLAYER1)
 73   {
 74     leds[pos] = color;
 75   }
 76   else // player == PLAYER2
 77   {
 78     leds[NUM_LEDS - pos - 1] = color;
 79   }
 80 }
 81 
 82 // Fonction permettant de changer la couleur d'une LED
 83 void ledColor(int pos, CRGB color)
 84 {
 85   leds[pos] = color;
 86 }
 87 
 88 // Variables de fonctionnement du jeu
 89 Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
 90 float ballSpeed = SPEED;  // Vitesse de la balle
 91 float ballPosition = 1; // Position de la balle sur la bande de led (Si ballPosition = 0, la balle est devant le player 1. Si ballPosition = 1, la balle est devant le player 2)
 92 int player1Score = 0;   // Score du player 1
 93 int player2Score = 0;   // Score du player 2
 94 Player lastWinner = PERSONNE;
 95 
 96 unsigned long lastMillis = 0;
 97 unsigned long gameBegin = 0;
 98 unsigned int counter = 0;
 99 
100 
101 // Fonction servant à afficher les scores
102 void showScore()
103 {
104   // On commence par effacer toutes les couleurs de led
105   FastLED.clear();
106 
107   // On allume le nombre de led correspondant au score du player 1
108   for (int i = 0; i < player1Score; i++)
109   {
110     ledColor(PLAYER1, NUM_LEDS / 2 - (i + 1), PLAYER1_COLOR);
111   }
112 
113   // On allume le nombre de led correspondant au score du player 2
114   for (int i = 0; i < player2Score; i++)
115   {
116     ledColor(PLAYER2, NUM_LEDS / 2 - (i + 1), PLAYER2_COLOR);
117   }
118 
119   // On envoie les nouvelles couleurs a la bande de led
120   FastLED.show();
121 
122   // On fait clignotter trois fois
123   if (lastWinner == PLAYER1)
124   {
125     for (int i = 0; i < 3; i++)
126     {
127       // On eteint la derniere LED pendant 0.5s
128       delay(500);
129       ledColor(PLAYER1, NUM_LEDS / 2 - player1Score, NOIR);
130       FastLED.show();
131 
132       // On allume la derniere LED pendant 0.5s
133       delay(500);
134       ledColor(PLAYER1, NUM_LEDS / 2 - player1Score, PLAYER1_COLOR);
135       FastLED.show();
136     }
137   }
138   else // lastWinner == PLAYER2
139   {
140     for (int i = 0; i < 3; i++)
141     {
142       // On eteint la derniere LED pendant 0.5s
143       delay(500);
144       ledColor(PLAYER2, NUM_LEDS / 2 - player2Score, NOIR);
145       FastLED.show();
146 
147       // On allume la derniere LED pendant 0.5s
148       delay(500);
149       ledColor(PLAYER2, NUM_LEDS / 2 - player2Score, PLAYER2_COLOR);
150       FastLED.show();
151     }
152   }
153 
154   // Si la partie est terminée on va a l'affichage de fin
155   if (player1Score == MAX_SCORE || player2Score == MAX_SCORE)
156   {
157     gameState = START;
158 
159     // On reinitialise les scores
160     player1Score = 0;
161     player2Score = 0;
162 
163     // On reinitialise la vitesse
164     ballSpeed = SPEED;
165 
166     // On reinitialise les leds
167     FastLED.clear();
168   }
169   // Sinon on reprend le jeu
170   else
171   {
172     gameState = GAME;
173     ballSpeed = SPEED;
174   }
175 }
176 
177 
178 
179 /****************************************************************
180    Cette fonction s'execute une fois lorsque la carte s'allume.
181  ****************************************************************/
182 void setup() {
183   Serial.begin(115200);
184   // Initialisation des LEDs
185   FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
186 
187   // Initialisations des boutons
188   pinMode(BUTTON1_PIN, INPUT_PULLUP);
189   pinMode(BUTTON2_PIN, INPUT_PULLUP);
190 
191   // Initialisation du haut parleur
192   pinMode(HAUT_PARLEUR_PIN, OUTPUT);
193 
194   // COULEUR DES LEDS EN DEBUT DE PARTIE
195   FastLED.clear();
196   // Couleurs player 1
197   ledColor(PLAYER1, 0, PLAYER1_COLOR);
198   ledColor(PLAYER1, 1, PLAYER1_COLOR);
199   ledColor(PLAYER1, 2, PLAYER1_COLOR);
200   ledColor(PLAYER1, 3, PLAYER1_COLOR);
201   ledColor(PLAYER1, 4, PLAYER1_COLOR);
202 
203   // Couleurs player 2
204   ledColor(PLAYER2, 0, PLAYER2_COLOR);
205   ledColor(PLAYER2, 1, PLAYER2_COLOR);
206   ledColor(PLAYER2, 2, PLAYER2_COLOR);
207   ledColor(PLAYER2, 3, PLAYER2_COLOR);
208   ledColor(PLAYER2, 4, PLAYER2_COLOR);
209 
210   // On envoie les changements a la bande de leds
211   FastLED.show();
212 }
213 
214 /*************************************************************
215    Cette fonction s'execute en continue tout au long du jeu.
216  *************************************************************/
217 void loop() {
218 
219   switch (gameState)
220   {
221     case START:
222       // Si un player a gagne, on affiche l'arc en ciel du cote du vainqueur
223       if (lastWinner == PLAYER1)
224       {
225         fill_rainbow(leds, NUM_LEDS / 2, counter++, 7);
226         FastLED.show();
227       }
228       else if (lastWinner == PLAYER2)
229       {
230         fill_rainbow(leds + NUM_LEDS / 2, NUM_LEDS / 2, counter++, 7);
231         FastLED.show();
232       }
233 
234       // On regarde si un des boutons est appuye
235       if (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW)
236       {
237         // La partie commence
238         gameState = GAME;
239 
240         // Initialisation de la varable lastMillis
241         lastMillis = millis();
242 
243         // Initialisation du temps de début de jeu
244         gameBegin = millis();
245       }
246       break;
247 
248     case GAME:
249       // Calcul du temps ecoule entre deux boucles
250       unsigned long currentMillis = millis();
251 
252       // On calcule le numero de la LED allumee
253       int ballLed = int(ballPosition * NUM_LEDS);
254 
255       // On s'assure que la position de la balle ne dépasse pas la taille de la bande de LED
256       ballLed = min(ballLed, NUM_LEDS - 1);
257 
258       // On regarde qui est en train de jouer
259       if (player == PLAYER1)
260       {
261         // On regarde si le player a appuye sur son bouton et si le délai de début de jeu est passé
262         if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - gameBegin > 500)
263         {
264           // Si la balle est hors de la zone de tir, l'autre player marque un point
265           if (ballLed >= HIT_ZONE)
266           {
267             player2Score += 1;
268             lastWinner = PLAYER2;
269             ballPosition = 0;
270 
271             // On passe en mode affichage des scores
272             showScore();
273 
274             // C'est a l'autre player de jouer
275             player = PLAYER2;
276 
277             // Actualisation de la variable lastMillis
278             lastMillis = millis();
279           }
280           else
281           {
282             // On accelere la balle
283             ballSpeed *= 1.0 + ACCELERATION / 100;
284 
285             // C'est a l'autre player de jouer
286             player = PLAYER2;
287 
288             // On joue la note de musique
289             tone(HAUT_PARLEUR_PIN, NOTE_DO_1, 300);
290           }
291 
292           break;
293         }
294 
295         // On fait avancer la balle
296         ballPosition -= ballSpeed * (currentMillis - lastMillis) * 0.001f;
297 
298         // On regarde si la balle est sortie de la zone
299         if (ballPosition < 0.0f)
300         {
301           // Si oui le player 2 marque un point
302           player2Score += 1;
303           lastWinner = PLAYER2;
304           ballPosition = 0;
305 
306           // On passe en mode affichage des scores
307           showScore();
308 
309           // C'est a l'autre player de jouer
310           player = PLAYER2;
311 
312           // Actualisation de la variable lastMillis
313           lastMillis = millis();
314           break;
315         }
316       }
317       else // player == PLAYER2
318       {
319         // On regarde si le player a appuye sur son bouton et si le délai de début de jeu est passé
320         if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - gameBegin > 500)
321         {
322           // Si la balle est hors de la zone de tir, l'autre player marque un point
323           if (ballLed < NUM_LEDS - HIT_ZONE)
324           {
325             player1Score += 1;
326             lastWinner = PLAYER1;
327             ballPosition = 1;
328 
329             // On passe en mode affichage des scores
330             showScore();
331 
332             // C'est a l'autre player de jouer
333             player = PLAYER1;
334 
335             // Actualisation de la variable lastMillis
336             lastMillis = millis();
337           }
338           else
339           {
340             // On accelere la balle
341             ballSpeed *= 1.1;
342 
343             // C'est a l'autre player de jouer
344             player = PLAYER1;
345           }
346 
347           break;
348         }
349 
350         // On fait avancer la balle dans l'autre sens
351         ballPosition += ballSpeed * (currentMillis - lastMillis) * 0.001f;
352 
353         // On regarde si la balle est sortie de la zone
354         if (ballPosition >= 1)
355         {
356           // Si oui le player 1 marque un point
357           player1Score += 1;
358           lastWinner = PLAYER1;
359           ballPosition = 1;
360 
361           // On passe en mode affichage des scores
362           showScore();
363           // C'est a l'autre player de jouer
364           player = PLAYER1;
365 
366           // Actualisation de la variable lastMillis
367           lastMillis = millis();
368           break;
369         }
370       }
371 
372       ///// AFFICHAGE BANDE DE LEDs /////
373       // Premierement on efface toutes les couleurs precedentes
374       FastLED.clear();
375 
376       // Ensuite on allume faiblement les LEDs correspondant a la zone de chaque cote
377       for (int i = 0; i < HIT_ZONE; i++)
378       {
379         // On allume de chaque cote
380         ledColor(PLAYER1, i, PLAYER1_COLOR / 10);  // On divise la couleur par 10 pour la rendre 10 fois moins puissante
381         ledColor(PLAYER2, i, PLAYER2_COLOR / 10);
382       }
383 
384       // Ensuite on allume faiblement les LEDs correspondant aux scores
385       // Pour le player 1
386       for (int i = 0; i < player1Score; i++)
387       {
388         ledColor(PLAYER1, NUM_LEDS / 2 - (i + 1), PLAYER1_COLOR / 15);
389       }
390       // Pour le player 2
391       for (int i = 0; i < player2Score; i++)
392       {
393         ledColor(PLAYER2, NUM_LEDS / 2 - (i + 1), PLAYER2_COLOR / 15);
394       }
395 
396       // Ensuite on actualise la position de la balle
397       // On donne la couleur de la led en fonction de si la balle est dans la zone d'un player ou non
398 
399       // Si la balle est dans le camp d'un des player, elle est rouge.
400       if (ballLed < HIT_ZONE || ballLed >= NUM_LEDS - HIT_ZONE)
401       {
402         ledColor(ballLed, ROUGE);
403       }
404       // Si elle en est proche, elle est jaune
405       else if (ballLed < 2 * HIT_ZONE || ballLed >= NUM_LEDS - 2 * HIT_ZONE)
406       {
407         ledColor(ballLed, JAUNE);
408       }
409       // Sinon la balle a sa couleur par defaut
410       else
411       {
412         ledColor(ballLed, BALL_COLOR);
413       }
414 
415       // On envoie la couleur des leds a la bande de leds
416       FastLED.show();
417 
418       // On actualise la variable lastMillis pour la boucle suivante
419       lastMillis = currentMillis;
420       break;
421   }
422 }

étapes de fabrication

indiquer autant d'étape que nécessaire, chacune illustrée par des images (phot, dessins, ...)

étape 1

étape 2

étape ...

troubleshouting

quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

Sources et documentation complémentaire

Récupérée de « http://wiki.lesfabriquesduponant.net/index.php?title=ENIB_2024_:_GNOP&oldid=24911 »