Premiers pas avec le développement du micrologiciel ESP32

2024-09-06 · 4min · Juicecat

Table of Contents

Un ESP32 est un SoC petit et bon marché doté de capacités natives WiFi et Bluetooth (avec LE). Ils sont disponibles dans toutes les saveurs et toutes les tailles, mais ils ressemblent généralement à ceci (dans ma main pour référence de taille) :

Cette version spécifique que j'ai est une imitation chinoise de this model que j'ai trouvée sur aliexpress. J'en ai acheté un paquet de 10 pour environ ~70 USD. Il utilise la puce ESP32-WROOM-32D et dispose d'un connecteur USB-C ainsi que d'une LED intégrée épinglée au GPIO-2 (étiquetée D2 sur la carte). Ceci est très utile pour les tests.

Quoi qu'il en soit, lors de l'écriture de code pour l'ESP32, vous pouvez choisir de suivre 4 chemins distincts.

Écrivez du code C en utilisant esp-idf
Écrivez du code micropython
Écrivez le code C++ avec les externes et les rappels C (également avec esp-idf)
Écrivez le code Arduino

Le but de cet article est de passer en revue les forces et les faiblesses de chaque méthode afin de décider laquelle vous convient le mieux.

Norme C

L'écriture en C est une excellente option pour le développement de firmware sur cette puce. Le SDK, esp-idf, est bien documenté et robuste. Écrire en C signifie cependant une gestion manuelle de la mémoire, un code difficile à lire et un paradigme de programmation non objectif. Ce que vous obtenez faire avec C, c'est un code efficace et un accès direct au matériel. Voici un exemple simple de clignotement de type hello-world utilisant le code C :

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "led_strip.h"
#include "sdkconfig.h"

static const char *TAG = "example";
#define BLINK_GPIO 2
static uint8_t s_led_state = 0;

static void blink_led(void) {
    gpio_set_level(BLINK_GPIO, s_led_state);
}

static void configure_led(void) {
    ESP_LOGI(TAG, "Example configured to blink GPIO LED!");
    gpio_reset_pin(BLINK_GPIO);
    gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
}

void app_main(void) {
    configure_led();
    while (1) {
        ESP_LOGI(TAG, "Turning the LED %s!", s_led_state == true ? "ON" : "OFF");
        blink_led();
        s_led_state = !s_led_state;
        vTaskDelay(CONFIG_BLINK_PERIOD / portTICK_PERIOD_MS);
    }

}

Micropython

Micropython est un portage de CPython destiné à être exécuté sur des SoC comme ESP32. Pensez-y un peu comme un sous-ensemble de Python 3 traditionnel. Pour que cela fonctionne, vous devrez flasher un micrologiciel Micropython fourni sur la puce, qui vous fournira ensuite un REPL interactif via une connexion UART. Il est également possible d'utiliser un outil appelé adafruit-ampy pour copier des fichiers sur le système de fichiers afin de les exécuter au démarrage de la puce au lieu de simplement générer un REPL, mais vous pouvez faire vos propres recherches à ce sujet si vous le souhaitez.

J'ai des sentiments mitigés sur Micropython. D'une part, c'est de loin (pour moi) le moyen le plus simple de programmer un ESP32 pour effectuer des tâches simples telles que faire des requêtes http. Cependant, son accès matériel est limité, il dépend fortement de packages prédéfinis et, comme il nécessite un interpréteur (le micrologiciel Micropython), il est également très limité en termes de taille des programmes et de mémoire dont il dispose.

Voici le même exemple de clignotement, écrit en Micropython :

import machine
import time
led = machine.Pin(2, machine.Pin.OUT)
while True:
led.value(1)
time.sleep(1)
led.value(0)
time.sleep(1)

Comme vous pouvez le constater, il est incroyablement simple à lire et à comprendre, ce qui le rend très attrayant pour les nouveaux utilisateurs.

C++

C'est étrange. Étant donné que C++ est un sur-ensemble de C de par sa conception, il est possible d'écrire du code dans C++ et de lui faire utiliser esp-idf de la même manière que le C normal. Malheureusement, il y a quelques points à noter.

La gestion dynamique de la mémoire C++ peut être un inconvénient en raison des ressources limitées à bord
Vous devrez utiliser des instructions externes pour intégrer esp-idf
Les choses se compliquent lorsqu'on mélange les deux langues

Voici le même exemple de clignotement, écrit en C++ :

#ifdef __cplusplus
extern "C" {
#endif
#include <esp_log.h>
#include <string>

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "sdkconfig.h"
#ifdef __cplusplus
}
#endif
static char tag[] = "cpp_helloworld";

extern "C"
{
	void app_main(void);
}

class Blink
{
  public:
	Blink(gpio_num_t blinkPin)
	{
		this->blinkPin = blinkPin;
		gpio_pad_select_gpio(blinkPin);
		gpio_set_direction(blinkPin, GPIO_MODE_OUTPUT);
	}

	void blinkTimes(int x)
	{
		ESP_LOGD(tag, "Blink Times %d", x);

		int delayMs = 50;
		int level = gpio_get_level(blinkPin);
		gpio_set_level(blinkPin, 0);
		vTaskDelay(1000 / delayMs);
		for (int i = 0; i < x; i++)
		{
			gpio_set_level(blinkPin, 1);
			vTaskDelay(1000 / delayMs);
			gpio_set_level(blinkPin, 0);
			vTaskDelay(1000 / delayMs);
		}
		gpio_set_level(blinkPin, level);
	}

  private:
	gpio_num_t blinkPin = GPIO_NUM_2;
};

void app_main(void)
{
	vTaskDelay(1);
	Blink blink(GPIO_NUM_2);
	blink.blinkTimes(5);
}

###Arduino

Arduino est étrange et je ne le comprends toujours pas complètement. Arduino en tant que langage est un wrapper et une couche d'abstraction placés sur C. L'avantage d'Arduino réside dans ses bibliothèques et son support étendus, tout en étant extrêmement simple. Le noyau Arduino fournit presque toutes les capacités de esp-idf, avec la syntaxe agréable et facile à lire d'Arduino. Les inconvénients sont assez abstraits et un peu controversés. Le principal argument que j'ai vu contre l'utilisation d'Arduino pour écrire du code ESP32 est que cela peut éventuellement devenir un fardeau lors de l'écriture de code volumineux, tournant généralement autour d'un argument contre les fonctions setup() et loop().

Voici le même exemple, mais en Arduino :

const int ledPin = 2;

void setup() {
  pinMode (ledPin, OUTPUT);
}

void loop() {
  digitalWrite (ledPin, HIGH);
  delay(1000);
  digitalWrite (ledPin, LOW);
  delay(1000);
}

TL;DR

Écrire en C est la façon viril et cool de faire les choses", mais c'est pénible.
Écrire en C++ est la même chose qu'en C, mais pour les personnes "trop cool pour le C normal".
L'écriture en micropython est idéale pour les projets petit et simple, comme faire une requête HTTP rapide.
L'écriture en Arduino est essentiellement la même que celle en C, mais sans les aspects viril et cool, et est immensément plus facile à utiliser et possède une communauté plus large.