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

SE4Binome2023-11

2024-01-18T16:18:46Z

Belhasna : /* Liens utiles */

= '''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/GROUPE11_CARTE_CLAVIER git]

SE4Binome2023-11

2024-01-17T23:49:16Z

Belhasna : /* Programmation de l'ordonnanceur. */

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

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-17T23:23:37Z

Belhasna : /* Liens utiles */

= '''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{CPU*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)]]

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-17T23:01:24Z

Belhasna : /* Programmation de l'ordonanceur. */

= '''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{CPU*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)]]

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_SE4_11.git git]

SE4Binome2023-11

2024-01-17T22:35:00Z

Belhasna : /* Communication SPI avec carte fille Clavier USB. */

SE4Binome2023-11

2024-01-17T21:56:37Z

Belhasna : /* Communication SPI avec carte fille Clavier USB. */

SE4Binome2023-11

2024-01-17T21:38:59Z

Belhasna : /* Ordonnanceur (OS) */

SE4Binome2023-11

2024-01-17T21:36:42Z

Belhasna : /* Test Ordonnanceur */

Fichier:Video demonstration Afficheur 7 Segment SPI.mp4

2024-01-17T21:22:27Z

Belhasna :

Cette video montre la communication SPI entre la carte mère et l'afficheur 7 segment

SE4Binome2023-11

2023-09-22T21:38:54Z

Belhasna : /* Lecture carte SD */

SE4Binome2023-11

2023-09-22T20:23:43Z

Belhasna :

SE4Binome2023-11

2023-09-22T20:22:51Z

Belhasna : /* Test des LEDs */

Fichier:Video demonstration Test des LEDs.mov

2023-09-22T20:21:11Z

Belhasna :

Le vidéo montre le bon fonctionnement des LEDs. Une LED reste allumé toujours on vas modifier le code et on va tester le soudage de la LED la séance prochaine.

SE4Binome2023-11

2023-09-22T20:16:02Z

Belhasna : /* Lecture carte SD */

SE4Binome2023-11

2023-09-22T09:08:58Z

Belhasna : /* Test des LEDs et Lecture carte SD. */

[[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 et Lecture carte SD. ===
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 travaillé sur le code Arduino pour vérifier le bon fonctionnement des LEDs.<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>

//leds, cables, connecteurs he10//

//code leds, ordo, 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

SE4Binome2023-11

2023-09-21T20:11:50Z

Belhasna : /* Ordonnanceur (OS) */

[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier après soudure|303x303px]]
[[Fichier:Shield&Arduino.jpg|vignette|Carte mère prototype|303x303px]]

= '''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 et Lecture carte SD. ===
Dans la deuxième séance on a finaliser la soudure du SHIELD avec les différents composantes (LEDs, résistances , Lecteur carte SD et les PINs) et on a testé le fonctionnement des LEDs avec un ampèremètre . Après on a travaillé sur le code Arduino pour tester les LEDs.<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);
}
</syntaxhighlight>

//leds, cables, connecteurs he10//

//code leds, ordo, carte sd//
= '''Carte fille FPGA programmée par VHDL''' =

//

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

= '''Rendus''' =
On a meme commencé à créer notre repository pour mettre nos fichiers source pour l'ordonanceur et les cartes filles à réaliser. https://archives.plil.fr/belhasna/Pico_SE4.git

SE4Binome2023-11

2023-09-21T20:07:02Z

Belhasna : /* Ordonnanceur (OS) */

[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier après soudure|303x303px]]
[[Fichier:Shield&Arduino.jpg|vignette|Carte mère prototype|303x303px]]

= '''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 et Lecture carte SD. ===
Dans la deuxième séance on a finaliser la soudure du SHIELD avec les diffirents composantes (LEDs, Resistances, Lecteur carte SD et les PINs) et on a testé le fonctionnement des LEDs avec un ampermetre. Après on a travaillé sur le code arduino pour tester les LEDs.

<nowiki>#</nowiki>include <avr/io.h>

<nowiki>#</nowiki>include <util/delay.h>

void setup() {

// Configuration des PINs 1,4,7, A0 et A3 connectés au LEDs comme des OUTPUT en manipulant les registres DDRB et DDRC.

DDRB |= (1 << DDB1);

DDRD |= (1 << DDD4);

DDRD |= (1 << DDD7);

// Configuration des PINs analogique.

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);

}

//leds, cables, connecteurs he10//

//code leds, ordo, carte sd//
= '''Carte fille FPGA programmée par VHDL''' =

//

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

= '''Rendus''' =
On a meme commencé à créer notre repository pour mettre nos fichiers source pour l'ordonanceur et les cartes filles à réaliser. https://archives.plil.fr/belhasna/Pico_SE4.git

SE4Binome2023-11

2023-09-20T11:01:31Z

Belhasna :

[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier après soudure|303x303px]]
[[Fichier:Shield&Arduino.jpg|vignette|Carte mère prototype|303x303px]]

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

//leds, cables, connecteurs he10//

//code leds, ordo, carte sd//
= '''Carte fille FPGA programmée par VHDL''' =

//

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

= '''Rendus''' =
On a meme commencé à créer notre repository pour mettre nos fichiers source pour l'ordonanceur et les cartes filles à réaliser. https://archives.plil.fr/belhasna/Pico_SE4.git

SE4Binome2023-11

2023-09-20T10:59:22Z

Belhasna :

[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier après soudure|303x303px]]
[[Fichier:Shield&Arduino.jpg|vignette|Carte mère prototype|303x303px]]

= '''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.
= '''Carte fille FPGA programmée par VHDL''' =

//

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

= '''Rendus''' =
On a meme commencé à créer notre repository pour mettre nos fichiers source pour l'ordonanceur et les cartes filles à réaliser. https://archives.plil.fr/belhasna/Pico_SE4.git

SE4Binome2023-11

2023-09-16T09:34:08Z

Belhasna : /* SOUDURE SHIELD. */

[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier après soudure]]
[[Fichier:Shield&Arduino.jpg|vignette|Carte mère prototype]]
ReX : Supprimez ce sommaire manuel, mediawiki en générera un correct lui même

= '''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.
= '''Carte fille FPGA programmée par VHDL''' =

//

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

= '''Rendus''' =
On a meme commencé à créer notre repository pour mettre nos fichiers source pour l'ordonanceur et les cartes filles à réaliser. https://archives.plil.fr/belhasna/Pico_SE4.git

SE4Binome2023-11

2023-09-16T09:26:27Z

Belhasna : /* Rendus */

[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Bouclier après soudure]]
[[Fichier:Shield&Arduino.jpg|vignette|Carte mère prototype]]
ReX : Supprimez ce sommaire manuel, mediawiki en générera un correct lui même

= '''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
= '''Carte fille FPGA programmée par VHDL''' =

//

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

= '''Rendus''' =
On a meme commencé à créer notre repository pour mettre nos fichiers source pour l'ordonanceur et les cartes filles à réaliser. https://archives.plil.fr/belhasna/Pico_SE4.git

SE4Binome2023-11

2023-09-16T09:08:03Z

Belhasna : /* Ordonnanceur (OS) */

ReX : Supprimez ce sommaire manuel, mediawiki en générera un correct lui même

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

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|Carte mère prototype]]

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

//

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

= '''Rendus''' =

SE4Binome2023-11

2023-09-16T09:02:49Z

Belhasna : /* SOUDURE SHIELD. */

ReX : Supprimez ce sommaire manuel, mediawiki en générera un correct lui même

= '''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.
[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Carte mère prototype]]

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

//

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

= '''Rendus''' =

SE4Binome2023-11

2023-09-16T09:01:23Z

Belhasna : /* Ordonnanceur (OS) */

ReX : Supprimez ce sommaire manuel, mediawiki en générera un correct lui même

= '''Ordonnanceur (OS)''' =

=== SOUDURE SHIELD. ===
Dans la première séance on a commancé a souder le shield qui servera comme une carte mère de prototypage pour les carte filles que on va réaliser au cours de ce module. Premièrement on a fait le soudage du lecteure de la Carte SD et les résistances 3.3 kOhm, 680 Ohm et les LEDs pour tester le bon fonctionement du shield aprés.
[[Fichier:Shield-soudage.png|alt=Shield de prototypage|vignette|Carte mère prototype]]

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

//

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

= '''Rendus''' =

Fichier:Shield-soudage.png

2023-09-16T09:00:20Z

Belhasna :

Demonstration du shield de prototypage du cate mère avec soudage du lecteur de la carte masse SD et les autres composantes.

SE4Binome2023-11

2023-09-16T08:43:48Z

Belhasna :

ReX : Supprimez ce sommaire manuel, mediawiki en générera un correct lui même

= '''Ordonnanceur (OS)''' =
//

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

//

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

= '''Rendus''' =

SE4Binome2023-11

2023-09-16T08:43:07Z

Belhasna : Suite au notation de notre professeur j'ai supprimé le sommaire manuel car MediaWiki en générera lui-même le sommaire.