SE4Binome2024-6

GIT

Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

Objectif

Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

• Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

• Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

• Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

• Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

• Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

• Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.

Shield

Realisation

Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.

schematique du Bouclier	PCB routé
Carte après soudure

Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:

connexion Bouclier-Arduino

connexion Bouclier-Arduino

Tests

LEDs

Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.

Code C

Vidéo fonctionnement

#define BROCHE_LED_BLEU 4 #define BROCHE_LED_ORANGE 7 #define BROCHE_LED_ROUGE 14 #define BROCHE_LED_JAUNE 17 #define BROCHE_D3 0 void setup() { pinMode(BROCHE_LED_BLEU, OUTPUT); pinMode(BROCHE_LED_JAUNE, OUTPUT); pinMode(BROCHE_LED_ROUGE, OUTPUT); pinMode(BROCHE_LED_ORANGE, OUTPUT); pinMode(BROCHE_D3, OUTPUT) ; } void loop() { digitalWrite(BROCHE_D3, HIGH); digitalWrite(BROCHE_LED_ORANGE, HIGH); delay (1000); digitalWrite(BROCHE_LED_ROUGE, HIGH); delay(1000); digitalWrite (BROCHE_LED_BLEU, HIGH); delay (1000); digitalWrite(BROCHE_LED_JAUNE, HIGH); delay (1000) ; digitalWrite(BROCHE_LED_ROUGE, LOW); digitalWrite(BROCHE_LED_BLEU, LOW); digitalWrite(BROCHE_LED_JAUNE, LOW); digitalWrite(BROCHE_LED_ORANGE, LOW); delay(1000); }

clignotement des LEDs

fonctionnement effectif du bouclier (LED allumées)

fonctionnement effectif du bouclier (LED allumées)

Puce mémoire

Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.

Problème

En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès. Nous avons donc vérifié l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):

Code C	Visualisation
#include <SPI.h> // set pin 10 as the slave select for the digital pot: const int slaveSelectPin = 10; void setup() { // set the slaveSelectPin as an output: Serial.begin (9600); pinMode(slaveSelectPin, OUTPUT), // initialize SPI: SPI.begin(); } void loop() { digitalWrite(slaveSelectPin, LOW); SPI.transfer(0xaa); Serial.write("ok"); delay(100); }	Signal d'horloge

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

Carte SD reconnue

Connecteurs HE10

À l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6. Pour cela nous configurons la communication SPI avec avr-gcc grâce au code présent dans notre fichier spi.c grandement inspiré du code présent sur le site de Mr Redon (https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme.html). Ci-dessous un aperçu du code source utilisé pour gerer la communication SPI ainsi que celui utilisé pour gérer l'affichage du sept segments.

Configuration communication SPI
#define SPI_DDR DDRB #define SS_DDR DDRC #define SPI_PORT PORTC #define SPI_SS_M 2 // master ? #define SPI_MOSI 3 #define SPI_MISO 4 #define SPI_SCK 5 void spi_activer(void){ // Activer le périphérique SPI_PORT &= ~(1<<0); // Ligne SS à l'état bas } void spi_desactiver(void){ // Désactiver le périphérique SPI_PORT |= (1<<0); // 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 spi_init(void){ // Initialisation du bus SPI SPI_DDR |= (1<<SPI_MOSI)|(1<<SPI_SCK)|(1<<SPI_SS_M); // Définition des sorties SPI_DDR &= ~(1<<SPI_MISO); // Définition de l'entrée // Désactivation du périphérique SS_DDR |= (1<<0); // afficheur sur pc0 SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1); // Activation SPI (SPE) en état maître (MSTR) SPI_PORT |= (1<<0); // horloge F_CPU/64 (SPR1=1,SPR0=0) }
Code de gestion du sept segments	Image de fonctionnement
#include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include "SPI.h" int main(void){ spi_init(); spi_activer(); spi_echange(0x76); // adresse de l'afficheur du 7 segment spi_desactiver(); while(1){ spi_activer(); // active spi_echange('G'); _delay_ms(5); spi_echange('R'); _delay_ms(5); spi_echange('p'); _delay_ms(5); spi_echange('6'); spi_desactiver(); //désactive _delay_ms(5); } return 0; }	connecteur HE10 fonctionnel

Accomplissement des taches

Ordonnanceur

La principale tâche à accomplir en premier lieu est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le minuteur 1 de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les 20ms. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c

Le Timer 1 est configuré en mode CTC c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR non nue avec notre timer. Le code suivant nous a permis de réaliser cette tâche.

Code C

Vidéo de fonctionnement

#include <avr/io.h> #include <avr/interrupt.h> #define PRESCALER 256 #define NB_TICK 1250 #define CTC1 WGM12 // Better name void init_timer(void){ TCCR1A = 0; TCCR1B = 1<<CTC1; #if (PRESCALER==8) TCCR1B |= (1<<CS11); #elif (PRESCALER==64) TCCR1B |= (1<<CS11 | 11<<CS10); #elif (PRESCALER==256) TCCR1B |= (1<<CS12); #elif (PRESCALER==1024) TCCR1B |= (1<<CS12 | 1<<CS10); #endif OCR1A = NB_TICK; TCNT1 = 0; TIMSK1 = (1<<OCIE1A); } ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption PORTB ^= (1<<PB5); } int main(void) { DDRB |= (1<<PB5); init_timer(); sei(); while(1); }

LED PB5 clignote

Pour passer d'une ISR non nue à une ISR naked il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :

• pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h
• pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

typedef struct {
  void (*tache)(void);	
  int pile;
  int etat;//wake ou sleepy (processus actif ou en attente)
}tache; 
tache taches[TACHE_MAX];

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches (init_taches()) et une ISR nue cette fois, qui gère la succession des tâches. Nous utilisons cette fois une ISR NAKED pour avoir un contrôle total sur la gestion des registres et pour éviter la surcharge des sauvegardes et/ou restaurations automatiques générées par le compilateur.

Code C

Vidéo de fonctionnement

void init_taches() { for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++) { uint16_t sauv = SP; SP = taches[cpt].pile; uint16_t addresse=(uint16_t) taches[cpt].tache; asm volatile("push %0" : : "r" (addresse & 0x00ff)); asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8)); SAVE_REGISTERS(); taches[cpt].pile = SP; SP = sauv; } } ISR(TIMER1_COMPA_vect,ISR_NAKED) { // Sauvegarde du contexte de la tâche interrompue SAVE_REGISTERS(); taches[tache_courante].pile = SP; tache_courante ++; if (tache_courante >= TACHE_MAX) { tache_courante = 0; } // Récupération du contexte de la tâche ré-activée SP = taches[tache_courante].pile; RESTORE_REGISTERS(); asm volatile ( "reti" ); TCNT1=0; }

Les 2 LEDS clignotent à des fréquences differentes

Notre ordonnanceur est désormais capable de lancer plusiuers tâches en parallèle, nous pouvons donc passer à la gestion de l'état endormi de nos processus. Jusqu'à présent pour effectuer des pauses dans l'exécution de nos tâches nous utilisions la fonction _delay_ms en incluant la bibliothèque <util/delay.h> . Pour améliorer notre ordonnanceur nos effectuons maintenant les pauses avec une fonction que nous avons écrite (_delay). Pour l'utilisation de notre fonction nous avons redefini la structure des tâches à laquelle nous avons ajouté un champ temps représentant le temps pendant lequel la tâche reste endormie. Nous avons également écrit une fonction ordonnanceur qui décremente le champ temps d'une tâche puis la reveille une fois que le temps écoulé. Ci-dessous vous pouvez voir à quoi ressemblent ces fonctions.

Code fonction ordonnanceur

Code fonction _delay

void ordonnanceur() { int cpt_ord = 0; uint8_t tache_suivante = tache_courante; for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++) { if (taches[cpt].etat == SLEEPY) { taches[cpt].temps--; if(taches[cpt].temps <= 0) { taches[cpt].etat = WAKE; } ++cpt_ord; } } if (cpt_ord == (TACHE_MAX - 1)) { tache_suivante = 0; } else { do { tache_suivante = (tache_suivante + 1) % TACHE_MAX; } while (taches[tache_suivante].etat != WAKE); } tache_courante = tache_suivante; }

void _delay(uint16_t temps){ cli(); taches[tache_courante].temps = temps;// taches[tache_courante].etat = SLEEPY; sei(); TIMER1_COMPA_vect(); }

La nouvelle structure de tâche se presente de la façon suivante :

Code de la structure finale representant les tâches

typedef struct { void (*tache)(void); uint16_t pile; uint16_t temps; uint16_t etat; }tache

Ci-dessous, une vidéo de fonctionnement de la gestion de l'état endormi des processus. Vous pouvez voir au debut de la vidéo que seule la LED verte est active (état WAKE) pendant que la LED orange est endormie. Une fois le temps d'endormissement écoulé, vous pouvez voir la led orange commencer à clignoter (elle est passée à l'état WAKE) à la même fréquence que la LED verte. Pour une bonne gestion de l'état endormi nous ajoutons à notre liste de tâches une tâche _wait qui ne fait rien en bouclant juste indéfinimment.

Liste des tâches	Vidéo de fonctionnement
tache taches[TACHE_MAX] = {{_wait,0x0800,10,SLEEPY}, {gestion_LED4,0x0400,1000,SLEEPY}, {gestion_LED2,0x0600,10,WAKE}, };

video test multitache ordo (portsérie/LEDs) :

Carte file écran LCD

La carte fille écran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement nécessaire, mais suite au rajout d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux de MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.

Voici les étapes de conceptions de notre carte fille:

Schématique de notre carte fille écran	Routage de notre carte fille écran
Visualisation 3D de notre carte PCB (face avant)	Visualisation 3D de notre carte PCB (face arrière)

réception de la carte PCB: