ENIB 2024 : GNOP
Titre de la fiche expérience :
Sommaire
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 :
Photos
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
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é !
