Micro-ordinateur pour la pédagogie : Différence entre versions

De Wiki d'activités IMA
(Présentation générale)
(20 Avril - 14 Juin)
 
(61 révisions intermédiaires par le même utilisateur non affichées)
Ligne 7 : Ligne 7 :
  
 
=Projet=
 
=Projet=
[[Fichier:Man In The Middle concept.jpeg|240px|thumb|right|Man In The Middle concept]]
 
Le concept du Man In The Middle 802.1x est le suivant : soit un PC connecté sur un réseau ethernet et communiquant avec un serveur distant. On insère sur ce même réseau un PC "d'attaque" qui viendra écouter la communication qui s'effectue sur le réseau. L'objectif de cette manoeuvre est de pouvoir intercepter les échanges qui s'effectuent entre les deux parties de manière totalement discrète et de se faire passer pour l'un ou les 2 parties. 
 
  
Pour entrer plus dans les détails, supposons 2 interlocuteurs A et B possédant chacun une '''''clé publique''''' que nous nommerons Ap et Bp, et une '''''clé privée''''' que nous nommerons As et Bs :
+
==Objectif==
* lors d'un échange de données chiffrées normal, A envoie ses données à B en les protégeant avec la clé Bp. B n'aura qu'à les déchiffrer avec Bs;
 
* à ces 2 interlocuteurs, nous insérons un troisième, C, possédant les clés Cp et Cs. C ne peut déchiffrer ni Ap ni Bp car ne possède pas les clés privées adéquates;
 
* dans le cas d'une attaque, on suppose que B répond à A en chiffrant ses données avec Ap. C intercepte donc les données, modifie la clé publique et renvoie ainsi sa clé Cp à A en se faisant passer pour B (sans que A s'en aperçoive);
 
* A va donc répondre à C en chiffrant ses données avec la clé Cp (sans le savoir): C est en mesure de déchiffrer les données avec Cs et donc voir le contenu du message envoyé;
 
* C retransmet ainsi le message à B avec la clé Bp (légèrement modifiée si nécessaire) qui va déchiffrer le message avec Bs sans se douter de rien.
 
Ainsi, A et B vont continuer de s'échanger des messages en pensant utiliser la clé publique de l'autre sans se douter que c'est celle de C qu'ils utilisent en réalité. L'intrusion est ainsi un succès.
 
  
==Le sujet==
+
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.
  
Notre objectif pour ce projet est de concevoir une carte électronique qui nous permettra d'effectuer ce même type d'attaque mais cette fois sur un réseau ethernet 802.1x . Nous simulerons, une fois la carte réalisée, une attaque sur le réseau ethernet des PC disponibles dans les salles de TP de Polytech en suivant le même procédé. Pour cela, nous nous inspirerons des travaux menés par les ingénieurs Erwan Broquaire et Pierre-Yves TANNIOU qui ont déjà réalisé un tel montage à base de relais, l'idée étant de proposer un modèle optimisé par rapport à celui-là.
+
==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é=
 
=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...).
 +
 +
[[Fichier:atxmegac3.jpg]]
 +
 +
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.
 +
 +
[[Fichier:LEDs.jpg]]
 +
 +
Selon le formulaire, on peut déterminer les pins des LEDs: PR0x01, PR0x02, PD0x10, PD0x20.
 +
 +
[[Fichier:DR.jpg]]
 +
 +
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 :
 +
 +
[[Fichier:Exempllle.jpg]]
 +
 +
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é :
 +
 +
[[Fichier:minicom3.jpg]]
 +
 +
==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
 +
 +
[[Fichier:Exempllllllle.jpg]]
 +
 +
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.

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...).

Atxmegac3.jpg

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.

LEDs.jpg

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

DR.jpg

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 :

Exempllle.jpg

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é :

Minicom3.jpg

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

Exempllllllle.jpg

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.