I2L 2025 Groupe9

Proposition de système (étudiants)

L'idée de notre projet est de reproduire le jeu simon says (https://www.youtube.com/watch?v=vLi1qnRmpe4),

Le jeu se passe avec 4 couleurs: Quand on démarre le jeu (quand on appuie sur n'importe quel bouton), une séquence de couleurs générée automatiquent à reproduire apparaît sur les LEDs (chaque LED est associé à une couleur), il faut reproduire la séquence en appuyant sur les boutons associés aux couleurs.

La fonctionnalité USB du projet serait un logiciel dédié à la carte, il faut brancher la carte en USB sur l'ordinateur et le logiciel reconnaîtra la carte.

Il y aurait une interface une fois la carte reconnue, qui permettrai de créer manuellement une séquence de couleurs à reproduire, et l'envoyer sur la carte.

Contre-proposition (intervenant)

OK pour la proposition, elle décrit bien un mode autonome et un mode connecté en USB. Ajoutez des sons (au pire des notes) pour renforcer les LED.

Carte

Schéma initial (étudiants)

• schéma (projet KiCAD) : Fichier:I2L-2025-Carte-G9.zip

Carte routée (intervenant)

Vous pouvez utiliser la carte avec batterie. Ainsi le mode autonome pourrait se faire sans alimentation autre que la batterie LiPo.

Les LED soudées sur la carte sont des LED rouges. Il est envisageable d'en remplacer par des LED bleue, verte et jaune.

A la date du 10 octobre 2025, 3 LED rouges ont été remplacées par des LED bleue, jaune et verte.

Carte réalisée (intervenant)

Photo de la carte

La carte est entiérement soudée.

Travaux (étudiants)

Les LED fonctionnent

Les Boutons fonctionnent

Le HP fonctionne

Chaque bouton actionne une Led et un son

On travaille sur la partie USB avec LUFA

Bouton pour lancer la séquence aléatoire

Avec le bouton (voir ci-dessous) une séquence aléatoire de 4 couleurs est lancée : correspond au mode autonome

- La séquence est jouée (LED + Son)

- Les 4 autres boutons sont donc associés à une couleur et un son.

- Si le joueur arrive à reproduire la séquence, alors une autre séquence est automatiquement relancée. Cette nouvelle séquence aura alors une couleur supplémentaire.

- Si le joueur échoue alors la LED Rouge s'allume et un son est joué pour signaler l'échec.

Simon GUI

Nous avons implémenté LUFA sur notre carte pour la fonctionnalité USB.

Nous avons également une interface python.

LUFA et notre interface permet de faire communiquer le PC et la carte.

Il s'agit donc du mode 2 joueurs :

- Le premier joueur peut choisir une séquence de couleurs et peut l'envoyer au jeu (la carte)

- Il peut également voir l'état du jeu :

- "En attente" = Au lancement du jeu donc pas encore de séquence à jouer

- "Séquence envoyé, en attente du joueur... " = Le premier joueur a envoyé la séquence et attend de voir si le second joueur réussi ou échoue

- "Séquence échouée ! " = Le second joueur n'a pas réussi à reproduire la séquence

- "Séquence réussie ! " = Le second joueur a réussi à reproduire la séquence

Extraits significatifs de code (étudiants)

Pour désactiver le JTAG (oui il faut le mettre 2 fois)

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD);

Fonction USB_Manage_Out pour envoyer une séquence à partir de l'interface vers la carte :

void USB_Manage_Out(void)
{
    if (usb_state != 0)
        return;

    Endpoint_SelectEndpoint(OUT_EPADDR);
  
	if (!Endpoint_IsOUTReceived())
        return;

    if (!Endpoint_IsReadWriteAllowed()) {
        Endpoint_ClearOUT();
        return;
    }

    uint8_t buffer[OUT_EPSIZE];
    Endpoint_Read_Stream_LE(&buffer, sizeof(buffer), NULL);
    Endpoint_ClearOUT();

    if (buffer[0] < 0 || buffer[0] > OUT_EPSIZE - 1)
        return;
    
    int sequence_length = buffer[0];
    LedId sequence[15];

    for (int i = 0; i < sequence_length; i++)
        sequence[i] = buffer[i + 1];

    game_set_sequence(sequence, sequence_length);
}

Fonction game_set_sequence appelée dans la fonction USB_Manage_Out, elle permet de :

- set la séquence de l'interface python

- lancer la partie (usb_state = 1)

- désactiver le bouton de lancement de partie en mode autonome (launched = 1)

void game_set_sequence(const LedId *seq, uint8_t length)
{
    if (length > MAX_SEQUENCE_LENGTH)
        length = MAX_SEQUENCE_LENGTH;

    for (uint8_t i = 0; i < length; i++)
        sequence[i] = seq[i];

    current_length = length;
    launched = 1;
    usb_state = 1;
}

Fonction USB_Manage_In : permet d'envoyer l'état de la partie à notre interface python.

void USB_Manage_In(void)
{
    if (usb_state <= 1)
        return;

    Endpoint_SelectEndpoint(IN_EPADDR);

    if (!Endpoint_IsINReady())
        return;
    
    Endpoint_Write_8(usb_state);
    Endpoint_ClearIN();

    usb_state = 0;
}

Fonction loop_game :

void loop_game(void) {
    if (launched == 0) {
        if (!button_pressed(BUTTON_LAUNCH)) {
            return;
        }

        launched = 1;
        current_length = 4;
        generate_sequence();
        _delay_ms(500);
    }

    play_sequence(sequence, current_length);
    int success = handle_player_input();
    
    _delay_ms(500);

    if (usb_state == 1) {
        usb_state = success ? 2 : 3;
        launched = 0;
        return;
    }

    if (!success || current_length >= MAX_SEQUENCE_LENGTH) {
        launched = 0;
        return;
    }

    current_length++;
    generate_sequence();
}

Code permettant de jouer un son :

void note_init_all() {
    DDRD = 0xFF;
}

void make_note_delay(int note)
{
    switch (note)
    {
    case 987:
        _delay_us(1000000 / 987 / 2);
        break;
    case 1047:
        _delay_us(1000000 / 1047 / 2);
        break;
    case 1175:
        _delay_us(1000000 / 1175 / 2);
        break;
    case 1319:
        _delay_us(1000000 / 1319 / 2);
        break;
    case 1397:
        _delay_us(1000000 / 1397 / 2);
        break;
    case 1568:
        _delay_us(1000000 / 1568 / 2);
        break;
    case 825:
        _delay_us(1000000 / 825 / 2);
        break;
    case 1056:
        _delay_us(1000000 / 1056 / 2);
        break;
    }
}

void play_note(int note, int periode)
{
    for (int i = 0; i < periode; i++)
    {
        PORTD = 255;
        make_note_delay(note);
        PORTD = 0;
        make_note_delay(note);
    }
}

Rendus (étudiants)

Projet KiCAD : Fichier:I2L-2025-Carte-G9-final.zip

Programmes :

• microcontrôleur : Fichier:I2L-2025-Programmes-uC-G9.zip
• ordinateur Fichier:I2L-2025-Programmes-PC-G9.zip