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 :

Outil et matériel

Pour fabriquer ce jeu, nous avons eut besoin de :

• Carte Arduino Nano
• 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
• Scie à bois

Fichiers à joindre

On mettra une vidéo

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 }

Étapes de fabrication

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é !