Apprendre à programmer une carte de développement à base d’ESP32 avec le framework officiel ESP-IDF

Installation et configuration dans une machine virtuelle Linux

L’ESP-IDF (ESP Iot Development Framework) est le framework officiel du fabricant Espressif, et donc certainement le plus complet pour supporter toutes les fonctionnalités d’un ESP32.

Ce tutoriel explique comment installer le framework et faire vos premiers pas dans la programmation d’une carte ESP32 sous Linux, dans une machine virtuelle Lubuntu.

4 commentaires Donner une note  l'article (5)

Article lu   fois.

L'auteur

Profil Pro

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Présentation de l’ESP : ESP32-DevKit

Vous allez sans doute commencer par vous offrir une carte de développement, par exemple celle du kit officiel du fabricant Espressif : une ESP32-DevKitC.

Image non disponible
Module ESP32-WROOM-32 soudé sur la carte de développement ESP32-DevKitC V4

Cette carte (ou une des nombreuses cartes compatibles disponibles sur le marché) peut être enfichée directement sur une plaque d’essai (breadbord) pour des montages en prototype.

Le cœur de la carte sur la photo est un module ESP32, ici référencé ESP32-WROOM-32, soudé sur la carte principale. La carte dispose ainsi de 2x19 broches GPIO permettant l’accès aux fonctionnalités classiques du microcontrôleur (ADC, DAC, PWM, I2C, SPI, etc.), un bouton EN (Enable ou Reset), un bouton Boot à utiliser éventuellement lors du téléversement du firmware, une LED témoin d’alimentation 5V, un port micro-USB et un convertisseur USB-Série pour la communication avec un PC et l’alimentation.

II. Configuration d’une Machine Virtuelle Lubuntu avec Oracle VM VirtualBox

Étant principalement sur Windows 10, mais avec quelques habitudes sous Linux, j’ai préféré faire mes premiers pas dans une machine virtuelle Lubuntu grâce à Oracle VM VirtualBox.

L’image ISO est téléchargée depuis le site de Lubuntu : https://lubuntu.fr/

Par exemple, la version 64 bits : lubuntu-20.04-desktop-amd64.iso.

Démarrez Oracle VM VirtualBox, et lancez la création d’une nouvelle machine :

Image non disponible

On peut laisser la configuration par défaut pour le moment :

  • taille de la mémoire vive recommandée : 1024 Mo ;
  • cochez « Créer un disque dur virtuel maintenant », puis laissez l’option « type de fichier de disque dur » : VDI (Image de Disque VirtualBox) ;
  • stockage sur le disque dur physique : dynamiquement alloué.
Image non disponible

Une fois le disque dur virtuel créé, entrez dans la configuration de la machine et dans les options de stockage :

Image non disponible

Cliquez sur l’icône Image non disponible et « Choisissez un fichier de disque optique virtuel… ». Le fichier en question est l’image iso récupérée plus tôt :

Image non disponible

Vous pouvez maintenant démarrer la machine virtuelle. Tout se passe comme si vous aviez démarré une machine avec un CD d’installation Lubuntu gravé avec l’image ISO, l’installation se fera donc sur le fichier VDI de disque dur virtuel.

L’installation se poursuit avec les options de langue, de disposition du clavier, de mises à jour, etc. Laissez-vous guider par les différents écrans qui se succèdent, les options par défaut suffisent en général.

Image non disponible

Il existe quelques fonctionnalités bien pratiques à rajouter comme :

  • faire des copier-coller, du glisser-déposer ou des partages de fichiers dans les deux sens, du système hôte Windows vers le système invité Linux Lubuntu, et inversement, du système invité vers le système hôte ;
  • taille d’écran automatique ;
  • etc.

Pour cela, dans le menu Périphériques de VirtualBox, sélectionnez « insérez l’image CD des additions invité… ». Depuis un terminal ouvert dans le disque des additions invité monté, lancez la commande :

 
Sélectionnez
sudo ./VBoxLinuxAdditions.run
Image non disponible

Il faudra dans tous les cas redémarrer la machine virtuelle pour refaire le noyau.

Dans le menu Périphériques, vous pouvez maintenant activer le Glisser-Déposer, le presse-papier partagé, etc.

À cette étape, il est recommandé de créer un instantané de votre machine virtuelle Linux avant de poursuivre les installations (menu Machine > Prendre un instantané…). Ainsi, en cas de problème, vous pourrez restaurer votre machine virtuelle à son état précédent plus facilement.

III. Installation des outils du kit ESP-IDF

Toute la procédure est décrite sur le site d’Espressif : Standard Setup of Toolchain for Linux.

III-A. Installation des prérequis

Pour installer les prérequis, saisissez les commandes suivantes dans un terminal sous Lubuntu :

 
Sélectionnez
sudo apt-get install git 
sudo apt-get install wget
sudo apt-get install flex
sudo apt-get install bison
sudo apt-get install gperf 
sudo apt-get install cmake
sudo apt-get install ninja-build
sudo apt-get install ccache
sudo apt-get install libffi-dev
sudo apt-get install libssl-dev
sudo apt-get install dfu-util

sudo apt-get install python3 python3-pip python3-setuptools
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3 10

III-B. Accès au port USB

Flasher un programme dans le devKit via la liaison USB-série passe par la reconnaissance de la carte par la machine virtuelle et l’autorisation d’accéder au port USB.

Dans un terminal de la machine Lubuntu, listez les ports série :

 
Sélectionnez
ls /dev/tty*

Connectez maintenant votre devKit ESP au port USB de votre PC.

En bas à droite de la fenêtre de la machine virtuelle, faites un clic droit sur l’icône des périphériques USB, et activez le pilote « Silicon Labs CP2102 USB to UART Bridge Controller » :

Image non disponible

Si vous listez à nouveau les ports série avec ls /dev/tty*, un nouveau port USB devrait apparaître, le plus souvent /dev/ttyUSB0.

Pour avoir les accès en lecture-écriture au port USB sur Linux, on doit en général ajouter l’utilisateur au groupe dialout avec la commande :

 
Sélectionnez
sudo usermod -a -G dialout $USER

Il faudra redémarrer la session pour rendre les droits effectifs.

III-C. Installation du framework ESP-IDF

Le framework se trouve sur le dépôt GitHub d’Espressif : https://github.com/espressif/esp-idf.

Commencez par cloner la dernière version du dossier dans un répertoire ~/esp :

 
Sélectionnez
mkdir ~/esp
cd ~/esp
git clone --recursive https://github.com/espressif/esp-idf.git

Le framework est installé dans un sous-dossier ~/esp/esp-idf.

Dans le sous-dossier ~/esp/esp-idf, lancez l’installation du kit ESP-IDF avec la commande :

 
Sélectionnez
./install.sh

Si tout se passe bien, l’installation se termine par le sympathique message « All down! … »

Il reste à compléter la variable d’environnement PATH pour utiliser les outils en ligne de commande. Un utilitaire est fourni pour cela qu’on lance avec la commande :

 
Sélectionnez
. $HOME/esp/esp-idf/export.sh

Notez l’espace entre le point et le nom du chemin.

Pour rendre le processus permanent, vous pouvez ajouter cette ligne dans le fichier ~/.profile.

IV. Un premier projet

Un dossier template pour les projets du kit ESP-IDF est disponible dans les dépôts à l’adresse : https://github.com/espressif/esp-idf-template.

 
Sélectionnez
cd ~/esp
git clone https://github.com/espressif/esp-idf-template.git app-template

Le fichier principal main.c de cette application minimale (un Hello World!) est le suivant :

main.c
Sélectionnez
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"


void app_main(void)
{
    int i = 0;
    while (1) {
        printf("[%d] Hello world!\n", i);
        i++;
        vTaskDelay(5000 / portTICK_PERIOD_MS);
    }
}

Vous pouvez maintenant générer le projet avec la commande :

 
Sélectionnez
idf.py build

Pour flasher le binaire dans l’ESP32 :

 
Sélectionnez
idf.py -p /dev/ttyUSB0 flash

Éventuellement, il faut maintenir le bouton Boot de la carte appuyé pendant le téléversement.

Et pour rendre compte des messages dans un terminal :

 
Sélectionnez
idf.py -p /dev/ttyUSB0 monitor

Tapez CTRL + ] pour quitter (CTRL + AltGr + ) sur mon clavier français).

Image non disponible

On peut s’amuser en plus à faire clignoter une LED connectée au port GPIO 4 en modifiant le programme comme suit :

main.c
Sélectionnez
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include "driver/gpio.h"


void app_main(void)
{
    int i = 0;
    
    gpio_set_direction(GPIO_NUM_4, GPIO_MODE_OUTPUT);
    int level = 0;
    
    while (1) {
        printf("[%d] Hello world!\n", i);        
        gpio_set_level(GPIO_NUM_4, level);
        
        level = !level;
        i++;
        
        vTaskDelay(5000 / portTICK_PERIOD_MS);
    }
}

V. Un deuxième projet : connexion WiFi

Ce projet fait partie des exemples fournis dans le dossier ~/esp/esp-idf/examples.

On commence par dupliquer le projet dans un dossier ~/esp/wifi-sta :

 
Sélectionnez
cd ~/esp
cp -r ~/esp/esp-idf/examples/wifi/getting_started/station ~/esp/wifi-sta
cd wifi-sta

Le programme de démonstration de cet exemple cherche à connecter votre ESP à votre Box/Routeur en WiFi (mode Station STA).

On accède à la configuration du projet avec la commande :

 
Sélectionnez
idf.py menuconfig
Image non disponible

En sélectionnant le menu « Example Configuration », vous pourrez renseigner l’identifiant SSID et le mot de passe WiFi :

Image non disponible

Un fichier sdkconfig est généré en quittant la configuration (menu [Q]).

Notez que ce menu personnalisé pour renseigner l’identifiant SSID et le mot de passe doit son existence au contenu du fichier Kconfig.projbuild.

Kconfig.projbuild
Sélectionnez
menu "Example Configuration"

    config ESP_WIFI_SSID
        string "WiFi SSID"
        default "myssid"
        help
            SSID (network name) for the example to connect to.

    config ESP_WIFI_PASSWORD
        string "WiFi Password"
        default "mypassword"
        help
            WiFi password (WPA or WPA2) for the example to use.

    config ESP_MAXIMUM_RETRY
        int "Maximum retry"
        default 5
        help
            Set the Maximum retry to avoid station reconnecting to the AP unlimited when the AP is really inexistent.
endmenu

Vous pouvez maintenant générer le projet avec la commande :

 
Sélectionnez
idf.py build

Pour flasher le binaire dans l’ESP32 :

 
Sélectionnez
idf.py -p /dev/ttyUSB0 flash

Et à nouveau, pour rendre compte des messages dans un terminal :

 
Sélectionnez
idf.py -p /dev/ttyUSB0 monitor

Tapez CTRL + ] pour quitter (CTRL + AltGr + )).

Image non disponible

Les dernières lignes montrent que l’ESP s’est bien connectée sur le réseau domestique en prenant l’adresse IP 192.168.0.24.

VI. Conclusion

Votre configuration est maintenant prête pour vos premières expérimentations. Le répertoire /esp-idf/examples comprend déjà de nombreux exemples à adapter à vos projets (voir également sur GitHub). Vous trouverez la documentation sur le site d’Espressif : ESP-IDF Programming Guide.

Je remercie Vincent PETIT et Claude Leloup pour leur relecture.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Licence Creative Commons
Le contenu de cet article est rédigé par f-leb et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2020 Developpez.com.