Comenzando con el desarrollo de firmware ESP32

2024-09-06 · 5min · Juicecat

Table of Contents

Un ESP32 es un SoC pequeño y barato con capacidades nativas de WiFi y Bluetooth (con LE).Vienen en todos los sabores y tamaños, pero generalmente se ven así (en mi mano para referencia de tamaño):

Esta versión específica que tengo es una imitación china de this model que encontré en AliExpress.Compré un paquete de 10 de ellos para alrededor de ~ 70 USD.Utiliza el chip ESP32-WROOM-32D y tiene un conector USB-C y también un LED integrado fijado a GPIO-2 (etiquetado D2 en la placa).Esto es muy útil para las pruebas.

De todos modos, al escribir código para el ESP32, hay 4 rutas distintas que puede elegir bajar.

Escriba el código C usando esp-idf
Escribir código de micrypthon
Escriba el código C++ con C externs y devoluciones de llamada (también con esp-idf)
Escribir código Arduino

El propósito de este artículo es repasar las fortalezas y debilidades de cada método para decidir cuál puede ser mejor para usted.

Estándar C

Escribir en C es una gran opción para el desarrollo de firmware en este chip.El SDK, esp-idf, está bien documentado y robusto.Sin embargo, escribir en C significa gestión de memoria manual, código difícil de leer y un paradigma de programación no objetivo.Lo que obtienes con C es un código eficiente y acceso directo al hardware.Aquí hay un simple ejemplo de parpadeo de tipo Hello-World usando el código 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);
    }

}

Micrypthon

Micrypthon es un puerto de CPython destinado a ejecutarse en SOC como ESP32.Piense en esto como un subconjunto de Python 3 tradicional. Para que esto funcione, deberá flashear un firmware de micryphon proporcionado en el chip, que luego le proporciona una replicación interactiva a través de una conexión UART.También es posible usar una herramienta llamada adafruit-ampy para copiar archivos en el sistema de archivos para que se ejecutaran en el arranque del chip en lugar de simplemente generar un replica, pero puede hacer su propia investigación sobre eso si lo desea.

Tengo sentimientos encontrados en Micrypthon.Por un lado, es, con mucho, (para mí) la forma más fácil de programar un ESP32 para hacer tareas simples, como hacer solicitudes HTTP.Sin embargo, es limitado en el acceso al hardware, altamente dependiendo de los paquetes prebuencados, y debido a que necesita un intérprete (el firmware de Micropython), también es muy limitado en el tamaño de los programas y la memoria que tiene disponible.

Aquí está el mismo ejemplo de parpadeo, escrito en Micopython:

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)

Como puede ver, es increíblemente simple de leer y comprender, lo que lo hace muy atractivo para los nuevos usuarios.

C++

Este es extraño.Debido a que C++ es un superconjunto de C por diseño, es posible escribir código en C++ y hacer que use esp-idf de la misma manera que lo hace Normal C.Desafortunadamente, hay algunas cosas que deben tenerse en cuenta.

C++ La gestión de la memoria dinámica puede ser un inconveniente debido a los recursos limitados a bordo
Deberá usar declaraciones extern para integrarse con esp-idf
Las cosas se ponen finas al mezclar los dos idiomas

Aquí está el mismo ejemplo de parpadeo, escrito 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 es extraño, y todavía no lo entiendo completamente.Arduino como idioma es una capa de envoltura y abstracción puesta sobre C. La gran parte de Arduino es sus extensas bibliotecas y soporte, así como es extremadamente simple.El núcleo Arduino proporciona casi todas las capacidades de esp-idf, con la sintaxis agradable y fácil de leer de Arduino.Las desventajas de esto son bastante abstractas y un poco polémicas.El argumento principal que he visto en contra de usar Arduino para escribir el código ESP32 es que eventualmente puede convertirse en una carga al escribir un código extenso, generalmente girando en torno a un argumento contra las funciones setup() y loop().

Aquí está el mismo ejemplo, pero 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

Escribir en C es la forma varonil y cool de hacer las cosas ", pero es un dolor en el culo.
Escribir en C++ es lo mismo que C, pero para las personas que son "demasiado geniales para la C".
Escribir en Micopython es excelente para los proyectos small and simple, como hacer una solicitud HTTP rápida.
Escribir en Arduino es principalmente lo mismo que C, pero sin los aspectos varonil y cool, y es inmensamente más fácil de usar y tiene una comunidad más grande.