Version actuelle datée du 29 août 2020 à 06:36

Présentation générale

• Nom du projet : Micro-ordinateur pour la pédagogie

• Stagiaire : Xuelu YAN

• Encadrant : Xavier REDON

Projet

Objectif

Concevoir et réaliser un ordinateur du même type que les ordinateurs familiaux des années 1980. L'ordinateur sera donc à base de micro-contrôleur mais avec clavier, écran et périphérique de sauvegarde.

Description

Le but de ce projet est de réaliser un ordinateur peu puissant mais en le concevant de A à Z. Concernant le matériel :

1.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 ;

2.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 ;

3.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 ;

4.Pour le stockage, une carte micro-SD semble adaptée ;

5.Une interface réseau est probablement indispensable qu'elle soit Ethernet ou WiFi.

Le travail effectué

09 Mars - 22 Mars

Les tâches pour semaine 1

-Essayer la ATXMEGA384C3-XPLN

-Tester le programme intégré

-Ecrire un programme de clignotement de LED

-Charger le programme par DFU si possible

-Trouver le bootloader de l'ATXMEGA384C3, le téléchargeur pour le AVR DRAGON

-Compiler micropython par un ATXMEGA384C3

-Téléverser micropython sur l'ATXMEGA384C3

-Tester micropython sur l'ATXMEGA384C3

Réalisation

Tout d'abord, j'ai essayé la carte ATXMEGA384C3 et testé le programme original. Il y a un micro-écran sur la carte, après connecté sur l'ordinateur, il a affiché les informations (température...).

Ensuite, avant d'écrire le programme de clignotement des LEDs, il faut changer le mode en DFU. J'ai trouvé le méthode pour changer le mode en DFU avec le lien :

https://www.mouser.com/datasheet/2/268/doc8429-1066104.pdf

Le chargeur de démarrage Atmel ATxmegaA3BU par défaut est configuré de sorte qu'il est possible d'activer le chargeur de démarrage DFU en utilisant le bouton-poussoir SW0 sur le kit Atmel XMEGA-A3BU Xplained. Pour activer le mode DFU, appuyez sur SW0 tout en connectant le kit à l'USB.

Et puis, afin d'écrire le programme de clignotement des LEDs, j'ai réfère le datasheet de la carte pour déterminer les pins des LEDs. Dans ce cas, on peut ajuster le clignotement des LEDs.

Selon le formulaire, on peut déterminer les pins des LEDs: PR0x01, PR0x02, PD0x10, PD0x20.

Enfin, j'ai testé le programme. Il y a quatre LED disponibles sur la carte qui peuvent être allumées et éteintes. Deux LEDs jaunes, une LED verte (LED témoin d'alimentation) et une LED rouge (LED d'état). Les LEDs verte et rouge sont à l'intérieur du même boîtier et donc les couleurs peuvent être mélangées à l'orange lorsque les deux sont activées. Les LED jaunes et la LED rouge peuvent être activées en conduisant la ligne d'E / S connectée à GND. La LED verte est contrôlée via un FET et est allumée par défaut lorsque la carte est alimentée. Cependant, ce voyant d'alimentation peut également être éteint en entraînant la porte du FET vers GND.

23 Mars - 19 Avril

Après avoir vérifié le port série, micro-python n'implante pas le port série pour les atxmega. Il faut donc le faire avec l'example Virtualserial de la Lufa. Ensuite, j'ai trouvé la dernière version de la bibliothèque LUFA avec le lien : http://www.fourwalledcubicle.com/LUFA.php

Ensuite, j'ai récupéré le bibliothèque Lufa sur le pc avec les commandes :

mount /dev/sda2 /mnt
cp -r /mnt/lufa-LUFA-170418 /home/pifou

Et puis, M.RENON m'envoyé le fichier VirtualSerial qui est modifié pour l'atxmega384c3. Il faut mettre ce fichier sous le répertoire PolytechLille qui se trouve dans le répertoire lufa-LUFA-170418 :

mkdir PolytechLille    (dans le répertoire lufa-LUFA-170418)
mount /dev/sda2 /mnt
cp -r /mnt/Serial /home/pifou/lufa-LUFA-170418/PolytechLille

Et puis dans le répertoire Serial, j'ai obtenue le fichier VirtualSerial.hex avec la commande 'make'. Pour envoyer le fichier sur la carte :

dfu-programmer atxmega384c3 erase
dfu-programmer atxmega384c3 flash VirtualSerial.hex
dfu-programmer atxmega384c3 reset

Ensuite il faut rebrancher la carte et vérifier le port série avec la commande :

ls -l /dev/tty*

Puis il faut créer une petite fonction Bonton() afin de tester la carte dans minicom :

J'ai trouvé le port série /dev/tty/ACM0. Enfin, j'ai changé le port série à /dev/tty/ACM0 dans minicom pour réaliser la configuration. Après sortir, j'ai testé la carte dans minicom et il a affiché :

20 Avril - 14 Juin

Pour la suite, il faut faire la fusion du fichier Virtual Serial avec micropython. Tout d'abord, j'ai téléchargé les répertoires micropython et avr8-dummy, les liens sont comme la suivante:

https://github.com/micropython/micropython
https://github.com/slavaza/micropython-avr8

Pour réaliser la fusion, il faut d'abord pouvoir lancer le makefile de la demo Virtual Serial à partir du makefile de micropython. Le makefile de micropython étant donc le makefile principal que l'on lancera par la suite.

Pour ce faire, on ajoute cela au makefile de micropython :

LUFA_PROJECT = ./LUFA/SerialUSB 
$(LUFA_PROJECT):
      $(MAKE) -C $(LUFA_PROJECT)

Et il faut aussi mettre à l'intérieur du makefile de VirtualSerial :

first: $(TARGET).a
      mv $(TARGET).a lib$(TARGET).a

Ce makefile va donc compiler les fichiers .c et stocker à l'intérieur d'une librairie .a tous les .o créé.

Une fois cela effectué, il a fallu regrouper les fonctions principales à nos souhaits (VirtualSerial + Micropython) dans le main.c

Tout d'abord, je me suis concentré sur le fonctionnement de virtualSerial dans le main.c de la fusion.

void LUFA_USB_Initialization(void)
{
     /* Start the PLL to multiply the 2MHz RC oscillator to 32MHz and switch the CPU core to run from it */
     XMEGACLK_StartPLL(CLOCK_SRC_INT_RC2MHZ, 2000000, F_CPU);
     XMEGACLK_SetCPUClockSource(CLOCK_SRC_PLL);
     /* Start the 32MHz internal RC oscillator and start the DFLL to increase it to 48MHz using the USB SOF as a reference */
     XMEGACLK_StartInternalOscillator(CLOCK_SRC_INT_RC32MHZ);
     XMEGACLK_StartDFLL(CLOCK_SRC_INT_RC32MHZ, DFLL_REF_INT_USBSOF, F_USB);
     PMIC.CTRL = PMIC_LOLVLEN_bm | PMIC_MEDLVLEN_bm | PMIC_HILVLEN_bm;
     /* Hardware Initialization */
     USB_Init();
     GlobalInterruptEnable();
}

void LUFA_USB_Handling(void){
    CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
    USB_USBTask();
}

Ces deux fonctions sont définis dans le fichier VirtualSerial.c compilé par le makefile de VirtualSerial. Puis j'ai inclu ces fonctions dans le fichier VirtualSerialPublic.h, permettant de récupérer et d'utiliser ces fonctions dans le main.c.

Donc il faut ajouter la ligne suivante afin d'utiliser ces fonctions dans le main.c

#include "LUFA/SerialUSB/VirtualSerialPublic.h"

J'ai obtenu donc une création du port série ACM0 comme précédemment en lançant le makefile :

cd micropython/ports/atxmega-cdc/
make clean
make all

Ensuite, j'ai crée le fichier .hex par la commande de transformation et lancé le fichier .hex sur l'atxmega384c3 :

cd build/
avr-objcopy -O ihex firmware.elf firmware.hex
dfu-programmer atxmega384c3 erase
dfu-programmer atxmega384c3 flash VirtualSerial.hex
dfu-programmer atxmega384c3 reset

Après cela réalisé, j'implémente la fonction main des fonctions pour générer micropython.

static char *stack_top;
static char heap[2048];
int main(int argc, char **argv) {
   usb_vcp_init0();    
   int stack_dummy;
   stack_top = (char*)&stack_dummy;
   #if MICROPY_ENABLE_GC
   gc_init(heap, heap + sizeof(heap));
   #endif
   mp_init();
   #if MICROPY_ENABLE_COMPILER
   #if MICROPY_REPL_EVENT_DRIVEN
   pyexec_event_repl_init();
   for (;;) {
       usb_vcp_handling();    
       int c=mp_hal_stdin_rx_chr();
       if(c>0){
           if (pyexec_event_repl_process_char(c)) {
               break;
           }
       }
   }
   #else
   pyexec_friendly_repl();
   #endif
   //do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\\n')", MP_PARSE_SINGLE_INPUT);
   //do_str("for i in range(10):\r\n  print(i)", MP_PARSE_FILE_INPUT);
   #else
   pyexec_frozen_module("frozentest.py");
   #endif
   mp_deinit();
   return 0;
}

Après j’ai testé le programme dans le minicom:

minicom ACM0

En utilisant minicom sur le port ACM0, on se rend bien compte que les fonctions micropython sont bien utilisé car on se rend bien compte de la compréhension par le port série de certaine commande utilisé. Cependant il persiste un problème au niveau du résultat de la fonction. On peut voir que la commande print et la ligne avec une simple addition sont bien reçu, cependant il n'y a pas d'affichage du résultat de celle-ci.