Les Fabriques du Ponant - Contributions de l’utilisateur [fr]

ENIB 2024 : GNOP

2024-01-25T14:25:39Z

Laouen : /* Étape 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 :
 
Arthur :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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.*
 
[[Fichier:GNOP.jpg|200px]]

===É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.

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:25:19Z

Laouen : /* Étape 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 :
 
Arthur :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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.
[[Fichier:GNOP.jpg|200px]]

===É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.

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:24:50Z

Laouen : /* Étape 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 :
 
Arthur :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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.
[[Fichier:GNOP.jgp|200px]]

===É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.

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:GNOP.jpg

2024-01-25T14:23:49Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T14:22:12Z

Laouen : /* Étapes de fabrication */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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.

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:20:43Z

Laouen : /* Étapes de fabrication */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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===
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.

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:20:11Z

Laouen : /* Étapes de fabrication */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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 maquette, 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.

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:17:14Z

Laouen : /* Problèmes rencontrés */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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===
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.

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:06:35Z

Laouen :

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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===
Le jeu peut être pleinement apprécié !!

==Problèmes rencontrés==

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:05:45Z

Laouen : /* Photos */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:05:34Z

Laouen : /* Outil et matériel */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==Photos==

==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==
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:04:54Z

Laouen : /* Outil et matériel */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==Photos==

==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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:03:41Z

Laouen : /* Étape 9 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* Batterie
* Ruban de LEDS
* Haut-parleur
 
Nous nous sommes servis de plusieurs outils :
* Fer à souder
* Pistolet à colle
* Cutter
* Scie à bois

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:03:16Z

Laouen : /* Étape 8 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* Batterie
* Ruban de LEDS
* Haut-parleur
 
Nous nous sommes servis de plusieurs outils :
* Fer à souder
* Pistolet à colle
* Cutter
* Scie à bois

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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.
 
[[Fichier:final.jpg|200px]]

===Étape 9===
Ensuite, on fait des trous pour faire passer les boutons d'arcade

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T14:02:06Z

Laouen : /* Étape 8 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* Batterie
* Ruban de LEDS
* Haut-parleur
 
Nous nous sommes servis de plusieurs outils :
* Fer à souder
* Pistolet à colle
* Cutter
* Scie à bois

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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
[[Fichier:final.jpg|200px]]

===Étape 9===
Ensuite, on fait des trous pour faire passer les boutons d'arcade

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Final.jpg

2024-01-25T14:01:10Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T13:56:15Z

Laouen : /* Fichiers à joindre */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* Batterie
* Ruban de LEDS
* Haut-parleur
 
Nous nous sommes servis de plusieurs outils :
* Fer à souder
* Pistolet à colle
* Cutter
* Scie à bois

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T13:54:59Z

Laouen : /* Fichiers à joindre */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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.
Ensuite sur Arduino IDE

==É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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T11:27:21Z

Laouen :

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===É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

===É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===
Le jeu peut être pleinement apprécié !!

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T11:05:11Z

Laouen : /* Étape 5 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg|200px]]

===Étape 6===
Ensuite, le jeu peut être utilisé !

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T11:04:41Z

Laouen : /* Étape 5 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
 
[[Fichier:board_pres.jpg]]

===Étape 6===
Ensuite, le jeu peut être utilisé !

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Board pres.jpg

2024-01-25T11:02:31Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T11:01:44Z

Laouen : /* Étape 4 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.png]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
===Étape 6===
Ensuite, le jeu peut être utilisé !

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T11:00:11Z

Laouen : /* Étape 4 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

===É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
 
[[Fichier:Schema.jpg]]

===Étape 5===
Puis on commence à mettre tous nos composants sur la maquette réelle
===Étape 6===
Ensuite, le jeu peut être utilisé !

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Schema.png

2024-01-25T10:57:42Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T10:57:01Z

Laouen : /* Étape 2 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|100px]]

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Bouton.jpg

2024-01-25T10:54:38Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T10:51:52Z

Laouen : /* Étape 2 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
 
[[Fichier:ruban_led.png|200px]]
[[Fichier:bouton.jpg|200px]]

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T10:48:40Z

Laouen : /* Étape 2 */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
 
[[Fichier:ruban_led.png|100px]]

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T10:48:20Z

Laouen : /* Étapes de fabrication */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

==É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
[[Fichier:ruban_led.png|100px]]
===É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é !

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Ruban led.png

2024-01-25T10:46:32Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T10:32:27Z

Laouen : /* Étapes de fabrication */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T10:26:09Z

Laouen : /* Outil et matériel */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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 (Switch)
* 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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T10:24:43Z

Laouen : /* Description */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 : (parti au combat)
[[Fichier:virgule.jpg|100px]]
Alban : (jamais vu)
[[Fichier:alban.jpg|100px]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Alban.jpg

2024-01-25T10:23:40Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T10:21:02Z

Laouen : /* Description */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]
Ewen 2 :(parti au combat)
[[Fichier:virgule.jpg|100px]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Virgule.jpg

2024-01-25T10:19:40Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T10:18:17Z

Laouen : /* Description */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]
Ewen 1 :
[[Fichier:ramzi.jpg|100px]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Ramzi.jpg

2024-01-25T10:17:21Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T10:14:19Z

Laouen : /* Description */

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 :
[[Fichier:arthur.jpg|100px]]
Laouen :
[[Fichier:laouen.jpg|100px]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T10:13:18Z

Laouen : /* Description */

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 :
 
[[Fichier:arthur.jpg|200px|thumb|right|Arthur]]
[[Fichier:laouen.jpg|200px|thumb|right|Laouen]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Laouen.jpg

2024-01-25T10:12:26Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T10:10:36Z

Laouen : /* Description */

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 :
 
[[Fichier:arthur.jpg|200px|thumb|right|Arthur]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T10:09:06Z

Laouen : /* Description */

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 :
 
[[Fichier:arthur.jpg|200px|left|Arthur]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T10:08:46Z

Laouen : /* Description */

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 :
 
[[Fichier:arthur.jpg|200px|Arthur]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T10:08:14Z

Laouen : /* Description */

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 :
 
[[Fichier:arthur.jpg|200px|thumb|left|Arthur]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

Fichier:Arthur.jpg

2024-01-25T10:06:59Z

Laouen :

ENIB 2024 : GNOP

2024-01-25T10:05:11Z

Laouen : /* Outil et matériel */

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 :
 
[[Fichier:LAVRAITEAM.jpg|200px]]

==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
* Scie à bois

==Fichiers à joindre==
On mettra une vidéo

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : GNOP

2024-01-25T09:48:54Z

Laouen : /* Code Arduino */

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 :
 
[[Fichier:LAVRAITEAM.jpg|200px]]

==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===
<syntaxhighlight lang="Arduino" line>
/*
Code de fonctionnement pour le jeu PONG.
Par les petits debrouillards.
*/

#include <FastLED.h>

// Definition des couleurs
const CRGB NOIR = CRGB(0, 0, 0 ); //Création d'une constante de type CRGB de couleur noire
const CRGB BLANC = CRGB(255, 255, 255); //Création d'une constante de type CRGB de couleur blanche
const CRGB ROUGE = CRGB(255, 0, 0 ); //Création d'une constante de type CRGB de couleur rouge
const CRGB VERT = CRGB(0, 255, 0 ); //Création d'une constante de type CRGB de couleur verte
const CRGB BLEU = CRGB(0, 0, 255); //Création d'une constante de type CRGB de couleur bleue
const CRGB JAUNE = CRGB(255, 255, 0 ); //Création d'une constante de type CRGB de couleur jaune
const CRGB ROSE = CRGB(255, 0, 255); //Création d'une constante de type CRGB de couleur rose
const CRGB CYAN = CRGB(0, 255, 255); //Création d'une constante de type CRGB de couleur cyan

// Definition des notes de musique
const int PONG_SOUND = 250; //380
const int LOOSE_SOUND = 180;

/******************************
PARAMETRES DE BRANCHEMENTS
******************************/

const int LED_PIN = 8; // Numero de branchement de la bande de LEDs
const int BUTTON1_PIN = 2; // Numero de branchement du premier bouton
const int BUTTON2_PIN = 4; // Numero de branchement du deuxieme bouton
const int HAUT_PARLEUR_PIN = 5; // Numero de branchement du haut parleur (optionnel)

/***********************
PARAMETRES GENERAUX
***********************/
const int NUM_LEDS = 60; // Nombre de LEDs sur la bande
const CRGB PLAYER1_COLOR = VERT; // Couleur Player 1
const CRGB PLAYER2_COLOR = ROUGE; // Couleur Player 2

/***********************
PARAMETRES PONG
***********************/
const float BALL_SPEED = 0.5; // Vitesse de la balle
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
const int HIT_ZONE = 8; // Nombre de LED pendant lesquelles on peut renvoyer la balle
const int MAX_SCORE = 3; // Score maximum avant la fin du jeu

const CRGB BALL_COLOR = BLANC; // Couleur de la balle

/*******************************
PARAMETRES TIR A LA CORDE
*******************************/
const float INCREMENT = 0.05; // De combien avance la corde lorsqu'on appuie sur le bouton
const float ROPE_SMOOTH = 1.0; // Paramètre servant a lisser la position de la corde

const float WAVE_LENGTH = 0.2; // Taille des ondes
const float WAVE_SPEED = 1.0; // Vitesse des ondes

/******************************
VARIABLES GENERALES
******************************/
// Players
enum Player
{
PERSONNE,
PLAYER1,
PLAYER2
};

// Etats du jeu
enum GameState
{
START,
PONG, // Mode pong
TAC // Mode tir a la corde
};

unsigned long lastMillis = 0;
unsigned long beginTimer = 0;
unsigned int counter = 0;

Player player = PLAYER1; // Prochain joueur a appuyer sur son bouton
Player lastWinner = PERSONNE;

CRGB leds[NUM_LEDS];
GameState gameState = START;

/**********************************************
FONCTIONS DE FONCTIONNEMENT GENERALES
**********************************************/

// 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 PONG
*********************************************/
float ballSpeed = BALL_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

/**********************************************
FONCTIONS DE FONCTIONNEMENT DU PONG
**********************************************/
// Fonction servant a 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 terminee 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 = BALL_SPEED;

// On reinitialise les leds
FastLED.clear();
}
// Sinon on reprend le jeu
else
{
gameState = PONG;
ballSpeed = BALL_SPEED;
}
}

/***************************************
FONCTION PRINCIPALE DU PONG
***************************************/
void pong_loop()
{
// Calcul du temps ecoule entre deux boucles
unsigned long currentMillis = millis();

// On calcule le numero de la LED allumee
int ballLed = ballPosition * NUM_LEDS;

// On s'assure que la position de la balle ne depasse 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 delai de debut de jeu est passe
if (digitalRead(BUTTON1_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}
else // player == PLAYER2
{
// On regarde si le player a appuye sur son bouton et si le delai de debut de jeu est passe
if (digitalRead(BUTTON2_PIN) == LOW && currentMillis - beginTimer > 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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;

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);
}

return;
}

// 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 joue le son de defaite
tone(HAUT_PARLEUR_PIN, LOOSE_SOUND, 800);

// 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();
return;
}
}

///// 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;
}

/*******************************************************
VARIABLES DE FONCTIONNEMENT DU TIR A LA CORDE
*******************************************************/
float ropePosition = 0.5; // Position non lissee de la corde
float displayedRopePosition = 0.5; // Position lissee de la corde
bool player1Pushed = false;
bool player2Pushed = false;

float player1Waves[10] = { 0 };
float player2Waves[10] = { 0 };

/***********************************************
FONCTION PRINCIPALE DU TIR A LA CORDE
***********************************************/
void tac_loop()
{
// Calcul des temps
unsigned long ms = millis();
float dt = (ms - lastMillis) * 0.001f;
lastMillis = ms;

// Si moins d'une seconde s'est ecoule depuis le debut, on ne fait rien (pour eviter d'appuyer sans faire expres)
if (ms - beginTimer < 1000)
return;

bool player1Push = !digitalRead(BUTTON1_PIN);
bool player2Push = !digitalRead(BUTTON2_PIN);

if (player1Push && !player1Pushed)
{
// On incremente la position de la corde
ropePosition += INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player1Waves[i] == 0.0f)
{
//player1Waves[i] = WAVE_SPEED * dt;
player1Waves[i] = 0.01f;
break;
}
}
}
if (player2Push && !player2Pushed)
{
// On incremente la position de la corde
ropePosition -= INCREMENT;

// On lance une nouvelle onde
for (int i = 0; i < 10; i++)
{
if (player2Waves[i] == 0.0f)
{
player2Waves[i] = 0.99f;
break;
}
}
}

// Memorisation des etats des boutons
player1Pushed = player1Push;
player2Pushed = player2Push;

// On calcule la position lissee de la corde (displayedRopePosition correspond a la variable ropePosition avec un lissage supplementaire)
displayedRopePosition += (ropePosition - displayedRopePosition) * dt / ROPE_SMOOTH;

// On regarde si player 1 a gagne
if (displayedRopePosition >= 1.0f)
{
lastWinner = PLAYER1;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}
// On regarde si player 2 a gagne
else if (displayedRopePosition <= 0.0f)
{
lastWinner = PLAYER2;
gameState = START;
beginTimer = millis();

ropePosition = 0.5f;
displayedRopePosition = 0.5f;

FastLED.clear();
return;
}

// On propage les ondes
float dx = WAVE_SPEED * dt;

for (int wave = 0; wave < 10; wave++)
{
// Ondes player 1
if (player1Waves[wave] != 0.0f)
{
player1Waves[wave] += dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player1Waves[wave] - WAVE_LENGTH > displayedRopePosition)
{
player1Waves[wave] = 0.0f;
}
}

// Ondes player 2
if (player2Waves[wave] != 0.0f)
{
player2Waves[wave] -= dx;

// Si toute l'onde depasse le point de la corde, on l'arrete
if (player2Waves[wave] + WAVE_LENGTH < displayedRopePosition)
{
player2Waves[wave] = 0.0f;
}
}
}

// On actualise la bande de leds
float ledLuminosity;
float ledPosition;

FastLED.clear();

// On commence par calculer le numero de la led correspondant a la position de la corde
int ropeLedPosition = NUM_LEDS * displayedRopePosition;

// On dessine la zone du player 1
// Pour cela on calcule la luminosite led par led
for (int led = 0; led < ropeLedPosition; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player1Waves[wave] == 0.0f || player1Waves[wave] < ledPosition)
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player1Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER1_COLOR / int(2.0f / ledLuminosity) / 5);
}

// On dessine la zone du player 2
for (int led = ropeLedPosition + 1; led < NUM_LEDS; led++)
{
// La luminosite minimale d'une led est 10% de la luminosite max
ledLuminosity = 0.1f;
ledPosition = float(led) / float(NUM_LEDS);

// Pour chaque onde, on ajoute la luminosite a la led
for (int wave = 0; wave < 10; wave++)
{
// Si l'onde n'est pas active ou si l'onde est avant la led, on n'ajoute aucune luminosite
if (player2Waves[wave] == 0.0f || ledPosition > player2Waves[wave])
continue;

// On ajoute de la luminosite de facon decroissante. plus l'onde est loin, moins on ajoute de luminosite.
ledLuminosity += max(0.0f, 0.9f - (player2Waves[wave] - ledPosition) / WAVE_LENGTH);
}
// La valeur maximale de luminosite est 1.0
if (ledLuminosity > 2.0f)
ledLuminosity = 2.0f;

// On actualise la valeur de luminosite de la led
ledColor(led, PLAYER2_COLOR / int(1.0f / ledLuminosity) / 5);
}

// On actualise la led correspondant a la position de la corde
ledColor(ropeLedPosition, BLANC);
FastLED.show();
}

/****************************************************************
Cette fonction s'execute une fois lorsque la carte s'allume.
****************************************************************/
void setup() {
// 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();

// Initialisation du temps d'allumage
beginTimer = millis();
}

/*************************************************************
Cette fonction s'execute en continue tout au long du jeu.
*************************************************************/
void loop() {

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 temps minimim s'est ecoule et si un des boutons est appuye
if (millis() - beginTimer > 1000 && (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW))
{
unsigned long pushBegin = millis();

while (digitalRead(BUTTON1_PIN) == LOW || digitalRead(BUTTON2_PIN) == LOW);

if (millis() - pushBegin < 1000)
{
gameState = PONG;
}
else
{
gameState = TAC;
}

// On joue la note de musique
tone(HAUT_PARLEUR_PIN, PONG_SOUND, 100);

// Initialisation de la varable lastMillis
lastMillis = millis();

// Initialisation du temps de debut de jeu
beginTimer = millis();
}

break;

case PONG:
pong_loop();
break;

case TAC:
tac_loop();
break;
}
}
</syntaxhighlight>

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

==Sources et documentation complémentaire==
[[Catégorie:Enib2024]]

ENIB 2024 : l

2024-01-25T09:47:45Z

Laouen : Page créée avec « Titre de la fiche expérience : ==description (résumé)== éventuelle photo de l'équipe 200px ==Introduction== éventu... »

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Totem-maisonsDesMinerauxCrozon.JPG|200px]]

==Introduction==

éventuelle vidéo
==outil et matériel==

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
#define PIN 9
#include <Arduino_GFX_Library.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
// put your main code here, to run repeatedly:

}

</syntaxhighlight>

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

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]