CompilationDeLInterpreteursNopMicroPython < IoT_Course

---+ Compilation et installation de l'Interpreteur !MicroPython et des programmes outil
---++ Introduction

Avant de pouvoir commencer à programmer le processeur ESP32 en !MicroPython l’interpréteur doit être installé dans la mémoire flash de la carte CPU. Ce chapitre décrit comment télécharger le code source de !MicroPython, comment le compiler et comment transférer le binaire dans la mémoire flash.
---++ Quelques outils

Il est important de garder une structure du système de fichier bien propre pour pouvoir retrouver ses fichiers facilement. Pour cette raison je propose de préparer un classeur _/opt/ucad_ comme classeur de base pour le cours. Dans opt/ucad on crée des classeurs
   * <p>micros/esp32: pour toutes le programmes système du ESP32 (source de Micropython, éditeur, programmeur flash …)</p>
   * doc: pour la documentation comme les fiches techniques du ESP32 ou des capteurs
   * transparents: pour les transparents du cours
   * exercices :
      * problèmes : la description des l’exercices
      * solutions: les solutions des exercices. Le code Python sera téléchargé dans un répertoire github, où les étudiants ont facilement accès
   * Freenove_Ultimate_Starter_Kit_for_ESP32 : la doc et les programmes fourni par Freenove
*thonny* est environnement de développement intégré (<b>I</b>ntegrated <b>D</b>evelopment <b>E</b>nvironment IDE) qui est disponible dans Ubuntu:
<verbatim>sudo apt install thonny</verbatim>

La communication entre l’ESP32 et le PC se fait via une ligne série à l’aide d’un convertisseur USB – ligne série, qui se trouve sur la carte CPU de l’ESP32. Pour l'utiliser on a besoins d’un terminal sériel virtuel comme minicom ou gtkterm. Les deux programmes existent comme paquet Ubuntu et peuvent être installé de la même sorte que thonny :
<verbatim>sudo apt install minicom</verbatim>

Ces programmes doivent encore être configuré pour travaille
   * avec le port /dev/ttyUSB0
   * à 115200 baud
   * sans "flow control"
Lancer
<verbatim>sudo minicom -s</verbatim>

Faire les changements dans "Serial port setup" et les sauver avec "Save setup as dfl".
---++ Compiler !MicroPython

Pour pouvoir compiler !MicroPython le compilateur xtensa-esp32-elf-gcc doit être installée et accessible dans le système Linux du PC. En plus les librairies [[https://github.com/espressif/esp-idf][esp-idf]] sont nécessaires. Télécharger esp-idf:

<verbatim>git clone https://github.com/micropython/micropython.git</verbatim>

et exécuter install.sh. Ceci devrait installer les compilateurs pour les différentes versions de l'ESP32 dans $HOME/.espressif.

Dans mon _.bash_profile_ j'ai défini les variables d'environnement ESPIDF et IDF_PATH:
   * export ESPIDF=/opt/ucc/micros/esp32/esp-idf
   * export IDF_PATH=/opt/ucc/micros/esp32/esp-idf
ou _/opt/ucc/micros/esp32/esp-idf_ est le classeur dans lequel esp-idf a été transféré.

En plus
   * $ESPIDF/tools
   * $HOME/.espressif/tools/xtensa-esp32s2-elf/esp-2020r3-8.4.0/xtensa-esp32s2-elf/bin (le compilateur pour l'ESP32)
a été rajouté dans la variable PATH.

Pour compiler !MicroPython une série de modules Python avec des versions bien spécifiques sont nécessaire. Si on essaie de compiler dans l'environnement Python par défaut on reçoit les erreurs similaire à ceci:

<img alt="mpCompilErrs.png" height="393" src="%ATTACHURL%/mpCompilErrs.png" title="mpCompilErrs.png" width="897" />

On doit alors créer un environnement virtuel Python avec tous les modules nécessaire à la compilation de !MicroPython. Pour ce faire on a besoin du paquet python3-venv:

<verbatim>sudo apt install python3-venv</verbatim>

En suite il faut créer l'environnement virtuel que j'appelle "esp-idf"

<verbatim>cd $HOME/pythonEnvironnements
python3 -m venv esp-idf</verbatim>

Enfin on active cet environnement :

<verbatim>source esp-idf/bin/activate</verbatim>

Le terminal indique que nous nous trouvons dans le nouvel environnement :

<img alt="virtualEnv.png" height="57" src="%ATTACHURL%/virtualEnv.png" title="virtualEnv.png" width="594" />

Maintenant nous pouvons installer les modules requis avec pip, par example:
<verbatim>pip3 install pyparsing==2.3.1 </verbatim>

pour installer la version 2.3.1 de pyparsing.

Une fois tous les modules seront installé, la compilation de !MicroPython devrait marcher sans problèmes. Dans mon cas j'ai copié le classeur <br />ports/esp32/boards/GENERIC_SPIRAM dans ports/esp32/boards/WROVER et je compile avec la commande :
<verbatim>make BOARD=WROVER </verbatim>

Ceci permet de faire des modifications pour notre carte CPU WROVER sans toucher à la source de !MicroPython.

On peut effacer tous les résidus d'une compilation précédente avec

<verbatim>make BOARD=WROVER clean</verbatim>

La commande :

<verbatim>make erase</verbatim>

efface tous la contenue de la mémoire flash et

<verbatim>make BOARD=WROVER deploy</verbatim>

transfert l'interpréteur !MicroPython fraichement compilé dans la mémoire flash de l'ESP32. Notre interpréteur !MicroPython peut maintenant être utilisé avec minicom, ampy ou thonny.

-- %USERSIG{UliRaich - 2021-05-10}%

---++ Comments

%COMMENT%
Attachments
Topic attachments
I	Attachment	History	Action	Size	Date	Who	Comment
png	mpCompilErrs.png	r1	manage	79.8 K	2021-06-17 - 10:46	UliRaich
png	virtualEnv.png	r1	manage	20.1 K	2021-06-17 - 13:58	UliRaich
This topic: IoT_Course_French > WebHome > CompilationDeLInterpreteursNopMicroPython
Topic revision: r5 - 2021-06-20 - UliRaich