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

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T14:03:46Z

Bazz : /* étape 6 : Câblage final */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus haut)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Câblage final===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

Nous n'avons malheureusement pas pu aller au bout de cette étape par manque de temps. En l'état final, la dernière ligne de led de la matrice ne s'allumait pas en raison d'un problème d’alimentation. Il faudrait peut être utiliser une alimentation différente pour la carte et pour la matrice pour éviter ce problème.

[[Fichier:Montage et test.jpg|300px]]

[[Fichier:Led final.jpg|300px]]

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T14:03:31Z

Bazz : /* étape 6 : Câblage final */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus haut)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Câblage final===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

Nous n'avons malheureusement pas pu aller au bout de cette étape par manque de temps. En l'état final, la dernière ligne de led de la matrice ne s'allumait pas en raison d'un problème d’alimentation. Il faudrait peut être utiliser une alimentation différente pour la carte et pour la matrice pour éviter ce problème.

[[Fichier:Montage et test.jpg|300px]] 

[[Fichier:Led final.jpg|300px]]

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T14:03:06Z

Bazz : /* étape 6 : Câblage final */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus haut)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Câblage final===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

Nous n'avons malheureusement pas pu aller au bout de cette étape par manque de temps. En l'état final, la dernière ligne de led de la matrice ne s'allumait pas en raison d'un problème d’alimentation. Il faudrait peut être utiliser une alimentation différente pour la carte et pour la matrice pour éviter ce problème.

[[Fichier:Montage et test.jpg|300px]] 

[[Fichier:Led final.jpg300px|300px]]

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T14:02:17Z

Bazz : /* étape 6 : Câblage final */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus haut)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Câblage final===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

Nous n'avons malheureusement pas pu aller au bout de cette étape par manque de temps. En l'état final, la dernière ligne de led de la matrice ne s'allumait pas en raison d'un problème d’alimentation. Il faudrait peut être utiliser une alimentation différente pour la carte et pour la matrice pour éviter ce problème.

[[Fichier:Montage et test.jpg|300px]] 

[[ENIB 2024 :300px|300px]]

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

Fichier:Led final.jpg

2024-01-25T14:01:07Z

Bazz : Bazz a téléversé une nouvelle version de Fichier:Led final.jpg

Fichier:Led final.jpg

2024-01-25T13:59:33Z

Bazz : Bazz a téléversé une nouvelle version de Fichier:Led final.jpg

Fichier:Led final.jpg

2024-01-25T13:57:03Z

Bazz : Bazz a téléversé une nouvelle version de Fichier:Led final.jpg

Fichier:Led final.jpg

2024-01-25T13:55:53Z

Bazz :

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:55:29Z

Bazz : /* étape 6 : Cablage final */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus haut)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Câblage final===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

Nous n'avons malheureusement pas pu aller au bout de cette étape par manque de temps. En l'état final, la dernière ligne de led de la matrice ne s'allumait pas en raison d'un problème d’alimentation. Il faudrait peut être utiliser une alimentation différente pour la carte et pour la matrice pour éviter ce problème.

[[Fichier:Montage et test.jpg|400px]]

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:39:39Z

Bazz : /* étape 6 : Cablage final */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus haut)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Cablage final===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

[[Fichier:Montage et test.jpg|400px]]

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

Fichier:Montage et test.jpg

2024-01-25T13:38:47Z

Bazz :

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:37:36Z

Bazz : /* étape 6 : Conception et assemblage de la structure */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus haut)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Cablage final===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:30:37Z

Bazz : /* étape 3 : Codage du jeu */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus haut)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Conception et assemblage de la structure===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:30:15Z

Bazz : /* étape 2 : étude du câblage et réalisation du support de l'écran */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|400px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus bas)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Conception et assemblage de la structure===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:29:07Z

Bazz : /* étapes de fabrication */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus bas)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 6 : Conception et assemblage de la structure===

Câblage final sur la structure, on testera d'abord le bon fonctionnement des leds et des cartes.

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cependant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps. Nous Etions également très limités par le temps car nous avions seulement 1 journée et demie pour finaliser le projet.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:24:21Z

Bazz : /* étape 3 : Codage du jeu */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino. (le code est fourni plus bas)

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cepandant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:23:33Z

Bazz : /* fichiers à joindre */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]] 

[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cepandant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:22:52Z

Bazz : /* fichiers à joindre */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]]
[[Fichier:Impression 3D structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cepandant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

Fichier:Impression 3D structure arcade.zip

2024-01-25T13:22:11Z

Bazz : Fichier pour impression 3D de la borne d'arcade

Fichier pour impression 3D de la borne d'arcade

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:20:25Z

Bazz : /* fichiers à joindre */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...

[[Fichier:Catia structure arcade.zip]]

===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cepandant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

Fichier:Catia structure arcade.zip

2024-01-25T13:19:17Z

Bazz : plans catia de la borne d'arcade pour space invader

plans catia de la borne d'arcade pour space invader

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:12:55Z

Bazz : /* description (résumé) */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cepandant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T13:08:09Z

Bazz : /* outil et matériel */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre GF1002, et bouton poussoir le jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cepandant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:40:32Z

Bazz : /* troubleshouting */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===troubleshouting===

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

Nous avons rencontrés des problèmes lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu était destiné à une matrice de led 8x8, hors, nous n'avions qu'une matrice 16x16. Nous avons donc décidé de faire notre propre matrice de led. Cepandant, effectuer 168 soudures et points de colle s'est avéré très long et nous avons donc perdu du temps.

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:37:02Z

Bazz : /* étape 4 : Câblage et fixation des leds */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

[[Fichier:Support de leds basile.jpg|200px]]

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

Fichier:Support de leds basile.jpg

2024-01-25T11:36:16Z

Bazz :

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:35:35Z

Bazz : /* étape 5 : Conception et assemblage de la structure */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]] [[Fichier:Structure finale2 arcade basile.jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

Fichier:Structure finale2 arcade basile.jpg

2024-01-25T11:34:43Z

Bazz : Bazz a téléversé une nouvelle version de Fichier:Structure finale2 arcade basile.jpg

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:34:07Z

Bazz : /* étape 5 */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

===étape 5 : Conception et assemblage de la structure===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 
[[Fichier:Structure finale arcade basile(1).jpg|200px]]

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

Fichier:Structure finale arcade basile(1).jpg

2024-01-25T11:32:42Z

Bazz :

Fichier:Structure finale2 arcade basile.jpg

2024-01-25T11:29:53Z

Bazz :

Fichier:Structure finale arcade basile.jpg

2024-01-25T11:23:29Z

Bazz :

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:23:00Z

Bazz : /* étape 4 */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4 : Câblage et fixation des leds===

Il faut ensuite fixer Les leds sur le support découpé à l'étape précédente. Il faudra souder les anodes verticalement et les cathodes horizontalement. Celà va prendre beaucoup de temps et sera source de dysfonctionnement si les soudures sont mal faites. L'idéal sera d'avoir une matrice de led 8x8 déjà cablée. Il faudra penser à adapter le code si nécéssaire.

===étape 5===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:13:27Z

Bazz : /* étape 4 */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4===

Fixation des led et soudure des anodes et des cath

===étape 5===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:12:21Z

Bazz : /* étape 5 */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4===

===étape 5===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:12:07Z

Bazz : /* étape 4 */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4===

===étape 5===

Assemblage des leds sur

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:11:03Z

Bazz : /* étape 5 */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 5===

Assemblage des leds sur

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:10:25Z

Bazz : /* étape 4 */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4===

Il faut ensuite dessiner les pièces de la structure de la borne sur Catia ou un autre logiciel de conception 3D. 

On imprimera ensuite les pièces. Lorsque l'impression sera finie, on pourra par la suite les assembler avec un pistolet à colle ou du scotch. 

Il est également possible de tester le code du jeu sans la structure pendant l'impression des pièces par exemple. 

===étape 5===

Assemblage de la structure finale, fixation des composants et compte rendu du projet sur le wiki

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:07:02Z

Bazz : /* étape 3 : Codage du jeu */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino.

===étape 4===

Dessin des pièces sur Catia et Mise en plan pour découpeuse 3D. et tests du jeu sans la structure en parallèle

===étape 5===

Assemblage de la structure finale, fixation des composants et compte rendu du projet sur le wiki

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T11:06:38Z

Bazz : /* Mettre du code Arduino */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

// Déclaration du numéro de broche pour les LED
#define PIN 9

// Inclusion de la bibliothèque FastLED pour la gestion des LED
#include <FastLED.h>

// Définition du nombre de bandes LED et du nombre de LED par bande
#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256

// Déclaration d'un tableau à deux dimensions pour stocker les couleurs des LED
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

// Définition de la position actuelle pour afficher le motif
int position;

// Définition des couleurs disponibles (0xRRGGBB)
int color[3] {0x000000, 0x000020, 0x200000};

// Définition d'un motif sous forme de tableau à deux dimensions
int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
// ... (ajoutez les autres lignes de votre motif ici)
};

// Pour la duplication des bandes, toutes les étapes spéciales se produisent uniquement dans la configuration.
// Nous ajoutons simplement les bandes de LED plusieurs fois, une fois pour chaque bande.
void setup() {
// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 3
// FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// Indique à FastLED qu'il y a 60 LEDs NEOPIXEL sur la broche 4
// FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);
}

// Fonction pour afficher le motif sur les LEDs
void affiche() {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
// Logique pour inverser la direction des LEDs sur les lignes impaires
if (x % 2 == 1) {
position = x * 16 + y;
} else {
position = x * 16 + 15 - y;
}
// Attribution de la couleur de la LED en fonction du motif
leds[0][position] = color[test[x][y]];
}
}
// Affichage des LEDs mises à jour
FastLED.show();
}

// Boucle principale du programme
void loop() {
// Appel de la fonction d'affichage du motif
affiche();
// Pause pour ralentir le défilement des motifs
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino

===étape 4===

Dessin des pièces sur Catia et Mise en plan pour découpeuse 3D. et tests du jeu sans la structure en parallèle

===étape 5===

Assemblage de la structure finale, fixation des composants et compte rendu du projet sur le wiki

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T09:55:57Z

Bazz : /* Mettre du code Arduino */

Titre de la fiche expérience :
==description (résumé)==
éventuelle photo de l'équipe

[[Fichier:Imagewiki bazz.jpg|100px]]

==Introduction==
L'objectif de ce projet est de réaliser le jeu "Space Invader" sur une borne d'arcade, à partir d'une carte Arduino et de leds

==outil et matériel==

Carte ESP800266modÀ 

64x leds 

Structure de la borne en bois, usinée avec la découpeuse laser. 

Ordinateur avec un logiciel Arduino. 

Fer à souder et câbles pour l'assemblage de la matrice de led 8x8. 

Potentiomètre ou joystick pour les commandes du jeu. 

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
#define PIN 9
#include <Arduino_GFX_Library.h>

/// @file ArrayOfLedArrays.ino
/// @brief Set up three LED strips, all running from an array of arrays
/// @example ArrayOfLedArrays.ino

// ArrayOfLedArrays - see https://github.com/FastLED/FastLED/wiki/Multiple-Controller-Examples for more info on
// using multiple controllers. In this example, we're going to set up three NEOPIXEL strips on three
// different pins, each strip getting its own CRGB array to be played with, only this time they're going
// to be all parts of an array of arrays.

#include <FastLED.h>

#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 256
CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP];

int position;
int color[3] {0x000000,0x000020,0x200000};

int test[16][16] { \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 2, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 2, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} \
};

// For mirroring strips, all the "special" stuff happens just in setup. We
// just addLeds multiple times, once for each strip
void setup() {
// tell FastLED there's 60 NEOPIXEL leds on pin 2
FastLED.addLeds<NEOPIXEL, 2>(leds[0], NUM_LEDS_PER_STRIP);

// tell FastLED there's 60 NEOPIXEL leds on pin 3
FastLED.addLeds<NEOPIXEL, 3>(leds[1], NUM_LEDS_PER_STRIP);

// tell FastLED there's 60 NEOPIXEL leds on pin 4
FastLED.addLeds<NEOPIXEL, 4>(leds[2], NUM_LEDS_PER_STRIP);

}

void affiche() {
for(int x = 0; x < 16; x++) {
for(int y = 0; y < 16;y++){
if (x%2 == 1){
position = x*16+y;
}
else{
position = x*16+15-y;
}
leds[0][position] = color[test[x][y]];

}
}
FastLED.show();
}

void loop() {
affiche();
delay(100);
}

</syntaxhighlight>

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

# Élément de la liste numérotée
===étape 1===

Il est préférable de commencer par construire une maquette carton de la structure de la borne d'arcade, afin de se faire une premières idée des dimensions, en prenant en compte la taille de votre écran de led.
dessin, découpage au cutter, et assemblage au pistolet à colle.

[[Fichier:Maquette bazz.jpg|200px]]

===étape 2 : étude du câblage et réalisation du support de l'écran===

Il faudra ensuite étudier la documentation technique et le fonctionnement du câblage. Vous pouvez les retrouver sur cette page, avec un petit tuto vidéo. 

https://www.hackster.io/mircemk/space-invaders-game-on-8x8-homemade-led-matrix-4029f8 

Puis, si vous n'avez pas déjà une matrice de led 8x8, dessiner et découper le support où on fixera les led. On se servira d'une découpeuse laser pour être plus précis dans la découpe. 
[[Fichier:Schéma câblage basile.PNG|200px]]

===étape 3 : Codage du jeu===

Codage du jeu en Arduino

===étape 4===

Dessin des pièces sur Catia et Mise en plan pour découpeuse 3D. et tests du jeu sans la structure en parallèle

===étape 5===

Assemblage de la structure finale, fixation des composants et compte rendu du projet sur le wiki

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

Nous avons rencontrés des soucis lors de l'étude du câblage et de la doc car le code que nous avions récupéré pour le jeu

==Sources et documentation complémentaire==

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T09:10:09Z

Bazz : /* étape 2 : étude du câblage et réalisation du support de l'écran */

Fichier:Schéma câblage basile.PNG

2024-01-25T09:08:39Z

Bazz :

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T09:06:52Z

Bazz : /* étape 2 */

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T09:01:25Z

Bazz : /* étape 3 */

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T09:00:52Z

Bazz : /* étape 2 */

ENIB 2024 : Les zinzins envahisseurs

2024-01-25T08:56:03Z

Bazz : /* étape 1 */

ENIB 2024 : Les zinzins envahisseurs

2024-01-24T15:52:25Z

Bazz : /* étape 1 */

Fichier:Maquette bazz.jpg

2024-01-24T15:51:13Z

Bazz : maquette de la borne d'arcade groupe de Basile

maquette de la borne d'arcade groupe de Basile

ENIB 2024 : Les zinzins envahisseurs

2024-01-24T15:48:07Z

Bazz : /* étape 1 */