SE4Binome2024-3
Description
L'objectif de ce projet est de réaliser un pico ordinateur. Nous allons traiter le développement de la carte mère, un shield arduino ainsi que la programmation d'un ordonnanceur.
Notre carte mère sera alimenté via une alimentation secteur en 5v et le code sera implanté par USB.
Liens
Lien du git : https://gitea.plil.fr/vdetrez/SE4_PICO_DETREZ_CART
Réalisation d'un shield arduino
Schématique et routage
|
|
|---|
PINOUT
| LED1 | PC0 |
| LED2 | PC3 |
| LED3 | PD1 |
| LED4 | PD4 |
| LED5 | PD7 |
Brasage du shield
shield nu
shield fini
Test du shield
Réalisation carte mère
Schématique et routage
 |
 |
|---|
Brasage carte mère
carte mère nue
ajout ATmega 328p
ajout ATmega 8U2
mise en lien des ATmega et correction de conception
La correction consiste en l'ajout d'un bouton reset et HWB pour l'ATmega8U2.
carte finale
Tests
Test de clignotement d'une LED (25ms)
Programmation des cartes
27/11/24 : pour le moment le µc atmega328p a réussi à être programmé par ISP en changeant les fuses grâce à avrdude. En revanche, impossible de programmer l'atmega8u2. Nous avons essayé de lui mettre un bootloader et de changer ses fuses mais c'est impossible dans les deux cas et la carte n'est donc pas détectée en USB.
4/12/24 : nous avons réussi à mettre un bootloader dans le 8u2, en revanche nous n'arrivons toujours pas à programmer le 328p grâce au port USB. La cause : nous n'arrivons pas à burn le bootloader du 328p pour qu'il puisse recevoir des données via usb_série ...
Solution trouvée : Nous avons changé le bootloader en mettant celui-ci (/usr/share/arduino/hardware/arduino/avr/bootloaders/optiboot) à la place pour augmenter la place de ce dernier. Maintenant le 328p peut être programmé grâce à l'USB.
Programmation ordonnanceur
Initialisation de la pile
void init_pile(int N){
uint16_t tempSP = SP;
SP = task[N].stackPointer;
uint16_t adresse=(uint16_t)task[N].addressFunction;
asm volatile("push %0" : : "r" (adresse & 0x00ff) );
asm volatile("push %0" : : "r" ((adresse & 0xff00)>>8) );
SAVE_REGISTERS();
task[N].stackPointer = SP;
SP = tempSP;
}
La fonction init_pile() sert à charger un processus dans la pile. Cette fonction est appelée dans une boucle au début du main pour initialiser tous les processus.
Interruption de l'ordonnanceur
L'ordonnanceur est appelé à un interval de temps régulier grâce à des interruptions du Timer1.
Avant de passer d'une tâche à une autre (mode Round Robin) il faut d'abord effectuer quelques opérations sur la mémoire du micro-processeur.
ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
/* Sauvegarde du contexte de la tâche interrompue */
SAVE_REGISTERS();
task[currentTask].stackPointer = SP;
/* Appel à l'ordonnanceur */
scheduler();
/* Récupération du contexte de la tâche ré-activée */
SP = task[currentTask].stackPointer;
RESTORE_REGISTERS();
asm volatile ( "reti" );
}
La routine d'interruption est générée par le Timer1 avec comme paramètre ISR_NAKED qui permet de ne pas avoir le prologue et l'épilogue automatique du compilateur ce qui nous est très utile pour gérer manuellement ces interruptions afin d'éxecuter nos tâches.
La macro SAVE_REGISTERS() nous permet de sauvegarder les 32 registres sur la pile. Cela permet de s’assurer qu’au retour de l'interruption, la tâche interrompue pourra reprendre son exécution là où elle s’était arrêtée, sans perdre son contexte.
task[currentTask].stackPointer = SP permet de sauvegarder le pointeur de pile de la tâche associée.
scheduler() est expliqué ici.
SP = task[currentTask].stackPointer permet de replacer le pointeur de pile à celui de la nouvelle tâche engendrée par le scheduler.
La macro RESTORE_REGISTERS() remets la nouvelle fonction sur les 32 registres avec des Pop().
asm volatile ( "reti" ) : étant en ISR_NAKED, il faut dire manuellement la fin de l'interruption avec cette commande assembleur RETurn from Interrupt.
Structure d'une tâche
enum States{
AWAKE,
IDLE
};
enum IDLE_TYPE{
IDLE_TYPE_DELAY,
IDLE_TYPE_STABLE
};
typedef union {
int sleeping_time;
} Time;
typedef struct {
enum IDLE_TYPE type;
Time time;
} Etat ;
typedef struct{
uint16_t stackPointer; // stack pointer, défini le début du process
void (*addressFunction)(void); // adresse de l'instruction en cours
enum States state; // état de la fonction (Awake ou Idle)
Etat etat;
}process;
Les tâches sont définies par leurs pointeurs de piles, leurs adresses, un état qui est soit IDLE ou AWAKE et enfin un dernier état qui lui gère permet d'avoir différent type d'IDLE.
L'utilisation d'unions n'est pas forcément justifiée ici mais permet de limiter la place que va prendre la structure dans l'optique de futures implémentations.
Code de l'ordonnanceur
void scheduler(){
// décrémentation de l'attente de toutes les tâches en IDLE
for(int i=0;i<NB_TASKS;i++){
if(task[i].state==IDLE && (task[i].etat.type==IDLE_TYPE_DELAY)){
task[i].etat.time.sleeping_time -= PERIODE;
if(task[i].etat.time.sleeping_time <= 0){
task[i].etat.time.sleeping_time = 0;
task[i].state = AWAKE;
}
}
}
do{
currentTask ++;
if(currentTask >= NB_TASKS) currentTask = 0; // ordonnanceur en mode Round Robin
}while(task[currentTask].state == IDLE);
}
L'ordonnanceur est en mode Round Robin (tourniquet) ce qui veut dire qu'il n'y a pas de priorité de tâche, elles sont toutes appelées une à une dans l'ordre avant de boucler et ainsi de suite...
L'un des ajouts a été de mettre un mode IDLE à nos tâches qui indique la veille de ces dernières. Si une tâche est en IDLE, elle ne sera pas appelée lors de la sélection des tâches et son temps de sommeil sera décrémenté. Cela permet de créer des attentes passives donc d'éviter d'attendre inutilement des tâches qui ne font qu'attendre. On bon exemple pour comprendre serait avec un clignotement de LED. Au lieu de mettre un _delay_ms(1000) qui éxecutera une attente à chaque fois que cette tâche est appelée, on la passe pendant 1000 ms ce qui permet d'éxécuter d'autres tâches entre temps.
Fonction wait
void wait(int time_ms){
task[currentTask].state = IDLE;
task[currentTask].etat.type=IDLE_TYPE_DELAY;
task[currentTask].etat.time.sleeping_time = time_ms;
TCNT1 = 0;
TIMER1_COMPA_vect();
}
La fonction permet d'endormir un processus pendant un temps donné en ms.
Elle passe la tâche en IDLE, remet le Timer1 à zéro pour éviter de garder un décalage de temps car le changement est surement fait en plein milieu d'une tâche.
Et ensuite elle appelle l'interruption pour qu'une nouvelle tâche soit en cours.
Exemple de tâches
void USART_Init(unsigned int ubrr)
{
/*Set baud rate */
UBRR0H = (unsigned char)(ubrr>>8);
UBRR0L = (unsigned char)ubrr;
/*Enable receiver and transmitter */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
/* Set frame format: 8data, 2stop bit */
UCSR0C = (1<<USBS0)|(3<<UCSZ00);
}
void LED_init(){
DDRC |= (1<<LED1) | (1<<LED2);
DDRD |= (1<<LED3) | (1<<LED4) | (1<<LED5);
PORTC |= (1<<LED1)|(1<<LED2);
PORTD |= (1<<LED3)|(1<<LED4)|(1<<LED5);
}
void LED1_blink(){
while(1){
PORTC ^= (1<<LED1);
_delay_ms(1000);
}
}
void LED2_blink(){
while(1){
PORTC ^= (1<<LED2);
wait(100);
}
}
void Serial_Message(){
unsigned char data;
while(1){
data = USART_Receive();
USART_Transmit(data);
}
}
void USART_Transmit(unsigned char data)
{
/* Wait for empty transmit buffer */
while (!(UCSR0A & (1<<UDRE0)))
;
/* Put data into buffer, sends the data */
UDR0 = data;
}
unsigned char USART_Receive(void)
{
/* Wait for data to be received */
while (!(UCSR0A & (1<<RXC0)))
;
/* Get and return received data from buffer */
return UDR0;
}
void spi_activer(void){ // Activer le périphérique
PORTD &= ~(1<<SPI_SS); // Ligne SS à l'état bas
}
void spi_desactiver(void){ // Désactiver le périphérique
PORTD |= (1<<SPI_SS); // Ligne SS à l'état haut
}
uint8_t spi_echange(uint8_t envoi){ // Communication sur le bus SPI
SPDR = envoi; // Octet a envoyer
while(!(SPSR & (1<<SPIF))); // Attente fin envoi (drapeau SPIF du statut)
return SPDR; // Octet reçu
}
void seven_seg(){
while(1){
spi_activer();
spi_echange(0x01);
spi_desactiver();
}
}
Exemple d'utilisation
Clignotement de 5 Leds asynchrones
Affichage clavier avec minicom
Création mémoire sur carte SD
Schéma de fonctionnement de la mémoire
La mémoire de la carte SD est composé de plusieurs paquets d'octets qui s'appellent "Bloc". Nous pouvons alors dire qu'un bloc est semblable à :
uint8_t Bloc[512]
Nous pouvons donc organiser notre espace comme nous le voulons.
Nous avons pris la liberté de changer légèrement le sujet en mettant le nom du fichier sur 14 octets au maximum et en disant qu'un bloc représente 512 octets, ce qui est d'ailleurs le cas sur nos cartes SD. Cela nous permet de décrire un fichier en 32 octets (nom + taille + indices) et de pouvoir mettre 16 description de fichier par bloc et d'ainsi utiliser tous les octets d'un bloc.
Récupération des commandes de base
Dans un premier temps, nous avons un programme qui permet à la carte de mère de reconnaitre 3 commandes: ls, rm et cp. Cela nous permettra par la suite de créer des fichiers, les supprimer et lire les fichiers présents dans le répertoire.
int main(){
init_stdio();
char data[Max_chaine],cmd[Max_chaine], arg1[Max_chaine],arg2[Max_chaine];
while(1) {
fgets(data,Max_chaine,stdin);
fprintf(stdout,"\r");
fflush(stdout);
int taille = sscanf(data,"%s %s %s", cmd,arg1,arg2);
if(taille != 0){
switch(taille){
case 1 :
if(strcmp(cmd,"ls") == 0) fprintf(stdout,"je suis un ls\n");
else fprintf(stdout,"je suis une fraude\n");
break;
case 2 :
if(strcmp(cmd,"rm") == 0) fprintf(stdout,"je suis un rm\n mon arg est : %s \n",arg1);
else fprintf(stdout,"je suis une fraude\n");
break;
case 3:
if(strcmp(cmd,"cp") == 0) {
fprintf(stdout,"je suis un cp\n");
fprintf(stdout,"mon arg1 est : %s\n",arg1);
fprintf(stdout,"mon arg2 est : %s\n",arg2);}
else fprintf(stdout,"je suis une fraude\n");
break;
}
}
}
}
Lors de l'utilisation de minicom, le fgets ne s'exécute que lors d'un "/n", cependant, un entrée sur le clavier correspond à un "/r", nous avons donc converti chaque "/r" en "/n" dans notre fonction de scan pour fluidifier l'utilisation.
static int get_serial_scanf(FILE *stream) {
static unsigned char nl=0;
if(stream==stdin){
if(nl){ nl=0; return '\n'; }
char c=get_serial();
if(c=='\r') nl=1;
return c;
}
return _FDEV_EOF;
}
À l'inverse, lors d'un fprintf, il est naturel en C de placer un "/n" à la fin d'une chaine de caractère. Cependant, la carte mère à besoin d'un "\r" pour effectuer ce retour à la ligne. Nous avons donc converti chaque "\n" en "\r" dans notre fonction d'impression.
static int send_serial_printf(char c,FILE *stream){
if(stream==stdout){
if(c=='\n') send_serial('\r');
send_serial(c);
}
return 0;
}
Accès mémoire de la carte SD
Pour pouvoir utiliser la carte SD, nous avons utilisé les fichiers Sd2Card qui sont une modification de la bibliothèque arduino. Ces fichiers permettent d'utiliser des fonctions comme readBlock et writeBlock afin de manipuler directement la mémoire de la carte SD par SPI.
Primitive système
Plusieurs primitives systèmes ont été ajoutés afin de manipuler la mémoire de la carte SD. Vous pouvez trouver ces fichiers dans le répertoire SD/ de notre dépôt git. Toutes les primitives renvoient leurs informations via le port série.
FORMAT
Cette primitive permet de formater la carte SD d'un bloc à un autre précisé en paramètre. Pour ce faire, la fonction écrit des 0 dans les blocs.
void FORMAT(int debut,int fin){
uint8_t buffer[BLOC_TAILLE];
memset(buffer,0,BLOC_TAILLE);
for(int i = debut; i<fin; i++) {writeBlock(&sd,i,buffer);}
}
LS
Pour lister les fichiers, seul le Superbloc est important. Plus précisément, les blocs compris entre 0 et 13. Dans ces blocs, nous récupérons seulement les 14 premiers octets (TAILLE_NOM) de chaque fichiers et ces noms de fichiers sont espacés de 32 octets (voir schéma)
Dans notre fonction, i représente le numéro de fichier que l'on va regarder et k permet de savoir à quel fichier dans le bloc nous sommes. La fonction envoi alors sur la sortie standard tous les fichiers ne commençant pas par 0.
void LS(){
uint8_t buffer[BLOC_TAILLE];
int BlockNumber = 0;
uint8_t filename[TAILLE_NOM];
readBlock(&sd,BlockNumber,buffer);
for(uint8_t i=0, k=0; i<NB_FILE_MAX; i++,k++){ // on parcours tous les emplacements potentiels des desc de fichiers
memset(filename,0,TAILLE_NOM); // reset du tampon qui contient le nom du fichier
if(k>((BLOC_TAILLE/sizeof(SD_files_desc))-1)){ // reset de k et passage au bloc suivant
BlockNumber++;
readBlock(&sd,BlockNumber,buffer);
k=0;
}
for(int j=0; j<TAILLE_NOM;j++){// Copie du nom dans filename
if(buffer[j+k*sizeof(SD_files_desc)] == 0) break; // Comparaison avec le caractère \0
else filename[j] = buffer[j+k*sizeof(SD_files_desc)];
}
if(filename[0] != 0)fprintf(stdout,"%s\n", filename);
}
}
APPEND
Crée un nouveau fichier ou le modifie s'il est déjà existant. Dans notre application, append() demande la taille du fichier et propose à l'utilisateur d'écrire dans son fichier bloc par bloc.
READ
Lis les blocs de données d'un fichier sous forme de chaîne de caractères.
CP
Permet de copier un fichier source dans un fichier de destination. Il récupère d'abord la taille et les indices de bloc des fichiers, regarde quels sont les blocs disponibles puis réécrit ces blocs avec la data du fichier src.
RM
Supprime le fichier spécifié en supprimant le descripteur du SuperBloc (nom + taille + indices) et passe à 0 dans la bitmap les octets représentant les blocs de données du fichier. Cependant, RM ne supprime pas les données du fichier : les fichiers créés nettoient d'abord les blocs avant d'écrire dessus. On évite donc de faire deux fois l'opération.
Fonctionnement des primitives
Bilan de puissance
Afin d'être sûr de l'alimentation de toutes les cartes, nous utilisons une alimentation +5V d'une Raspberry PI branchée sur secteur.
|
|
| |||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
CONCLUSION
Dans l’état actuel, les différentes cartes filles et la carte mère ne sont malheureusement pas encore en mesure de communiquer entre elles. Cependant, ce projet s’est révélé particulièrement enrichissant, car il nous a permis de mobiliser un large éventail de compétences acquises au cours de notre cursus, telles que la conception de PCB ou encore l’ordonnancement des tâches. En outre, il a constitué une excellente opportunité de développer nos capacités en gestion d’équipe, notamment à travers la coordination entre les différents groupes travaillant sur les cartes filles. Parmi les principaux défis rencontrés, la gestion de la mémoire de la carte SD a été particulièrement complexe, qu’il s’agisse de comprendre les mécanismes de communication avec cette dernière ou de définir une stratégie efficace pour la gestion des fichiers. Nous espérons sincèrement que ce wiki servira de guide utile aux futures promotions, en leur permettant d’éviter les erreurs que nous avons commises, et pourquoi pas, d’achever complètement ce projet ambitieux.