IMA3/IMA4 2019/2021 P1+
Présentation générale
- Nom du projet : Micro-ordinateur pour la pédagogie
- Stagiaire : Andrei FLOREA
- Encadrant : Xavier REDON
- Durée : 6 semaines (17 Mai - 25 Juin 2021)
Description
Concevoir et réaliser un ordinateur du même type que les ordinateurs familiaux des années 1980. L'ordinateur sera à base de micro-contrôleur mais avec clavier, écran et périphérique de sauvegarde.
Objectifs
Le but de ce projet est de réaliser un ordinateur peu puissant mais en le concevant de A à Z. Concernant le matériel :
- Le coeur doit être un micro-contrôleur, un processeur étant trop complexe à maîtriser, même si un AVR est envisageable, il serait préférable de partir vers un Cortex-M pour bénéficier d'une mémoire plus importante ;
- Pour les périphériques d'entrée, il faut utiliser un clavier USB et éventuellement une souris USB, ce qui implique de choisir un micro-contrôleur avec gestion USB ;
- Plusieurs choix sont possibles pour l'écran, un choix est de partir sur la génération de signaux VGA, il semble même envisageable d'utiliser une puce HDMI et enfin il existe le choix de l'écran LCD avec contrôleur intégré, choix fait par les concepteurs de la calculatrice NumWorks ;
- Pour le stockage, une carte micro-SD semble adaptée ;
- Une interface réseau est probablement indispensable qu'elle soit Ethernet ou WiFi.
Le système d'exploitation de l'ordinateur peut être basé sur micro-python avec ajout d'options spécifiques
Préparation du projet
Une première tentative de porter micro-python sur une carte ATXMEGAC3-XPLD a déjà été faite par Xuelu YAN en 2020. Je base donc mes efforts sur les siens.
De plus, il existe un port de micropython sur AVR.
Cahier des charges
Choix techniques : matériel et logiciel
- Matériel :
- Carte ATXMEGAC3-XPLD pour le prototypage
- Logiciel :
Liste des tâches à effectuer
- Première partie : Prototypage
- Prise en main de la carte ATXMEGAC3-XPLD
- Porter micro-python sur la carte ATXMEGAC3-XPLD
- OU créer un OS "maison"
- Créer un module USB (pour brancher un clavier)
- Choisir les composants
- Concevoir le circuit
- L'imprimer et y souder les composants
- Porter la bibliothèque LUFA de commande USB
- Coder l'interaction avec l'ATXMEGAC3
Calendrier prévisionnel
Réalisation du Projet
Prologue
Semaine 1
Exploration du code source de micro-python
J'ai d'abord commencé par explorer le code de micropython; je me suis dans un premier temps penché sur le port "avr8-dummy", qui est un exemple très basique (et générique) d'une implémentation de micro-python sur AVR.
On y voit un main.c, avec une fonction main qui ressemble à ça :
int main()
{
...
pyexec_event_repl_init();
for(;;) {
int c = mp_hal_stdin_rx_chr();
if (pyexec_event_repl_process_char(c)) {
break;
}
}
pyexec_friendly_reply();
...
}
Il semble que mp_hal_stdin_rx_chr serve à lire un caractère sur l'entrée standard,, et mp_hal_stdout_tx_strn. Une question se pose alors : qu'est-ce que l'entrée/sortie standard sur une Arduino ?
En cherchant un peu, j'ai trouvé le fichier mphalports.h, qui définit ces deux fonctions. Il me faut maintenant modifier la définition pour utiliser le port série. C'est ici que rentre en jeu la bibliothèque LUFA.
Exploration du code source de LUFA
LUFA est une librairie USB pour les microcontrolleurs AVR. Elle permet notamment de créer une connexion série entre un ordi et la carte.
Pour faciliter la tâche, on peut utiliser l'exemple VirtualSerial.
En modifiant légèrement le code du port micropython, on peut modifier les fonctions de façon à ce que les read et les print se fassent sur le port série.
Fusion de micropython et de LUFA
En ajoutant la bibliothèque LUFA dans le projet micropython, on peut maintenant interagir avec l’Arduino via le port série avec minicom. On peut interagir avec l'invite de commandes, mais..
On peut voir que micropython n'a pas l'air de très bien savoir ce qu'on veut de lui. Par conséquent, c'est le moment de plonger plus loin dans le code de micropython.
Replonger dans micropython
La fonction la plus intéressante dans main est pyexec_event_repl_process_char. Cette fonction appelle les fonctions suivantes (seules les fonctions les plus intéressantes (selon moi) sont renseignées) :
FONCTIONS DEFINITIONS
pyexec_event_repl_process_char (lib/utils/pyexec.c:345)
└ pyexec_friendly_repl_process_char (lib/utils/pyexec.c:232)
└ parse_compile_execute (lib/utils/pyexec.c:62)
├ mp_lexer_new_from_str_len (py/lexer.c:706)
│ └ mp_lexer_new (py/lexer.c:670)
├ mp_parse (py/parse.c:832)
├ mp_compile (py/compile.c:3527)
│ ├ mp_compile_to_raw_code (py/compile.c:3364)
│ └ mp_make_function_from_raw_code (py/emitglue.c:122)
└ mp_call_function_0 (py/runtime.c:601)
└ mp_call_function_n_kw (py/runtime.c:617)
└ mp_obj_get_type (py/obj.c:40)
└ type->call (py/obj.h:481)
En résumé, l'erreur peut venir de l'une des 4 étapes suivantes :
- lexing
- parsing
- compilation
- exécution
Pour l'instant, je n'ai pas envie de toucher aux parties lexing-parsing-compilation ; je vois d'abord la partie exécution. Je m’intéresse donc à la fonction mp_call_function_n_kw. La première fonction appelée par cette dernière est DEBUG_OP_printf, qui imprime des informations sur la fonction exécutée ; il suffit de definir MICROPY_DEBUG_VERBOSE = 1 pour activer l'affichage des printf de déverminage. J'ai également rajouté l'affichage de la mémoire utilisée, afin de déverminer de ce côté aussi. Malheureusement, je n'ai rien trouvé.
Semaine 2
Après l'échec avec micropython, je passe alors à l'option "créer mon propre OS". Puisque j'aime bien les fleurs, je décide de le nommer "fleurOS".
fleurOS
Dans un premier temps, je crée une invite de commandes :
Documents Rendus
source (archives.plil.fr)
