Començar amb el desenvolupament del firmware ESP32

2024-09-06 · 4min · Juicecat

Table of Contents

Un ESP32 és un SOC petit i barat amb wifi native i bluetooth (amb LE). Venen amb tots els sabors i mides, però normalment semblen una cosa així (a la meva mà per referència de mida):

Aquesta versió específica que tinc és una eliminació xinesa de this model que he trobat a Aliexpress. Vaig comprar un paquet de 10 per uns 70 USD. Utilitza el xip ESP32-WROOM-32D i té un connector USB-C i un LED integrat fixat a GPIO-2 (etiquetat D2 al tauler). Això és molt útil per fer proves.

De totes maneres, a l’hora d’escriure codi per a l’ESP32, hi ha 4 camins diferents que podeu triar.

Escriviu el codi C mitjançant esp-idf
Escriu el codi de micropython
Escriu el codi C++ amb C externs i devolució de trucades (també amb esp-idf)
Escriu el codi Arduino

L’objectiu d’aquest article és superar els punts forts i els punts febles de cada mètode per decidir quin pot ser el millor per a vosaltres.

estàndard C

Escriure a C és una opció ideal per al desenvolupament del firmware en aquest xip. El SDK, esp-idf, està ben documentat i robust. Tanmateix, escriure a C significa gestió de memòria manual, codi difícil de llegir i un paradigma de programació no objectius. El que fer obté amb C és un codi eficient i un accés directe al maquinari. Aquí teniu un simple exemple de tipus de tipus Hello-World mitjançant el codi 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 és un port de cpython destinat a ser executat a SOC com ESP32. Penseu que és com un subconjunt de Python tradicional. Per aconseguir que funcioni, haureu de fulminar un firmware de micropython proporcionat al xip, que després us proporciona una resposta interactiva mitjançant una connexió UART. També és possible utilitzar una eina anomenada adafruit-ampy per copiar fitxers al sistema de fitxers per fer -los funcionar a Chip Boot en lloc de simplement generar una replicació, però podeu fer la vostra investigació sobre això si voleu.

He barrejat sentiments a Micropython. D’una banda, és de molt (per a mi) la manera més fàcil de programar un ESP32 per fer tasques senzilles com ara fer sol·licituds HTTP. Tot i això, està limitat en l’accés al maquinari, molt confiat en paquets pre -construïts i, a causa que necessiti un intèrpret (el firmware de micropython), també és molt limitat en la mida dels programes i la memòria que té disponible.

Aquí teniu el mateix exemple de parpelleig, escrit a 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)

Com veieu, és increïblement senzill de llegir i comprendre, cosa que fa que sigui molt atractiu per als usuaris nous.

C++

Això és estrany. A causa que C++ és un superset de c per disseny, és possible escriure codi a C++ i fer -lo utilitzar esp-idf de la mateixa manera que el normal C. Malauradament, hi ha algunes coses que cal destacar.

C++ La gestió de la memòria dinàmica pot ser un desavantatge a causa dels recursos limitats a bord
Haureu d'utilitzar instruccions externes per integrar -vos amb esp-idf
Les coses es fan Finnicky en barrejar els dos idiomes

Aquí teniu el mateix exemple de parpelleig, escrit a 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 és estrany i encara no ho entenc del tot. Arduino com a idioma és un embolcall i una capa d’abstracció posada a C. La gran part d’Arduino és que són les biblioteques i el suport extensos, a més de ser extremadament senzill. El nucli Arduino proporciona gairebé totes les capacitats de esp-idf, amb la sintaxi agradable i fàcil de llegir d'Arduino. Els inconvenients són força abstractes i una mica controvertits. L’argument principal que he vist en contra d’utilitzar el codi Arduino per escriure el codi ESP32 és que es pot convertir en una càrrega a l’hora d’escriure un codi extens, normalment girar al voltant d’un argument contra les funcions setup() i loop().

Aquí teniu el mateix exemple, però a Arduino:

const int ledPin = 2;

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

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

tl; dr

Escriure a C és la manera masculí i tranquil·la de fer les coses ", però és un dolor al cul.
Escriure a C++ és el mateix que C, però per a les persones que són "massa fresques per a C".
Escriure a Micropython és excel·lent per als projectes Petit i senzill, com fer una sol·licitud HTTP ràpida.
Escriure a Arduino és principalment el mateix que C, però sense els aspectes masculí i tranquil·la, i és immensament més fàcil d'utilitzar més, té una comunitat més gran.