SE3 PSE Binome2023-4

Introduction

Le projet que nous présentons ici vise à concevoir et réaliser une manette de jeu personnalisée, intégrant des composants électroniques simples et des techniques de programmation avancées. À travers ce projet, nous avons cherché à combiner l'apprentissage de la conception de circuits imprimés (PCB) avec le logiciel KiCad, la soudure des composants électroniques, ainsi que la programmation d'un microcontrôleur AVR pour faire fonctionner la manette.

Notre objectif principal était de créer une manette dotée de quatre boutons poussoirs et de quatre LED, toutes intégrées sur une carte électronique. Nous avons choisi KiCad pour sa flexibilité et ses outils puissants de conception de schémas et de routage de PCB. La programmation du microcontrôleur a été réalisée en utilisant des outils comme LUFA et LIBUSB, permettant ainsi la communication USB entre la manette et un ordinateur.

Conception Kicad

Premièrement, nous devons modéliser le schéma de notre carte PCB, pour cela nous avons fait le choix du logiciel dit Kicad pour sa simplicité et son efficacité mise en avant par les enseignants.

Nous nous somme inspiré de différents schéma déjà existant que les enseignants nous on fournit ainsi que nos propres recherches pour modéliser notre cartes et y intégré tout les éléments spécifique à notre projets, voici donc le schéma final de notre carte:

Voici notre schéma

Une fois la schématique de notre manette validée par les enseignants, nous passons au routage de notre système, le routage consiste à préparer la fabrication de notre carte et lui donner l'allure souhaité en agençant minutieusement chaque composant et chaque fil de cuivre les reliant les un aux autres, voici notre routage complet et validé par nos enseignants:

Voici notre routage

Soudure

Une fois la carte sortie de fabrication et reçu en salle, l'heure est à la soudure de nos composants sur notre PCB, pour être rigoureux chaque composant, après avoir été soudé, doit être testé avec un multimètre pour vérifier la continuité à travers notre circuit.

Voici une photo de la carte soudée :

Carte entièrement soudée

Programmation

Programmateur AVR

Nous pouvons dès à présent attaquer la partie programmation, nous allons tester nos LED en codant un simple code permettant de les faire clignoter, nous allons utiliser un programmateur AVR (à défaut d'avoir bootloader la carte pour l'instant) pour programmer pour µC et exécuter le code

voici le code en question:

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

#define F_CPU 8000000UL // Définition de la fréquence du microcontrôleur (8 MHz)

int main(void) {
    CLKSEL0 = 0b00010101;   // sélection de l'horloge externe
    CLKSEL1 = 0b00001111;   // minimum de 8Mhz
    CLKPR = 0b10000000;     // modification du diviseur d'horloge (CLKPCE=1)
    CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)

    // Configuration des broches PD1 et PD2 comme sorties
    DDRD |= (1 << PD1) | (1 << PD2);

    while (1) {
        // Allumer la LED connectée à PD1
        PORTD |= (1 << PD1);
        _delay_ms(500); // Attendre 500 millisecondes

        // Éteindre la LED connectée à PD1 et allumer la LED connectée à PD2
        PORTD &= ~(1 << PD1);
        PORTD |= (1 << PD2);
        _delay_ms(500); // Attendre 500 millisecondes

        // Éteindre la LED connectée à PD2
        PORTD &= ~(1 << PD2);
        _delay_ms(500); // Attendre 500 millisecondes
    }

    return 0;
}

ainsi que le Makefile fournit par notre enseignant:

export CC = avr-gcc

export MCU = atmega8u2
export TARGET_ARCH = -mmcu=$(MCU)

export CFLAGS =  -Wall -I. -DF_CPU=16000000 -Os #-g
export LDFLAGS = -g $(TARGET_ARCH) -lm -Wl,--gc-sections #	-Os


TARGET = AVR_prog
TERM = /dev/ttyUSB0
#TERM = /dev/ttyACM0
CPPFLAGS = -mmcu=$(MCU)
PGMER = -c stk500v1 -b 57600 -P $(TERM)
PGMERISP = -c stk500v1 -b 115200 -P $(TERM)
ARVDUDECONF= -C /usr/local/arduino/arduino-0021/hardware/tools/avrdude.conf
export DUDE = /usr/bin/avrdude -F -v -p $(MCU) $(AVRDUDECONF)

C_SRC = $(wildcard *.c)
OBJS = $(C_SRC:.c=.o)


all: $(TARGET).hex

ass:$(C_SRC)
	$(CC) -S $(CPPFLAGS) $(CFLAGS) $< -o $@

clean:
	rm -f *.o

%.o:%.c
	$(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@


$(TARGET).elf: $(OBJS)
	$(CC) $(LDFLAGS) -o $@ $(OBJS)

$(TARGET).hex: $(TARGET).elf
	avr-objcopy -j .text -j .data -O ihex $(TARGET).elf $(TARGET).hex

upload: $(TARGET).hex
	stty -F $(TERM) hupcl # reset
	$(DUDE) $(PGMER) -U flash:w:$(TARGET).hex
#	$(DUDE) $(PGMERISP) -U flash:w:$(TARGET).hex

size: $(TARGET).elf
	avr-size --format=avr --mcu=$(MCU) $(TARGET).elf

Programmation µC

Programmation via ISP

Lors de l'exécution de la commande "lsusb" dans le terminal, notre µC n'est pas détecté par l'ordinateur, nous devons donc bootloader notre carte en la connectant via l'ISP à un Arduino que l'enseignant possède et exécuter cette commande dans le terminal:

avrdude -c stk500v1 -p atmega32u4 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xFF:m -U efuse:w:0xF7:m

Après avoir bootloader notre µC via l'ISP, notre manette est reconnaissable par l'ordinateur et prête à l'emploi et l'AtMega passera en mode DFU lors de la pression des boutons HWB et Reset simultanément, nous avons utiliser la commande "lsusb" dans le terminal pour voir si l'ordinateur détectait notre manette lorsque nous la branchons via USB:

Carte detecté par l'ordinateur

Test des LED

Nous pouvons d'ores et déjà tester notre carte sans passer par un programmateur AVR, en compilant et flashant directement le code sur notre manette, il s'exécutera automatiquement lors de la mise en tension de notre carte, voici le code:

#include<avr/io.h> #include<stdio.h>
#include<util/delay.h>
int main (void)
MCUCR |= (1<<JTD) ;
MCUCR |= (1<<JTD) ;
DDRF = 0XFF;
while (1)
｛
PORTF = 0x20;
delay_ms (1000) ;
PORTF = 0x10;
_delay_ms (1000) ;
머
return 0;
｝

Nous utilisons le Makefile suivant:

export CC = avr-gcc

export MCU = atmega32u4
export TARGET_ARCH = -mmcu=$(MCU)

export CFLAGS =  -Wall -I. -DF_CPU=16000000 -Os #-g
export LDFLAGS = -g $(TARGET_ARCH) -lm -Wl,--gc-sections #	-Os


TARGET = AVR_prog
TERM = /dev/ttyUSB0
#TERM = /dev/ttyACM0
CPPFLAGS = -mmcu=$(MCU)
PGMER = -c stk500v1 -b 57600 -P $(TERM)
PGMERISP = -c stk500v1 -b 115200 -P $(TERM)
ARVDUDECONF= -C /usr/local/arduino/arduino-0021/hardware/tools/avrdude.conf
export DUDE = /usr/bin/avrdude -F -v -p $(MCU) $(AVRDUDECONF)

C_SRC = $(wildcard *.c)
OBJS = $(C_SRC:.c=.o)


all: $(TARGET).hex

ass:$(C_SRC)
	$(CC) -S $(CPPFLAGS) $(CFLAGS) $< -o $@

clean:
	rm -f *.o *.elf *.hex

%.o:%.c
	$(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@


$(TARGET).elf: $(OBJS)
	$(CC) $(LDFLAGS) -o $@ $(OBJS)

$(TARGET).hex: $(TARGET).elf
	avr-objcopy -j .text -j .data -O ihex $(TARGET).elf $(TARGET).hex

upload: $(TARGET).hex
	stty -F $(TERM) hupcl # reset
	$(DUDE) $(PGMER) -U flash:w:$(TARGET).hex

size: $(TARGET).elf
	avr-size --format=avr --mcu=$(MCU) $(TARGET).elf

# Ajout des cibles spécifiques pour effacer, démarrer et flasher
start:
	$(DUDE) $(PGMER) -U flash:w:$(TARGET).hex

erase:
	$(DUDE) $(PGMER) -e

flash: erase $(TARGET).hex
	$(DUDE) $(PGMER) -U flash:w:$(TARGET).hex

.PHONY: clean start erase flash upload size

GIT

projet git : https://archives.plil.fr/yyahiani/Yassine_Bilal_PSE.git