SE4Binome2024-5

Introduction

Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.

Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.

Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : Lien du Git

Shield

Carte

Recto de la carte avant soudage des composants

Verso de la carte avant soudage des composants

Carte Shield après soudure des composants

Photo de la carte avec les composants soudés

Test

Allumage de LEDS sur Programmateur AVR

Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds.

https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink

Vidéo de Test des leds

Test de lecture de la carte SD

Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.

https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo

Carte SD bien détéctée

Test des connecteurs IDC HE10

Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. (Code ici (section : Example 2 SPI))

Test connecteur HE10 avec afficheur 7 segments.

Ordonnanceur

Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.

Lien du répertoire

Processus

Structure

typedef struct {
    uint16_t adresseDepart;  //adresse de la fonction de départ 
    uint16_t adressePile;       //adresse de la pile d'exécution
    Etat etat;        
} Process;

Notre structure caractérisant un processus est définie par les trois champs ci-contre.

Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.

Etat d'un processus

typedef union {
  int sleepingtime;       
} Time;

typedef struct {
  int id;
  Time time;
} Etat ;

L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)

Tableau des états

Etat	ACTIVE	SLEEPY	...	...
Id	0	1	...	...

ISR

ISR(TIMER1_COMPA_vect, ISR_NAKED)    // Procédure d'interruption
{
  TCNT1=0;//reset timer
  /* Sauvegarde du contexte de la tâche interrompue */
  portSAVE_REGISTERS();
   table_process[indice_tache].adressePile = SP;
  /* Appel à l'ordonnanceur */
  selectProcess();
  /* Récupération du contexte de la tâche ré-activée */
  SP = table_process[indice_tache].adressePile;
  portRESTORE_REGISTERS();
  
  asm volatile ( "reti" );
}

L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.

Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.