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

ENIB 2024 : catch the light

2024-01-25T14:31:49Z

Elio : /* Fichiers à joindre */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois de chêne / scie à bois/ etaux
* petite vis x6
* EPI: lunettes / gants
* perceuse / tournevis

==Fichiers à joindre==
[[Media:Decoupeuse.svg|téléchargez le svg]]
==code==
<syntaxhighlight lang="Arduino" line>
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 60 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 4 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)

int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu

int level = 0; // Initialisation du jeu

int lev = 0; // Variable pour sauter la fin du niveau

int score = 0; // Initialisation du score

int delay_level = 300; // Initialisation de la vitesse de jeu

int led; // Implémentation de la variable globale "led"

unsigned long time = 0; // Initialisation de la variable globale "time"

void setup() { // Fonction d'initialisation du jeu
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(10); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);
}

void loop() { // Fonction de boucle du jeu
left(); // Fonction left pour déplacer les leds depuis la gauche
right(); // Fonction right pour déplacer les leds depuis la droite
//Serial.println(score);
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
if(millis()-time > 100 && level < NUM_LEVEL){ // Vérification du temps d'appuie bouton pour éviter le rebond
time=millis(); // Mettre à jour le bouton pour le prochain appuie
score += (NUM_LED_PER_LEVEL)-2*abs(NUM_LED_PER_LEVEL*level+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.show();
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant

delay(100); // Attendre 100 ms
}
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(2000); // Attendre 500 ms
for(int i = 0; i <= 3; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
delay(50);
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
score = 0; // Réinitialiser le score
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Réinitialiser l'affichage led
leds.show(); // Réinitialiser l'affichage led
}

void left(){
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la gauche

}

void right(){
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
//Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la droite

}
</syntaxhighlight>

==Etapes de fabrication==

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''Test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

{| class="wikitable"
|-
| [[Fichier : Decoupe bois.jpg|400px]]
|-
| ''Découpe du bois manuellement''
|}

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

Fichier:Decoupeuse.svg

2024-01-25T14:27:50Z

Elio :

ENIB 2024 : catch the light

2024-01-25T14:03:11Z

Elio : /* Fichiers à joindre */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois de chêne / scie à bois/ etaux
* petite vis x6
* EPI: lunettes / gants
* perceuse / tournevis

==Fichiers à joindre==

#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 60 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 4 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)

int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu

int level = 0; // Initialisation du jeu

int lev = 0; // Variable pour sauter la fin du niveau

int score = 0; // Initialisation du score

int delay_level = 300; // Initialisation de la vitesse de jeu

int led; // Implémentation de la variable globale "led"

unsigned long time = 0; // Initialisation de la variable globale "time"

void setup() { // Fonction d'initialisation du jeu
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(10); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);
}

void loop() { // Fonction de boucle du jeu
left(); // Fonction left pour déplacer les leds depuis la gauche
right(); // Fonction right pour déplacer les leds depuis la droite
//Serial.println(score);
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
if(millis()-time > 100 && level < NUM_LEVEL){ // Vérification du temps d'appuie bouton pour éviter le rebond
time=millis(); // Mettre à jour le bouton pour le prochain appuie
score += (NUM_LED_PER_LEVEL)-2*abs(NUM_LED_PER_LEVEL*level+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.show();
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant

delay(100); // Attendre 100 ms
}
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(2000); // Attendre 500 ms
for(int i = 0; i <= 3; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
delay(50);
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
score = 0; // Réinitialiser le score
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Réinitialiser l'affichage led
leds.show(); // Réinitialiser l'affichage led
}

void left(){
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la gauche

}

void right(){
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
//Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la droite

}

==Etapes de fabrication==

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''Test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

{| class="wikitable"
|-
| [[Fichier : Decoupe bois.jpg|400px]]
|-
| ''Découpe du bois manuellement''
|}

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T14:02:29Z

Elio : /* Fichiers à joindre */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois de chêne / scie à bois/ etaux
* petite vis x6
* EPI: lunettes / gants
* perceuse / tournevis

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 60 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 4 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)

int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu

int level = 0; // Initialisation du jeu

int lev = 0; // Variable pour sauter la fin du niveau

int score = 0; // Initialisation du score

int delay_level = 300; // Initialisation de la vitesse de jeu

int led; // Implémentation de la variable globale "led"

unsigned long time = 0; // Initialisation de la variable globale "time"

void setup() { // Fonction d'initialisation du jeu
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(10); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);
}

void loop() { // Fonction de boucle du jeu
left(); // Fonction left pour déplacer les leds depuis la gauche
right(); // Fonction right pour déplacer les leds depuis la droite
//Serial.println(score);
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
if(millis()-time > 100 && level < NUM_LEVEL){ // Vérification du temps d'appuie bouton pour éviter le rebond
time=millis(); // Mettre à jour le bouton pour le prochain appuie
score += (NUM_LED_PER_LEVEL)-2*abs(NUM_LED_PER_LEVEL*level+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.show();
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant

delay(100); // Attendre 100 ms
}
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(2000); // Attendre 500 ms
for(int i = 0; i <= 3; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
delay(50);
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
score = 0; // Réinitialiser le score
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Réinitialiser l'affichage led
leds.show(); // Réinitialiser l'affichage led
}

void left(){
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la gauche

}

void right(){
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
//Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la droite

}

==Etapes de fabrication==

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''Test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

{| class="wikitable"
|-
| [[Fichier : Decoupe bois.jpg|400px]]
|-
| ''Découpe du bois manuellement''
|}

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T13:30:34Z

Elio : /* Etapes de fabrication */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois de chêne / scie à bois/ etaux
* petite vis x6
* EPI: lunettes / gants
* perceuse / tournevis

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 60 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 4 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int lev = 0; // Variable pour sauter la fin du niveau
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"
unsigned long time = 0; // Initialisation de la variable globale "time"

void setup() { // Fonction d'initialisation du jeu
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(10); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);
}

void loop() { // Fonction de boucle du jeu
left(); // Fonction left pour déplacer les leds depuis la gauche
right(); // Fonction right pour déplacer les leds depuis la droite
//Serial.println(score);
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
if(millis()-time > 100 && level < NUM_LEVEL){ // Vérification du temps d'appuie bouton pour éviter le rebond
time=millis(); // Mettre à jour le bouton pour le prochain appuie
score += (NUM_LED_PER_LEVEL)-2*abs(NUM_LED_PER_LEVEL*level+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.show();
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant

delay(100); // Attendre 100 ms
}
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(2000); // Attendre 500 ms
for(int i = 0; i <= 3; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
delay(50);
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
score = 0; // Réinitialiser le score
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Réinitialiser l'affichage led
leds.show(); // Réinitialiser l'affichage led
}

void left(){
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la gauche

}

void right(){
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
//Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la droite

}

==Etapes de fabrication==

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''Test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

{| class="wikitable"
|-
| [[Fichier : Decoupe bois.jpg|400px]]
|-
| ''Découpe du bois manuellement''
|}

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T13:27:24Z

Elio : /* Mettre du code Arduino */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois de chêne / scie à bois/ etaux
* petite vis x6
* EPI: lunettes / gants
* perceuse / tournevis

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 60 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 4 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int lev = 0; // Variable pour sauter la fin du niveau
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"
unsigned long time = 0; // Initialisation de la variable globale "time"

void setup() { // Fonction d'initialisation du jeu
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(10); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);
}

void loop() { // Fonction de boucle du jeu
left(); // Fonction left pour déplacer les leds depuis la gauche
right(); // Fonction right pour déplacer les leds depuis la droite
//Serial.println(score);
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
if(millis()-time > 100 && level < NUM_LEVEL){ // Vérification du temps d'appuie bouton pour éviter le rebond
time=millis(); // Mettre à jour le bouton pour le prochain appuie
score += (NUM_LED_PER_LEVEL)-2*abs(NUM_LED_PER_LEVEL*level+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.show();
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant

delay(100); // Attendre 100 ms
}
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(2000); // Attendre 500 ms
for(int i = 0; i <= 3; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
delay(50);
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
score = 0; // Réinitialiser le score
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Réinitialiser l'affichage led
leds.show(); // Réinitialiser l'affichage led
}

void left(){
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la gauche

}

void right(){
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
if (lev != level){
lev++;
break;
}
//Serial.println(led);
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
if (lev != level){
lev++;
break;
}
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
} // Fonction permettant de déplacer la led en partant de la droite

}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''Test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

{| class="wikitable"
|-
| [[Fichier : Decoupe bois.jpg|400px]]
|-
| ''Découpe du bois manuellement''
|}

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T13:24:00Z

Elio : /* Outil et Matériel */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois de chêne / scie à bois/ etaux
* petite vis x6
* EPI: lunettes / gants
* perceuse / tournevis

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''Test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

{| class="wikitable"
|-
| [[Fichier : Decoupe bois.jpg|400px]]
|-
| ''Découpe du bois manuellement''
|}

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:21:05Z

Elio : /* étape 4 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''Test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

{| class="wikitable"
|-
| [[Fichier : Decoupe bois.jpg|400px]]
|-
| ''Découpe du bois manuellement''
|}

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:20:15Z

Elio : /* étape 3 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''Test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:20:01Z

Elio : /* étape 3 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''test du programme''
|}

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:19:18Z

Elio : /* étape 3 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

{| class="wikitable"
|-
|[[Fichier:Test prog.jpg|400px]]
|-
| ''schéma avec dimensions''
|}

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:18:46Z

Elio : /* étape 2 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''Montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:18:25Z

Elio : /* étape 2 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''montage plaque''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:17:32Z

Elio : /* étape 2 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

{| class="wikitable"
|-
| [[Fichier:Connectique.jpg|400px]]
|-
| ''schéma avec dimensions''
|}

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:16:41Z

Elio : /* étape 1 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:16:25Z

Elio : /* étape 1 */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

{| class="wikitable"
|-
| [[Fichier: Soudure led.jpg|400px]] || [[Fichier:Sens led.jpg|400px]]
|-
| ''Soudure de la led'' || ''Sens de la led''
|}

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:14:30Z

Elio : /* Description */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:14:11Z

Elio : /* Description */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

{| class="wikitable"
|-
| [[Fichier:Groupebg.jpg|400px]]]
|-
| ''photo du groupe''
|}

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:10:14Z

Elio : /* Description */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]
*Image1:groupe de travail

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:09:49Z

Elio : /* Description */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]
Image1:groupe de travail

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:08:11Z

Elio : /* troubleshouting */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

===Problèmes rencontrés et Solutions===

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:07:05Z

Elio : /* troubleshouting */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Après quelques test le code contient quelques bug. Solution: Tester et adapter le codes

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:04:45Z

Elio : /* étapes de fabrication */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:04:15Z

Elio : /* fichiers à joindre */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==Fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:03:51Z

Elio : /* Outil et Matériel */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil à souder
* pistolet à colle
* petits câbles de connexion
* résistance pour led
* bois/ scie à bois

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:02:37Z

Elio : /* outil et matériel */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==Outil et Matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* pistolet a colle
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:01:44Z

Elio : /* Introduction */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:01:27Z

Elio : /* description */

Titre de la fiche expérience :
==Description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

<Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:01:12Z

Elio : /* description (résumé) */

Titre de la fiche expérience :
==description==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

<Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T11:00:46Z

Elio : /* Introduction */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

<Voici une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T10:59:43Z

Elio : /* Introduction */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Une démo pour mieux comprendre comment fonctionne le jeu.

<html>
<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</html>

==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T10:56:55Z

Elio : /* Introduction */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

Une démo pour mieux comprendre comment fonctionne le jeu.

<iframe width="560" height="315" src="https://www.youtube.com/embed/BmxxJo5Vk4c?si=USwnw7a0nQp_TOaV" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T10:29:26Z

Elio : /* troubleshouting */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T10:28:24Z

Elio : /* troubleshouting */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service. Solution: nous avons pris une autre carte déjà soudée.
*Deux éléments assez dissipés. Solution: Des taches simples et rapides pour eux

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T10:24:51Z

Elio : /* étape 4 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

[[Fichier : Decoupe bois.jpg|400px]]

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T10:23:30Z

Elio : /* étape 3 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[[Fichier:Test prog.jpg|400px]]

===étape 4===

*Fabrique de notre support en bois

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

ENIB 2024 : catch the light

2024-01-25T10:22:39Z

Elio : /* étape 3 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

[Fichier:Test prog.jpg|400px]

===étape 4===

*Fabrique de notre support en bois

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

==Sources et documentation complémentaire==
* [http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement Filtre anti-rebond]

[[Catégorie:Enib2024]]

Fichier:Test prog.jpg

2024-01-25T10:20:39Z

Elio : Test du programme. Résolution des problèmes. Recherche d'amélioration.

Test du programme. Résolution des problèmes. Recherche d'amélioration.

ENIB 2024 : catch the light

2024-01-25T10:14:45Z

Elio : /* étape 2 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaque et la connecter à l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

===étape 4===

*Fabrique de notre support en bois

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

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

ENIB 2024 : catch the light

2024-01-25T10:14:00Z

Elio : /* étape 1 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de leds en série en faisant attention au sens de fléchage.

[[Fichier: Soudure led.jpg|400px]] [[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaques et connecter la carte a l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

===étape 4===

*Fabrique de notre support en bois

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

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

ENIB 2024 : catch the light

2024-01-25T10:13:15Z

Elio : /* étape 2 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de led en série en faisant attention au sens de fléchage.

[[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaques et connecter la carte a l'ordinateur.

[[Fichier:Connectique.jpg|400px]]

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

===étape 4===

*Fabrique de notre support en bois

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

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

ENIB 2024 : catch the light

2024-01-25T10:11:28Z

Elio : /* étape 1 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de led en série en faisant attention au sens de fléchage.

[[Fichier:Sens led.jpg|400px]]

===étape 2===

*Faire les branchements sur la plaques et connecter la carte a l'ordinateur.

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

===étape 4===

*Fabrique de notre support en bois

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

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

Fichier:Sens led.jpg

2024-01-25T10:08:27Z

Elio : fléchage led

fléchage led

Fichier:Connectique.jpg

2024-01-25T10:03:06Z

Elio : Relier carte bouton ordinateur

Relier carte bouton ordinateur

Fichier:Decoupe bois.jpg

2024-01-25T10:01:13Z

Elio : Découpe du bois a la scie

Découpe du bois a la scie

Fichier:Soudure led.jpg

2024-01-25T09:58:40Z

Elio : Soudure des leds en série

Soudure des leds en série

ENIB 2024 : catch the light

2024-01-25T09:49:38Z

Elio : /* étapes de fabrication */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de led en série en faisant attention au sens de fléchage.

===étape 2===

*Faire les branchements sur la plaques et connecter la carte a l'ordinateur.

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

===étape 4===

*Fabrique de notre support en bois

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

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

ENIB 2024 : catch the light

2024-01-25T09:49:13Z

Elio : /* étape 4 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de led en série en faisant attention au sens de fléchage.

===étape 2===

*Faire les branchements sur la plaques et connecter la carte a l'ordinateur.

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

===étape 4===

*Fabrique de notre support en bois

===étape 5===
===étape 6===
===étape 7===
===étape 8===

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

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

ENIB 2024 : catch the light

2024-01-25T09:48:35Z

Elio : /* étape 3 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de led en série en faisant attention au sens de fléchage.

===étape 2===

*Faire les branchements sur la plaques et connecter la carte a l'ordinateur.

===étape 3===

*Téléverser notre programme et le tester/debug/améliorer par rapport au rendu réel.

===étape 4===
===étape 5===
===étape 6===
===étape 7===
===étape 8===

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

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

ENIB 2024 : catch the light

2024-01-25T09:46:08Z

Elio : /* étape 2 */

Titre de la fiche expérience :
==description (résumé)==

Le jeu "catch the light" est un jeu de timing. Une lumière se déplace sur un axe horizontal, et fait des aller retour. Le but est d'appuyer sur le bouton poussoir au bon moment afin de stopper la lumière lorsqu'elle se trouve au centre. Il y a 5 bandes horizontales qui représentent 5 étapes. A chaque étape la lumière se déplace plus vite.

[[Fichier:Groupebg.jpg|400px]]

==Introduction==

éventuelle vidéo
==outil et matériel==
* bouton poussoir
* carte D1 mini avec Arduino
* rubans de led
* une solderless breadboard
* appareil a souder
* colle/scotch
* petits cables de connexion
* resistance pour led

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
#include <Adafruit_NeoPixel.h> //Importer la bibliotèque "Adafruit_NeoPixel"

#define NUM_TOTAL_LED 15 // Nombres total de led
#define NUM_LED_PER_LEVEL 15 // Nombres de led par level
#define NUM_LEVEL 1 // Nombres de level
#define PIN_BUTON 3 // Pin bouton sur la carte
#define PIN_LED 2 // Pin led sur la carte

Adafruit_NeoPixel leds(NUM_TOTAL_LED, PIN_LED, NEO_GRB + NEO_KHZ800); // Activer les leds => Adafruit_NeoPixel leds(Nombres de leds, pin arduino commandant les leds, type de leds)
int LED_MIDDLE = NUM_LED_PER_LEVEL/2; // Calcul de la led du milieu
int level = 0; // Initialisation du jeu
int score = 0; // Initialisation du score
int delay_level = 300; // Initialisation de la vitesse de jeu
int led; // Implémentation de la variable globale "led"

void setup() { // Fonction d'initialisation du jeu
Serial.println("Begin");
pinMode(PIN_BUTON, INPUT); // Définition de "PIN_BUTON" en tant qu'entrée

leds.begin(); // Initialisation des leds
leds.setBrightness(255); // Régler la luminosité des leds
leds.show(); // Afficher les leds

attachInterrupt(digitalPinToInterrupt(PIN_BUTON), bouton, RISING); // Création d'une interruption à chaque appuie sur le bouton => attachInterrupt(digitalPinToInterrupt(pin arduino de commande du bouton), fonction associée, type de changement)
Serial.begin(9600);

}

void loop() { // Fonction de boucle du jeu
left();
Serial.println("left"); // Fonction left pour déplacer les leds depuis la gauche
right();
Serial.println("right"); // Fonction right pour déplacer les leds depuis la droite
}

void bouton(){ // Fonction en cas d'appuie sur le bouton
score += NUM_LED_PER_LEVEL-2*(int)abs(NUM_LED_PER_LEVEL*level-1+LED_MIDDLE-led); // Modification du score du joueur

leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(0, 0, 0)); // Éteindre la led du milieu
leds.setPixelColor(led, leds.Color(0, 0, 255)); // Allumer en bleu la led cliquée
leds.show(); // Afficher la led allumée

level++; // Passer au level suivant
delay_level /= 2; // Accélérer la vitesse de jeu
led = NUM_LED_PER_LEVEL*level; // Initialiser la led du level suivant
delay(100); // Attendre 100 ms
}

void end(){ // Fonction de fin du jeu
leds.fill(leds.Color(0, 0, 0), 0, NUM_TOTAL_LED); // Éteindre toutes les leds
leds.fill(leds.Color(255, 0, 0), 0, score); // Afficher le score du joueur
leds.show(); // Afficher le score du joueur
delay(500); // Attendre 500 ms
for(int i = 0; i <= 10; i++){ // Boucle d'affichage des leds de fin
for(led = 0; led < NUM_TOTAL_LED; led++){ // Boucle d'affichage des leds de fin
if(i%2 == 0){ // Si la boucle est pair
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Afficher la led en blanc
}
else{ // Sinon
int couleur_1 = random(0, 255); // Valeur aléatoire de rouge
int couleur_2 = random(0, 255); // Valeur aléatoire de vert
int couleur_3 = random(0, 255); // Valeur aléatoire de bleu
leds.setPixelColor(led, leds.Color(couleur_1, couleur_2, couleur_3)); // Afficher la led en fonction des couleurs aléatoires
}
leds.show(); // Afficher la leds
}
}
level = 0; // Réinitialiser le jeu
delay_level = 300; // Réinitialiser la vitesse du jeu
}

void left(){ // Fonction permettant de déplacer la led en partant de la gauche
for(led = NUM_LED_PER_LEVEL*level; led < NUM_LED_PER_LEVEL*(level+1)-1; led++){ // Boucle d'affichage des leds en partant de la gauche
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

void right(){ // Fonction permettant de déplacer la led en partant de la droite
for(led = NUM_LED_PER_LEVEL*(level+1)-1; led > NUM_LED_PER_LEVEL*level; led--){ // Boucle d'affichage des leds en partant de la droite
if(level == NUM_LEVEL){ // Si le level est égal au nombre de level
end(); // Fonction de fin du jeu
}
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.setPixelColor(led, leds.Color(0, 100, 0)); // Allumer la led qui se déplace
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
leds.setPixelColor(led, leds.Color(0, 0, 0)); // Éteindre la led qui se déplace
leds.setPixelColor(NUM_LED_PER_LEVEL*level+LED_MIDDLE, leds.Color(255, 0, 0)); // Allumer la led du milieu
leds.show(); // Afficher les leds
delay(delay_level); // Attendre un certain temps pour créer la vitesse du jeu
}
}

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

===étape 1===

*Souder les bandeaux de led en série en faisant attention au sens de fléchage.

===étape 2===

*Faire les branchements sur la plaques et connecter la carte a l'ordinateur.

===étape 3===
===étape 4===
===étape 5===
===étape 6===
===étape 7===
===étape 8===

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

*1er code récupéré qui ne fonctionnait pas. Solution: nous avons rédigé notre propre code.
*Carte D1 hors service.

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