SE4Binome2024-8

Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.

GIT du projet

PicoShield

Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.

23 septembre 2024

Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.

Le schéma de la carte mère

Le PCB de la carte mère

30 septembre 2024

Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille

Les LEDs fonctionnent

L'afficheur externe

1 octobre 2024

Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.

Lecture de la carte SD

Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.

Ordonnanceur

Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs). Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.

Les LEDs clignotent

Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile.

void init_task(int t){
    uint16_t oldSP = SP;
    SP = Taches[t].stack;
    uint16_t adresse = (uint16_t)Taches[t].start;
    asm volatile("push %0" : : "r" (adresse & 0x00ff));
    asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));
    portSAVE_Registers();
    Taches[t].stack = SP;
    SP = oldSP;
}

A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.

ISR(TIMER1_COMPA_vect, ISR_NAKED){
    /* Sauvegarde du contexte de la tâche interrompue */
    portSAVE_Registers();
    Taches[courant].stack = SP;
    /* Appel à l'ordonnanceur */
    ordonnanceur();
    /* Récupération du contexte de la tâche ré-activée */
    SP = Taches[courant].stack;
    portRESTORE_Registers();
    asm volatile("reti");
}

Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.

Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, serial_buffer est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions Serial_Transmit() et Serial_Receive() sont déclarées dans pico_serial.h et proviennent de la documentation AVR.

void SerialWrite(){
    while (1){
        Serial_Transmit('\r\n');
        Serial_Transmit(serial_buffer);
    }
}

void SerialRead(){
    while(1){
        serial_buffer = Serial_Receive();
    }
}

Paramètres du Minicom

Message reçu par le port série

Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.

Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches). Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.

void SPI_send(uint8_t data) {
    DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer
    SPDR = data;
    while (!(SPSR & (1 << SPIF)));
    DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran 
}

void clearDisplaySPI() {
    SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche
}

Pour afficher un caractère sur l'écran il suffit donc d'appeler SPI_send() en passant en paramètre le caractère à envoyer.

Les 5 tâches en parallèle

Carte mère

Parmi notre groupe, nous sommes le binôme en charge de la carte mère. Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec avr-dude pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB.

Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.

Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui est largement suffisant.

Notre PCB est terminé, voici le schéma et un rendu du PCB final.

Le schéma final (en 3 pages)

Le PCB final

Les fichiers GERBER sont disponibles dans notre dépot GIT