SE4Binome2023-11
Ordonnanceur (OS)
SOUDURE SHIELD.
Dans la première séance on a commencé à souder le Shield qui servira comme une carte-mère de prototypage pour les cartes filles qu'on va réaliser au cours de ce module. Premièrement on a fait le soudage du lecteur de la carte SD et les résistances 3.3 k Ohm, 680 Ohm et les LEDs pour tester le bon fonctionnement du Shield après.
Ensuite, on a passé à la 2ème partie de soudage : Le bouclier avec la carte Arduino. L'objectif sera de pouvoir tester régulièrement notre carte fille (Clavier "USB") en se servant de le carte mère prototype (Shield + Arduino).
Pour la séance prochaine on continue sur le soudage du Shield et on va tester son fonctionnement et la lecture de la carte de masse SD.
Test des LEDs
Dans la deuxième séance on a finalisé la soudure du SHIELD avec les différents composantes (LEDs, résistances , Lecteur carte SD, les PINs et les connecteurs HE-10).
On a testé le fonctionnement des LEDs avec un ampèremètre .
Après, on a implémenté le code suivant dans une carte Arduino pour revérifier le clignotement des LEDs (1s on / 1s off) :
#include <avr/io.h>
#include <util/delay.h>
void setup() {
// Configuration des PINs 1,4,7 connectés au LEDs comme des OUTPUT.
DDRB |= (1 << DDB1);
DDRD |= (1 << DDD4);
DDRD |= (1 << DDD7);
// Configuration des PINs analogique A0, A3.
DDRC |= (1 << DDC0);
DDRC |= (1 << DDC3);
}
void loop() {
// Mettre les PINs à l'état HIGH.
PORTB |= (1 << PORTB1);
PORTD |= (1 << PORTD4);
PORTD |= (1 << PORTD7);
PORTC |= (1 << PORTC0);
PORTC |= (1 << PORTC3);
_delay_ms(1000); // Delay de 1000 milliseconds
// Basculement d'état des LEDs
PORTB &= ~(1 << PORTB1);
PORTD &= ~(1 << PORTD4);
PORTD &= ~(1 << PORTD7);
PORTC &= ~(1 << PORTC0);
PORTC &= ~(1 << PORTC3);
_delay_ms(1000);
}
int main(void){
setup();
while(1){
loop();
}
return 0;
}
Lecture carte SD
Dans la troisième séance, on a travaillé sur le code pour vérifier le bon fonctionnement des LEDs.
Après on a passé au test de la carte SD et on a vérifié le bon fonctionnement de lecture et écriture pour la carte SD avec les commandes :
// Pour tester la carte SD en écriture.
make upload
Carte fille FPGA programmée par VHDL
//
Carte fille clavier "USB"
Conception de la carte
Pour une première étape on a essayé d'avoir une idée sur le microcontrôleur utilisé (AT90USB647), pour cela on a commencé par lire la fiche technique du microcontrôleur en annexes (Rendus). on a choisi deux portes USB, une porte USB A femelle pour le clavier et une porte USB-Mini mâle pour la programmation.
On a créé le schéma de la carte fille dans kiCAD :
Après avoir bien vérifier le schéma, on a commencé à importer les footprints de chaque composant (en utilisant la bibliothéque SparkFun pour USB A-S femelle) pour se lancer à la réalisation de schéma PCB de la carte.
Programmation de la carte
Gestion du clavier
On a utilisé la bibliothèque LUFA comme hôte USB avec l'utilitaire dfu-programmer pour pouvoir programmer AT90USB647.
Pour la partie gestion du clavier USB, on s'est appuyé sur la démonstration KeyboardHost présente dans la bibliothèque LUFA.
Dans un premier temps, on a commencé par débuguer les appuis des touches sur le clavier de telle façon à basculer l'état de la LED D4 (jaune) quand une lettre est appuyée ([a-z]), et basculer l'état de la LED D3 (bleue) si un chiffre est appuyé ([0-9]) (vous trouvez le code source et la démonstration de cette partie ci-dessous).
A bien noter que la convention de ce code, est pour un clavier de type QWERTY. On développera par la suite une primitive qui gére la conversion QWERTY -> AZERTY.
void KeyboardHost_Task(void){
if (USB_HostState != HOST_STATE_Configured)
return;
/* Select keyboard data pipe */
Pipe_SelectPipe(KEYBOARD_DATA_IN_PIPE);
/* Unfreeze keyboard data pipe */
Pipe_Unfreeze();
/* Check to see if a packet has been received */
if (!(Pipe_IsINReceived())){
/* Refreeze HID data IN pipe */
Pipe_Freeze();
return;
}
/* Ensure pipe contains data before trying to read from it */
if (Pipe_IsReadWriteAllowed()){
USB_KeyboardReport_Data_t KeyboardReport;
/* Read in keyboard report data */
Pipe_Read_Stream_LE(&KeyboardReport, sizeof(KeyboardReport), NULL);
uint8_t KeyCode = KeyboardReport.KeyCode[0];
/* Check if a key has been pressed */
if (KeyCode){
char PressedKey = 0;
//keyBuffer[bufferCount++] = KeyCode;
// Activer l'interruption si ce n'est pas déjà fait et le tampon n'est pas vide
/*if(bufferCount==1){
// Activer l'interruption externe INT0 pour la broche PB4
EIMSK |= (1 << INT0);
}*/
// Retrieve pressed key character if alphanumeric.
if ((KeyCode >= HID_KEYBOARD_SC_A) && (KeyCode <= HID_KEYBOARD_SC_Z)){
PressedKey = (KeyCode - HID_KEYBOARD_SC_A) + 'A';
/* Stocker la touche dans le tompon des touches */
/* Envoyer la touche avec SPI vers le ATMEGA328P */
if(SendPressedKey(PressedKey)==0){
ToggleLEDs(PC0,100);
}
/* Toggle status LED to indicate keypress */
}else if ((KeyCode >= HID_KEYBOARD_SC_1_AND_EXCLAMATION) & (KeyCode < HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS)){
PressedKey = (KeyCode - HID_KEYBOARD_SC_1_AND_EXCLAMATION) + '1';
ToggleLEDs(PC1,100);
}else if (KeyCode == HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS){
PressedKey = '0';
}else if (KeyCode == HID_KEYBOARD_SC_SPACE){
PressedKey = ' ';
}else if (KeyCode == HID_KEYBOARD_SC_ENTER){
PressedKey = '\n';
}
}
}
/* Clear the IN endpoint, ready for next data packet */
Pipe_ClearIN();
/* Refreeze keyboard data pipe */
Pipe_Freeze();
}
//
Rendus
On a même commencé à créer notre repository pour mettre nos fichiers source pour l’ordonnanceur et les cartes filles à réaliser. https://archives.plil.fr/belhasna/Pico_SE4.git