ENIB 2024 : GNOP

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 :
Arthur : Laouen : Ewen 1 : Ewen 2 : (parti au combat) Alban : (jamais vu)

Outil et matériel

Pour fabriquer ce jeu, nous avons eut besoin de :

• Carte Arduino Nano
• 2 boutons d'arcade
• Carton
• Fils électriques
• Batterie externe
• Ruban de LEDS
• Haut-parleur
• Bois

Nous nous sommes servis de plusieurs outils :

• Fer à souder
• Pistolet à colle
• Cutter
• Scie à bois
• Lime à bois
• Découpeuse Vinyle

Code Arduino

  1  
  2 /*
  3    Code de fonctionnement pour le jeu PONG.
  4    Par les petits debrouillards.
  5 */
  6 
  7 #include <FastLED.h>
  8 
  9 // Definition des couleurs
 10 const CRGB NOIR  = CRGB(0,   0,   0  ); //Création d'une constante de type CRGB de couleur noire
 11 const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
 12 const CRGB ROUGE = CRGB(255, 0,   0  ); //Création d'une constante de type CRGB de couleur rouge
 13 const CRGB VERT  = CRGB(0,   255, 0  ); //Création d'une constante de type CRGB de couleur verte
 14 const CRGB BLEU  = CRGB(0,   0,   255); //Création d'une constante de type CRGB de couleur bleue
 15 const CRGB JAUNE = CRGB(255, 255, 0  ); //Création d'une constante de type CRGB de couleur jaune
 16 const CRGB ROSE  = CRGB(255, 0,   255); //Création d'une constante de type CRGB de couleur rose
 17 const CRGB CYAN  = CRGB(0,   255, 255); //Création d'une constante de type CRGB de couleur cyan
 18 
 19 // Definition des notes de musique
 20 const int PONG_SOUND = 250; //380
 21 const int LOOSE_SOUND = 180;
 22 
 23 
 24 /******************************
 25     PARAMETRES DE BRANCHEMENTS
 26  ******************************/
 27 
 28 const int LED_PIN = 8;          // Numero de branchement de la bande de LEDs
 29 const int BUTTON1_PIN = 2;      // Numero de branchement du premier bouton
 30 const int BUTTON2_PIN = 4;      // Numero de branchement du deuxieme bouton
 31 const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)
 32 
 33 
 34 /***********************
 35     PARAMETRES GENERAUX
 36  ***********************/
 37 const int   NUM_LEDS = 60;            // Nombre de LEDs sur la bande
 38 const CRGB  PLAYER1_COLOR = VERT;     // Couleur Player 1
 39 const CRGB  PLAYER2_COLOR = ROUGE;    // Couleur Player 2
 40 
 41 
 42 /***********************
 43      PARAMETRES PONG
 44  ***********************/
 45 const float BALL_SPEED = 0.5;   // Vitesse de la balle
 46 const float ACCELERATION = 9;   // Accélération de la balle a chaque tir, si ACCELERATION = 10 on augmente la vitesse de 10 pourcent a chaque tir
 47 const int   HIT_ZONE = 8;       // Nombre de LED pendant lesquelles on peut renvoyer la balle
 48 const int   MAX_SCORE = 3;      // Score maximum avant la fin du jeu
 49 
 50 const CRGB  BALL_COLOR = BLANC;      // Couleur de la balle
 51 
 52 /*******************************
 53      PARAMETRES TIR A LA CORDE
 54  *******************************/
 55 const float INCREMENT = 0.05;   // De combien avance la corde lorsqu'on appuie sur le bouton
 56 const float ROPE_SMOOTH = 1.0;  // Paramètre servant a lisser la position de la corde
 57 
 58 const float WAVE_LENGTH = 0.2;  // Taille des ondes
 59 const float WAVE_SPEED =  1.0;  // Vitesse des ondes
 60 
 61 
 62 
 63 /******************************
 64       VARIABLES GENERALES
 65  ******************************/
 66 // Players
 67 enum Player
 68 {
 69   PERSONNE,
 70   PLAYER1,
 71   PLAYER2
 72 };
 73 
 74 // Etats du jeu
 75 enum GameState
 76 {
 77   START,
 78   PONG,   // Mode pong
 79   TAC     // Mode tir a la corde
 80 };
 81 
 82 unsigned long lastMillis = 0;
 83 unsigned long beginTimer = 0;
 84 unsigned int counter = 0;
 85 
 86 Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
 87 Player lastWinner = PERSONNE;
 88 
 89 CRGB leds[NUM_LEDS];
 90 GameState gameState = START;
 91 
 92 
 93 /**********************************************
 94       FONCTIONS DE FONCTIONNEMENT GENERALES
 95  **********************************************/
 96 
 97 // Fonction permettant de changer la couleur d'une LED relativement au player 1 ou 2
 98 void ledColor(Player player, int pos, CRGB color)
 99 {
100   if (player == PLAYER1)
101   {
102     leds[pos] = color;
103   }
104   else // player == PLAYER2
105   {
106     leds[NUM_LEDS - pos - 1] = color;
107   }
108 }
109 
110 // Fonction permettant de changer la couleur d'une LED
111 void ledColor(int pos, CRGB color)
112 {
113   leds[pos] = color;
114 }
115 
116 /*********************************************
117       VARIABLES DE FONCTIONNEMENT DU PONG
118  *********************************************/
119 float ballSpeed = BALL_SPEED;  // Vitesse de la balle
120 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)
121 int player1Score = 0;   // Score du player 1
122 int player2Score = 0;   // Score du player 2
123 
124 /**********************************************
125       FONCTIONS DE FONCTIONNEMENT DU PONG
126  **********************************************/
127 // Fonction servant a afficher les scores
128 void showScore()
129 {
130   // On commence par effacer toutes les couleurs de led
131   FastLED.clear();
132 
133   // On allume le nombre de led correspondant au score du player 1
134   for (int i = 0; i < player1Score; i++)
135   {
136     ledColor(PLAYER1, NUM_LEDS / 2 - (i + 1), PLAYER1_COLOR);
137   }
138 
139   // On allume le nombre de led correspondant au score du player 2
140   for (int i = 0; i < player2Score; i++)
141   {
142     ledColor(PLAYER2, NUM_LEDS / 2 - (i + 1), PLAYER2_COLOR);
143   }
144 
145   // On envoie les nouvelles couleurs a la bande de led
146   FastLED.show();
147 
148   // On fait clignotter trois fois
149   if (lastWinner == PLAYER1)
150   {
151     for (int i = 0; i < 3; i++)
152     {
153       // On eteint la derniere LED pendant 0.5s
154       delay(500);
155       ledColor(PLAYER1, NUM_LEDS / 2 - player1Score, NOIR);
156       FastLED.show();
157 
158       // On allume la derniere LED pendant 0.5s
159       delay(500);
160       ledColor(PLAYER1, NUM_LEDS / 2 - player1Score, PLAYER1_COLOR);
161       FastLED.show();
162     }
163   }
164   else // lastWinner == PLAYER2
165   {
166     for (int i = 0; i < 3; i++)
167     {
168       // On eteint la derniere LED pendant 0.5s
169       delay(500);
170       ledColor(PLAYER2, NUM_LEDS / 2 - player2Score, NOIR);
171       FastLED.show();
172 
173       // On allume la derniere LED pendant 0.5s
174       delay(500);
175       ledColor(PLAYER2, NUM_LEDS / 2 - player2Score, PLAYER2_COLOR);
176       FastLED.show();
177     }
178   }
179 
180   // Si la partie est terminee on va a l'affichage de fin
181   if (player1Score == MAX_SCORE || player2Score == MAX_SCORE)
182   {
183     gameState = START;
184 
185     // On reinitialise les scores
186     player1Score = 0;
187     player2Score = 0;
188 
189     // On reinitialise la vitesse
190     ballSpeed = BALL_SPEED;
191 
192     // On reinitialise les leds
193     FastLED.clear();
194   }
195   // Sinon on reprend le jeu
196   else
197   {
198     gameState = PONG;
199     ballSpeed = BALL_SPEED;
200   }
201 }
202 
203 
204 /***************************************
205       FONCTION PRINCIPALE DU PONG
206  ***************************************/
207 void pong_loop()
208 {
209   // Calcul du temps ecoule entre deux boucles
210   unsigned long currentMillis = millis();
211 
212   // On calcule le numero de la LED allumee
213   int ballLed = ballPosition * NUM_LEDS;
214 
215   // On s'assure que la position de la balle ne depasse pas la taille de la bande de LED
216   ballLed = min(ballLed, NUM_LEDS - 1);
217 
218   // On regarde qui est en train de jouer
219   if (player == PLAYER1)
220   {
221     // On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
222     if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 500)
223     {
224       // Si la balle est hors de la zone de tir, l'autre player marque un point
225       if (ballLed >= HIT_ZONE)
226       {
227         player2Score += 1;
228         lastWinner = PLAYER2;
229         ballPosition = 0;
230 
231         // On joue le son de defaite
232         tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);
233 
234         // On passe en mode affichage des scores
235         showScore();
236 
237         // C'est a l'autre player de jouer
238         player = PLAYER2;
239 
240         // Actualisation de la variable lastMillis
241         lastMillis = millis();
242       }
243       else
244       {
245         // On accelere la balle
246         ballSpeed *= 1.0 + ACCELERATION / 100;
247 
248         // C'est a l'autre player de jouer
249         player = PLAYER2;
250 
251         // On joue la note de musique
252         tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
253       }
254 
255       return;
256     }
257 
258     // On fait avancer la balle
259     ballPosition -= ballSpeed * (currentMillis - lastMillis) * 0.001f;
260 
261     // On regarde si la balle est sortie de la zone
262     if (ballPosition < 0.0f)
263     {
264       // Si oui le player 2 marque un point
265       player2Score += 1;
266       lastWinner = PLAYER2;
267       ballPosition = 0;
268 
269       // On joue le son de defaite
270       tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);
271 
272       // On passe en mode affichage des scores
273       showScore();
274 
275       // C'est a l'autre player de jouer
276       player = PLAYER2;
277 
278       // Actualisation de la variable lastMillis
279       lastMillis = millis();
280       return;
281     }
282   }
283   else // player == PLAYER2
284   {
285     // On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
286     if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 500)
287     {
288       // Si la balle est hors de la zone de tir, l'autre player marque un point
289       if (ballLed < NUM_LEDS - HIT_ZONE)
290       {
291         player1Score += 1;
292         lastWinner = PLAYER1;
293         ballPosition = 1;
294 
295         // On joue le son de defaite
296         tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);
297 
298         // On passe en mode affichage des scores
299         showScore();
300 
301         // C'est a l'autre player de jouer
302         player = PLAYER1;
303 
304         // Actualisation de la variable lastMillis
305         lastMillis = millis();
306       }
307       else
308       {
309         // On accelere la balle
310         ballSpeed *= 1.1;
311 
312         // C'est a l'autre player de jouer
313         player = PLAYER1;
314 
315         // On joue la note de musique
316         tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
317       }
318 
319       return;
320     }
321 
322     // On fait avancer la balle dans l'autre sens
323     ballPosition += ballSpeed * (currentMillis - lastMillis) * 0.001f;
324 
325     // On regarde si la balle est sortie de la zone
326     if (ballPosition >= 1)
327     {
328       // Si oui le player 1 marque un point
329       player1Score += 1;
330       lastWinner = PLAYER1;
331       ballPosition = 1;
332 
333       // On joue le son de defaite
334       tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);
335 
336       // On passe en mode affichage des scores
337       showScore();
338       // C'est a l'autre player de jouer
339       player = PLAYER1;
340 
341       // Actualisation de la variable lastMillis
342       lastMillis = millis();
343       return;
344     }
345   }
346 
347   ///// AFFICHAGE BANDE DE LEDs /////
348   // Premierement on efface toutes les couleurs precedentes
349   FastLED.clear();
350 
351   // Ensuite on allume faiblement les LEDs correspondant a la zone de chaque cote
352   for (int i = 0; i < HIT_ZONE; i++)
353   {
354     // On allume de chaque cote
355     ledColor(PLAYER1, i, PLAYER1_COLOR / 10);  // On divise la couleur par 10 pour la rendre 10 fois moins puissante
356     ledColor(PLAYER2, i, PLAYER2_COLOR / 10);
357   }
358 
359   // Ensuite on allume faiblement les LEDs correspondant aux scores
360   // Pour le player 1
361   for (int i = 0; i < player1Score; i++)
362   {
363     ledColor(PLAYER1, NUM_LEDS / 2 - (i + 1), PLAYER1_COLOR / 15);
364   }
365   // Pour le player 2
366   for (int i = 0; i < player2Score; i++)
367   {
368     ledColor(PLAYER2, NUM_LEDS / 2 - (i + 1), PLAYER2_COLOR / 15);
369   }
370 
371   // Ensuite on actualise la position de la balle
372   // On donne la couleur de la led en fonction de si la balle est dans la zone d'un player ou non
373 
374   // Si la balle est dans le camp d'un des player, elle est rouge.
375   if (ballLed < HIT_ZONE || ballLed >= NUM_LEDS - HIT_ZONE)
376   {
377     ledColor(ballLed, ROUGE);
378   }
379   // Si elle en est proche, elle est jaune
380   else if (ballLed < 2 * HIT_ZONE || ballLed >= NUM_LEDS - 2 * HIT_ZONE)
381   {
382     ledColor(ballLed, JAUNE);
383   }
384   // Sinon la balle a sa couleur par defaut
385   else
386   {
387     ledColor(ballLed, BALL_COLOR);
388   }
389 
390   // On envoie la couleur des leds a la bande de leds
391   FastLED.show();
392 
393   // On actualise la variable lastMillis pour la boucle suivante
394   lastMillis = currentMillis;
395 }
396 
397 
398 
399 /*******************************************************
400       VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
401  *******************************************************/
402 float ropePosition = 0.5;           // Position non lissee de la corde
403 float displayedRopePosition = 0.5;  // Position lissee de la corde
404 bool player1Pushed = false;
405 bool player2Pushed = false;
406 
407 float player1Waves[10] = { 0 };
408 float player2Waves[10] = { 0 };
409 
410 /***********************************************
411       FONCTION PRINCIPALE DU TIR A LA CORDE
412  ***********************************************/
413 void tac_loop()
414 {  
415   // Calcul des temps
416   unsigned long ms = millis();
417   float dt = (ms - lastMillis) * 0.001f;
418   lastMillis = ms;
419 
420   // Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
421   if (ms - beginTimer < 1000)
422     return;
423 
424   bool player1Push = !digitalRead(BUTTON1_PIN);
425   bool player2Push = !digitalRead(BUTTON2_PIN);
426 
427   if (player1Push && !player1Pushed)
428   {
429     // On incremente la position de la corde
430     ropePosition += INCREMENT;
431 
432     // On lance une nouvelle onde
433     for (int i = 0; i < 10; i++)
434     {
435       if (player1Waves[i] == 0.0f)
436       {
437         //player1Waves[i] = WAVE_SPEED * dt;
438         player1Waves[i] = 0.01f;
439         break;
440       }
441     }
442   }
443   if (player2Push && !player2Pushed)
444   {
445     // On incremente la position de la corde
446     ropePosition -= INCREMENT;
447 
448     // On lance une nouvelle onde
449     for (int i = 0; i < 10; i++)
450     {
451       if (player2Waves[i] == 0.0f)
452       {
453         player2Waves[i] = 0.99f;
454         break;
455       }
456     }
457   }
458 
459   // Memorisation des etats des boutons
460   player1Pushed = player1Push;
461   player2Pushed = player2Push;
462 
463 
464 
465 
466   // On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
467   displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;
468 
469   // On regarde si player 1 a gagne
470   if (displayedRopePosition >= 1.0f)
471   {
472     lastWinner = PLAYER1;
473     gameState = START;
474     beginTimer = millis();
475 
476     ropePosition = 0.5f;
477     displayedRopePosition = 0.5f;
478 
479     FastLED.clear();
480     return;
481   }
482   // On regarde si player 2 a gagne
483   else if (displayedRopePosition <= 0.0f)
484   {
485     lastWinner = PLAYER2;
486     gameState = START;
487     beginTimer = millis();
488 
489     ropePosition = 0.5f;
490     displayedRopePosition = 0.5f;
491 
492     FastLED.clear();
493     return;
494   }
495 
496   // On propage les ondes
497   float dx = WAVE_SPEED * dt;
498 
499   for (int wave = 0; wave < 10; wave++)
500   {
501     // Ondes player 1
502     if (player1Waves[wave] != 0.0f)
503     {
504       player1Waves[wave] += dx;
505 
506       // Si toute l'onde depasse le point de la corde, on l'arrete
507       if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
508       {
509         player1Waves[wave] = 0.0f;
510       }
511     }
512 
513     // Ondes player 2
514     if (player2Waves[wave] != 0.0f)
515     {
516       player2Waves[wave] -= dx;
517 
518       // Si toute l'onde depasse le point de la corde, on l'arrete
519       if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
520       {
521         player2Waves[wave] = 0.0f;
522       }
523     }
524   }
525 
526   // On actualise la bande de leds
527   float ledLuminosity;
528   float ledPosition;
529 
530   FastLED.clear();
531 
532   // On commence par calculer le numero de la led correspondant a la position de la corde
533   int ropeLedPosition = NUM_LEDS * displayedRopePosition;
534 
535   // On dessine la zone du player 1
536   // Pour cela on calcule la luminosite led par led
537   for (int led = 0; led < ropeLedPosition; led++)
538   {
539     // La luminosite minimale d'une led est 10% de la luminosite max
540     ledLuminosity = 0.1f;
541     ledPosition = float(led) / float(NUM_LEDS);
542 
543     // Pour chaque onde, on ajoute la luminosite a la led
544     for (int wave = 0; wave < 10; wave++)
545     {
546       // Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
547       if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
548         continue;
549 
550       // On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
551       ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
552     }
553     // La valeur maximale de luminosite est 1.0
554     if (ledLuminosity > 2.0f)
555       ledLuminosity = 2.0f;
556 
557     // On actualise la valeur de luminosite de la led
558     ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
559   }
560 
561   // On dessine la zone du player 2
562   for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
563   {
564     // La luminosite minimale d'une led est 10% de la luminosite max
565     ledLuminosity = 0.1f;
566     ledPosition = float(led) / float(NUM_LEDS);
567 
568     // Pour chaque onde, on ajoute la luminosite a la led
569     for (int wave = 0; wave < 10; wave++)
570     {
571       // Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
572       if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
573         continue;
574 
575       // On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
576       ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
577     }
578     // La valeur maximale de luminosite est 1.0
579     if (ledLuminosity > 2.0f)
580       ledLuminosity = 2.0f;
581 
582     // On actualise la valeur de luminosite de la led
583     ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
584   }
585 
586   // On actualise la led correspondant a la position de la corde
587   ledColor(ropeLedPosition, BLANC);
588   FastLED.show();
589 }
590 
591 
592 
593 /****************************************************************
594    Cette fonction s'execute une fois lorsque la carte s'allume.
595  ****************************************************************/
596 void setup() {
597   // Initialisation des LEDs
598   FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
599 
600   // Initialisations des boutons
601   pinMode(BUTTON1_PIN, INPUT_PULLUP);
602   pinMode(BUTTON2_PIN, INPUT_PULLUP);
603 
604   // Initialisation du haut parleur
605   pinMode(HAUT_PARLEUR_PIN, OUTPUT);
606 
607   // COULEUR DES LEDS EN DEBUT DE PARTIE
608   FastLED.clear();
609   // Couleurs player 1
610   ledColor(PLAYER1, 0, PLAYER1_COLOR);
611   ledColor(PLAYER1, 1, PLAYER1_COLOR);
612   ledColor(PLAYER1, 2, PLAYER1_COLOR);
613   ledColor(PLAYER1, 3, PLAYER1_COLOR);
614   ledColor(PLAYER1, 4, PLAYER1_COLOR);
615 
616   // Couleurs player 2
617   ledColor(PLAYER2, 0, PLAYER2_COLOR);
618   ledColor(PLAYER2, 1, PLAYER2_COLOR);
619   ledColor(PLAYER2, 2, PLAYER2_COLOR);
620   ledColor(PLAYER2, 3, PLAYER2_COLOR);
621   ledColor(PLAYER2, 4, PLAYER2_COLOR);
622 
623   // On envoie les changements a la bande de leds
624   FastLED.show();
625 
626   // Initialisation du temps d'allumage
627   beginTimer = millis();
628 }
629 
630 /*************************************************************
631    Cette fonction s'execute en continue tout au long du jeu.
632  *************************************************************/
633 void loop() {
634 
635   switch (gameState)
636   {
637     case START:
638       // Si un player a gagne, on affiche l'arc en ciel du cote du vainqueur
639       if (lastWinner == PLAYER1)
640       {
641         fill_rainbow(leds, NUM_LEDS / 2, counter++, 7);
642         FastLED.show();
643       }
644       else if (lastWinner == PLAYER2)
645       {
646         fill_rainbow(leds + NUM_LEDS / 2, NUM_LEDS / 2, counter++, 7);
647         FastLED.show();
648       }
649 
650       // On regarde si un temps minimim s'est ecoule et si un des boutons est appuye
651       if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
652       {
653         unsigned long pushBegin = millis();
654 
655         while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);
656 
657         if (millis() - pushBegin < 1000)
658         {
659           gameState = PONG;
660         }
661         else
662         {
663           gameState = TAC;
664         }
665 
666         // On joue la note de musique
667         tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
668 
669         // Initialisation de la varable lastMillis
670         lastMillis = millis();
671 
672         // Initialisation du temps de debut de jeu
673         beginTimer = millis();
674       }
675 
676       break;
677 
678     case PONG:
679       pong_loop();
680       break;
681 
682     case TAC:
683       tac_loop();
684       break;
685   }
686 }

La biblothèque FastLED est nécéssaire pour pouvoir faire fonctionner le programme.
Pour l'installer il faut télécharger FastLED avec ce lien : https://github.com/FastLED/FastLED et le mettre dans le répertoire des bibliothèques d'Arduino. Et sur Arduino IDE avec celui-là : https://www.arduino.cc/en/main/software.
Sur le ligociel, il faut chosir la bonne carte, le bon port de sortie et il suffit enfin de téléverser pour pouvoir charger le programme sur la carte.
Et maintenant, pour pouvoir utiliser le jeu partout, il faut tout simplement utiliser une batterie (avec piles ou externe) et la brancher à la carte qui à été préalablement chargée avec le programme.

Étapes de fabrication

Nous avons fait nos étapes dans cet ordre là car nous avons suivi les étapes dans le Wikidabrouillard Voici toutes les étapes de fabrication de notre projet :

Étape 1

Tout d'abord on se rend compte du matériel qu'on nous donne et on regarde les différentes étapes à suivre sur le Wikidébrouillard

Étape 2

On soude des fils électriques au ruban de LEDS et sur les pattes des interrupteurs

Étape 2-1

En même temps, on construit le support sur lequel le jeu va être joué

Étape 3

On soude aussi les broches de support sur la carte Arduino

Étape 4

On réalise le câblage sur la plaquette qui nous a été fourni pour pouvoir tester le code

Étape 5

Puis on commence à mettre tous nos composants sur la maquette réelle

Étape 6

Ensuite, le jeu peut être utilisé !

Étape 7

On commence à créer notre produit final qui sera fait tout en bois

Étape 8

Pour cela, on va venir couper une planche en bois, et les chutes serviront à faire le maintien de la planche.

Étape 9

Ensuite, on fait des trous pour faire passer les boutons d'arcade, vous pouvez le voir sur la photo ci-dessus.

Étape 10

On en fait un aussi pour faire passer les fils connectés au ruban de LEDS

Étape 11

On reconnecte tout le système sur notre maquette finale

Étape 12

On colle notre BreadBoard au dos de notre planche pour qu'elle ne soit pas vue

Étape 13

On colle aussi les câbles pour ne pas les vois tomber

Étape 14

Pour ajouter un peu d'esthétique à notre projet, nous avons gravé à la découpeuse vinyle le titre de notre projet.*

Étape 15

Le jeu peut être pleinement apprécié !!

Problèmes rencontrés

Nous avons confronté un certain nombre de problèmes durant la conception de ce projet.
Une fois que nous avions fini le projet sur la première maquette, le téléversement ne se faisait pas, sur Arduino IDE, dans l'onglet Tools>Processor il fallait prendre la rubrique "Old Bootloader" et nous étions sur celui de base, mais si l'un ne marche pas c'est que l'autre fonctionne, nous avons donc réussi à résoudre ce problème.
Nous avons aussi également essayé d'incorporer un haut-parleur classique pour faire du son dès qu'un bouton est appuyé, mais le son n'était clairement pas assez fort donc on a voulu utilisé un amplificateur mais nous n'avons pas réussi à bien le brancher. On a donc opter d'utiliser un buzzer pour que le son soit plus fort pour être entendu.
Une des broches de notre carte n'a plus été fonctionnel, nous avons mis du temps à comprendre qu'un de nos problèmes venait de là, on a donc tout simplement changer de broche.
Nous utilisions au début, une batterie à pile, mais celle-ci ne délivrait pas assez de puissance pour faire fonctionner la carte et le programme, nous avons changé cette batterie et opter pour une batterie externe rechargeable qui, elle, convenait parfaitement avec le système.