projets-se.plil.fr - Contributions [fr]

SE4Binome2023-11

2024-01-18T16:42:03Z

Achaouni : /* Conclusion & Axes d'amélioration */

= '''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.[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier en phase de soudage|406x406px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|386x386px|Câbles pour les connecteurs HE-10]]
[[Fichier:Carte mère prototype.jpg|centré|vignette|380x380px|Carte mère prototype]]
=== Test avec des LEDs ===
[[Fichier:Video demonstration Test des LEDs.mov|vignette|Démo fonctionnement LEDs|0x0px]]
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) : <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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 :

<math display="block">Nombre de Ticks = \frac{FrequenceCPU*Delay}{Prescalar} - 1</math>

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 :<syntaxhighlight lang="c++" line="1">
#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);
}
</syntaxhighlight>

=== 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 :<syntaxhighlight lang="c++" line="1">
/* 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);
}
}
</syntaxhighlight>La video demonstration:
[[Fichier:Video demonstration Afficheur 7 Segment SPI.mp4|vignette|centré|Afficheur 7 segment avec SPI.]]

=== 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) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>La fonction de verrouillage de ressource V(Semaphore) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>Pour le code du sémaphore on a s'inspirer du projet des SE promo 2015.

lien : [https://wiki-ima.plil.fr/mediawiki//index.php/Malette_Arduino_%C3%A9ducative_I 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 [https://ww1.microchip.com/downloads/en/DeviceDoc/doc7593.pdf fiche technique] du microcontrôleur en annexes (Rendus). on a décidé de travailler avec deux ports USB, <code>USB A</code> femelle pour la connexion du clavier et <code>USB-Mini</code> mâle pour la programmation de la carte.

On a créé le schéma de la carte fille dans kiCAD :
[[Fichier:Schéma de la carte clavier sous kiCAD.png|centré|Schéma de la carte fille (Clavier USB)|vignette|645x645px]]

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.
[[Fichier:SchematicPCB.png|alt=schematicPCB|centré|Schéma PCB de la carte fille (après routage)|vignette|650x650px]]

== Programmation de la carte et gestion du clavier ==
On a utilisé la bibliothèque <code>LUFA</code> comme hôte USB avec l'utilitaire <code>dfu-programmer</code> pour pouvoir programmer AT90USB647.

Pour la partie gestion du clavier USB, on s'est appuyé sur la démonstration <code>KeyboardHost</code> 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 [https://fourwalledcubicle.com/files/LUFA/Doc/151115/html/group___group___u_s_b_class_h_i_d_common.html LUFA Library]<syntaxhighlight line="1" start="1" lang="abap">
/* 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);
}
</syntaxhighlight>
[[Fichier:Démo clavier.mp4|vignette|Démo clavier]]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 :<syntaxhighlight lang="abap" line="1" start="1">
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)
}
}
</syntaxhighlight>

== Programmation en SPI - Envoi et réception des données ==

=== Principe de fonctionnement ===
[[Fichier:SPI.png|vignette|Communication SPI]]
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 [...]

[[Fichier:Démo SPI MasterSlave.mp4|vignette|Démo SPI (Master->Slave)]]

Pour un premier essai, on a testé et de-bugué l'envoi SPI dans un seul sens Envoi depuis Master <code>ATMega328p</code> -> Réception Slave <code>AT90USB647</code>, voir la démonstration dans la vidéo à coté.

Une fois la communication MOSI établie, on a préparé une primitive <code>send_buffer_to_master</code> qui s'occupe de l'envoi des touches stockées dans le buffer (stockage réalisé par la fonction <code>addKeyToBuffer</code> ) :

<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>
Cette fonction sera appelée par la suite dans une interruption <code>ISR(SPI_STC_vect)</code> 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.

[[Fichier:Demo2 SPI.mp4|centré|vignette|Démo SPI (2)]]

=== Primitive au niveau de la carte mère ===
On a créé une primitive <code>spi_receive_buffer</code> (à 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<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>

= '''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 : [https://archives.plil.fr/belhasna/GROUPE11_CARTE_CLAVIER git]

SE4Binome2023-11

2024-01-18T16:20:32Z

Achaouni : /* Primitive au niveau de la carte mère */

= '''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.[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier en phase de soudage|406x406px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|386x386px|Câbles pour les connecteurs HE-10]]
[[Fichier:Carte mère prototype.jpg|centré|vignette|380x380px|Carte mère prototype]]
=== Test avec des LEDs ===
[[Fichier:Video demonstration Test des LEDs.mov|vignette|Démo fonctionnement LEDs|0x0px]]
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) : <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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 :

<math display="block">Nombre de Ticks = \frac{FrequenceCPU*Delay}{Prescalar} - 1</math>

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 :<syntaxhighlight lang="c++" line="1">
#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);
}
</syntaxhighlight>

=== 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 :<syntaxhighlight lang="c++" line="1">
/* 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);
}
}
</syntaxhighlight>La video demonstration:
[[Fichier:Video demonstration Afficheur 7 Segment SPI.mp4|vignette|centré|Afficheur 7 segment avec SPI.]]

=== 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) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>La fonction de verrouillage de ressource V(Semaphore) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>Pour le code du sémaphore on a s'inspirer du projet des SE promo 2015.

lien : [https://wiki-ima.plil.fr/mediawiki//index.php/Malette_Arduino_%C3%A9ducative_I 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 [https://ww1.microchip.com/downloads/en/DeviceDoc/doc7593.pdf fiche technique] du microcontrôleur en annexes (Rendus). on a décidé de travailler avec deux ports USB, <code>USB A</code> femelle pour la connexion du clavier et <code>USB-Mini</code> mâle pour la programmation de la carte.

On a créé le schéma de la carte fille dans kiCAD :
[[Fichier:Schéma de la carte clavier sous kiCAD.png|centré|Schéma de la carte fille (Clavier USB)|vignette|645x645px]]

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.
[[Fichier:SchematicPCB.png|alt=schematicPCB|centré|Schéma PCB de la carte fille (après routage)|vignette|650x650px]]

== Programmation de la carte et gestion du clavier ==
On a utilisé la bibliothèque <code>LUFA</code> comme hôte USB avec l'utilitaire <code>dfu-programmer</code> pour pouvoir programmer AT90USB647.

Pour la partie gestion du clavier USB, on s'est appuyé sur la démonstration <code>KeyboardHost</code> 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 [https://fourwalledcubicle.com/files/LUFA/Doc/151115/html/group___group___u_s_b_class_h_i_d_common.html LUFA Library]<syntaxhighlight line="1" start="1" lang="abap">
/* 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);
}
</syntaxhighlight>
[[Fichier:Démo clavier.mp4|vignette|Démo clavier]]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 :<syntaxhighlight lang="abap" line="1" start="1">
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)
}
}
</syntaxhighlight>

== Programmation en SPI - Envoi et réception des données ==

=== Principe de fonctionnement ===
[[Fichier:SPI.png|vignette|Communication SPI]]
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 [...]

[[Fichier:Démo SPI MasterSlave.mp4|vignette|Démo SPI (Master->Slave)]]

Pour un premier essai, on a testé et de-bugué l'envoi SPI dans un seul sens Envoi depuis Master <code>ATMega328p</code> -> Réception Slave <code>AT90USB647</code>, voir la démonstration dans la vidéo à coté.

Une fois la communication MOSI établie, on a préparé une primitive <code>send_buffer_to_master</code> qui s'occupe de l'envoi des touches stockées dans le buffer (stockage réalisé par la fonction <code>addKeyToBuffer</code> ) :

<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>
Cette fonction sera appelée par la suite dans une interruption <code>ISR(SPI_STC_vect)</code> 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.

[[Fichier:Demo2 SPI.mp4|centré|vignette|Démo SPI (2)]]

=== Primitive au niveau de la carte mère ===
On a créé une primitive <code>spi_receive_buffer</code> (à 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<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>

= '''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 c'était intéressant de rencontrer ce type de problèmes afin de renforcer nos compétences pour les futurs projets.

= '''Liens utiles''' =
Git repository pour nos codes sources : [https://archives.plil.fr/belhasna/GROUPE11_CARTE_CLAVIER git]

SE4Binome2023-11

2024-01-18T16:17:47Z

Achaouni : /* Tests et Réalisations */

= '''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.[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier en phase de soudage|406x406px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|386x386px|Câbles pour les connecteurs HE-10]]
[[Fichier:Carte mère prototype.jpg|centré|vignette|380x380px|Carte mère prototype]]
=== Test avec des LEDs ===
[[Fichier:Video demonstration Test des LEDs.mov|vignette|Démo fonctionnement LEDs|0x0px]]
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) : <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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 :

<math display="block">Nombre de Ticks = \frac{FrequenceCPU*Delay}{Prescalar} - 1</math>

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 :<syntaxhighlight lang="c++" line="1">
#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);
}
</syntaxhighlight>

=== 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 :<syntaxhighlight lang="c++" line="1">
/* 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);
}
}
</syntaxhighlight>La video demonstration:
[[Fichier:Video demonstration Afficheur 7 Segment SPI.mp4|vignette|centré|Afficheur 7 segment avec SPI.]]

=== 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) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>La fonction de verrouillage de ressource V(Semaphore) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>Pour le code du sémaphore on a s'inspirer du projet des SE promo 2015.

lien : [https://wiki-ima.plil.fr/mediawiki//index.php/Malette_Arduino_%C3%A9ducative_I 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 [https://ww1.microchip.com/downloads/en/DeviceDoc/doc7593.pdf fiche technique] du microcontrôleur en annexes (Rendus). on a décidé de travailler avec deux ports USB, <code>USB A</code> femelle pour la connexion du clavier et <code>USB-Mini</code> mâle pour la programmation de la carte.

On a créé le schéma de la carte fille dans kiCAD :
[[Fichier:Schéma de la carte clavier sous kiCAD.png|centré|Schéma de la carte fille (Clavier USB)|vignette|645x645px]]

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.
[[Fichier:SchematicPCB.png|alt=schematicPCB|centré|Schéma PCB de la carte fille (après routage)|vignette|650x650px]]

== Programmation de la carte et gestion du clavier ==
On a utilisé la bibliothèque <code>LUFA</code> comme hôte USB avec l'utilitaire <code>dfu-programmer</code> pour pouvoir programmer AT90USB647.

Pour la partie gestion du clavier USB, on s'est appuyé sur la démonstration <code>KeyboardHost</code> 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 gére la conversion QWERTY -> AZERTY.<syntaxhighlight line="1" start="1" lang="abap">
/* 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);
}
</syntaxhighlight>
[[Fichier:Démo clavier.mp4|vignette|Démo clavier]]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 :<syntaxhighlight lang="abap" line="1" start="1">
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)
}
}
</syntaxhighlight>

== Programmation en SPI - Envoi et réception des données ==

=== Principe de fonctionnement ===
[[Fichier:SPI.png|vignette|Communication SPI]]
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 [...]

[[Fichier:Démo SPI MasterSlave.mp4|vignette|Démo SPI (Master->Slave)]]

Pour un premier essai, on a testé et de-bugué l'envoi SPI dans un seul sens Envoi depuis Master <code>ATMega328p</code> -> Réception Slave <code>AT90USB647</code>, voir la démonstration dans la vidéo à coté.

Une fois la communication MOSI établie, on a préparé une primitive <code>send_buffer_to_master</code> qui s'occupe de l'envoi des touches stockées dans le buffer (stockage réalisé par la fonction <code>addKeyToBuffer</code> ) :

<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>
Cette fonction sera appelée par la suite dans une interruption <code>ISR(SPI_STC_vect)</code> 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.

[[Fichier:Demo2 SPI.mp4|centré|vignette|Démo SPI (2)]]

=== Primitive au niveau de la carte mère ===
On a créé une primitive <code>spi_receive_buffer</code> (à 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<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>

= '''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 c'était intéressant de rencontrer ce type de problèmes afin de renforcer nos compétences pour les futurs projets.

= '''Liens utiles''' =
Git repository pour nos codes sources : [https://archives.plil.fr/belhasna/PICO_GROUPE11 git]

Fichier:Demo2 SPI.mp4

2024-01-18T16:17:11Z

Achaouni :

Demo2 SPI

SE4Binome2023-11

2024-01-18T09:00:44Z

Achaouni : /* Conclusion & Axes d'amélioration */

= '''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.[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier en phase de soudage|406x406px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|386x386px|Câbles pour les connecteurs HE-10]]
[[Fichier:Carte mère prototype.jpg|centré|vignette|380x380px|Carte mère prototype]]
=== Test avec des LEDs ===
[[Fichier:Video demonstration Test des LEDs.mov|vignette|Démo fonctionnement LEDs|0x0px]]
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) : <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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 :

<math display="block">Nombre de Ticks = \frac{FrequenceCPU*Delay}{Prescalar} - 1</math>

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 :<syntaxhighlight lang="c++" line="1">
#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);
}
</syntaxhighlight>

=== 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 :<syntaxhighlight lang="c++" line="1">
/* 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);
}
}
</syntaxhighlight>La video demonstration:
[[Fichier:Video demonstration Afficheur 7 Segment SPI.mp4|vignette|centré|Afficheur 7 segment avec SPI.]]

=== 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) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>La fonction de verrouillage de ressource V(Semaphore) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>Pour le code du sémaphore on a s'inspirer du projet des SE promo 2015.

lien : [https://wiki-ima.plil.fr/mediawiki//index.php/Malette_Arduino_%C3%A9ducative_I 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 [https://ww1.microchip.com/downloads/en/DeviceDoc/doc7593.pdf fiche technique] du microcontrôleur en annexes (Rendus). on a décidé de travailler avec deux ports USB, <code>USB A</code> femelle pour la connexion du clavier et <code>USB-Mini</code> mâle pour la programmation de la carte.

On a créé le schéma de la carte fille dans kiCAD :
[[Fichier:Schéma de la carte clavier sous kiCAD.png|centré|Schéma de la carte fille (Clavier USB)|vignette|645x645px]]

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.
[[Fichier:SchematicPCB.png|alt=schematicPCB|centré|Schéma PCB de la carte fille (après routage)|vignette|650x650px]]

== Programmation de la carte et gestion du clavier ==
On a utilisé la bibliothèque <code>LUFA</code> comme hôte USB avec l'utilitaire <code>dfu-programmer</code> pour pouvoir programmer AT90USB647.

Pour la partie gestion du clavier USB, on s'est appuyé sur la démonstration <code>KeyboardHost</code> 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 gére la conversion QWERTY -> AZERTY.<syntaxhighlight line="1" start="1" lang="abap">
/* 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);
}
</syntaxhighlight>
[[Fichier:Démo clavier.mp4|vignette|Démo clavier]]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 :<syntaxhighlight lang="abap" line="1" start="1">
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)
}
}
</syntaxhighlight>

== Programmation en SPI - Envoi et réception des données ==

=== Principe de fonctionnement ===
[[Fichier:SPI.png|vignette|Communication SPI]]
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 [...]

[[Fichier:Démo SPI MasterSlave.mp4|vignette|Démo SPI (Master->Slave)]]

Pour un premier essai, on a testé et de-bugué l'envoi SPI dans un seul sens Envoi depuis Master <code>ATMega328p</code> -> Réception Slave <code>AT90USB647</code>, voir la démonstration dans la vidéo à coté.

Une fois la communication MOSI établie, on a préparé une primitive <code>send_buffer_to_master</code> qui s'occupe de l'envoi des touches stockées dans le buffer (stockage réalisé par la fonction <code>addKeyToBuffer</code> ) :

<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>
Cette fonction sera appelée par la suite dans une interruption <code>ISR(SPI_STC_vect)</code> 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.

=== Primitive au niveau de la carte mère ===
On a créé une primitive <code>spi_receive_buffer</code> (à 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<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>

= '''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 c'était intéressant de rencontrer ce type de problèmes afin de renforcer nos compétences pour les futurs projets.

= '''Liens utiles''' =
Git repository pour nos codes sources : [https://archives.plil.fr/belhasna/PICO_GROUPE11 git]

SE4Binome2023-11

2024-01-18T08:20:49Z

Achaouni : /* Conclusion & Axes d'amélioration */

= '''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.[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier en phase de soudage|406x406px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|386x386px|Câbles pour les connecteurs HE-10]]
[[Fichier:Carte mère prototype.jpg|centré|vignette|380x380px|Carte mère prototype]]
=== Test avec des LEDs ===
[[Fichier:Video demonstration Test des LEDs.mov|vignette|Démo fonctionnement LEDs|0x0px]]
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) : <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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 :

<math display="block">Nombre de Ticks = \frac{FrequenceCPU*Delay}{Prescalar} - 1</math>

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 :<syntaxhighlight lang="c++" line="1">
#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);
}
</syntaxhighlight>

=== 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 :<syntaxhighlight lang="c++" line="1">
/* 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);
}
}
</syntaxhighlight>La video demonstration:
[[Fichier:Video demonstration Afficheur 7 Segment SPI.mp4|vignette|centré|Afficheur 7 segment avec SPI.]]

=== 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) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>La fonction de verrouillage de ressource V(Semaphore) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>Pour le code du sémaphore on a s'inspirer du projet des SE promo 2015.

lien : [https://wiki-ima.plil.fr/mediawiki//index.php/Malette_Arduino_%C3%A9ducative_I 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 [https://ww1.microchip.com/downloads/en/DeviceDoc/doc7593.pdf fiche technique] du microcontrôleur en annexes (Rendus). on a décidé de travailler avec deux ports USB, <code>USB A</code> femelle pour la connexion du clavier et <code>USB-Mini</code> mâle pour la programmation de la carte.

On a créé le schéma de la carte fille dans kiCAD :
[[Fichier:Schéma de la carte clavier sous kiCAD.png|centré|Schéma de la carte fille (Clavier USB)|vignette|645x645px]]

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.
[[Fichier:SchematicPCB.png|alt=schematicPCB|centré|Schéma PCB de la carte fille (après routage)|vignette|650x650px]]

== Programmation de la carte et gestion du clavier ==
On a utilisé la bibliothèque <code>LUFA</code> comme hôte USB avec l'utilitaire <code>dfu-programmer</code> pour pouvoir programmer AT90USB647.

Pour la partie gestion du clavier USB, on s'est appuyé sur la démonstration <code>KeyboardHost</code> 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 gére la conversion QWERTY -> AZERTY.<syntaxhighlight line="1" start="1" lang="abap">
/* 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);
}
</syntaxhighlight>
[[Fichier:Démo clavier.mp4|vignette|Démo clavier]]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 :<syntaxhighlight lang="abap" line="1" start="1">
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)
}
}
</syntaxhighlight>

== Programmation en SPI - Envoi et réception des données ==

=== Principe de fonctionnement ===
[[Fichier:SPI.png|vignette|Communication SPI]]
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 [...]

[[Fichier:Démo SPI MasterSlave.mp4|vignette|Démo SPI (Master->Slave)]]

Pour un premier essai, on a testé et de-bugué l'envoi SPI dans un seul sens Envoi depuis Master <code>ATMega328p</code> -> Réception Slave <code>AT90USB647</code>, voir la démonstration dans la vidéo à coté.

Une fois la communication MOSI établie, on a préparé une primitive <code>send_buffer_to_master</code> qui s'occupe de l'envoi des touches stockées dans le buffer (stockage réalisé par la fonction <code>addKeyToBuffer</code> ) :

<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>
Cette fonction sera appelée par la suite dans une interruption <code>ISR(SPI_STC_vect)</code> 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.

=== Primitive au niveau de la carte mère ===
On a créé une primitive <code>spi_receive_buffer</code> (à 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<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>

= '''Conclusion & Axes d'amélioration''' =
//

= '''Liens utiles''' =
Git repository pour nos codes sources : [https://archives.plil.fr/belhasna/PICO_GROUPE11 git]

SE4Binome2023-11

2024-01-18T08:17:59Z

Achaouni : /* Tests et Réalisations */

= '''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.[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier en phase de soudage|406x406px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|386x386px|Câbles pour les connecteurs HE-10]]
[[Fichier:Carte mère prototype.jpg|centré|vignette|380x380px|Carte mère prototype]]
=== Test avec des LEDs ===
[[Fichier:Video demonstration Test des LEDs.mov|vignette|Démo fonctionnement LEDs|0x0px]]
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) : <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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 :

<math display="block">Nombre de Ticks = \frac{FrequenceCPU*Delay}{Prescalar} - 1</math>

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 :<syntaxhighlight lang="c++" line="1">
#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);
}
</syntaxhighlight>

=== 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 :<syntaxhighlight lang="c++" line="1">
/* 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);
}
}
</syntaxhighlight>La video demonstration:
[[Fichier:Video demonstration Afficheur 7 Segment SPI.mp4|vignette|centré|Afficheur 7 segment avec SPI.]]

=== 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) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>La fonction de verrouillage de ressource V(Semaphore) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>Pour le code du sémaphore on a s'inspirer du projet des SE promo 2015.

lien : [https://wiki-ima.plil.fr/mediawiki//index.php/Malette_Arduino_%C3%A9ducative_I 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 [https://ww1.microchip.com/downloads/en/DeviceDoc/doc7593.pdf fiche technique] du microcontrôleur en annexes (Rendus). on a décidé de travailler avec deux ports USB, <code>USB A</code> femelle pour la connexion du clavier et <code>USB-Mini</code> mâle pour la programmation de la carte.

On a créé le schéma de la carte fille dans kiCAD :
[[Fichier:Schéma de la carte clavier sous kiCAD.png|centré|Schéma de la carte fille (Clavier USB)|vignette|645x645px]]

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.
[[Fichier:SchematicPCB.png|alt=schematicPCB|centré|Schéma PCB de la carte fille (après routage)|vignette|650x650px]]

== Programmation de la carte et gestion du clavier ==
On a utilisé la bibliothèque <code>LUFA</code> comme hôte USB avec l'utilitaire <code>dfu-programmer</code> pour pouvoir programmer AT90USB647.

Pour la partie gestion du clavier USB, on s'est appuyé sur la démonstration <code>KeyboardHost</code> 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 gére la conversion QWERTY -> AZERTY.<syntaxhighlight line="1" start="1" lang="abap">
/* 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);
}
</syntaxhighlight>
[[Fichier:Démo clavier.mp4|vignette|Démo clavier]]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 :<syntaxhighlight lang="abap" line="1" start="1">
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)
}
}
</syntaxhighlight>

== Programmation en SPI - Envoi et réception des données ==

=== Principe de fonctionnement ===
[[Fichier:SPI.png|vignette|Communication SPI]]
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 [...]

[[Fichier:Démo SPI MasterSlave.mp4|vignette|Démo SPI (Master->Slave)]]

Pour un premier essai, on a testé et de-bugué l'envoi SPI dans un seul sens Envoi depuis Master <code>ATMega328p</code> -> Réception Slave <code>AT90USB647</code>, voir la démonstration dans la vidéo à coté.

Une fois la communication MOSI établie, on a préparé une primitive <code>send_buffer_to_master</code> qui s'occupe de l'envoi des touches stockées dans le buffer (stockage réalisé par la fonction <code>addKeyToBuffer</code> ) :

<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>
Cette fonction sera appelée par la suite dans une interruption <code>ISR(SPI_STC_vect)</code> 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.

=== Primitive au niveau de la carte mère ===
On a créé une primitive <code>spi_receive_buffer</code> (à 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<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>

= '''Conclusion & Axes d'amélioration''' =

= '''Liens utiles''' =
Git repository pour nos codes sources : [https://archives.plil.fr/belhasna/PICO_GROUPE11 git]

SE4Binome2023-11

2024-01-18T07:38:02Z

Achaouni : /* Tests et Réalisations */

= '''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.[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier en phase de soudage|406x406px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|386x386px|Câbles pour les connecteurs HE-10]]
[[Fichier:Carte mère prototype.jpg|centré|vignette|380x380px|Carte mère prototype]]
=== Test avec des LEDs ===
[[Fichier:Video demonstration Test des LEDs.mov|vignette|Démo fonctionnement LEDs|0x0px]]
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) : <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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 :

<math display="block">Nombre de Ticks = \frac{FrequenceCPU*Delay}{Prescalar} - 1</math>

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 :<syntaxhighlight lang="c++" line="1">
#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);
}
</syntaxhighlight>

=== 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 :<syntaxhighlight lang="c++" line="1">
/* 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);
}
}
</syntaxhighlight>La video demonstration:
[[Fichier:Video demonstration Afficheur 7 Segment SPI.mp4|vignette|centré|Afficheur 7 segment avec SPI.]]

=== 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) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>La fonction de verrouillage de ressource V(Semaphore) :<syntaxhighlight lang="c++" line="1">
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();
}
</syntaxhighlight>Pour le code du sémaphore on a s'inspirer du projet des SE promo 2015.

lien : [https://wiki-ima.plil.fr/mediawiki//index.php/Malette_Arduino_%C3%A9ducative_I 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 [https://ww1.microchip.com/downloads/en/DeviceDoc/doc7593.pdf fiche technique] du microcontrôleur en annexes (Rendus). on a décidé de travailler avec deux ports USB, <code>USB A</code> femelle pour la connexion du clavier et <code>USB-Mini</code> mâle pour la programmation de la carte.

On a créé le schéma de la carte fille dans kiCAD :
[[Fichier:Schéma de la carte clavier sous kiCAD.png|centré|Schéma de la carte fille (Clavier USB)|vignette|645x645px]]

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.
[[Fichier:SchematicPCB.png|alt=schematicPCB|centré|Schéma PCB de la carte fille (après routage)|vignette|650x650px]]

== Programmation de la carte et gestion du clavier ==
On a utilisé la bibliothèque <code>LUFA</code> comme hôte USB avec l'utilitaire <code>dfu-programmer</code> pour pouvoir programmer AT90USB647.

Pour la partie gestion du clavier USB, on s'est appuyé sur la démonstration <code>KeyboardHost</code> 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 gére la conversion QWERTY -> AZERTY.<syntaxhighlight line="1" start="1" lang="abap">
/* 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);
}
</syntaxhighlight>
[[Fichier:Démo clavier.mp4|vignette|Démo clavier]]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 :<syntaxhighlight lang="abap" line="1" start="1">
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)
}
}
</syntaxhighlight>

== Programmation en SPI - Envoi et réception des données ==

=== Principe de fonctionnement ===
[[Fichier:SPI.png|vignette|Communication SPI]]
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 <code>ATMega328p</code> -> Réception Slave <code>AT90USB647</code>, voir la démonstration dans la vidéo ci-dessous.

[[Fichier:Démo SPI MasterSlave.mp4|vignette|Démo SPI (Master->Slave)]]

Une fois la communication MOSI établie, on a préparé une primitive qui s'occupe de l'envoi des touches stockées dans le buffer en s'appuyant sur la fonction <code>addKeyToBuffer</code> [...]

On a créé une primitive <code>spi_receive_buffer</code> (à implanter dans la carte mère) qui gére le réception et le stockage des touches :<syntaxhighlight lang="abap" line="1" start="1">
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;
}
}
}
</syntaxhighlight>

= '''Conclusion & Axes d'amélioration''' =

= '''Liens utiles''' =
Git repository pour nos codes sources : [https://archives.plil.fr/belhasna/PICO_GROUPE11 git]

SE4Binome2023-11

2024-01-17T09:50:46Z

Achaouni : /* Conclusion & Axes d'amélioration */

SE4Binome2023-11

2024-01-17T09:50:14Z

Achaouni : /* Liens utiles */

SE4Binome2023-11

2024-01-17T09:46:42Z

Achaouni : /* Conception de la carte */

SE4Binome2023-11

2024-01-17T09:42:00Z

Achaouni :

SE4Binome2023-11

2024-01-17T09:40:24Z

Achaouni :

Fichier:SPI.png

2024-01-17T09:33:47Z

Achaouni :

SPI

SE4Binome2023-11

2024-01-17T09:23:54Z

Achaouni : /* Programmation de la carte */

SE4Binome2023-11

2024-01-16T08:33:14Z

Achaouni : /* Rendus */

SE4Binome2023-11

2024-01-16T08:28:14Z

Achaouni : /* Carte fille FPGA programmée par VHDL */

SE4Binome2023-11

2023-12-21T08:56:23Z

Achaouni : /* SPI - Envoi et réception des données */

SE4Binome2023-11

2023-12-21T08:48:04Z

Achaouni : /* Test avec des LEDs */

SE4Binome2023-11

2023-12-20T16:04:26Z

Achaouni : /* Carte fille FPGA programmée par VHDL */

SE4Binome2023-11

2023-12-20T16:02:08Z

Achaouni : /* Lecture carte SD */

SE4Binome2023-11

2023-12-20T16:01:43Z

Achaouni : /* Lecture carte SD */

SE4Binome2023-11

2023-12-17T09:34:21Z

Achaouni : /* Gestion du clavier */

SE4Binome2023-11

2023-12-17T09:31:24Z

Achaouni : /* Programmation de la carte */

SE4Binome2023-11

2023-12-14T09:47:19Z

Achaouni : /* SPI - Envoi et réception des données */

Fichier:Démo SPI MasterSlave.mp4

2023-12-14T09:46:56Z

Achaouni :

Démo SPI Master>Slave

SE4Binome2023-11

2023-12-11T15:37:11Z

Achaouni : /* Rendus */

SE4Binome2023-11

2023-12-11T13:44:07Z

Achaouni : /* SPI - Envoi et réception des données */

SE4Binome2023-11

2023-12-11T11:20:19Z

Achaouni : /* SPI - Envoi des données */

SE4Binome2023-11

2023-12-11T11:07:00Z

Achaouni : /* SPI - Envoi des données */

SE4Binome2023-11

2023-12-07T11:13:51Z

Achaouni : /* Gestion du clavier */

SE4Binome2023-11

2023-12-07T11:12:53Z

Achaouni : /* Programmation de la carte */

SE4Binome2023-11

2023-12-07T10:14:06Z

Achaouni : /* Programmation de la carte */

SE4Binome2023-11

2023-12-07T10:08:46Z

Achaouni : /* Rendus */

SE4Binome2023-11

2023-12-07T10:07:51Z

Achaouni : /* Rendus */

SE4Binome2023-11

2023-12-07T10:07:29Z

Achaouni : /* Programmation de la carte */

SE4Binome2023-11

2023-12-07T10:06:15Z

Achaouni : /* Programmation de la carte */

Fichier:Démo clavier.mp4

2023-12-07T10:05:33Z

Achaouni :

Démonstration clavier

SE4Binome2023-11

2023-12-07T09:53:28Z

Achaouni : /* Programmation de la carte */

SE4Binome2023-11

2023-12-07T09:37:02Z

Achaouni : /* Carte fille clavier "USB" */

SE4Binome2023-11

2023-11-07T12:57:39Z

Achaouni :

SE4Binome2023-11

2023-11-07T12:55:59Z

Achaouni :

SE4Binome2023-11

2023-11-06T10:53:25Z

Achaouni : /* Test des LEDs */

SE4Binome2023-11

2023-11-06T09:52:35Z

Achaouni : /* Carte fille clavier "USB" */

Fichier:SchematicPCB.png

2023-11-06T09:50:26Z

Achaouni :

Schéma PCB de la carte fille (après routage)

Fichier:Schéma de la carte clavier sous kiCAD.png

2023-11-06T09:38:45Z

Achaouni :

Schéma de la carte

SE4Binome2023-11

2023-09-22T19:05:05Z

Achaouni :

SE4Binome2023-11

2023-09-22T19:00:56Z

Achaouni :

[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier après soudure|303x303px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|305x305px|Câbles pour les connecteurs HE-10]]

= '''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 . <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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

= '''Carte fille FPGA programmée par VHDL''' =

//

= '''Carte fille clavier "USB"''' =
//

= '''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

Fichier:Carte mère prototype.jpg

2023-09-22T18:58:17Z

Achaouni :

Carte mère prototype

SE4Binome2023-11

2023-09-22T09:45:35Z

Achaouni :

[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier après soudure|303x303px]]
[[Fichier:Shield&Arduino.jpg|vignette|Carte mère prototype|303x303px]]
[[Fichier:Câbles pour les connecteurs HE-10.jpg|vignette|305x305px|Câbles pour les connecteurs HE-10]]

= '''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 . <syntaxhighlight lang="abap" line="1" start="1">
#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;
}
</syntaxhighlight>

=== 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

= '''Carte fille FPGA programmée par VHDL''' =

//

= '''Carte fille clavier "USB"''' =
//

= '''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