La Seeed Studio XIAO ESP32-S3 es una pequeña placa microcontroladora diseñada para aplicaciones embebidas e IoT. Forma parte de la serie XIAO, que se centra en placas de factor de forma muy pequeño con gran capacidad de procesamiento. La placa mide solo unos 21 × 17,8 mm, lo que la hace adecuada para diseños con espacio limitado.
Está basada en el chip ESP32-S3 con un procesador dual-core Xtensa LX7 que funciona hasta 240 MHz. La placa incluye Wi-Fi integrado y Bluetooth Low Energy, permitiendo comunicación inalámbrica sin hardware adicional. También ofrece memoria flash y PSRAM integradas, que soportan aplicaciones avanzadas como IA en el borde y procesamiento de datos.
La gestión de energía es una característica importante de esta placa. Soporta carga de batería y ofrece modos de bajo consumo para diseños energéticamente eficientes. Esto la hace adecuada para proyectos portátiles y alimentados por batería.
En este tutorial aprenderás cómo programar la XIAO ESP32-S3 usando el Arduino IDE.
Dónde Comprar
Puedes adquirir la XIAO ESP32-S3 en Seeed Studio o Amazon. También necesitarás un cable USB-C, si no tienes uno ya. Además, podría ser necesario un pequeño disipador de calor si vas a ejecutar procesos intensivos en la placa.
XIAO ESP32-S3
Cable USB C
Pequeño disipador 9×9 mm
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Características de la placa XIAO ESP32-S3
La XIAO ESP32-S3 está construida alrededor del sistema en chip ESP32-S3R8. Utiliza un procesador dual-core Xtensa LX7 con arquitectura de 32 bits. La CPU puede funcionar a una frecuencia de hasta 240 MHz. La foto a continuación muestra el frente y el reverso de la placa:
El chip proporciona 8 MB de memoria flash y 8 MB de PSRAM. Esta memoria extendida permite ejecutar firmware más complejo y soporta el almacenamiento en búfer para aplicaciones intensivas en datos como procesamiento de audio o imágenes.
El ESP32-S3 también incluye soporte hardware para instrucciones vectoriales. Esto mejora el rendimiento en procesamiento de señales e inferencia de redes neuronales.
Conectividad Inalámbrica
La placa integra un subsistema Wi-Fi completo de 2.4 GHz. Soporta los estándares IEEE 802.11 b/g/n para comunicación en red. El radio Wi-Fi está integrado en el chip y no requiere componentes externos aparte de una antena para mejor recepción. La imagen a continuación muestra la XIAO ESP32-S3 con la antena externa conectada.
También se soporta Bluetooth Low Energy 5.0. Esto permite comunicación de bajo consumo con sensores, smartphones y otros dispositivos BLE. El chip también puede operar en modo Bluetooth Mesh para redes IoT distribuidas.
GPIO e Interfaces Periféricas
La XIAO ESP32-S3 expone múltiples interfaces digitales y analógicas. Proporciona hasta 11 pines GPIO con capacidad PWM. También incluye hasta 9 canales ADC para entrada analógica. La siguiente imagen muestra el pinout de la XIAO ESP32-S3:
La placa soporta protocolos de comunicación comunes. Estos incluyen UART, I2C y SPI. El ESP32-S3 utiliza una matriz GPIO flexible que permite mapear la mayoría de funciones periféricas a diferentes pines.
Hay pines dedicados para comunicación I2C usando señales SDA y SCL. Las señales SPI incluyen reloj, MOSI y MISO. UART está disponible para comunicación serial y depuración.
Características adicionales incluyen un LED de usuario y un LED de estado de carga. También hay botones de reset y boot para control y flasheo del firmware.
USB e Integración del Sistema
El ESP32-S3 incluye soporte USB nativo. La placa XIAO usa un conector USB-C para alimentación, programación y transferencia de datos. La interfaz USB está conectada directamente al microcontrolador, sin necesidad de un convertidor USB a serial externo.
El chip soporta funcionalidad USB OTG. Esto le permite actuar tanto como dispositivo USB como host USB. Esta característica habilita aplicaciones como dispositivos USB HID o registro de datos en almacenamiento externo.
Gestión de Energía
La placa soporta alimentación tanto por USB como por batería. Un circuito de carga integrado permite cargar una batería de litio de 3.7 V. Esto posibilita operación autónoma sin hardware externo de gestión de energía.
El voltaje de operación es típicamente 3.3 V. El regulador a bordo proporciona energía estable para el microcontrolador y periféricos.
El ESP32-S3 soporta múltiples modos de ahorro de energía. Estos incluyen modem sleep, light sleep y deep sleep. La tabla a continuación muestra el consumo de corriente del ESP32-S3 en diferentes modos:
| Modo | Corriente Típica (Chip) | Unidad | Descripción |
|---|---|---|---|
| Modem Sleep | ~10.5 – 90 | mA | CPU activa, Wi-Fi deshabilitado |
| Light Sleep | ~240 – 750 | µA | CPU pausada, memoria retenida |
| Deep Sleep | ~7 – 25 | µA | RTC activo, la mayor parte del sistema apagado |
Estos valores representan solo el chip ESP32-S3. La placa XIAO ESP32-S3 típicamente consume un poco más debido al hardware a bordo.
Especificaciones Técnicas
La siguiente tabla resume las características técnicas de la XIAO ESP32-S3:
| Parámetro | Especificación |
|---|---|
| Microcontrolador | ESP32-S3R8 (Xtensa LX7 dual-core) |
| Frecuencia CPU | Hasta 240 MHz |
| Arquitectura | 32 bits |
| Memoria Flash | 8 MB |
| PSRAM | 8 MB |
| Conectividad inalámbrica | Wi-Fi 802.11 b/g/n, Bluetooth LE 5.0 |
| USB | USB-C, USB OTG nativo |
| Pines GPIO | Hasta 11 |
| Canales ADC | Hasta 9 |
| Interfaces de Comunicación | UART, I2C, SPI |
| Voltaje de Operación | 3.3 V |
| Entrada de Energía | USB-C o batería LiPo de 3.7 V |
| Características de Energía | Carga de batería, soporte deep sleep |
| Dimensiones | ~21 × 17.8 mm |
| Características Adicionales | LED de usuario, LED de carga, botones de reset y boot |
Comparación de la XIAO ESP32-S3 con otras placas ESP32 populares
El ecosistema ESP32 ha crecido mucho y elegir la placa adecuada puede ser confuso. La tabla a continuación compara las opciones más populares, incluyendo la compacta serie XIAO y las placas clásicas ESP32.
| Característica | XIAO ESP32-S3 | XIAO ESP32-S3 Plus | XIAO ESP32-S3 Sense | ESP32-C5 | ESP32 DevKit | ESP32-CAM |
|---|---|---|---|---|---|---|
| MCU | ESP32-S3 | ESP32-S3 | ESP32-S3 | ESP32-C5 | ESP32 | ESP32 |
| CPU | Dual-core LX7 | Dual-core LX7 | Dual-core LX7 | RISC-V | Dual-core LX6 | Dual-core LX6 |
| Velocidad de Reloj | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz |
| Aceleración AI | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
| PSRAM | 8 MB | Hasta 8MB+ | 8 MB | ❌ | Opcional | 4 MB |
| Flash | 8–16 MB | Hasta 16MB+ | 8–16 MB | Externa | 4–16 MB | 4 MB |
| Wi-Fi | 2.4 GHz | 2.4 GHz | 2.4 GHz | Wi-Fi 6 (2.4 + 5 GHz) | 2.4 GHz | 2.4 GHz |
| Bluetooth | BLE 5 | BLE 5 | BLE 5 | BLE 5.3 | Clásico + BLE | Clásico + BLE |
| USB | USB nativo | USB nativo | USB nativo | Depende de la placa | Chip UART | No |
| Cámara | ❌ | ❌ | ✅ | ❌ | ❌ | ✅ |
| Micrófono | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
| Factor de Forma | Ultra compacto | Compacto | Compacto + complemento | Variable | Grande | Módulo |
| GPIO | Limitado | Moderado | Limitado | Moderado | Alto | Muy limitado |
| Mejor Caso de Uso | IoT compacto | Proyectos de expansión | IA / Visión | IoT con Wi-Fi 6 | Prototipado general | Streaming con cámara |
¿Qué placa deberías elegir?
- XIAO ESP32-S3: Mejor equilibrio entre tamaño, rendimiento y características para la mayoría de proyectos IoT.
- XIAO ESP32-S3 Plus: Buena opción si necesitas más opciones de expansión y flexibilidad.
- XIAO ESP32-S3 Sense: Ideal para proyectos de IA, cámara y audio (reconocimiento facial, detección de objetos).
- ESP32-C5: Mejor para aplicaciones inalámbricas modernas con Wi-Fi 6 y soporte 5 GHz.
- ESP32 DevKit: Perfecto para principiantes y prototipado en breadboard con máximo acceso a GPIO.
- ESP32-CAM: Opción económica para proyectos simples de streaming con cámara, pero más limitada.
Una de las ventajas más subestimadas del ESP32-S3 es su capacidad USB nativa. A diferencia de las placas ESP32 clásicas, que dependen de un chip UART externo para comunicación, el S3 puede comunicarse directamente por USB. Esto habilita funciones potentes como USB HID (permitiendo que la placa actúe como teclado o ratón) y comunicación serial CDC nativa sin hardware adicional.
También es importante destacar la PSRAM para aplicaciones que manejan grandes o continuos flujos de datos, como procesamiento de audio, captura de video y cargas de trabajo de IA. Estos casos de uso superan rápidamente la SRAM interna limitada de microcontroladores típicos. En la práctica, la PSRAM suele marcar la diferencia entre un proyecto que apenas funciona y uno que corre de forma fiable.
Si vas a comenzar un nuevo proyecto en 2026, la familia ESP32-S3 es generalmente la mejor opción debido al soporte USB nativo y aceleración AI. Las placas clásicas ESP32 siguen siendo útiles, pero principalmente para proyectos sensibles al costo o legados que no requieren las nuevas características del ESP32-S3.
Instalar ESP32 Core
Si quieres usar el Arduino IDE para programar la placa, primero necesitas instalar el ESP32 Core para habilitar soporte para placas ESP32 dentro del Arduino IDE. Abre tu Arduino IDE y sigue los pasos indicados a continuación. Si tienes problemas, puedes encontrar instrucciones más detalladas en nuestro tutorial Install ESP32 core in Arduino IDE.
URLs adicionales para el gestor de placas
Primero abre el diálogo de Preferencias seleccionando «Preferences…» en el menú «File»:
Esto abrirá el diálogo de Preferencias mostrado abajo. En la pestaña Settings encontrarás un cuadro de edición al final del diálogo etiquetado como «Additional boards manager URLs»:
En este campo copia la siguiente URL: «https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json«
Esto indicará al Arduino IDE dónde encontrar las librerías core del ESP32. A continuación instalaremos las librerías core del ESP32 usando el Gestor de Placas.
Gestor de Placas
Abre el BOARDS MANAGER haciendo clic en el icono de placa en la barra lateral del Arduino IDE:
Verás aparecer el BOARDS MANAGER a la derecha de la barra lateral. Escribe «ESP32» en el campo de búsqueda arriba y deberías ver dos tipos de placas ESP32; las «Arduino ESP32 Boards» y las placas «esp32 by Espressif». Queremos las librerías esp32 de Espressif. Haz clic en el botón INSTALL y espera a que la descarga e instalación finalicen.
Una vez instalado, tu Gestor de Placas debería verse así, aunque la versión (aquí 3.3.7) puede variar.
En el siguiente paso te muestro cómo seleccionar la placa ESP32 para la XIAO ESP32-S3.
Seleccionar placa XIAO_ESP32S3
Puedes seleccionar una placa desde el selector desplegable bajo la barra de menú: en el ejemplo abajo se muestra Arduino Uno como placa seleccionada, por ejemplo:
Al hacer clic en el nombre de la placa actualmente seleccionada (Arduino Uno), se abrirá el diálogo de selección de placa. En el cuadro de búsqueda escribe «xiao s3» y selecciona «XIAO_ESP32S3» como se muestra abajo:
Si la placa está conectada a tu PC vía USB, también deberías poder seleccionar el puerto COM. En la captura de pantalla arriba es COM13, pero en tu caso puede ser otro puerto COM.
Ejemplos de Código
En esta sección, te proporcionaré algunos ejemplos de código para probar las principales características de la XIAO ESP32-S3.
Encontrar pines I2C y SPI
Este primer ejemplo de código imprime las interfaces I2C y SPI, que necesitarás para conectar muchos sensores y pantallas:
void print(const char* name, int pin) {
Serial.print(name);
Serial.println(pin);
}
void setup() {
Serial.begin(115200);
delay(2000);
print("LED: ", LED_BUILTIN);
print("SDA: ", SDA);
print("SCL: ", SCL);
print("SS: ", SS);
print("MOSI: ", MOSI);
print("MISO: ", MISO);
print("SCK: ", SCK);
}
void loop() { }
Puedes usar este código también para otras placas soportadas en el Arduino IDE. Para más información, consulta el Find I2C and SPI default pins tutorial. Para la XIAO ESP32-S3 este código imprime:
LED: 21 SDA: 5 SCL: 6 SS: 44 MOSI: 9 MISO: 8 SCK: 7
Parpadear LED a bordo
Este es el común Blink ejemplo. Enciende y apaga el LED a bordo durante un segundo. El LED a bordo de la XIAO ESP32-S3 está conectado al GPIO21 pero está invertido. LOW significa que el LED está encendido y HIGH que está apagado. Puedes verlo en el ejemplo de código abajo:
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
Serial.println("Off");
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
Serial.println("On");
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Leer y Escribir GPIO
En los siguientes ejemplos muy cortos, leemos y escribimos GPIO. Para especificar pines en el código puedes usar el número GPIO x o el número Dx. Por ejemplo, según el pinout, D3 o GPIO4 identifican el mismo pin y en tu código puedes usar cualquiera de los dos. Los siguientes dos ejemplos de código son idénticos en función y configuran GPIO4 a HIGH:
digitalWrite(D3, HIGH); // D3 == GPIO4
digitalWrite(4, HIGH); // D3 == GPIO4
Si quieres leer señales analógicas puedes usar las constantes predefinidas Ax. Por ejemplo, el siguiente código lee una entrada analógica de A3, que es igual que el pin GPIO4:
int val = analogRead(A3); // A3 == GPIO4
int val = analogRead(4); // A3 == GPIO4
Los valores analógicos van de 0 a 4095, lo que equivale a un voltaje en la entrada entre 0 y 3.3V.
Entrada táctil
Este ejemplo demuestra cómo usar los pines táctiles capacitivos de la XIAO ESP32-S3 para detectar toques. Si tocas el primer pin (D0) de la placa, el LED incorporado se encenderá. Puede que tengas que ajustar el umbral de detección.
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
int value = touchRead(T1);
Serial.println(value);
if (value > 30000) {
digitalWrite(LED_BUILTIN, LOW);
} else {
digitalWrite(LED_BUILTIN, HIGH);
}
delay(200);
}
HID para Control de Volumen
El ESP32-S3 soporta USB HID (Dispositivo de Interfaz Humana), lo que significa que puedes controlar dispositivos del ordenador como teclado o volumen con el ESP32 conectado. En los siguientes ejemplos usamos las entradas táctiles T1 y T2 para aumentar o disminuir el volumen del ordenador:
#include "USB.h"
#include "USBHIDConsumerControl.h"
USBHIDConsumerControl UCC;
#define TOUCH_THRESHOLD 30000
bool upPressed() {
return touchRead(T1) > TOUCH_THRESHOLD;
}
bool downPressed() {
return touchRead(T2) > TOUCH_THRESHOLD;
}
void setup() {
USB.begin();
UCC.begin();
}
void loop() {
if (upPressed()) {
UCC.press(CONSUMER_CONTROL_VOLUME_INCREMENT);
UCC.release();
}
if (downPressed()) {
UCC.press(CONSUMER_CONTROL_VOLUME_DECREMENT);
UCC.release();
}
delay(100);
}
En lugar de las entradas táctiles, obviamente también podrías conectar botones. Pero con las entradas táctiles solo necesitas conectar cables en el primer (D0) y segundo (D1) pin para probar el código del controlador de volumen.
Consulta la arduino-esp32 librería para más ejemplos HID. Ten cuidado al usar el ESP32 para HID, ya que puedes deshabilitar fácilmente tu ratón o saturar tu ordenador con pulsaciones, dejándolo inutilizable mientras el ESP32 esté conectado.
También ten en cuenta que la placa no puede ser flasheada mientras HID está activo. Desaparecerá como dispositivo USB en el Arduino IDE. Para volver a poner la placa en modo flash necesitas:
- Presionar y mantener el botón BOOT (B)
- Mientras mantienes BOOT (B), presiona y suelta RESET (R)
- Suelta el botón BOOT (B)
Como los botones BOOT (B) y RESET (R) en el ESP32-S3 son muy pequeños, esto puede ser bastante complicado.
Wi-Fi
El siguiente ejemplo te muestra cómo conectar la XIAO ESP32 a una red Wi-Fi. Esto funcionará sin la antena externa si estás cerca del router Wi-Fi. Pero para mejor alcance deberías instalar la antena.
#include <WiFi.h>
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.print("Connecting");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nConnected");
Serial.println(WiFi.localIP());
}
void loop() {
}
Servidor Web
Puedes ampliar el ejemplo WiFi anterior y construir fácilmente un servidor web simple. El siguiente código crea un servidor web, imprime la dirección IP que sirve y muestra el texto «Hello from XIAO ESP32-S3!» en la página raíz:
#include <WiFi.h>
#include <WebServer.h>
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
WebServer server(80);
void handleRoot() {
server.send(200, "text/plain", "Hello from XIAO ESP32-S3!");
}
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println(WiFi.localIP());
server.on("/", handleRoot);
server.begin();
}
void loop() {
server.handleClient();
}
Descarga el código a tu ESP32-S3, abre el Monitor Serial y copia la dirección IP que se imprime allí (por ejemplo «192.168.1.160») en la barra de direcciones de tu navegador. Deberías ver aparecer el mensaje:
Escáner Web
Si quieres escanear tu red Wi-Fi local para detectar redes disponibles, aquí tienes un ejemplo de código:
#include "WiFi.h"
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
}
void loop() {
Serial.println("scan start");
int n = WiFi.scanNetworks();
Serial.println("scan done");
if (n == 0) {
Serial.println("no networks found");
} else {
Serial.print(n);
Serial.println(" networks found");
for (int i = 0; i < n; ++i) {
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : "*");
}
delay(10);
}
Serial.println("");
delay(5000);
}
Puedes empezar sin la antena Wi-Fi conectada y solo encontrarás las redes Wi-Fi más fuertes. Si conectas la antena probablemente descubrirás más redes. Por ejemplo, sin la antena obtengo una señal débil (-77 dB) y solo una red:
scan start scan done 1 networks found 1: maetasus (-77)*
Tan pronto como conecto la antena, se detectan más redes y la intensidad de señal de mi red local (maetasus) sube de -77 dB a -35 dB:
scan start scan done 5 networks found 1: maetasus (-35)* 2: FRITZ!Box 5590 DQ (-75)* 3: WLAN-762918 (-81)* 4: portthru (-83) 5: WLAN-579476 (-91)*
Bluetooth
Este ejemplo demuestra cómo crear un servidor Bluetooth Low Energy (BLE) simple.
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
void setup() {
Serial.begin(115200);
BLEDevice::init("XIAO-ESP32-S3");
BLEServer *pServer = BLEDevice::createServer();
BLEDevice::getAdvertising()->start();
Serial.println("BLE server started");
}
void loop() {
}
Puedes comprobar si el servidor está activo usando un escáner BLE en tu teléfono. Opciones comunes son nRF Connect o LightBlue. Si inicias un escaneo, verás aparecer «XIAO-ESP32-S3».
Sensor de Presión y Temperatura (BME280) vía I2C
Este ejemplo de código te muestra cómo conectar un sensor vía I2C a la XIAO ESP32-S3. Usaremos el BME280 en este ejemplo. Para más información sobre este sensor consulta los tutoriales How To Use BME280 Pressure Sensor With Arduino y Weather Station on e-Paper Display.
La interfaz I2C de la XIAO ESP32-S3 está en los pines 5 (SDA) y 6 (SCL). El diagrama de conexión abajo muestra cómo conectar el BME280 a la XIAO ESP32-S3.
El siguiente código muestra cómo leer presión, temperatura, humedad y altitud del sensor BME280 e imprimir las mediciones en el Monitor Serial:
#include "Adafruit_BME280.h"
#define SEALEVELPRESSURE_HPA 1013.25
#define BME280_ADDRESS 0x76
Adafruit_BME280 bme;
void setup() {
Serial.begin(11520);
while(!Serial);
if (!bme.begin(BME280_ADDRESS)) {
Serial.println("Can't find BME280!");
while(1) delay(10);
}
}
void loop() {
Serial.print("Temperature in degC = ");
Serial.println(bme.readTemperature());
Serial.print("Pressure in hPa = ");
Serial.println(bme.readPressure() / 100.0F);
Serial.print("Altitude in m = ");
Serial.println(bme.readAltitude(SEALEVELPRESSURE_HPA));
Serial.print("Humidity in %RH = ");
Serial.println(bme.readHumidity());
Serial.println();
delay(5000);
}
Si todo está cableado correctamente, deberías ver datos similares a la salida abajo:
Temperature in degC = 22.93 Pressure in hPa = 1000.40 Altitude in m = 107.53 Humidity in %RH = 34.61
OLED vía I2C
En el ejemplo de código usamos nuevamente la interfaz I2C pero conectamos una pantalla OLED a la XIAO ESP32-S3. Como antes usamos los pines 5 (SDA) y 6 (SCL) para I2C. La imagen abajo muestra la conexión que debes hacer con la OLED:
Y aquí está el código. Simplemente escribe el texto “make” en la pantalla. Ten en cuenta que necesitarás instalar la Adafruit_SSD1306 library primero.
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
void setup() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(4);
oled.setTextColor(WHITE);
}
void loop() {
oled.clearDisplay();
oled.setCursor(20, 16);
oled.print("make");
oled.display();
delay(1000);
}
Pantalla E-Paper por SPI
En este siguiente ejemplo, vamos a controlar una pantalla E-Paper vía la interfaz SPI de la XIAO ESP32-S3. Los pines SPI hardware para la XIAO ESP32-S3 son 8 (MISO), 9 (MOSI), 44 (CS/SS) y 7 (SCK). Los otros pines son libres para elegir.
El diagrama de conexión abajo muestra cómo conectar un 4.2″ e-Paper Display a los pines SPI:
Abajo una tabla con todas las conexiones para mayor comodidad. Ten en cuenta que puedes alimentar la pantalla con 3.3V o 5V pero las líneas de datos SPI deben ser 3.3V. Para mayor seguridad, usa 3.3V para la alimentación.
| Pantalla e-Paper | XIAO ESP32-S3 |
|---|---|
| CS/SS | GPIO44 |
| CLK/SCL/SCK | GPIO7 |
| SDA/DIN/MOSI | GPIO9 |
| BUSY | GPIO1 |
| RES/RST | GPIO2 |
| DC | GPIO3 |
| VCC | 3.3V |
| GND | G |
Antes de poder dibujar en la pantalla e-Paper necesitarás instalar la GxEPD2 librería, que provee el software controlador gráfico para la pantalla E-Paper. El ejemplo de código abajo usa la librería para imprimir el texto «Makerguides» en la pantalla:
#include "GxEPD2_BW.h"
// hardware SPI
// #define MISO 8
// #define MOSI 9
// #define SCK 7
#define CS 44
#define DC 3
#define RST 2
#define BUSY 1
GxEPD2_BW<GxEPD2_420_GDEY042T81, GxEPD2_420_GDEY042T81::HEIGHT>
epd(GxEPD2_420_GDEY042T81(CS, DC, RST, BUSY));
void setup() {
epd.init(115200, true, 50, false);
epd.setRotation(1);
epd.setTextColor(GxEPD_BLACK);
epd.setTextSize(2);
epd.setFullWindow();
epd.fillScreen(GxEPD_WHITE);
epd.setCursor(90, 190);
epd.print("Makerguides");
epd.display();
epd.hibernate();
}
void loop() {}
Si quieres implementar algo más interesante, echa un vistazo a los tutoriales Monthly Calendar on E-Paper Display o Analog Clock on e-Paper Display.
Deep Sleep
El siguiente código demuestra cómo usar el modo deep-sleep con el ESP32-S3. Cada 10 segundos pone el ESP32-S3 en deep-sleep por 5 segundos y luego lo despierta:
#define uS_TO_S_FACTOR 1000000ULL
#define TIME_TO_SLEEP 5
void setup() {
Serial.begin(115200);
Serial.println("Awake...");
delay(10000);
Serial.println("Going to sleep...");
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
esp_deep_sleep_start();
}
void loop() {}
Ten cuidado al aumentar el periodo de deep-sleep. Durante deep-sleep la placa se desconecta del USB y no puedes flashear nuevo software. Para volver a poner la placa en modo flash necesitas:
- Presionar y mantener el botón BOOT (B)
- Mientras mantienes BOOT, presiona y suelta RESET (R)
- Suelta el botón BOOT
Actualización OTA (Over The Air)
En este último ejemplo de código, te muestro cómo realizar una actualización Over The Air (OTA) del código en la XIAO ESP32-S3. Esto tiene la ventaja de que no necesitas conectar tu ESP32 para flashear nuevo código.
#include <WiFi.h>
#include <ArduinoOTA.h>
const char* wifi_ssid = "YOUR_SSID";
const char* wifi_pwd = "YOUR_PASSWORD";
const char* ota_pwd = "1234";
const char* ota_name = "my-xiao-esp32-s3";
void setup() {
WiFi.begin(wifi_ssid, wifi_pwd);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
ArduinoOTA.setHostname(ota_name);
ArduinoOTA.setPassword(ota_pwd);
ArduinoOTA.begin();
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
ArduinoOTA.handle();
// Main code
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
El ESP32 aparecerá bajo Tools -> Ports -> Network Ports con el nombre de host dado «my-xiao-esp32-s3». Si flasheas a ese host, el Arduino IDE pedirá una contraseña («1234») y luego flasheará el nuevo código por Wi-Fi. Obviamente, deberías elegir una contraseña mejor que «1234» ; )
En el ejemplo de código el programa principal es el simple Blink. Cambia el retardo, flashea el nuevo código y comprueba si la velocidad del parpadeo ha cambiado para probar la actualización OTA.
Conclusiones
Este post te mostró cómo empezar con la Seeed Studio XIAO ESP32-S3. Seeed Studio proporciona información adicional en su Wiki.
Ten en cuenta que existe una versión XIAO ESP32-S3-Plus que tiene más Flash (16MB) y pines GPIO. También está la XIAO-ESP32-S3-Sense, que viene con cámara y micrófono. Si quieres grabar audio o transmitir video, elige la XIAO-ESP32-S3-Sense. Si necesitas más memoria o IO, opta por la XIAO ESP32-S3-Plus.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje! 😉
