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 avec 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;
}
Programmation de l'ordonnanceur.
Après qu'on a testé notre shield, on a commencé a implementer les fonctionnalités de l'ordonnanceur. L'ordonnanceur qu'on a implémenté utilise un algorithme Round-Robine avec un quantum de 20 ms. Le principe l'ordonnateur est basé sur le déclenchement d'une interruption chaque 20 ms sur le timer1 de l'ATMEGA328 Pl'ATMEGA328p. Pour une fréquence d'horloge de 16 Mhz16mhz et un quantum de 20 ms on peut calculer la valeur à mettre dans le registre OCR1A du timer1 pour générer des interruptions chaque 20 ms. La relation est donnée par :
On choisit un diviseur de fréquence de 1024, pour générer les interruptions chaque 20 ms on aura besoin d'avoir un nombre de Ticks de 313.
L'implementation est donnée par :
#define PRESCALER 1024
#define NB_TICK 313
void Timer(){
TCCR1A=0;
TCCR1B=(0<<WGM12);
#if (PRESCALER==1024)
/* Pour avoir un diviseur de fréquence de 1024*/
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif
OCR1A=NB_TICK;
TCNT1=0;
/*
Le registre d'interruption du compteur/temporisateur 1 TIMSK1,
est configuré pour permettre l'interruption lorsqu'une correspondance est
trouvée avec la valeur de comparaison dans OCR1A.
*/
TIMSK1=(1<<OCIE1A);
}
Multitasking.
Pour tester notre ordonnanceur, on a essayé d'implementer deux à trois taches différentes. Une tache clignote une LED (LED D3) du Sheild et une autre tache qui permettra de piloter un afficheur 7 segments avec SPI. La fonction tache qui permet de piloter l'afficheur est :
/* Definition de la methode de la tache Afficheur 7 segemnt pour afficher
les données sur l'afficheur 7 segement.
*/
void afficher_7SEG(){
SPI_On(ChipSeelect5);
SendRecieveSPI(0x76);
SPI_Off(ChipSeelect5);
while (1){
SPI_On(ChipSeelect5);
for(int j=0; j<9999;j++){
SendRecieveSPI((j/1000)%10);
SendRecieveSPI((j/100)%10);
SendRecieveSPI((j/10)%10);
SendRecieveSPI(j%10);
wait(50)
}
SPI_Off(ChipSeelect5);
wait(50);
}
}
La video demonstration:
Gestion des Ressources partagées.
Vu que les deux taches qui gerent l'afficheur 7 segments et la carte clavier vont utilisées une ressource partagée (SPI) il sera nécessaire d'utiliser un mécanisme de gestion des ressources partagées comme un semaphore. Cette dernière permet de gérer les conflits des taches qui utilisent la même ressource. La tache qui prend la ressource appelle une fonction P(Semaphore) qui verrouille la ressource pour qu'aucune autre tache ne puisse l'apprend, lorsque la tache termine avec la ressource elle libere la ressource pour que les autres taches puissent exécuter leurs sections critiques. Le code qui permet d'implementer ce mécanisme est donnée ci-dessus :
La fonction de verrouillage de ressource P(Semaphor) :
void P(int s) {
// Obtient un pointeur vers la variable de sémaphore
int *p = get_pointer(s);
// Retourne si le pointeur est NULL (erreur)
if (p == NULL) return;
// Désactive les interruptions pour éviter les interférences.
cli();
// Vérifie si le sémaphore est déjà pris
if (*p == 1) {
// Met la tâche courante en attente du sémaphore s
task_current->etat = (WAIT_SEMAPHORE | STATE_SLEEP);
task_current->time = s;
// Appelle la routine d'interruption Timer1 pour déclencher le changement de contexte
TIMER1_COMPA_vect();
}
// Réactive les interruptions
sei();
}
La fonction de verrouillage de ressource V(Semaphore) :
void V(int s) {
// Obtient un pointeur vers la variable de sémaphore
int *p = get_pointer(s);
// Retourne si le pointeur est NULL (erreur)
if (p == NULL) return;
// Désactive les interruptions pour éviter les interférences.
cli();
// Libère la ressource associée au sémaphore
*p = 0;
// Initialise un pointeur vers la structure de tâche
Task *t = (Task *)tasks;
// Parcourt la liste des tâches
while (t->fct != NULL) {
// Vérifie si la tâche est en attente du sémaphore s
if (t->etat == (WAIT_SEMAPHORE | STATE_SLEEP) && t->time == s) {
// Change l'état de la tâche en exécution
t->etat = STATE_RUN;
// Libère la ressource associée au sémaphore
*p = 1;
// Sort de la boucle.
break;
}
// Passe à la tâche suivante
t++;
}
// Réactive les interruptions
sei();
}
Pour le code du sémaphore on a s'inspirer du projet des SE promo 2015.
lien : Malette Arduino éducative I.
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 décidé de travailler avec deux ports USB, USB A femelle pour la connexion du clavier et USB-Mini mâle pour la programmation de la carte.
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 et 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 adoptée (code ASCII), est pour un clavier de type QWERTY. On développera par la suite une primitive qui convertit le layout en s'appuyant sur la bibliothèque LUFA LUFA Library
/* Verifier si une touche a été appuyée */
if (KeyCode)
{
char PressedKey = 0;
if ((KeyCode >= HID_KEYBOARD_SC_A) && (KeyCode <= HID_KEYBOARD_SC_Z))
{
PressedKey = (KeyCode - HID_KEYBOARD_SC_A) + 'A';
}
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';
}
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';
}
else if (KeyCode == HID_KEYBOARD_SC_TAB)
{
PressedKey = '\t';
}
else if (KeyCode == HID_KEYBOARD_SC_DELETE)
{
PressedKey = 0x7f;
}
else if (KeyCode == HID_KEYBOARD_SC_SEMICOLON_AND_COLON)
{
PressedKey = 'M'; // ';' en qwerty -> 'M' en azerty
}
else if (Modifier & (1 << 1))
{
PressedKey = 0xff;
}
/* Stockage de la touche appuyée dans le buffer */
addKeyToBuffer(keyBuffer, PressedKey);
}
Avant d'envoyer les données à la carte mère, il faut d'abord les stocker dans un buffer et savoir combien de touches sont présentes dedans, tout en activant la ligne d'interruption pour chaque touche appuyée. On a donc décidé de travailler avec une structure qui permet cela :
struct KeyboardBuffer {
char keys[30]; // Tableau pour stocker les touches
uint8_t count; // Nombre de touches dans le tampon
uint8_t interruptFlag; // Drapeau d interruption
};
/* Fonction pour ajouter une touche au tampon et activer le drapeau d interruption */
void addKeyToBuffer(struct KeyboardBuffer *buffer, char key) {
if (buffer->count < sizeof(buffer->keys)) {
buffer->keys[buffer->count++] = key;
buffer->interruptFlag = 1; // Activer le drapeau d interruption (<=>PCINT4)
}
}
Programmation en SPI - Envoi et réception des données
Principe de fonctionnement
Le protocole SPI (Serial Peripheral Interface) est une méthode de communication série synchrone utilisée pour transférer des données entre un dispositif maître (carte mère) et un ou plusieurs dispositif(s) esclave(s) (carte fille).
Le maître ATMega328p contrôle le processus en initiant la communication, générant l'horloge de 16MHz, et activant/désactivant la ligne SS/CS selon le périphérique esclave visé (carte clavier ou carte d'affichage). Les données seront transférées en paquets de 8 bits (un octet).
Tests et Réalisations
Dans un premier temps, la carte mère doit identifier le clavier, elle envoie donc des commandes SPI 0x00.
La carte fille répond alors avec 0x01 lorsqu'elle détecte 0x00 pour dire à la carte mère "Hey, C'est moi le clavier !".
Lorsque cette identification est réalisée, on commence le traitement d'envoi des données (nombre de touches + les touches), sauf que l'envoi ne sera effectué que si une requête SPI de code commande 0x01 est reçue [...]
Pour un premier essai, on a testé et de-bugué l'envoi SPI dans un seul sens Envoi depuis Master ATMega328p -> Réception Slave AT90USB647, voir la démonstration dans la vidéo à coté.
Une fois la communication MOSI établie, on a préparé une primitive send_buffer_to_master qui s'occupe de l'envoi des touches stockées dans le buffer (stockage réalisé par la fonction addKeyToBuffer ) :
void send_buffer_to_master(struct KeyboardBuffer *keysBuffer) {
uint8_t receivedByte = SPDR;
if (receivedByte == 0x01) {
receivedByte = 0x02;
for (uint8_t i = 0; i < keysBuffer->count; i++) {
keysBuffer->keys[i] = SPDR;
}
}
}
Cette fonction sera appelée par la suite dans une interruption ISR(SPI_STC_vect) pour alerter la carte mère qu'il existe des touches dans le tampon en lui demandant de lui accorder "la permission" pour lui envoyer les touches appuyées.
Par la suite, on s'est assuré que l'envoi des données est bien réalisé en clignotant une LED à chaque envoi d'un octet (pour la carte mère) et à sa réception (pour la carte fille), voir la démonstration ci-dessous.
Primitive au niveau de la carte mère
On a créé une primitive spi_receive_buffer (à implanter dans la carte mère) qui prend en paramètres la ligne de selection SPI de notre clavier et le tampon des touches , et qui gére le réception et le stockage des touches dans le buffer
void spi_receive_buffer(uint8_t lineSelect, struct KeyboardBuffer *saveBuffer) {
/* Transmission du 0x01 = "(Carte mère): Je suis prêt à recevoir les données" */
SPDR = lineSelect;
/* Attente de la réponse */
while(!(SPSR & (1<<SPIF)));
/* Recevoir la réponse de la carte fille et vérifier si c'est 0x02 = "(Carte fille): Je suis prêt à envoyer les données" */
uint8_t receivedByte = SPDR;
if (receivedByte == 0x02) {
while (!(SPSR & (1 << SPIF))); // Attendre la réception de la taille
saveBuffer->count = SPDR; // Stockage de la taille dans le tampon
/* Reception des touches une par une */
for (uint8_t i = 0; i < saveBuffer->count; i++) {
// Attendre la réception de la touche
while (!(SPSR & (1 << SPIF)));
// Stockage touche par touche dans le buffer
saveBuffer->keys[i] = SPDR;
}
}
}
Conclusion & Axes d'amélioration
Ce type de projets a été une première expérience dans notre cas, le travail et le contenu du projet était bien enrichissant et nous a permis d'acquérir de nouvelles compétences, que ça soit du côté électronique (Conception, routage PCB, soudage, test...) ou du côté informatique (Programmation bas niveau, contrôle de version...). Certes, on a rencontré des difficultés techniques tout au long de cette période, certaines tâches étaient plus complexes pour nous, mais cela nous a pas empêché d'avancer sur le projet.
Pour bien s'organiser, nous avons définit des tâches pour chacun d'entre nous pour avancer en parallèle, jusqu'au moment où on avait rencontré un problème de communication SPI (sens MISO), en effet on avait remarqué que cette dernière ne s'établie jamais, on a alors revérifier le soudage, le code, les pins des connecteurs HE10 en les visualisant avec l'oscilloscope, mais le problème n'était pas clair ce qui nous a fait perdu pas mal de temps.
Dans l'ensemble, nous sommes contents du résultat de notre travail mais pas assez satisfait, certains objectifs été atteignables. En effet, nous aurions pu améliorer la méthodologie d'organisation de travail au début pour gagner du temps, nous aurions aimé tester le pico-ordinateur en entier, mais cela n'a pas été possible à cause de l'état d'avancement du groupe. En somme, c'était intéressant de rencontrer ce type de problèmes afin de mieux anticiper et de renforcer nos compétences pour les futurs projets.
Liens utiles
Git repository pour nos codes sources : git