A Seeed Studio XIAO ESP32-S3 é uma pequena placa microcontroladora projetada para aplicações embutidas e IoT. Faz parte da série XIAO, que foca em placas de formato muito pequeno com forte capacidade de processamento. A placa mede apenas cerca de 21 × 17,8 mm, tornando-a adequada para projetos com espaço limitado.
Baseia-se no chip ESP32-S3 com um processador dual-core Xtensa LX7 a funcionar até 240 MHz. A placa inclui Wi-Fi integrado e Bluetooth Low Energy, permitindo comunicação sem fios sem hardware adicional. Também oferece memória flash e PSRAM integradas, que suportam aplicações mais avançadas como IA de borda e processamento de dados.
A gestão de energia é uma característica importante desta placa. Suporta carregamento de bateria e oferece modos de baixo consumo para designs energeticamente eficientes. Isto torna-a adequada para projetos portáteis e alimentados por bateria.
Neste tutorial, aprenderás como programar a XIAO ESP32-S3 usando o Arduino IDE.
Onde Comprar
Podes adquirir a XIAO ESP32-S3 na Seeed Studio ou na Amazon. Também vais precisar de um cabo USB-C, caso ainda não tenhas um. Um pequeno dissipador de calor pode ser necessário se fizeres uso intensivo do processamento na placa.
XIAO ESP32-S3
Cabo USB C
Pequeno dissipador 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 da placa XIAO ESP32-S3
A XIAO ESP32-S3 é construída em torno do sistema em chip ESP32-S3R8. Utiliza um processador dual-core Xtensa LX7 com arquitetura de 32 bits. A CPU pode funcionar a uma frequência de até 240 MHz. A foto abaixo mostra a frente e o verso da placa:
O chip oferece 8 MB de memória flash e 8 MB de PSRAM. Esta memória estendida permite a execução de firmware mais complexo e suporta buffering para aplicações intensivas em dados, como processamento de áudio ou imagem.
O ESP32-S3 também inclui suporte de hardware para instruções vetoriais. Isto melhora o desempenho para processamento de sinais e inferência em redes neurais.
Conectividade Sem Fios
A placa integra um subsistema Wi-Fi completo a 2,4 GHz. Suporta os padrões IEEE 802.11 b/g/n para comunicação de rede. O rádio Wi-Fi está incorporado no chip e não requer componentes externos além de uma antena para melhor receção. A imagem abaixo mostra a XIAO ESP32-S3 com a antena externa ligada.
Também é suportado Bluetooth Low Energy 5.0. Isto permite comunicação de baixo consumo com sensores, smartphones e outros dispositivos BLE. O chip pode também operar em modo Bluetooth Mesh para redes IoT distribuídas.
GPIO e Interfaces Periféricas
A XIAO ESP32-S3 expõe múltiplas interfaces digitais e analógicas. Fornece até 11 pinos GPIO com capacidade PWM. Inclui também até 9 canais ADC para entrada analógica. A imagem seguinte mostra o pinout da XIAO ESP32-S3:
A placa suporta protocolos comuns de comunicação, incluindo UART, I2C e SPI. O ESP32-S3 usa uma matriz GPIO flexível, permitindo que a maioria das funções periféricas seja mapeada para diferentes pinos.
Existem pinos dedicados para comunicação I2C usando os sinais SDA e SCL. Os sinais SPI incluem clock, MOSI e MISO. UART está disponível para comunicação serial e depuração.
Características adicionais incluem um LED de utilizador e um LED de estado de carga. Existem também botões de reset e boot para controlo do firmware e flashing.
USB e Integração do Sistema
O ESP32-S3 inclui suporte USB nativo. A placa XIAO usa um conector USB-C para alimentação, programação e transferência de dados. A interface USB está diretamente ligada ao microcontrolador, não necessitando de um conversor USB-serial externo.
O chip suporta funcionalidade USB OTG, permitindo atuar tanto como dispositivo USB como host USB. Esta funcionalidade possibilita aplicações como dispositivos USB HID ou registo de dados em armazenamento externo.
Gestão de Energia
A placa suporta alimentação por USB e por bateria. Um circuito de carregamento integrado permite carregar uma bateria de lítio de 3,7 V. Isto possibilita operação autónoma sem hardware externo de gestão de energia.
A tensão de operação é tipicamente 3,3 V. O regulador onboard fornece energia estável para o microcontrolador e periféricos.
O ESP32-S3 suporta múltiplos modos de poupança de energia, incluindo modem sleep, light sleep e deep sleep. A tabela abaixo mostra o consumo de corrente do ESP32-S3 para diferentes modos:
| Modo | Corrente Típica (Chip) | Unidade | Descrição |
|---|---|---|---|
| Modem Sleep | ~10.5 – 90 | mA | CPU ativa, Wi-Fi desativado |
| Light Sleep | ~240 – 750 | µA | CPU pausada, memória retida |
| Deep Sleep | ~7 – 25 | µA | RTC ativo, a maior parte do sistema desligado |
Estes valores representam o chip ESP32-S3 em si. A placa XIAO ESP32-S3 normalmente consome um pouco mais de corrente devido ao hardware onboard.
Especificações Técnicas
A tabela seguinte resume as características técnicas da XIAO ESP32-S3:
| Parâmetro | Especificação |
|---|---|
| Microcontrolador | ESP32-S3R8 (Xtensa LX7 dual-core) |
| Frequência da CPU | Até 240 MHz |
| Arquitetura | 32 bits |
| Memória Flash | 8 MB |
| PSRAM | 8 MB |
| Sem Fios | Wi-Fi 802.11 b/g/n, Bluetooth LE 5.0 |
| USB | USB-C, USB OTG nativo |
| Pinos GPIO | Até 11 |
| Canais ADC | Até 9 |
| Interfaces de Comunicação | UART, I2C, SPI |
| Tensão de Operação | 3,3 V |
| Entrada de Energia | USB-C ou bateria LiPo 3,7 V |
| Características de Energia | Carregamento de bateria, suporte a deep sleep |
| Dimensões | ~21 × 17,8 mm |
| Características Adicionais | LED de utilizador, LED de carga, botões de reset e boot |
Comparação da XIAO ESP32-S3 com outras placas ESP32 populares
O ecossistema ESP32 cresceu significativamente, e escolher a placa certa pode ser confuso. A tabela abaixo compara as opções mais populares, incluindo a série compacta XIAO e as placas ESP32 clássicas.
| 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 |
| Velocidade de Relógio | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz |
| Aceleração AI | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
| PSRAM | 8 MB | Até 8MB+ | 8 MB | ❌ | Opcional | 4 MB |
| Flash | 8–16 MB | Até 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ássico + BLE | Clássico + BLE |
| USB | USB nativo | USB nativo | USB nativo | Depende da placa | Chip UART | Não |
| Câmara | ❌ | ❌ | ✅ | ❌ | ❌ | ✅ |
| Microfone | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
| Formato | Ultra compacto | Compacto | Compacto + add-on | Variável | Grande | Módulo |
| GPIO | Limitado | Moderado | Limitado | Moderado | Alto | Muito limitado |
| Melhor Caso de Uso | IoT compacto | Projetos de expansão | IA / Visão | IoT com Wi-Fi 6 | Prototipagem geral | Streaming de câmara |
Qual placa deves escolher?
- XIAO ESP32-S3: Melhor equilíbrio entre tamanho, desempenho e funcionalidades para a maioria dos projetos IoT.
- XIAO ESP32-S3 Plus: Boa escolha se precisares de mais opções de expansão e flexibilidade.
- XIAO ESP32-S3 Sense: Ideal para projetos de IA, câmara e áudio (reconhecimento facial, deteção de objetos).
- ESP32-C5: Melhor para aplicações sem fios modernas com suporte a Wi-Fi 6 e 5 GHz.
- ESP32 DevKit: Perfeito para iniciantes e prototipagem em breadboard com acesso máximo a GPIO.
- ESP32-CAM: Opção económica para projetos simples de streaming de câmara, mas mais limitada.
Uma das vantagens mais subestimadas do ESP32-S3 é a sua capacidade USB nativa. Ao contrário das placas ESP32 clássicas, que dependem de um chip UART externo para comunicação, o S3 pode comunicar diretamente via USB. Isto permite funcionalidades poderosas como USB HID (permitindo que a placa atue como teclado ou rato) e comunicação serial CDC nativa sem hardware adicional.
Note também a importância da PSRAM para aplicações que lidam com fluxos de dados grandes ou contínuos, como processamento de áudio, captura de vídeo e cargas de trabalho de IA. Estes casos de uso rapidamente ultrapassam a SRAM interna limitada dos microcontroladores típicos. Na prática, a PSRAM muitas vezes faz a diferença entre um projeto que mal funciona e um que corre de forma fiável.
Se vais iniciar um novo projeto em 2026, a família ESP32-S3 é geralmente a melhor escolha devido ao suporte USB nativo e aceleração AI. As placas ESP32 clássicas ainda são úteis, mas principalmente para projetos sensíveis ao custo ou legados que não requerem as novas funcionalidades do ESP32-S3.
Instalar ESP32 Core
Se quiseres usar o Arduino IDE para programar a placa, primeiro precisas de instalar o ESP32 Core para ativar o suporte a placas ESP32 dentro do Arduino IDE. Abre o teu Arduino IDE e segue os passos indicados abaixo. Se tiveres problemas, podes encontrar instruções mais detalhadas no nosso tutorial Install ESP32 core in Arduino IDE.
URLs adicionais para o gestor de placas
Primeiro abre o diálogo de Preferências selecionando “Preferences…” no menu “File”:
Isto abrirá o diálogo de Preferências mostrado abaixo. Na aba Settings encontrarás uma caixa de edição na parte inferior do diálogo rotulada “Additional boards manager URLs”:
Neste campo de entrada copia a seguinte URL: “https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json“
Isto informa o Arduino IDE onde encontrar as bibliotecas core do ESP32. A seguir vamos instalar as bibliotecas core do ESP32 usando o Boards Manager.
Gestor de Placas
Abre o BOARDS MANAGER clicando no ícone da placa na barra lateral do Arduino IDE:
Verás o BOARDS MANAGER aparecer à direita da barra lateral. Introduz “ESP32” no campo de pesquisa no topo e deverás ver dois tipos de placas ESP32; as “Arduino ESP32 Boards” e as placas “esp32 by Espressif”. Queremos as bibliotecas esp32 da Espressif. Clica no botão INSTALL e espera até o download e instalação terminarem.
Uma vez instalado, o teu Boards Manager deverá parecer com isto, embora a versão real (aqui 3.3.7) possa ser diferente.
No próximo passo, mostro-te como selecionar a placa ESP32 para a XIAO ESP32-S3.
Selecionar placa XIAO_ESP32S3
Podes selecionar uma placa no seletor suspenso sob a barra de menu: No exemplo abaixo está selecionada uma Arduino Uno, por exemplo:
Clicar no nome da placa atualmente selecionada (Arduino Uno) abrirá o diálogo de seleção de placa. Na caixa de pesquisa escreve “xiao s3” e seleciona “XIAO_ESP32S3” como mostrado abaixo:
Se a placa estiver ligada ao teu PC via USB, também deverás conseguir selecionar a porta COM. Na captura de ecrã acima é COM13, mas no teu caso pode ser outra porta COM.
Exemplos de Código
Nesta secção, vou fornecer-te alguns exemplos de código para experimentares as principais funcionalidades da XIAO ESP32-S3.
Encontrar pinos I2C e SPI
Este primeiro exemplo de código imprime as interfaces I2C e SPI, que vais precisar para ligar muitos sensores e displays:
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() { }
Podes usar este código para outras placas suportadas no Arduino IDE também. Para mais informações vê o Find I2C and SPI default pins tutorial. Para a XIAO ESP32-S3 este código imprime:
LED: 21 SDA: 5 SCL: 6 SS: 44 MOSI: 9 MISO: 8 SCK: 7
Piscar LED onboard
Este é o comum Blink exemplo. Liga e desliga o LED onboard durante um segundo. O LED onboard da XIAO ESP32-S3 está ligado ao GPIO21 mas é invertido. LOW significa que o LED está ligado e HIGH que está desligado. Podes ver isto no exemplo de código abaixo:
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);
}
Ler & Escrever GPIO
Nos exemplos muito curtos seguintes, lemos e escrevemos GPIO. Para especificar pinos no código podes usar o número GPIO x ou o número Dx. Por exemplo, de acordo com o pinout, D3 ou GPIO4 identificam o mesmo pino e no teu código podes usar qualquer um. Os dois exemplos de código seguintes são idênticos em função e definem GPIO4 para HIGH:
digitalWrite(D3, HIGH); // D3 == GPIO4
digitalWrite(4, HIGH); // D3 == GPIO4
Se quiseres ler sinais analógicos podes usar as constantes pré-definidas Ax. Por exemplo, o código seguinte lê uma entrada analógica de A3, que é o mesmo que o pino GPIO4:
int val = analogRead(A3); // A3 == GPIO4
int val = analogRead(4); // A3 == GPIO4
Os valores analógicos variam de 0 a 4095, o que equivale a uma tensão na entrada entre 0 e 3,3V.
Entrada Touch
Este exemplo demonstra como usar os pinos de toque capacitivo da XIAO ESP32-S3 para detetar toques. Se tocares no primeiro pino (D0) da placa, o LED incorporado acende. Podes ter de ajustar o limiar de deteção.
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 Controlo de Volume
O ESP32-S3 suporta USB HID (Human Interface Device), o que significa que podes controlar dispositivos do computador como teclado ou volume com o ESP32 ligado. Nos exemplos seguintes usamos as entradas touch T1 e T2 para aumentar ou diminuir o volume do computador:
#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);
}
Em vez das entradas touch, obviamente também podes ligar botões. Mas com as entradas touch só precisas de ligar cabos no primeiro (D0) e segundo (D1) pino para experimentar o código do controlador de volume.
Vê a biblioteca arduino-esp32 para mais exemplos HID. Cuidado ao usar o ESP32 para HID, pois podes facilmente desativar o rato ou inundar o computador com teclas – tornando-o inutilizável enquanto o ESP32 estiver ligado.
Note também que a placa não pode ser flashada enquanto o HID está a correr. Ela desaparecerá como dispositivo USB no Arduino IDE. Para colocar a placa novamente em modo flash precisas de:
- Pressionar e segurar o botão BOOT (B)
- Enquanto seguras BOOT (B), pressiona e solta RESET (R)
- Soltar o botão BOOT (B)
Como os botões BOOT (B) e RESET (R) no ESP32-S3 são muito pequenos, isto pode ser bastante complicado.
Wi-Fi
O exemplo seguinte mostra como ligar a XIAO ESP32 a uma rede Wi-Fi. Isto funcionará sem a antena externa, se estiveres perto do router Wi-Fi. Mas para melhor alcance deves instalar a 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
Podes estender o exemplo WiFi anterior e facilmente construir um servidor web simples. O código seguinte cria um servidor web, imprime o endereço IP onde o servidor está ativo e mostra o texto “Hello from XIAO ESP32-S3!” na página raiz:
#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();
}
Carrega o código para o teu ESP32-S3, abre o Monitor Serial e copia o endereço IP que é impresso lá (ex. “192.168.1.160”) para a barra de endereços do teu navegador. Deverás ver a mensagem aparecer:
Scanner Web
Se quiseres escanear a tua rede Wi-Fi local para detetar redes disponíveis, aqui está um exemplo 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);
}
Podes começar sem a antena Wi-Fi ligada e só encontrarás as redes Wi-Fi mais fortes. Se ligares a antena provavelmente descobrirás mais redes. Por exemplo, sem a antena recebo um sinal fraco (-77 dB) e apenas uma rede:
scan start scan done 1 networks found 1: maetasus (-77)*
Assim que ligo a antena, mais redes são detetadas e a força do sinal da minha rede local (maetasus) sobe de -77 dB para -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 exemplo demonstra como criar um servidor Bluetooth Low Energy (BLE) simples.
#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() {
}
Podes verificar se o servidor está ativo usando um scanner BLE no teu telemóvel. Opções comuns são nRF Connect ou LightBlue. Se iniciares uma pesquisa, verás “XIAO-ESP32-S3” aparecer.
Sensor de Pressão e Temperatura (BME280) via I2C
Este exemplo de código mostra como ligar um sensor via I2C à XIAO ESP32-S3. Usaremos o BME280 neste exemplo. Para mais informações sobre este sensor vê os tutoriais How To Use BME280 Pressure Sensor With Arduino e Weather Station on e-Paper Display.
A interface I2C da XIAO ESP32-S3 está nos pinos 5 (SDA) e 6 (SCL). O diagrama de ligação abaixo mostra como conectar o BME280 à XIAO ESP32-S3.
O código seguinte mostra como ler pressão, temperatura, humidade e altitude do sensor BME280 e imprimir as medições no 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);
}
Se tudo estiver ligado corretamente, deverás ver dados semelhantes à saída abaixo:
Temperature in degC = 22.93 Pressure in hPa = 1000.40 Altitude in m = 107.53 Humidity in %RH = 34.61
OLED via I2C
No exemplo de código usamos novamente a interface I2C, mas ligamos um display OLED à XIAO ESP32-S3. Como antes, usamos os pinos 5 (SDA) e 6 (SCL) para I2C. A imagem abaixo mostra a ligação que precisas fazer com o OLED:
E aqui está o código. Ele simplesmente escreve o texto “make” no display. Nota que precisarás de instalar a biblioteca Adafruit_SSD1306 library primeiro.
#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);
}
Display E-Paper via SPI
No próximo exemplo, vamos controlar um Display E-Paper via a interface SPI da XIAO ESP32-S3. Os pinos SPI hardware para a XIAO ESP32-S3 são 8 (MISO), 9 (MOSI), 44 (CS/SS) e 7 (SCK). Os outros pinos são livres para escolher.
O diagrama de ligação abaixo mostra como conectar um 4.2″ e-Paper Display aos pinos SPI:
Abaixo uma tabela com todas as ligações para conveniência. Nota que podes alimentar o display com 3,3V ou 5V, mas as linhas de dados SPI devem ser 3,3V! Para maior segurança, usa 3,3V para a alimentação.
| Display 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 poderes desenhar no display e-Paper precisarás de instalar a biblioteca GxEPD2 , que fornece o software do driver gráfico para o Display E-Paper. O exemplo de código abaixo usa a biblioteca para imprimir o texto “Makerguides” no display:
#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() {}
Se quiseres implementar algo mais interessante, dá uma vista de olhos nos tutoriais Monthly Calendar on E-Paper Display ou Analog Clock on e-Paper Display.
Deep Sleep
O código seguinte demonstra como usar o modo deep-sleep com o ESP32-S3. A cada 10 segundos coloca o ESP32-S3 em deep-sleep por 5 segundos e depois acorda-o novamente:
#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() {}
Cuidado ao aumentar o período de deep-sleep. Durante o deep-sleep a placa desconecta do USB e não podes flashar novo software. Para colocar a placa novamente em modo flash precisas de:
- Pressionar e segurar o botão BOOT (B)
- Enquanto seguras BOOT, pressiona e solta RESET (R)
- Soltar o botão BOOT
Atualização OTA (Over The Air)
Neste último exemplo de código, mostro como realizar uma atualização Over The Air (OTA) do código na XIAO ESP32-S3. Isto tem a vantagem de não precisares de ligar o teu ESP32 para flashar novo 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);
}
O ESP32 aparecerá em Tools -> Ports -> Network Ports com o hostname dado “my-xiao-esp32-s3”. Se flashes para esse host, o Arduino IDE pedirá uma password (“1234”) e depois fará o flash do novo código via Wi-Fi. Obviamente, deves escolher uma password melhor que “1234” ; )
No exemplo de código, o código principal é o programa simples Blink. Altera o delay, flasha o novo código e verifica se a taxa de piscar mudou para testar a atualização OTA.
Conclusões
Este artigo mostrou como começar com a Seeed Studio XIAO ESP32-S3. A Seeed Studio fornece informação adicional no seu Wiki.
Note que existe uma versão XIAO ESP32-S3-Plus que tem mais Flash (16MB) e pinos GPIO. E também existe a XIAO-ESP32-S3-Sense, que vem com câmara e microfone. Se quiseres gravar áudio ou fazer streaming de vídeo escolhe a XIAO-ESP32-S3-Sense. Se precisares de mais memória ou IO, opta pela XIAO ESP32-S3-Plus.
Se tiveres alguma dúvida, sente-te à vontade para deixar nos comentários.
Boas experiências a criar 😉
