SE4Binome2023-2

Ordonnanceur/ Système d'exploitation

Ordonnanceur

Durant les dernières séances, nous avons avancé sur la réalisation de l'ordonnanceur. En effet nous avons actuellement un version d'ordonnanceur qui fait marcher trois tâche de la carte simultanément. Nous avons adapté le delay des tâches pour avoir une alternance de 0.9s à l'état haut et 0.9s à l'état bas, et ce grâce à un Delay de 0.3s dans chaque tâche (0.3*3=0.9).

Arduino ordonnanceur 3 tâches

Lors de la Réalisation nous avons eu quelques problème, notamment dû a l'initialisation des adresses des tâches qui se faisait après l'initialisation des tâches elles même, rendant le code aléatoire. Nous devons à présent réaliser une fonction qui va permettre de mieux gérer les états des processus en les endormant pour ainsi les réveiller à la fin de l'ISR.

Soudure et test du SHIELD Arduino Uno

ReX : Mettez vos réalisations pour le matériel de l'ordonnancement dans la section appropriée.

Lors de la première séance, nous avons soudé tous les composants du shield. Sur l'un des connecteurs, il manque une led (led abimée lors de la soudure). Ce n'est pas grave car les leds sont uniquement des indicateurs pour savoir quelle carte a son ship select d'activé. Nous avons aussi réalisé un programme grâce à l'IDE arduino pour tester de façon rapide les différentes leds du shield.

void setup(){
pinMode(1, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(A3, OUTPUT);
  pinMode(A0, OUTPUT); // Led non soudée
}
void loop() {
  digitalWrite(1, HIGH);
  digitalWrite(4, HIGH);
  digitalWrite(7, HIGH);
  digitalWrite(A0, HIGH);
  digitalWrite(A3, HIGH);
  delay(1000);
  digitalWrite(1, LOW);
  digitalWrite(4, LOW);
  digitalWrite(7, LOW);
  digitalWrite(A0, LOW);
  digitalWrite(A3, LOW);
}

Pour finir, nous avons testé le lecteur micro-SD grâce au programme Fichier:TestSD avrgcc.zip et nous l'avons exectué grâce à la commande make upload.

SHIELD MONTE SUR ARDUINO AVEC LED	Message succès test carte micro-SD

Système d'exploitation

Pour faciliter l'activation des différents esclaves, nous avons créée un structure cs_t qui est composée d'un PORT et d'un PIN. Puis en initialisant un tableau de cette même structure, nous pouvons facilement associer un CS avec son PORT et son PIN. Maintenant plus besoin de vérifier sur quel PIN et quel PORT l'esclave est relié. Cela nous permet de gagner du temps mais également que le programme soit plus fiable car le tableau est initialisé, jamais modifié et correct.

Carte éléctronique numérique

Cartes Sparkfun

Prérequis SPI

Pour faire fonctionner les différentes cartes sparkfun, nous devons tout d'abords comprendre le fonctionnement du SPI. Les cartes ne possèdent pas de MISO car elles ne font que recevoir des données du maître. Pour initialiser le SPI sur un Atmega328p, il faut initialiser les différents registres du SPI.

void spi_init()
{
    // Initialisation des ports en mode SPI (sorties et entrées)
    DDRB |= (1 << PB2);
    DDRB |= (1 << MOSI);
    DDRB &= ~(1 << MISO);
    DDRB |= (1 << SCK);
    // Initialisation des différents CS(1-6)
    DDRB |= (1 << CS1);
    DDRC |= (1 << CS2);
    DDRC |= (1 << CS3);
    DDRD |= (1 << CS4);
    DDRD |= (1 << CS5);
    DDRB |= (1 << CS6);
    // Désactiver les différents esclaves
    PORTB |= (1 << CS1);
    PORTC |= (1 << CS2);
    PORTC |= (1 << CS3);
    PORTD |= (1 << CS4);
    PORTD |= (1 << CS5);
    PORTB |= (1 << CS6);
    //Configuration des paramètres du mode de com SPI
    SPCR = (1 << SPE)|(1 << MSTR)|(1<<SPR1);
}

Ensuite, le SPI discutera avec les différents esclaves en mettant les différents CS au niveau logique bas. C'est uniquement à ce moment que l'esclave se réveillera et lira les données sur le MOSI. Une fois l'esclave réveillé, nous devons envoyer des données sur le MOSI. Pour cela, nous allons devoir créer une fonction qui placera les données sur le MOSI.

// Envoie un octet sur le bus SPI
void SPI_transmit(uint8_t data)
{

    // Début de la transmission
    SPDR = data;

    // Attendre que la transmission ne finisse
    while (!(SPSR & (1 << SPIF)))
        ;
}

Une fois le code primitif du SPI effectué, nous devons comprendre comment les différentes cartes fonctionnent.

Afficheur 7 segments

Toutes les informations pour comprendre comment l'écran fonctionne sont disponibles sur ce site : [1]

Pour faire fonctionner l'écran, nous devons lui envoyer différentes commandes qui permetterons différentes actions. Il y a nottement des commandes pour selectionner la luminosité ou encore éteindre l'écran.

Les différentes commandes pour controler l'écran

Si on veut mettre un certain nombre sur l'écran, nous pouvons découper avec nombre avec ses milliers,centaines,dixaines et unités. Puis en selectionnant le 7 segments correctement, nous pouvons envoyer la donnée.

- Pour selectionner le bon 7 segments, nous devons agir sur le "Digit X control".

- Pour agir sur les points du 7 segments, nous devons agir sur le "Decimal control" puis envoyer une donnée pour choisir quel(s) point(s) allumer

Pour afficher le chiffre 9 et un point, nous aurions un code comme celui ci  :

Code	Résultat
int main(){ spi_init(); while(1){ set_activer(&PORTC,CS2); SPI_trans(0x7E); // Segment des unités SPI_trans(0b1101111); // Envoyer la donnée '9' SPI_trans(0x77); // Contrôle des points SPI_trans(0b0010000); // Envoyer le(s) point(s) à allumer ':' set_desactiver(&PORTC, CS2); _delay_ms(500); nettoyerEcran(&PORTC, CS2); // Permet de faire clognoter _delay_ms(500); } return 0; }

On peut facilement afficher n'importe quel nombre avec une fonction dédiée et faire un compteur par exemple (cf. fonction afficher_nombre).

Matrice de Leds

Toutes les informations sur le fonctionnement de la matrice de leds se trouvent sur cette page : [2]

Il est important de noter que la vitesse maximale de SCK est de 125KHz. Il faut donc régler les paramètres du SPI.

Pour cela, on va devoir modifier notre fonction spi_init(). On doit diviser la fréquence par 128 ( 16 MHz / 125 KHz ).

  void spi_init()
{
    // Initialisation des ports en mode SPI (sorties et entrées)
    DDRB |= (1 << PB2);
    DDRB |= (1 << MOSI);
    DDRB &= ~(1 << MISO);
    DDRB |= (1 << SCK);
    // Initialisation des différents CS(1-6)
    DDRB |= (1 << CS1);
    DDRC |= (1 << CS2);
    DDRC |= (1 << CS3);
    DDRD |= (1 << CS4);
    DDRD |= (1 << CS5);
    DDRB |= (1 << CS6);
    // Desactiver les différents esclaves
    PORTB |= (1 << CS1);
    PORTC |= (1 << CS2);
    PORTC |= (1 << CS3);
    PORTD |= (1 << CS4);
    PORTD |= (1 << CS5);
    PORTB |= (1 << CS6);
    // Configuration des paramètres du mode de com SPI avec une fréquence de 125KHz
    SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 <<SPR0);
}

Nous avons mis SPR0 et SPR1 à 1 comme expliqué dans la datasheet de l'AVR.

Tableau des correspondances des fréquences

Pour faire fonctionner la matrice de leds, il faut comprendre son fonctionnement. Le principe est très simple. Pour alumer toutes leds leds d'une certaine couleur, il suffira d'envoyer un certain code 64 fois pour que toutes les leds s'allument de cette couleurs. Les leds sont rangés par lignes puis collones.

Pour que le code fonctionne, il faut envoyer le code 0x26 pour réinitialiser l'indice de l'image.

On peut regarder les différents codes couleurs et effectuer un code pour afficher du orange par exemple :

Correspondances données couleurs

Pour le orange, il faut donc envoyer le code 0xFC.

Code	Résultat
set_activer(CS[2]); //Esclave à l'écoute SPI_trans(0x26); // Commande pour réinitialiser l'incide d'image for (int i = 0; i < 64 ; i++){ SPI_trans(0xFC); // Transferer 64 octets pour mettre les leds en Orange } set_desactiver(CS[2]); //Esclave s'endort

Type de carte choisie

Nous avons choisi la MOTHERBOARD

Design choisi

La MB est programmable via USB grace au FT232RL qui est un convertisseur USB série mais elle peut être programmée directement grâce à l'AVR ISP. La carte peut être alimentée en 5V grâce au port USB mais aussi en 12V avec le port Jack. Le 12V est converti en 5V pour les différents périphériques. On a pensé à mettre un connecteur pour un ventilateur (pourquoi pas) sur le 12V. Il y a un comparateur qui connecté avec un mosfet permet de choisir entre le une alimentation via l'USB ou directement par le port Jack. Il y a 2 differents convertisseurs : 12V-5V et 5V-3,3V. Le 3,3V est utilisé par la mémoire flash qui communique avec l'Atmega328p via le buffer.

Durant la deuxième séance nous avons avancé sur la réalisation du Schématique de la carte mère. Nous avons également soudée la carte qui permet de passer du connecteur HE10 à un afficheur 7 segment.

Lors de la troisième séance nous avons commencer le routage de la Carte mère.

Lors de la 6ième scéance, la carte mère nous avons finis le routage de la carte mère. Il y a eu des modifications et des ajouts pour le bon fonctionnement de la carte. La carte est prête à la fabrication.

Schématique de la MB	Routage de la CM
PCB de la CM

Lors de la séance du 7 Novembre 2023, nous avons commencé la soudure de la carte. Les composants indispensables au premiers tests ont été soudés à savoir l'AVR, le cristal, des capacités, des résistances ainsi qu'un led

Lors de la séance du 14 Novembre 2023, nous avons testé l'atmega328p grâce à un Arduino as ISP programmer.

Après le teste de programmation, nous avons continué de souder la carte à savoir le bridge USB - SERIE et des leds de test sur le RX, TX et l'alimentation 5V.

La carte est détectée par l'ordinateur avec la commande LSUSB. De plus toutes les leds s'allument ce qui est bon signe.

Par la suite il a fallu mettre un bootloader dans l'atmega328p pour la programmation via USB. Nous avons procédé au téléversement grâce à un arduino directement avec l'IDE. Par la suite nous avons essayé de mettre nous programme directement par USB. Malheureusement, nous avions une erreur stipulant avrdude: stk500_recv(): programmer is not responding. Cette erreur était due à une capacité manquante sur entre les broches DTR et RESET. Une fois soudée, nous avons réessayé de programmer l'AVR par USB. Et maintenant, ÇA FONCTIONNE !!! Il ne manque plus que de souder les autres leds, résistances et IC pour pouvoir programmer notre carte mère comme nous le faisons actuellement avec l'arduino et le shield.

FTDI reconnue par l'ordinateur	CM avec la partie USB et la capacité soudées

Lors de la séance du 20 Novembre 2023, nous avons finis les soudures de la carte mère (en réalité il manque la partie 12V mais elle n'est pas indispensable). Nous allons pouvoir faire les tests de l'ordonnanceur sur la carte mère au lieux de l'arduino. Nous allons également pouvoir tester la mémoire avec le code fourni.

Axe d'amélioration / Problèmes rencontrés

Bien que notre carte mère fonctionne de manière optimale, des améliorations sont possibles, notamment en intégrant une capacité de 100nF entre le DTR du FTDI et le reset de l'AVR. Cette modification aurait éliminé la nécessité de souder manuellement la capacité, assurant ainsi un résultat plus propre. De plus, la perforation de la carte pour l'ajout de patins clipables aurait constitué une autre amélioration pratique.

En revanche, nous avons découvert que nous avions inversé le MISO et le MOSI sur les connecteurs HE10. Cela nous a profondément freiné pour tester les périphériques en SPI. Une modification manuelle a été effectué en coupant et inversant les deux pistes en sortie de l'AVR ISP. Toutes les modifications indispensables sont disponibles sur le git.

Concernant les problèmes rencontrés. Nous avons eu pas mal de problème à différents niveau mais nous avons toujours essayé de trouver une solution et d'approfondir nos connaissances.

Il nous est arrivé de ne pas pouvoir téléverser de code sur la carte. En réalité, la carte mère n'était pas détectée. Le problème était qu'une trop grosse capacité de découplage (47µF à la place de 10µF) était installée. Quand nous débranchions et rebranchions rapidement, la capacité n'était pas totalement déchargée et donc avait une influence lors du démarrage (capacité débranchée, fonctionne bien sans). Aussi, quand la matrice de led est connectée à la carte, dès que nous branchons la CM à un SUB, aucun périphèrique n'est détecté. Nous pensons que la matrice led demande suffisement de puissance au démarrage pour que le FTDI ne démarre pas correctement. Nous ne rencontrons pas ce problème quand nous branchons uniquement le 7 segments.

Annexes

Lien Git: [3]