« I2L 2023 Groupe1 » : différence entre les versions

De wiki-se.plil.fr
Aller à la navigation Aller à la recherche
 
(40 versions intermédiaires par 3 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
= Proposition de système =
= Proposition de système =
Créer un jeu pour 4 joueurs avec 4 buzzers (bouton). Le buzzer émet 3 sons distincts, les joueurs doivent appuyer le plus rapidement possible sur le buzzer qui leur est attribué lorsque que le bon son est joué. Les sons émis par le haut-parleur sont configurables via une application lorsque l’ordinateur est connecté à la carte via le port USB. Une led RGB se trouve au milieu et affiche la couleur du vainqueur.
Créer un jeu pour 4 joueurs avec 4 buzzers (boutons). Le buzzer émet 3 sons distincts, les joueurs doivent appuyer le plus rapidement possible sur le buzzer qui leur est attribué lorsque que le bon son est joué. Les sons émis par le haut-parleur sont configurables via une application lorsque l’ordinateur est connecté à la carte via le port USB. Une led RGB se trouve au milieu et affiche la couleur du vainqueur.


Une interface de contrôle via USB sera mise en place.
Une interface de contrôle via USB sera mise en place.


= Contre-proposition =
= Contre-proposition =
Le périphérique USB doit être de type spécifique (classe 0) et utiliser un point d'accès de volume, vous pouvez vous appuyer sur cet exemple LUFA de base : [[Média:LUFA_Minimal.zip]].
Pour télécharger le son vers la carte, vous écrirez une application avec la bibliothèque <code>libusb</code>.


= Proposition définitive =
= Proposition définitive =
Ligne 12 : Ligne 16 :
= Carte =
= Carte =


[[Fichier:I2L-2023-Carte3D-G2.png|thumb|left|400px]]
[[Fichier:I2L-2023-Carte3D-G1.png|thumb|left|400px]]
 
[[Fichier:I2L-2023-CarteSchema-G1.pdf|thumb|right|400px]]
 
<p style="clear: both;" />
 
Seconde version pour corriger le DAC R-2R et pour mieux contrôler le volume.
 
[[Fichier:I2L-2023-Carte3D-G1-v2.png|thumb|left|400px]]
 
[[Fichier:I2L-2023-CarteSchema-G1-v2.pdf|thumb|right|400px]]
 
<p style="clear: both;" />
 
= Montage =
== Test d'implémentation du buzzer ==
 
== Premier montage ==
 
[[Fichier:2023_I2L_G1_Buzzer3.jpg|gauche|582x582px]]
[[Fichier:2023_I2L_G1_Montage_buzzer_carte.jpg|droite|400x400px]]
 
On a donc démonté un premier buzzer afin de voir ce qu'il s'y cachait.
 
A l'aide d'un testeur on a pu trouvé où était le signal, le plus et la masse.
 
 
On a ensuite connecté la carte au buzzer. On a réussi à alimenter le buzzer via l'alimentation de la carte, ce qui nous permet d'avoir le système de son du buzzer, qu'on pourrait utilisé par la suite.
 
On a aussi connecté un speaker afin d'émettre le son qui va par la suite permettre de déclencher le jeu.
 
A la suite de cela on a testé les différents élément avec la carte. (speaker / buzzers)
 
<p style="clear: both;" />
 
== Câblage des 4 boutons ==
[[Fichier:2023_I2L_G1_Cablage_Boutons.jpg|thumb|left|400x400px]]
[[Fichier:2023_I2L_G1_Cablage_Boutons_Bis.jpg|thumb|right|400x400px]]
 
Les 4 boutons ont été démontés pour souder un câble 4 conducteurs (type téléphonie) sur les points vus plus haut. Les quatre câbles ont été réunis et des connecteurs femelles ont été soudés aux extrémités pour la connexion à la carte. A noter que des LED ont été ajoutées aux boutons buzzer, la carte de ces boutons disposant d'une empreinte pour cela (mais sans le composant). L'effet n'est pas génial ce qui peut expliquer que l'empreinte n'était pas utilisée.
 
<p style="clear: both;" />


[[Fichier:I2L-2023-CarteSchema-G2.pdf|thumb|left|400px]]
[[Fichier:2023_I2L_G1_Cablage_Boutons_Connecteurs.jpg|thumb|center|400x400px]]


= Code =
= Code =
== Première approche ==
=== Test des LED ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
// Boutons sur le Port C
#define BUTTON_1_BIT 2
#define BUTTON_2_BIT 4
// Leds sur le Port D
#define LED_BLUE_BIT 0
#define LED_GREEN_BIT 1
#define LED_RED_BIT 2
#define BUTTON_BUZZER_BIT 6
int main(void)
{
    DDRD &= ~(1 << BUTTON_BUZZER_BIT);                                      // Entrée pour le buzzer
    DDRD |= (1 << LED_BLUE_BIT) | (1 << LED_GREEN_BIT) | (1 << LED_RED_BIT); // Sortie pour les LEDS
    DDRC &= ~(1 << BUTTON_1_BIT) & ~(1 << BUTTON_2_BIT);                    // Entrée pour les boutons
    PORTC |= (1 << BUTTON_1_BIT) | (1 << BUTTON_2_BIT);                      // Activation des résistances de pull-up
    PORTD |= (1 << BUTTON_BUZZER_BIT);                                      // Activation des résistances de pull-up
    while (1)
    {
        if (!(PINC & (1 << BUTTON_1_BIT)))
        {
            PORTD &= ~(1 << LED_BLUE_BIT);
        }
        else {
            PORTD |= (1 << LED_BLUE_BIT);
        }
        if (!(PINC & (1 << BUTTON_2_BIT)))
        {
            PORTD &= ~(1 << LED_GREEN_BIT);
        }
        else {
            PORTD |= (1 << LED_GREEN_BIT);
        }
        if (!(PIND & (1 << BUTTON_BUZZER_BIT)))
        {
            PORTD &= ~(1 << LED_RED_BIT);
        }
        else {
            PORTD |= (1 << LED_RED_BIT);
        }
    }
}
void loopLed()
{
    PORTD |= (1 << LED_BLUE_BIT);
    PORTD &= ~(1 << LED_GREEN_BIT);
    PORTD &= ~(1 << LED_RED_BIT);
    _delay_ms(100);
    PORTD &= ~(1 << LED_BLUE_BIT);
    PORTD |= (1 << LED_GREEN_BIT);
    PORTD &= ~(1 << LED_RED_BIT);
    _delay_ms(100);
    PORTD &= ~(1 << LED_BLUE_BIT);
    PORTD &= ~(1 << LED_GREEN_BIT);
    PORTD |= (1 << LED_RED_BIT);
    _delay_ms(100);
}
</syntaxhighlight>


== Conception ==
== Conception ==
Algorithme du déroulement du jeu : <syntaxhighlight lang="adl" line="1">
lancement
boucle
    boucle
        lecture sur le IN de la carte -> attente de l'appui sur un buzzer
    fin boucle
    lance musique pendant x secondes
    le joueur appuie sur son buzzer -> lecture sur le IN de la carte
    afficher le dernier joueur qui a appuyé -> sera ignoré pour la suite
fin boucle
message avec joueur vainqueur
</syntaxhighlight>


== Réalisation ==
== Réalisation ==


= Démonstrations =
= Démonstrations =
[https://www.youtube.com/watch?v=XfrJ4bamzGg Démonstration]


= Rendus =
= Rendus =

Version actuelle datée du 21 décembre 2023 à 14:42

Proposition de système

Créer un jeu pour 4 joueurs avec 4 buzzers (boutons). Le buzzer émet 3 sons distincts, les joueurs doivent appuyer le plus rapidement possible sur le buzzer qui leur est attribué lorsque que le bon son est joué. Les sons émis par le haut-parleur sont configurables via une application lorsque l’ordinateur est connecté à la carte via le port USB. Une led RGB se trouve au milieu et affiche la couleur du vainqueur.

Une interface de contrôle via USB sera mise en place.

Contre-proposition

Le périphérique USB doit être de type spécifique (classe 0) et utiliser un point d'accès de volume, vous pouvez vous appuyer sur cet exemple LUFA de base : Média:LUFA_Minimal.zip.

Pour télécharger le son vers la carte, vous écrirez une application avec la bibliothèque libusb.

Proposition définitive

Répartition du travail

Carte

I2L-2023-Carte3D-G1.png
I2L-2023-CarteSchema-G1.pdf

Seconde version pour corriger le DAC R-2R et pour mieux contrôler le volume.

I2L-2023-Carte3D-G1-v2.png
I2L-2023-CarteSchema-G1-v2.pdf

Montage

Test d'implémentation du buzzer

Premier montage

2023 I2L G1 Buzzer3.jpg
2023 I2L G1 Montage buzzer carte.jpg

On a donc démonté un premier buzzer afin de voir ce qu'il s'y cachait.

A l'aide d'un testeur on a pu trouvé où était le signal, le plus et la masse.


On a ensuite connecté la carte au buzzer. On a réussi à alimenter le buzzer via l'alimentation de la carte, ce qui nous permet d'avoir le système de son du buzzer, qu'on pourrait utilisé par la suite.

On a aussi connecté un speaker afin d'émettre le son qui va par la suite permettre de déclencher le jeu.

A la suite de cela on a testé les différents élément avec la carte. (speaker / buzzers)

Câblage des 4 boutons

2023 I2L G1 Cablage Boutons.jpg
2023 I2L G1 Cablage Boutons Bis.jpg

Les 4 boutons ont été démontés pour souder un câble 4 conducteurs (type téléphonie) sur les points vus plus haut. Les quatre câbles ont été réunis et des connecteurs femelles ont été soudés aux extrémités pour la connexion à la carte. A noter que des LED ont été ajoutées aux boutons buzzer, la carte de ces boutons disposant d'une empreinte pour cela (mais sans le composant). L'effet n'est pas génial ce qui peut expliquer que l'empreinte n'était pas utilisée.

2023 I2L G1 Cablage Boutons Connecteurs.jpg

Code

Première approche

Test des LED

#include <avr/io.h>
#include <util/delay.h>

// Boutons sur le Port C
#define BUTTON_1_BIT 2
#define BUTTON_2_BIT 4

// Leds sur le Port D

#define LED_BLUE_BIT 0
#define LED_GREEN_BIT 1
#define LED_RED_BIT 2

#define BUTTON_BUZZER_BIT 6

int main(void)
{
    DDRD &= ~(1 << BUTTON_BUZZER_BIT);                                       // Entrée pour le buzzer
    DDRD |= (1 << LED_BLUE_BIT) | (1 << LED_GREEN_BIT) | (1 << LED_RED_BIT); // Sortie pour les LEDS
    DDRC &= ~(1 << BUTTON_1_BIT) & ~(1 << BUTTON_2_BIT);                     // Entrée pour les boutons
    PORTC |= (1 << BUTTON_1_BIT) | (1 << BUTTON_2_BIT);                      // Activation des résistances de pull-up
    PORTD |= (1 << BUTTON_BUZZER_BIT);                                       // Activation des résistances de pull-up

    while (1)
    {
        if (!(PINC & (1 << BUTTON_1_BIT)))
        {
            PORTD &= ~(1 << LED_BLUE_BIT);
        }
        else {
            PORTD |= (1 << LED_BLUE_BIT);
        }

        if (!(PINC & (1 << BUTTON_2_BIT)))
        {
            PORTD &= ~(1 << LED_GREEN_BIT);
        }
        else {
            PORTD |= (1 << LED_GREEN_BIT);
        }

        if (!(PIND & (1 << BUTTON_BUZZER_BIT)))
        {
            PORTD &= ~(1 << LED_RED_BIT);
        }
        else {
            PORTD |= (1 << LED_RED_BIT);
        }
    }
}

void loopLed()
{
    PORTD |= (1 << LED_BLUE_BIT);
    PORTD &= ~(1 << LED_GREEN_BIT);
    PORTD &= ~(1 << LED_RED_BIT);

    _delay_ms(100);

    PORTD &= ~(1 << LED_BLUE_BIT);
    PORTD |= (1 << LED_GREEN_BIT);
    PORTD &= ~(1 << LED_RED_BIT);
    _delay_ms(100);

    PORTD &= ~(1 << LED_BLUE_BIT);
    PORTD &= ~(1 << LED_GREEN_BIT);
    PORTD |= (1 << LED_RED_BIT);
    _delay_ms(100);
}

Conception

Algorithme du déroulement du jeu :

lancement

boucle

    boucle

        lecture sur le IN de la carte -> attente de l'appui sur un buzzer

    fin boucle

    lance musique pendant x secondes

    le joueur appuie sur son buzzer -> lecture sur le IN de la carte

    afficher le dernier joueur qui a appuyé -> sera ignoré pour la suite

fin boucle
message avec joueur vainqueur

Réalisation

Démonstrations

Démonstration

Rendus

Projet KiCAD : Fichier:I2L-2023-Carte-G1.zip

Programmes : Fichier:I2L-2022-Programmes-G1.zip