« SE4Binome2024-2 » : différence entre les versions

De projets-se.plil.fr
Aller à la navigation Aller à la recherche
Aucun résumé des modifications
Ligne 2 : Ligne 2 :


== Introduction ==
== Introduction ==
Ce rapport présente les différentes étapes de conception et de développement d'un "pico ordinateur" basé sur Arduino. Le projet comporte plusieurs composants, notamment une carte Shield, un ordonnanceur, et une carte fille pour un afficheur 7 segments. Les sections suivantes détaillent chaque composant, les tests réalisés et les résultats obtenus.
Ce projet vise à concevoir un pico ordinateur divisé en plusieurs parties, réalisées par différents binômes. Le rôle de notre binôme est de développer une carte fille équipée d'un microcontrôleur ATMega328p et d'un écran LCD contrôlé par un HD44780, en plus de la conception d'un Shield et d'un ordonnanceur. Cette carte sera connectée à une carte mère via un connecteur HE10 et devra gérer l'affichage de caractères ASCII, ainsi que quelques commandes spécifiques VT100. De plus, nous avons ajouté une RAM SPI pour améliorer les performances de gestion de l'affichage.


== Carte Shield ==
== Carte Fille (Écran LCD) ==


=== Description ===
=== Description ===
La carte Shield utilisée est une carte Arduino customisée que nous avons soudée et testée. Cette carte comporte plusieurs connecteurs et fonctionnalités, dont des LED et un lecteur de carte SD.
La carte fille que nous avons développée contient les éléments suivants :
 
=== Tests Réalisés ===
Nous avons testé les éléments suivants :
 
* Clignotement des LED : Pour tester la fonctionnalité des LED, nous avons utilisé des codes d'exemples disponibles dans le logiciel Arduino, notamment le clignotement des LED via des boucles <code>digitalWrite()</code>.
 
* Afficheur 7 segments : Nous avons connecté un afficheur 7 segments à la carte Shield via une interface SPI. Voici un extrait du code utilisé pour afficher des nombres sur l'afficheur :
 
<syntaxhighlight lang="cpp">
#include <SPI.h>


const int ssPin = 1;
* Un microcontrôleur **ATMega328p** pour la gestion de l'affichage.
* Un écran **LCD avec contrôleur HD44780** pour l'affichage de caractères ASCII.
* Un **potentiomètre** pour ajuster la luminosité des cristaux liquides de l'écran.
* Un **connecteur HE10** pour relier la carte fille à la carte mère.
* Un **connecteur AVR ISP** pour la programmation du microcontrôleur.
* Une **RAM SPI (e.g. FM24C04B-GTR)** pour stocker temporairement les données d'affichage.


void setup() {
=== Fonctionnalités Demandées ===
  pinMode(ssPin, OUTPUT); 
1. **Gestion de l'écran LCD** : Le microcontrôleur doit gérer les écrans HD44780 avec 1, 2, 3 ou 4 lignes et afficher des caractères ASCII.
  digitalWrite(ssPin, HIGH); 
2. **Saut de ligne et retour chariot** : Les caractères spéciaux `\n` et `\r` doivent être pris en compte.
  SPI.begin(); 
3. **Commandes VT100** : Quelques codes VT100, notamment ceux pour le déplacement du curseur, doivent être supportés.
  SPI.setClockDivider(SPI_CLOCK_DIV64); 
4. **Défilement automatique** : Le contrôleur HD44780 doit être configuré pour activer le mode de défilement automatique.
}
5. **Connexion SPI** : La carte mère doit envoyer les commandes via SPI. Le premier octet envoyé doit être le code commande `0x01`, suivi des caractères à afficher.
6. **Vérification de la disponibilité de l'écran** : La carte fille met la ligne SPI en état haut lorsqu'un affichage est en cours. La carte mère doit attendre que l'état soit bas avant de transmettre de nouvelles données, ou envoyer des commandes `0xFF` pour vérifier si l'écran est prêt.


void loop() {
=== Ajout d'une RAM SPI ===
  // Envoi des données à l'afficheur
Pour complexifier la carte fille, nous avons ajouté une **RAM SPI** (e.g. FM24C04B-GTR). Cette mémoire permet de stocker temporairement les caractères reçus par SPI avant leur affichage. Le microcontrôleur de la carte fille rafraîchit régulièrement l'écran en lisant les données de la RAM, ce qui améliore la fluidité de l'affichage et permet de libérer la carte mère plus rapidement.
  digitalWrite(ssPin, LOW);
  SPI.transfer('1');  // Affiche '1' sur l'afficheur
  digitalWrite(ssPin, HIGH);
}
</syntaxhighlight>


Ce code configure la communication SPI et permet d'afficher des chiffres sur l'afficheur 7 segments.
Voici un schéma simplifié de la communication entre les composants :
* La **carte mère** écrit dans la RAM SPI via le bus SPI.
* Le **microcontrôleur** de la carte fille lit les données de la RAM SPI et les envoie à l'écran LCD pour mise à jour régulière.


* Lecteur de carte SD : Nous avons également testé le lecteur de carte SD intégré à la carte Shield à l'aide des exemples Arduino pour la gestion des fichiers.
=== Schéma de Connexion ===
Le schéma de la carte fille inclut :
* Connexion de l'écran LCD au microcontrôleur via le bus parallèle.
* Connexion SPI entre la carte mère et la carte fille via le connecteur HE10.
* Connexion entre la RAM SPI et le microcontrôleur pour la gestion des données d'affichage.


== Ordonnanceur ==
== Ordonnanceur ==


=== Introduction ===
=== Introduction ===
L'ordonnanceur est une partie essentielle de notre pico ordinateur, permettant la gestion de plusieurs tâches. Nous avons configuré un timer pour ordonnancer différentes tâches, mais les tests de ces tâches avec l'ordonnanceur n'ont pas encore abouti à un succès complet.
En complément de notre travail sur la carte fille, nous avons également participé au développement de l'ordonnanceur, qui permet la gestion des tâches dans le pico ordinateur. Cet ordonnanceur est crucial pour coordonner les différentes tâches, comme l'affichage, la gestion des périphériques, et l'exécution des programmes utilisateurs.
 
=== Fonctionnement du Timer ===
Nous avons initialisé le **timer 1** pour gérer l'ordonnancement des tâches. Voici une explication du code utilisé pour initialiser le minuteur :
 
<syntaxhighlight lang="cpp">
void init_minuteur(int diviseur, long periode) {
    TCCR1A = 0;             
    TCCR1B = (1 << CTC1);     
    switch (diviseur) {
        case 8: TCCR1B |= (1 << CS11); break;
        case 64: TCCR1B |= (1 << CS11 | 1 << CS10); break;
        case 256: TCCR1B |= (1 << CS12); break;
        case 1024: TCCR1B |= (1 << CS12 | 1 << CS10); break;
    }
    OCR1A = F_CPU / 1000 * periode / diviseur; 
    TCNT1 = 0;               
    TIMSK1 = (1 << OCIE1A); 
}
</syntaxhighlight>
 
Ce code configure le timer pour générer des interruptions à des périodes régulières, ce qui permet d'interrompre une tâche en cours et de passer à une autre.


=== Gestion des Tâches ===
=== Gestion des Tâches ===
Chaque tâche est définie dans un tableau structuré. Voici un extrait du tableau de processus qui stocke les tâches et leurs pointeurs de pile :
L'ordonnanceur utilise un système de **Round Robin** pour gérer les tâches, et chaque tâche est assignée à une ligne SPI spécifique pour les périphériques, comme l'écran ou les claviers.
 
<syntaxhighlight lang="cpp">
typedef struct process {
    uint16_t stackPointer;
    void (*addressFunction)(void);
    int state;
} process;
 
process task[NB_TASKS] = {
    {0x700, Serial_Led, 0},
    {0x600, LED1_blink, 0},
    {0x500, Serial_Message, 0}
};
</syntaxhighlight>


La fonction <code>scheduler()</code> se charge de passer d'une tâche à une autre :
Voici un extrait du code de l'ordonnanceur qui assure le changement de tâche :


<syntaxhighlight lang="cpp">
<syntaxhighlight lang="cpp">
Ligne 92 : Ligne 54 :
</syntaxhighlight>
</syntaxhighlight>


Une interruption est utilisée pour sauvegarder et restaurer les registres lors du changement de tâche.
L'ordonnanceur vérifie également que chaque périphérique est disponible avant d'envoyer une nouvelle commande, pour éviter des conflits dans la gestion des affichages et autres périphériques.
 
== Carte Shield ==
 
=== Description ===
La carte Shield est une carte mère qui sert à connecter et contrôler divers périphériques, notamment la carte fille (écran), un clavier, et d'autres composants. Nous avons conçu cette carte pour faciliter la gestion des communications SPI entre la carte mère et les différentes cartes filles.
 
=== Connectivité SPI ===
La carte Shield utilise plusieurs lignes SPI pour communiquer avec les cartes filles. Chaque périphérique, comme l'écran, est assigné à une ligne SPI spécifique. La carte Shield vérifie également la disponibilité des périphériques avant d'envoyer des commandes via SPI.
 
== Tests Réalisés ==


== Carte Fille Afficheur ==
=== Tests de la Carte Fille ===
* **Affichage ASCII** : Nous avons testé l'affichage de caractères ASCII sur l'écran LCD, en envoyant des chaînes de caractères via SPI. Le microcontrôleur décode les commandes reçues et met à jour l'écran en conséquence.
* **Défilement automatique** : Nous avons activé et testé le mode défilement automatique du contrôleur HD44780, qui permet de déplacer les lignes de texte à l'écran.
* **Commandes VT100** : Nous avons également implémenté et testé quelques commandes VT100 pour le déplacement du curseur à l'écran.


=== Schématique ===
=== Tests de l'Ordonnanceur ===
Nous avons commencé à dessiner le schéma de notre carte fille, qui sera utilisée pour connecter un afficheur. Ce schéma inclut les connexions SPI nécessaires pour l'afficheur 7 segments et les autres composants qui y seront intégrés.
* **Gestion des tâches** : Nous avons simulé plusieurs tâches, dont l'affichage et la gestion du clavier, et vérifié que l'ordonnanceur passe correctement d'une tâche à l'autre.


=== Liste des Composants ===
=== Tests de la RAM SPI ===
* [[Insérer la liste des composants ici]]
* **Stockage des données d'affichage** : Nous avons testé la communication entre la RAM SPI et le microcontrôleur, en vérifiant que les données sont correctement stockées dans la RAM avant d'être affichées à l'écran.


== Conclusion ==
== Conclusion ==
Bien que certains aspects du projet soient encore en développement, nous avons réussi à tester avec succès la carte Shield et certaines fonctionnalités comme l'affichage 7 segments et le clignotement des LED. L'implémentation de l'ordonnanceur et des tâches est en bonne voie, mais nécessite encore quelques ajustements pour une exécution parfaite. Nous prévoyons d'approfondir ces aspects dans les prochaines étapes du projet.
Le développement de la carte fille pour le pico ordinateur est en bonne voie, avec une gestion efficace de l'affichage via SPI et l'ajout d'une RAM SPI pour optimiser la gestion des données. L'ordonnanceur permet également de coordonner les tâches de manière efficace. Il reste encore quelques ajustements à faire pour la gestion des commandes VT100 et l'amélioration des performances globales du système.

Version du 15 octobre 2024 à 19:37

Rapport du Pico Ordinateur

Introduction

Ce projet vise à concevoir un pico ordinateur divisé en plusieurs parties, réalisées par différents binômes. Le rôle de notre binôme est de développer une carte fille équipée d'un microcontrôleur ATMega328p et d'un écran LCD contrôlé par un HD44780, en plus de la conception d'un Shield et d'un ordonnanceur. Cette carte sera connectée à une carte mère via un connecteur HE10 et devra gérer l'affichage de caractères ASCII, ainsi que quelques commandes spécifiques VT100. De plus, nous avons ajouté une RAM SPI pour améliorer les performances de gestion de l'affichage.

Carte Fille (Écran LCD)

Description

La carte fille que nous avons développée contient les éléments suivants :

  • Un microcontrôleur **ATMega328p** pour la gestion de l'affichage.
  • Un écran **LCD avec contrôleur HD44780** pour l'affichage de caractères ASCII.
  • Un **potentiomètre** pour ajuster la luminosité des cristaux liquides de l'écran.
  • Un **connecteur HE10** pour relier la carte fille à la carte mère.
  • Un **connecteur AVR ISP** pour la programmation du microcontrôleur.
  • Une **RAM SPI (e.g. FM24C04B-GTR)** pour stocker temporairement les données d'affichage.

Fonctionnalités Demandées

1. **Gestion de l'écran LCD** : Le microcontrôleur doit gérer les écrans HD44780 avec 1, 2, 3 ou 4 lignes et afficher des caractères ASCII. 2. **Saut de ligne et retour chariot** : Les caractères spéciaux `\n` et `\r` doivent être pris en compte. 3. **Commandes VT100** : Quelques codes VT100, notamment ceux pour le déplacement du curseur, doivent être supportés. 4. **Défilement automatique** : Le contrôleur HD44780 doit être configuré pour activer le mode de défilement automatique. 5. **Connexion SPI** : La carte mère doit envoyer les commandes via SPI. Le premier octet envoyé doit être le code commande `0x01`, suivi des caractères à afficher. 6. **Vérification de la disponibilité de l'écran** : La carte fille met la ligne SPI en état haut lorsqu'un affichage est en cours. La carte mère doit attendre que l'état soit bas avant de transmettre de nouvelles données, ou envoyer des commandes `0xFF` pour vérifier si l'écran est prêt.

Ajout d'une RAM SPI

Pour complexifier la carte fille, nous avons ajouté une **RAM SPI** (e.g. FM24C04B-GTR). Cette mémoire permet de stocker temporairement les caractères reçus par SPI avant leur affichage. Le microcontrôleur de la carte fille rafraîchit régulièrement l'écran en lisant les données de la RAM, ce qui améliore la fluidité de l'affichage et permet de libérer la carte mère plus rapidement.

Voici un schéma simplifié de la communication entre les composants :

  • La **carte mère** écrit dans la RAM SPI via le bus SPI.
  • Le **microcontrôleur** de la carte fille lit les données de la RAM SPI et les envoie à l'écran LCD pour mise à jour régulière.

Schéma de Connexion

Le schéma de la carte fille inclut :

  • Connexion de l'écran LCD au microcontrôleur via le bus parallèle.
  • Connexion SPI entre la carte mère et la carte fille via le connecteur HE10.
  • Connexion entre la RAM SPI et le microcontrôleur pour la gestion des données d'affichage.

Ordonnanceur

Introduction

En complément de notre travail sur la carte fille, nous avons également participé au développement de l'ordonnanceur, qui permet la gestion des tâches dans le pico ordinateur. Cet ordonnanceur est crucial pour coordonner les différentes tâches, comme l'affichage, la gestion des périphériques, et l'exécution des programmes utilisateurs.

Gestion des Tâches

L'ordonnanceur utilise un système de **Round Robin** pour gérer les tâches, et chaque tâche est assignée à une ligne SPI spécifique pour les périphériques, comme l'écran ou les claviers.

Voici un extrait du code de l'ordonnanceur qui assure le changement de tâche : 

void scheduler() {
    currentTask++;
    if (currentTask == NB_TASKS) currentTask = 0; // Mode Round Robin
}

L'ordonnanceur vérifie également que chaque périphérique est disponible avant d'envoyer une nouvelle commande, pour éviter des conflits dans la gestion des affichages et autres périphériques.

Carte Shield

Description

La carte Shield est une carte mère qui sert à connecter et contrôler divers périphériques, notamment la carte fille (écran), un clavier, et d'autres composants. Nous avons conçu cette carte pour faciliter la gestion des communications SPI entre la carte mère et les différentes cartes filles.

Connectivité SPI

La carte Shield utilise plusieurs lignes SPI pour communiquer avec les cartes filles. Chaque périphérique, comme l'écran, est assigné à une ligne SPI spécifique. La carte Shield vérifie également la disponibilité des périphériques avant d'envoyer des commandes via SPI.

Tests Réalisés

Tests de la Carte Fille

  • **Affichage ASCII** : Nous avons testé l'affichage de caractères ASCII sur l'écran LCD, en envoyant des chaînes de caractères via SPI. Le microcontrôleur décode les commandes reçues et met à jour l'écran en conséquence.
  • **Défilement automatique** : Nous avons activé et testé le mode défilement automatique du contrôleur HD44780, qui permet de déplacer les lignes de texte à l'écran.
  • **Commandes VT100** : Nous avons également implémenté et testé quelques commandes VT100 pour le déplacement du curseur à l'écran.

Tests de l'Ordonnanceur

  • **Gestion des tâches** : Nous avons simulé plusieurs tâches, dont l'affichage et la gestion du clavier, et vérifié que l'ordonnanceur passe correctement d'une tâche à l'autre.

Tests de la RAM SPI

  • **Stockage des données d'affichage** : Nous avons testé la communication entre la RAM SPI et le microcontrôleur, en vérifiant que les données sont correctement stockées dans la RAM avant d'être affichées à l'écran.

Conclusion

Le développement de la carte fille pour le pico ordinateur est en bonne voie, avec une gestion efficace de l'affichage via SPI et l'ajout d'une RAM SPI pour optimiser la gestion des données. L'ordonnanceur permet également de coordonner les tâches de manière efficace. Il reste encore quelques ajustements à faire pour la gestion des commandes VT100 et l'amélioration des performances globales du système.

Récupérée de « http:///mediawiki/index.php?title=SE4Binome2024-2&oldid=6313 »