SE3 PSE Binome2023-7
Hardware
Projet KiCad
Nous avons fait le choix de mettre 8 boutons pour multiplier les possibilités d'utilisations et 4 LEDs, nous pourrons leur trouver diverses utilités plus tard dans le projet.
Fichier compressé du projet KiCad : Fichier:SE3-pad 2.zip
PCB et Soudure des composants
Reçu carte vierge
Carte après soudure des composants
Différents problèmes rencontrés
Lors de la soudure du composants nous avons rencontrés principalement deux problèmes (si on ne compte pas la fois où nous avons soudé l'ATMega dans le mauvais sens). Le premier étant qu'une patte permettant de connecter celle du microP à la carte est morte, Mr.Redon a alors travaillé minutieusement afin de soudé un fil entre la résistance et la patte du microP. Le deuxième est que nous avons de relié la LED D1 au VCC (voir photo du routage), nous avons alors soudé un fil entre eux. (Pas minutieusement)
De plus, au début de notre programmation de la manette, nous remarquions que lorsqu'on effectuait la procédure pour reset la carte (HWB enfoncé et pression sur RESET) cela avait un comportement étrange. En effet, l'ATMega surchauffait beaucoup. Nous avons eu du mal à trouver la cause, mais c'est du à une broche du MircoP censé être connecté sur la masse mais le plan de masse semble coupé pour une raison que nous ignorons.
Nous avons alors relié via un fil le plan non relié à la masse.
Software
Allumage de LEDS sur Programmateur AVR
Avant de programmer directement sur la manette, nous avons allumé des LED sur un programmateur AVR.
#include<avr/io.h>
#include<stdio.h>
#include<stdlib.h>
void config(unsigned int bit, unsigned char port, unsigned int io){
if (io == 1){
if (port == 'B') DDRB |= (io<<bit);
if (port == 'C') DDRC |= (io<<bit);
if (port == 'D') DDRD |= (io<<bit);
}
else if (io == 0){
if (port == 'B') DDRB &= ~(1<<bit);
if (port == 'C') DDRC &= ~(1<<bit);
if (port == 'D') DDRD &= ~(1<<bit);
}
}
void put_bit(unsigned int bit, unsigned char port, unsigned int io){
if (io == 1){
if (port == 'B') PORTB |= (io<<bit);
if (port == 'C') PORTC |= (io<<bit);
if (port == 'D') PORTD |= (io<<bit);
}
else if (io == 0){
if (port == 'B') PORTB &= ~(1<<bit);
if (port == 'C') PORTC &= ~(1<<bit);
if (port == 'D') PORTD &= ~(1<<bit);
}
}
int get_bit(unsigned int bit, unsigned char port){
if (port == 'B') return 1 & (PINB>>bit);
if (port == 'C') return 1 & (PINC>>bit);
if (port == 'D') return 1 & (PIND>>bit);
return -1;
}
int main(void){
//Setup
config(2,'C',1);
config(4,'C',1);
put_bit(2,'C',1);
put_bit(4,'C',1);
while (1);
return 0;
}
Programmation de la manette
Programmation ISP
Premièrement, notre manette n'est pas reconnue comme un périphérique USB sur un ordinateur. Pour cela, nous la programmons par ISP afin de pouvoir installer le Bootloader USB et continuer. Nous devons alors connecter la manette par ISB avec un Arduino et rentrer les commandes suivantes dans le terminal :
avrdude -c stk500v1 -p atmega32u4 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xFF:m -U efuse:w:0xF7:m
L'ATMega sait alors qu'il faut passer en mode DFU quant le bouton d'HWB est pressé.
avrdude -c stk500v1 -p atmega32u4 -P /dev/ttyACM0 -b 19200 -U flash:w:ATMega32U4-usbdevice_dfu-1_0_0.hex
Cette commande doit être utiliser une fois avoir télécharger le Bootloader au lien suivant : https://www.microchip.com/en-us/product/ATmega32U4#document-table
Ainsi, notre manette est détectée.
Premier test
Essayons alors d'allumer nos deux LEDs présentes sur les ports PF5 et PF4. Il faut désactiver le JTAG afin que les pins soit utilisables comme une entrée/sortie numériques, pour cela on doit utiliser deux fois de suites la commande suivantes :
MCUCR |= (1<<JTD);
Donc, grâce au code suivant : (code entier dans le répertoire Manette/leds du git)
Ainsi les LEDs clignotent :
Second test
Une fois les boutons testés, nous essayons de faire fonctionner nos boutons. En effet, nous avons fait le choix de réaliser une matrice de boutons (Ce n'est pas pertinent pour ce projet mais cela pourra être utile dans notre futur de savoir comment faire ça, cela permet de libérer des pins du micro-controller). N'ayant pas accompagné les boutons de résistances, nous avons tout d'abord placé un '1' sur chaque colonne et ligne de la matrice. En déclarant les colonnes comme des entrées et les lignes comme des sorties. (code entier dans le répertoire Manette/boutons du git)
Ensuite, nous devons placé un '0' sur une ligne i, puis vérifier tour à tour la valeur de la j-ième colonne. Si elle est de '1' également, alors le bouton (i,j) est pressé. Exemple pour le bouton (0,0) :
LUFA et LIBUSB
LEDS
Pour commencer, nous avons adapté l'exemple donné Minimal afin de pouvoir allumé des LEDs grâce à un programme externe à la manette à l'aide de la libusb.(code entier : répertoire Manette/lufa_leds du GIT) Nous avons fais en sorte :
- D'avoir deux interfaces (une pour les LEDS et une pour les switchs plus tard)
- un ENDPoint OUT pour les leds car ce sont des sorties
- un ENDPoint IN pour les boutons car ce sont des entrées
Pour cela, nous devons les configurer dans le Descriptors.c :
Ensuite, nous n'oublions pas de donner du sens à Descriptors.c en modifiant le Descriptors.h en donnant des valeurs à ce qu'on utilise, comme le numéro des ENDPoints et des interfaces.
Enfin, nous déclarons nos LEDS comme des sorties dans le SetupHardware et créons des fonctions gérant les ENDPoints IN et OUT à l'aide du cours.
Maintenant, nous devons compiler tout ça et téléverser le fichier .hex dans la manette. Il nous faut alors créer un programme permettant de récupérer les adresses des ENDpoints afin de les manipuler. Pour cela, nous devons reconnaître chaque appareil USB connecté à l'ordinateur avec les bons ID_Vendor et ID_Product, ouvrir les interfaces puis trouver l'adresse des ENDpoints afin de pouvoir y envoyer des données où d'en collecter. En s'aidant du cours, nous avons pu allumer une led où une autre selon la donnée qu'on envoie sur un ENDPoint. Nous pouvions même choisir (théoriquement) quelle manette choisir si plusieurs étaient détectées.
Fichier:Usbprogramme.zip
JOYSTICK
Pour nous aider à configurer les directions de notre joystick, nous partons de l'exemple Joystick donné par la bibliothèque LUFA.(code entier : répertoire Manette/lufa_joystick du GIT) Premièrement, nous initialisons notre matrice de boutons dans le SetupHardware comme précédemment, en définissant nos colonnes et lignes :
Ensuite, chaque boutons va être testé, afin de définir nos quatre directions :
Enfin, notre carte est bien reconnu tel un joystick et deux boutons ainsi qu'un joystick directionnel sont exploitables.
MANETTE
Nous devons dès à présent fusionner les deux codes pour gérer le joystick et les LEDS en même temps. Ce qui donne, une fois compilé, les fichiers dans le répertoire Manette/lufa_manette du GIT. C'est simplement l'interface, le ENDPoint OUT et le code de la fonction manageOUT des programmes pour les LEDs rajouté dans ceux pour le joystick. On remarque que la manette est bien détecté par notre ordinateur avec la commande suivante
ls /dev/input/js*
Puis grâce à la commande jstest, nous nous assurons que les axes et les boutons sont bien reconnus et fonctionnelles.
jstest /dev/input/js0
Il reste plus qu'à adapter le code de notre jeu Space Invaders pour qu'il soit jouable avec notre manette.
Commençons alors à apprendre comment fonctionne la librairie SDL pour les joysticks.
Nous nous aiderons de la page web suivante : https://www.libsdl.org/release/SDL-1.2.15/docs/html/joystick.html
Ainsi, nous obtenons le programme suivant qui permet de vérifier l'état des axes et des boutons à chaque lancement de celui-ci : (code entier dans le fichier Manette/manette/usb.c)
Nous savons dès à présent exploiter la librairie SDL pour joystick.
Avant de pouvoir adapter le code de notre jeu, il ne faut pas oublier de faire de notre programme permettant d'allumer des LEDS à l'aide de la libusb, une bibliothèque utilisable dans notre code de jeu.
Pour cela, on enlève le main de notre fichier .c en ne laissant que les procédures. De plus, nous créons un fichier .h pour y mettre notre structure Device et les signatures de nos procédures. Sans oublier d'adapter notre Makefile (rajouter le -l usb-1.0 dans le LDLIBS et usb.o dans la ligne de compilation). Enfin, après avoir régler les nouveaux 'include', notre projet peut être compilé grâce à notre Makefile. (codes entiers dans le répertoire Envahisseurs/src/Usb du git)
On peut donc adapter notre code de jeu. Occupons nous de la partie joystick pour commencer. Nous ouvrons tout d'abord la première manette trouvé avant de lancer la boucle du jeu :
Puis nous rajoutons des conditions d'actions pour la manette dans les 'if' permettant de bouger et de tirer (On vérifie si une manette a bien été détecté pour que le jeu reste jouable sans manette) :
Enfin, il nous reste plus qu'à utiliser le programme transformer en bibliothèque qui envoie des données dans notre ENDPoint pour intéragir avec les LEDs.
Ainsi, notre jeu devient jouable avec la manette, que ce soit les boutons où l'allumage des LEDs !
Conclusion
Pour conclure, ce projet nous a permis de lier l'électronique à un programme informatique. En effet, nous avons appris à créer un périphérique USB reconnu comme voulu par notre machine. De plus, il était très intéressant de relier notre périphérique à un jeu que nous avons du programmé au préalable. L'intégration (même si peut être brouillonne) de notre manette dans notre code de jeu rend alors tout ce projet pertinent, avec une finalité qui donne la satisfaction de réussir.
La manette marche également sur d'autres jeux !