La descripción general, con ejemplos en ejecución, está en la página de la placa y El modelo de la ESP32 DevKit (todos los registros).
Qué es
La DOIT ESP32 DevKit V1, un módulo ESP32-WROOM-32 en una placa portadora de treinta pines, funcionando con nuestro propio núcleo Xtensa, la primera placa aquí cuyo conjunto de instrucciones no es ni RISC-V, ni AVR, ni Arm. El firmware es un ELF Xtensa que habla con las direcciones reales de la ESP32.
La placa mide 51.5 por 28.3 mm y sus dos hileras de quince pines están a 0.9 pulgadas de distancia, así que cabalga sobre el canal central de una protoboard dejando libre una hilera de orificios a cada lado.
This is the thirty-pin DOIT board, not the 38-pin Espressif DevKitC. The DevKitC is a full inch between rows, leaves no row free at all, and brings out more pins. If your board has 38 pins, use la ESP32-DevKitC V4, que es una placa propia en la caja de componentes.
Los pines
Quince pines por cada lado largo, el conector micro-USB abajo, el módulo y su antena PCB arriba.
Columna izquierda, de arriba abajo: EN, VP, VN, D34, D35, D32, D33, D25, D26, D27, D14, D12, GND, D13, VIN.
Columna derecha, de arriba abajo: D23, D22, TX0, RX0, D21, D19, D18, D5, TX2, RX2, D4, D0, D2, D15, 3V3.
Dn es el GPIO n. VP es el GPIO 36 y VN es el GPIO 39, nombrados en la serigrafía por su función y no por su número. EN es la habilitación del chip, que es el reset de esta placa. VIN es el riel de 5 V del USB.
Esta es una placa de 3.3 voltios y sus pines no toleran 5 V.
Tres cosas que el pinout te hace
Esto es del hardware, no del modelo, y cada una le pasa a alguien:
- Los GPIO 34 a 39 no pueden ser salidas. Nunca. Esos seis pines tienen un búfer de entrada y nada más: sin driver de salida y sin pull-up o pull-down internos.
pinMode(34, OUTPUT)escribe el registro, el bit no se mantiene y el pin queda en alta impedancia. Cuatro de ellos están en este header:D34,D35,VPyVN. Mokxi rechaza la escritura como lo hace el chip, la cuenta, y pone una pequeña marca ámbar en la placa en lugar de dejarte creer que un pin está alimentando algo. Si necesitas un pull-up en uno de estos, tiene que ser con una resistencia. - Los GPIO 6 a 11 no aparecen en el header, porque son la flash SPI de donde corre el programa. En placas que sí los exponen, activar uno detiene el chip.
- Los GPIO 0, 2, 5, 12 y 15 son pines de arranque (strapping). Deciden cómo arranca el chip, así que lo que esté conectado a ellos al encender importa. El GPIO 2 es también el LED azul, así que su estado antes de que corra
pinModevaría de placa a placa.
El LED y el botón
LED_BUILTIN es el GPIO 2, un LED azul común conectado en el sentido normal: HIGH lo enciende. BOOT es el GPIO 0, activo en bajo, y también está en el header como D0, así que puedes conectarlo; hacer clic en él en la placa pone el pin a tierra.
analogRead: ocho canales, y 4095 no es donde llega un riel de 3.3 V
Los ocho canales del ADC1 no son los GPIO 0 a 7. Son, en orden, los GPIO 36, 37, 38, 39, 32, 33, 34 y 35, y el 37 y el 38 no se exponen en una WROOM-32, así que lo que realmente puedes usar es VP, VN, D32, D33, D34 y D35.
Doce bits, y con la atenuación predeterminada de 11 dB la lectura sigue la curva de una ESP32 real en lugar de una línea recta: 0 durante los primeros 80 mV más o menos, casi lineal por el medio, y 4095 a partir de unos 3.1 V. Un potenciómetro conectado al propio riel de 3.3 V de esta placa por lo tanto llega a 4095 un poco antes del final de su recorrido y lee unos 1890, no 2048, en el medio. Eso es el componente real, y el ejemplo del potenciómetro imprime el número crudo para que no sea un misterio. analogReadMilliVolts() deshace la curva y lee voltios.
El ADC2 no está modelado. En una ESP32 real el ADC2 se comparte con la radio WiFi y deja de funcionar cuando se activa el WiFi, por eso nadie lo usa; aquí simplemente no existe, así que los ocho canales de arriba son todos.
La conversión en línea recta de aquí es una aproximación de un convertidor real que se curva en ambos extremos y se corrige con una curva de calibración grabada en el chip. Espera que el modelo sea un poco más amable que el silicio cerca de 0 V y cerca del tope del rango.
analogWrite es LEDC, y no le cuesta nada al núcleo
analogWrite(pin, 0..255) conecta uno de los ocho canales de alta velocidad de LEDC al pin la primera vez que se llama: ocho bits a 1 kHz, en cualquier pin con driver de salida, porque el canal llega al pad mediante la matriz GPIO y no por un pin fijo. Cuando importa la frecuencia, están ledcAttach(pin, frequency, bits) y ledcWrite(pin, duty), y los canales que piden la misma frecuencia y resolución comparten uno de los cuatro temporizadores.
Como LEDC es hardware real, aquí un LED con fundido no le cuesta nada al núcleo: el sketch puede quedarse en delay() y los flancos siguen llegando a tiempo. La ESP8266 NodeMCU es el contraste interesante: no tiene hardware PWM, así que su núcleo hace el trabajo. Ambas placas son honestas al respecto.
Serie
Serial es el UART0, que es el puerto donde está el puente USB de una DevKit, y está conectado al monitor serie. Los bytes salen a la velocidad en baudios que definas, así que un sketch que imprime más rápido de 115200 baudios puede acumular esperas aquí igual que en una mesa.
Serial1 y Serial2 son UART1 y UART2, puertos reales en los pines que les asignes, que envían y reciben tramas bit a bit por el cable, así que un módulo GPS, un HC-05, un PZEM-004T, un transceptor RS-485 o una segunda placa en esos pines los escucha:
Serial2.begin(9600, SERIAL_8N1, 16, 17); // RX, TX: the pins marked RX2 and TX2
Lo que hacen es lo que hace el núcleo arduino-esp32 3.x:
- Sin pines,
Serial1.begin(9600)usa los GPIO 26 (RX) y 27 (TX) ySerial2.begin(9600)los GPIO 4 y 25. El núcleo 2.x usaba el 16 y el 17 paraSerial2, por eso los tutoriales antiguos omiten los pines; Mokxi lo dice una vez en el monitor cuando un sketch lo hace.setPins(rx, tx)los cambia, antes o después debegin(). - La trama puede ser cualquiera de
SERIAL_5N1aSERIAL_8O2, y el parámetroinvertdebegin()invierte ambas líneas. - Los bytes recibidos llegan al sketch en bloques, como con el controlador de ESP-IDF: el UART pasa su FIFO a un anillo de 256 bytes (
setRxBufferSize()antes debegin()) cuando han entrado 120 bytes (setRxFIFOFull()) o cuando la línea ha estado en silencio durante el tiempo de un carácter (setRxTimeout()).available()cuenta el anillo, así que un byte que aún está en el FIFO todavía no está disponible. Un sketch que lee demasiado despacio pierde bytes igual que lo haría en el escritorio. onReceive()se llama después de cada bloque, entreloop()y mientras el sketch espera endelay(), y no desde una tarea de FreeRTOS.write()espera mientras el FIFO de 128 bytes está lleno, yflush()hasta que sale el último bit de parada.setTxBufferSize()se toma, pero no hay anillo de TX, así quewrite()sigue esperando en el FIFO.
El control de flujo por hardware, el modo RS-485, IrDA y el autobaud no se modelan. El pin de TX necesita un controlador de salida, así que del GPIO 34 al 39 solo pueden ser RX. SoftwareSerial.h también sigue funcionando en dos pines cualesquiera.
Un núcleo, no dos
Un ESP32 real tiene dos núcleos Xtensa LX6, y un sketch de Arduino aquí corre en uno: sin CPU de APP, sin interrupciones entre núcleos y sin FreeRTOS para repartir trabajo entre ellos. Un sketch escrito alrededor de setup() y loop() nunca lo nota. Cualquier cosa que inicie una tarea en el núcleo 1 no se ejecutará.
Un firmware que compilaste tú mismo es distinto: MicroPython y una compilación de ESP-IDF corren sobre un modelo del chip completo, donde ambos núcleos sí funcionan (abajo).
What is modeled
El Xtensa LX6 en su ABI con ventanas (el único ABI que emite su compilador), con la ventana de registros, los controladores de desbordamiento y subdesbordamiento de ventana, y las interrupciones de nivel 1. Alrededor: la matriz GPIO y el IO_MUX, el UART0, el temporizador 0 del grupo 0 detrás de millis() y micros(), el ADC1 en modo discreto a través del bloque SENS, el grupo de alta velocidad del LEDC, y de la matriz de interrupciones del DPORT lo que dos fuentes necesitan.
Ese es el conjunto que pinMode, digitalWrite, digitalRead, analogRead, analogWrite, ledcAttach, ledcWrite, millis, micros, delay, attachInterrupt y Serial necesitan, en sus direcciones reales.
WiFi, simulated
No hay radio. Nunca lo habrá: una MAC 802.11 no es algo que este modelo pudiera reproducir con honestidad.
Lo que hay en su lugar es una red simulada. Un bloque que es de Mokxi y no del chip (un buzón en 0x3FEF_E000, donde un ESP32 real no tiene nada mapeado) soporta WiFi.h, HTTPClient.h y WebServer.h, así que el código de Arduino que trae un tutorial corre aquí: la placa se conecta a un punto de acceso cuyo nombre y contraseña son propiedades de la placa, WiFi.status() recorre los mismos estados en el mismo uno a tres segundos, el DHCP le asigna 192.168.4.2, y un sketch puede descargar una página o servir una.
Lo que hay detrás es software, y no se oculta nada de eso. No hay 802.11, ni canal, ni escaneo, ni WPA2, ni TCP, ni TLS y no hay internet real: cuatro nombres inventados bajo .mokxi se resuelven y ningún otro, y nada de lo que haga un sketch puede llegar a la red donde está tu navegador. WiFiClientSecure compila y luego falla, diciendo que TLS no está simulado. Los paneles Web y Cloud en la parte de abajo del editor se abren con esa frase y no la hacen desaparecer al hacer scroll.
La única excepción es Internet real, un interruptor en el panel Cloud para cualquiera con sesión iniciada (más con Pro) que está apagado cada vez que se carga una página. Con él encendido, una petición por un nombre fuera de .mokxi,
https:// incluido, sale por la pasarela de Mokxi y la respuesta vuelve al sketch. Ver Internet real.
La dirección está en el hueco que el bus de datos del chip deja entre las ventanas de memoria externa y la ventana de periféricos, así que una imagen que la use falla en el silicio en lugar de leer el registro de otro periférico. Bluetooth se simula a través del mismo bloque, Classic y LE, con un celular en el panel de Bluetooth del editor y sin radio (Bluetooth, simulado).
Tres ejemplos vienen con esta placa: WiFi: conectarse a la red, WiFi: consultar el clima y WiFi: una lámpara en una página web.
WiFi, simulado explica cómo usarlo; WiFi simulado es el contrato, límite por límite.
Lo que no está
Una radio de cualquier tipo. No hay radio 802.11 ni Bluetooth en el modelo ni pretensión de ella; el WiFi y el Bluetooth de arriba son simulados y lo dicen. El segundo núcleo. La FPU: cada instrucción de punto flotante falla aquí en lugar de devolver un número incorrecto, y el entorno de ejecución es de punto flotante por software, así que float funciona y los binarios de punto flotante por hardware de los fabricantes no. La caché, la flash y la PSRAM: el código corre desde la RAM interna. El RTC, el coprocesador ULP y el sueño profundo. El ADC2, el sensor táctil y el sensor de efecto Hall. Los controladores I2C y SPI, el I2S y el RMT. Wire y SPI en el entorno de ejecución son software en pines normales, como en toda placa de aquí: Wire.begin() pone SDA en 21 y SCL en 22, y SPI usa 18 (SCK), 19 (MISO), 23 (MOSI) y 5 (SS). Adafruit_NeoPixel.h maneja una tira de WS2812 cronometrando cada bit con el contador de ciclos del núcleo, ya que el RMT que usaría un ESP32 real no está aquí. Los grupos de temporizadores más allá del primer temporizador del grupo 0 y su watchdog (que ejecuta el watchdog de tareas, como lo hace ESP-IDF).
Los binarios de ESP-IDF y del núcleo de Arduino de los fabricantes no correrán aquí: el entorno de ejecución es nuestro.
Compilar tu sketch
Edita el sketch y presiona Ejecutar: se compila en la pestaña, como en cualquier otra placa de aquí, con un clang real compilado a WebAssembly. Para este chip es el propio clang de Espressif, que tiene el back end de Xtensa, así que la primera compilación en un ESP32 descarga un toolchain aparte (clang-v3, unos 80 MB, una sola vez) y las compilaciones siguientes lo reutilizan. No se sube nada. Un ejemplo sin modificar sigue corriendo su programa precompilado; cambia una línea y Ejecutar compila el tuyo.
La aritmética de punto flotante funciona: este modelo no tiene FPU, así que la compilación hace las sumas de float y double por software, como en las placas sin FPU. Compilar en el navegador tiene el relato completo.
The full list of what the model implements, and a plain account of which register addresses came out of the technical reference manual and which are this model's belief, is in el modelo de la ESP32 DevKit. La sección 6 es la que hay que leer antes de llevar una compilación de aquí al silicio real.
Las bibliotecas estándar de Arduino con las que compilan las otras placas (Servo.h, Wire.h, EEPROM.h, Adafruit_SSD1306.h y las demás) también están en la ruta de inclusión aquí. Wire.h, Adafruit_NeoPixel.h y Keypad.h se probaron en esta placa, con un escaneo de I2C en 21 y 22, una tira encendida y un teclado 4x4; las demás aún no se han probado aquí.
MicroPython
La placa puede correr Python en lugar de un sketch. Elige MicroPython (main.py)
en su panel de Firmware y Ejecutar arranca el firmware oficial de MicroPython v1.29.0 para el ESP32 y corre tu main.py. Eso corre sobre un modelo del chip completo, arrancado desde la ROM de máscara de Espressif, así que los límites de arriba son los del entorno de ejecución de Arduino, no los de MicroPython: machine.I2C, machine.SPI, el RMT detrás de
neopixel y network.WLAN están ahí para él. Ver
MicroPython en el ESP32.
Los ejemplos
Blink, Button, Serial, Fade, Knob y los tres de WiFi: WiFi: unirse a la red, WiFi: obtener el clima y WiFi: una lámpara en una página web. Cada uno ejecuta su programa precompilado hasta que lo cambias, y entonces Ejecutar compila tu versión.
Un firmware que compilaste tú mismo
Aquí se compila un sketch de Arduino, y se ejecuta en un núcleo. Un programa compilado en otra parte, con ESP-IDF o en Rust (esp-hal, esp-idf-hal), también funciona, sobre un modelo del chip completo con ambos núcleos: sube su .bin o .elf en el panel de Firmware, y la placa arranca con él como después de idf.py flash. El Wi-Fi y el Bluetooth son la asignatura pendiente, porque sus controladores son bibliotecas cerradas de Espressif: un firmware que inicia cualquiera de los dos se detiene con un mensaje que lo indica. Los pasos y la lista completa están en
Ejecutar un firmware ya compilado.
En otras partes
- La página de la placa: /boards/esp32-devkit
- El documento de especificaciones: el modelo del ESP32 DevKit
- La otra placa Xtensa: el ESP8266 NodeMCU
- El mismo chip en otras placas: la ESP32-DevKitC V4, la LOLIN32 Lite, la Wemos D1 R32, el Cheap Yellow Display y el TTGO T-Display
- Los ESP32s de RISC-V: el ESP32-C3 y el ESP32-C6