Das Seeed Studio XIAO ESP32-S3 ist eine kleine Mikrocontroller-Platine, die für Embedded- und IoT-Anwendungen entwickelt wurde. Es gehört zur XIAO-Serie, die sich auf sehr kompakte Platinen mit starker Rechenleistung konzentriert. Die Platine misst nur etwa 21 × 17,8 mm und eignet sich somit für platzbeschränkte Designs.
Sie basiert auf dem ESP32-S3-Chip mit einem Dual-Core Xtensa LX7 Prozessor, der mit bis zu 240 MHz läuft. Die Platine verfügt über integriertes Wi-Fi und Bluetooth Low Energy, was drahtlose Kommunikation ohne zusätzliche Hardware ermöglicht. Außerdem bietet sie eingebauten Flash- und PSRAM-Speicher, der fortgeschrittene Anwendungen wie Edge-AI und Datenverarbeitung unterstützt.
Energiemanagement ist ein wichtiges Merkmal dieser Platine. Sie unterstützt das Laden von Batterien und bietet Energiesparmodi für energieeffiziente Designs. Dadurch eignet sie sich gut für tragbare und batteriebetriebene Projekte.
In diesem Tutorial lernst du, wie du den XIAO ESP32-S3 mit der Arduino IDE programmierst.
Wo kaufen
Du kannst den XIAO ESP32-S3 bei Seeed Studio oder Amazon erwerben. Falls du noch kein USB-C-Kabel hast, benötigst du auch eines. Außerdem könnte ein kleiner Kühlkörper nötig sein, wenn du rechenintensive Aufgaben auf der Platine ausführst.
XIAO ESP32-S3
USB-C-Kabel
Kleiner Kühlkörper 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.
Merkmale der XIAO ESP32-S3 Platine
Der XIAO ESP32-S3 basiert auf dem ESP32-S3R8 System-on-Chip. Er verwendet einen Dual-Core Xtensa LX7 Prozessor mit 32-Bit-Architektur. Die CPU kann mit bis zu 240 MHz getaktet werden. Das Foto unten zeigt Vorder- und Rückseite der Platine:
Der Chip bietet 8 MB Flash-Speicher und 8 MB PSRAM. Dieser erweiterte Speicher ermöglicht die Ausführung komplexerer Firmware und unterstützt Pufferung für datenintensive Anwendungen wie Audio- oder Bildverarbeitung.
Der ESP32-S3 verfügt außerdem über Hardware-Unterstützung für Vektor-Instruktionen. Das verbessert die Leistung bei Signalverarbeitung und neuronaler Netzwerkinferenz.
Drahtlose Konnektivität
Die Platine integriert ein komplettes 2,4-GHz-Wi-Fi-Subsystem. Sie unterstützt die IEEE 802.11 b/g/n Standards für die Netzwerkkommunikation. Das Wi-Fi-Radio ist im Chip integriert und benötigt keine externen Komponenten außer einer Antenne für besseren Empfang. Das Bild unten zeigt den XIAO ESP32-S3 mit angeschlossener externer Antenne.
Bluetooth Low Energy 5.0 wird ebenfalls unterstützt. Das ermöglicht energieeffiziente Kommunikation mit Sensoren, Smartphones und anderen BLE-Geräten. Der Chip kann auch im Bluetooth Mesh Modus für verteilte IoT-Netzwerke betrieben werden.
GPIO- und Peripherie-Schnittstellen
Der XIAO ESP32-S3 bietet mehrere digitale und analoge Schnittstellen. Er stellt bis zu 11 GPIO-Pins mit PWM-Funktionalität bereit. Außerdem sind bis zu 9 ADC-Kanäle für analoge Eingänge verfügbar. Das folgende Bild zeigt das Pinout des XIAO ESP32-S3:
Die Platine unterstützt gängige Kommunikationsprotokolle wie UART, I2C und SPI. Der ESP32-S3 verwendet eine flexible GPIO-Matrix, die es erlaubt, die meisten Peripheriefunktionen auf verschiedene Pins zu legen.
Dedizierte Pins sind für die I2C-Kommunikation mit SDA- und SCL-Signalen vorhanden. SPI-Signale umfassen Clock, MOSI und MISO. UART steht für serielle Kommunikation und Debugging zur Verfügung.
Zusätzliche Features sind eine Benutzer-LED und eine Lade-Status-LED. Außerdem gibt es Reset- und Boot-Tasten für Firmware-Steuerung und Flashen.
USB- und Systemintegration
Der ESP32-S3 unterstützt native USB-Funktionalität. Die XIAO-Platine verwendet einen USB-C-Anschluss für Stromversorgung, Programmierung und Datenübertragung. Die USB-Schnittstelle ist direkt mit dem Mikrocontroller verbunden und benötigt keinen externen USB-zu-Seriell-Wandler.
Der Chip unterstützt USB OTG (On-The-Go). Dadurch kann er sowohl als USB-Gerät als auch als USB-Host agieren. Diese Funktion ermöglicht Anwendungen wie USB-HID-Geräte oder Datenlogging auf externen Speichern.
Energiemanagement
Die Platine unterstützt sowohl USB- als auch Batterieversorgung. Ein integrierter Ladekreis ermöglicht das Laden einer 3,7 V Lithium-Batterie. So ist ein autarker Betrieb ohne externe Energiemanagement-Hardware möglich.
Die Betriebsspannung liegt typischerweise bei 3,3 V. Der Onboard-Spannungsregler sorgt für stabile Versorgung von Mikrocontroller und Peripherie.
Der ESP32-S3 unterstützt mehrere Energiesparmodi, darunter Modem Sleep, Light Sleep und Deep Sleep. Die folgende Tabelle zeigt den Stromverbrauch des ESP32-S3 in den verschiedenen Modi:
| Modus | Typischer Stromverbrauch (Chip) | Einheit | Beschreibung |
|---|---|---|---|
| Modem Sleep | ~10,5 – 90 | mA | CPU aktiv, Wi-Fi deaktiviert |
| Light Sleep | ~240 – 750 | µA | CPU pausiert, Speicher erhalten |
| Deep Sleep | ~7 – 25 | µA | RTC aktiv, Großteil des Systems abgeschaltet |
Diese Werte beziehen sich auf den ESP32-S3 Chip selbst. Die XIAO ESP32-S3 Platine verbraucht typischerweise etwas mehr Strom aufgrund der Onboard-Hardware.
Technische Spezifikationen
Die folgende Tabelle fasst die technischen Merkmale des XIAO ESP32-S3 zusammen:
| Parameter | Spezifikation |
|---|---|
| Mikrocontroller | ESP32-S3R8 (Xtensa LX7 Dual-Core) |
| CPU-Frequenz | Bis zu 240 MHz |
| Architektur | 32-Bit |
| Flash-Speicher | 8 MB |
| PSRAM | 8 MB |
| Drahtlos | Wi-Fi 802.11 b/g/n, Bluetooth LE 5.0 |
| USB | USB-C, native USB OTG |
| GPIO-Pins | Bis zu 11 |
| ADC-Kanäle | Bis zu 9 |
| Kommunikationsschnittstellen | UART, I2C, SPI |
| Betriebsspannung | 3,3 V |
| Stromversorgung | USB-C oder 3,7 V LiPo-Batterie |
| Energie-Features | Batterieladung, Deep-Sleep-Unterstützung |
| Abmessungen | ~21 × 17,8 mm |
| Zusätzliche Features | Benutzer-LED, Lade-LED, Reset- und Boot-Tasten |
Vergleich des XIAO ESP32-S3 mit anderen beliebten ESP32-Platinen
Das ESP32-Ökosystem ist stark gewachsen, und die Wahl der richtigen Platine kann verwirrend sein. Die folgende Tabelle vergleicht die beliebtesten Optionen, darunter die kompakte XIAO-Serie und klassische ESP32-Platinen.
| Feature | 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 |
| Taktfrequenz | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz |
| KI-Beschleunigung | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
| PSRAM | 8 MB | Bis zu 8 MB+ | 8 MB | ❌ | Optional | 4 MB |
| Flash | 8–16 MB | Bis zu 16 MB+ | 8–16 MB | Extern | 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 | Classic + BLE | Classic + BLE |
| USB | Native USB | Native USB | Native USB | Abhängig von der Platine | UART-Chip | Nein |
| Kamera | ❌ | ❌ | ✅ | ❌ | ❌ | ✅ |
| Mikrofon | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
| Formfaktor | Ultra kompakt | Kompakt | Kompakt + Erweiterung | Variiert | Groß | Modul |
| GPIO | Begrenzt | Mittel | Begrenzt | Mittel | Hoch | Sehr begrenzt |
| Beste Einsatzgebiete | Kompaktes IoT | Erweiterungsprojekte | KI / Vision | Wi-Fi 6 IoT | Allgemeines Prototyping | Kamera-Streaming |
Welche Platine solltest du wählen?
- XIAO ESP32-S3: Beste Balance aus Größe, Leistung und Features für die meisten IoT-Projekte.
- XIAO ESP32-S3 Plus: Gute Wahl, wenn du mehr Erweiterungsoptionen und Flexibilität brauchst.
- XIAO ESP32-S3 Sense: Ideal für KI-, Kamera- und Audio-Projekte (Gesichtserkennung, Objekterkennung).
- ESP32-C5: Am besten für moderne drahtlose Anwendungen mit Wi-Fi 6 und 5-GHz-Unterstützung.
- ESP32 DevKit: Perfekt für Einsteiger und Breadboard-Prototyping mit maximalem GPIO-Zugang.
- ESP32-CAM: Kostengünstige Option für einfache Kamera-Streaming-Projekte, aber eingeschränkter.
Einer der meist unterschätzten Vorteile des ESP32-S3 ist seine native USB-Fähigkeit. Im Gegensatz zu klassischen ESP32-Platinen, die für die Kommunikation einen externen UART-Chip benötigen, kann der S3 direkt über USB kommunizieren. Das ermöglicht leistungsstarke Funktionen wie USB-HID (die Platine kann als Tastatur oder Maus agieren) und native CDC-Serielle Kommunikation ohne zusätzliche Hardware.
Beachte auch die Bedeutung von PSRAM für Anwendungen, die große oder kontinuierliche Datenströme verarbeiten, wie Audioverarbeitung, Videoaufnahme und KI-Workloads. Diese Anwendungsfälle überschreiten schnell den begrenzten internen SRAM typischer Mikrocontroller. In der Praxis macht PSRAM oft den Unterschied zwischen einem Projekt, das gerade so funktioniert, und einem, das zuverlässig läuft.
Wenn du 2026 ein neues Projekt startest, ist die ESP32-S3 Familie aufgrund der nativen USB-Unterstützung und KI-Beschleunigung in der Regel die beste Wahl. Die klassischen ESP32-Platinen sind weiterhin nützlich, vor allem für kostenbewusste oder Legacy-Projekte, die keine der neuen ESP32-S3 Features benötigen.
ESP32 Core installieren
Wenn du die Arduino IDE zur Programmierung der Platine verwenden möchtest, musst du zuerst den ESP32 Core installieren, um die Unterstützung für ESP32-Platinen in der Arduino IDE zu aktivieren. Öffne dein Arduino IDE und folge den unten beschriebenen Schritten. Bei Problemen findest du detailliertere Anleitungen in unserem Tutorial Install ESP32 core in Arduino IDE.
Zusätzliche Boards Manager URLs
Öffne zuerst den Preferences-Dialog über „Preferences…“ im „File“-Menü:
Es öffnet sich der unten gezeigte Preferences-Dialog. Unter dem Tab „Settings“ findest du unten ein Eingabefeld mit der Bezeichnung „Additional boards manager URLs“:
Füge in dieses Feld folgende URL ein: „https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json„
So weiß die Arduino IDE, wo sie die ESP32 Core Bibliotheken findet. Als nächstes installieren wir die ESP32 Core Bibliotheken über den Boards Manager.
Boards Manager
Öffne den BOARDS MANAGER, indem du auf das Platinen-Symbol in der Seitenleiste der Arduino IDE klickst:
Der BOARDS MANAGER erscheint rechts neben der Seitenleiste. Gib oben im Suchfeld „ESP32“ ein, und du solltest zwei Arten von ESP32-Platinen sehen: die „Arduino ESP32 Boards“ und die „esp32 by Espressif“ Boards. Wir wollen die esp32 Bibliotheken von Espressif. Klicke auf INSTALL und warte, bis der Download und die Installation abgeschlossen sind.
Nach der Installation sollte dein Boards Manager so aussehen, wobei die tatsächliche Version (hier 3.3.7) abweichen kann.
Im nächsten Schritt zeige ich dir, wie du das ESP32 Board für den XIAO ESP32-S3 auswählst.
XIAO_ESP32S3 Board auswählen
Du kannst ein Board im Dropdown-Menü unter der Menüleiste auswählen. Im Beispiel unten ist z.B. ein Arduino Uno als ausgewähltes Board zu sehen:
Klicke auf den Namen des aktuell ausgewählten Boards (Arduino Uno), um den Board-Auswahldialog zu öffnen. Gib im Suchfeld „xiao s3“ ein und wähle „XIAO_ESP32S3“ wie unten gezeigt aus:
Wenn die Platine per USB mit deinem PC verbunden ist, solltest du auch den COM-Port auswählen können. Im Screenshot ist das COM13, bei dir kann es ein anderer COM-Port sein.
Code-Beispiele
In diesem Abschnitt gebe ich dir einige Code-Beispiele, um die Hauptfunktionen des XIAO ESP32-S3 auszuprobieren.
I2C- und SPI-Pins finden
Das erste Code-Beispiel gibt die I2C- und SPI-Schnittstellen aus, die du für viele Sensoren und Displays benötigst:
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() { }
Du kannst diesen Code auch für andere in der Arduino IDE unterstützte Boards verwenden. Weitere Informationen findest du im Find I2C and SPI default pins Tutorial. Für den XIAO ESP32-S3 gibt dieser Code Folgendes aus:
LED: 21 SDA: 5 SCL: 6 SS: 44 MOSI: 9 MISO: 8 SCK: 7
Onboard-LED blinken
Dies ist das übliche Blink Beispiel. Es schaltet die Onboard-LED für eine Sekunde an und aus. Die Onboard-LED des XIAO ESP32-S3 ist mit GPIO21 verbunden, aber invertiert. LOW bedeutet LED an, HIGH bedeutet LED aus. Das siehst du im folgenden Code-Beispiel:
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);
}
GPIO lesen & schreiben
In den folgenden kurzen Beispielen lesen und schreiben wir GPIO. Zur Pin-Definition im Code kannst du die GPIO x Nummer oder die Dx Nummer verwenden. Laut Pinout identifizieren D3 und GPIO4 denselben Pin, und im Code kannst du entweder verwenden. Die folgenden zwei Code-Beispiele sind funktional identisch und setzen GPIO4 auf HIGH:
digitalWrite(D3, HIGH); // D3 == GPIO4
digitalWrite(4, HIGH); // D3 == GPIO4
Wenn du analoge Signale lesen möchtest, kannst du die vordefinierten Ax Konstanten verwenden. Zum Beispiel liest der folgende Code einen analogen Eingang von A3, was dem GPIO4 Pin entspricht:
int val = analogRead(A3); // A3 == GPIO4
int val = analogRead(4); // A3 == GPIO4
Analoge Werte liegen zwischen 0 und 4095, was einer Eingangsspannung von 0 bis 3,3 V entspricht.
Touch-Eingabe
Dieses Beispiel zeigt, wie du die kapazitiven Touch-Pins des XIAO ESP32-S3 zur Erkennung von Berührungen nutzt. Wenn du den ersten Pin (D0) der Platine berührst, schaltet sich die eingebaute LED ein. Möglicherweise musst du den Erkennungsschwellenwert anpassen.
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 für Lautstärkeregelung
Der ESP32-S3 unterstützt USB HID (Human Interface Device), was bedeutet, dass du Computergeräte wie Tastatur oder Lautstärke mit dem verbundenen ESP32 steuern kannst. In den folgenden Beispielen verwenden wir die Touch-Eingänge T1 und T2, um die Lautstärke des Computers zu erhöhen oder zu verringern:
#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);
}
Statt der Touch-Eingänge könntest du natürlich auch Taster anschließen. Mit den Touch-Eingängen musst du nur Kabel an den ersten (D0) und zweiten (D1) Pin stecken, um den Lautstärkeregler-Code auszuprobieren.
Siehe die arduino-esp32 Bibliothek für weitere HID-Beispiele. Vorsicht bei der Verwendung des ESP32 als HID, da du leicht deine Maus deaktivieren oder den Computer mit Tastatureingaben überfluten kannst – was ihn unbenutzbar macht, solange der ESP32 verbunden ist.
Beachte auch, dass die Platine während laufendem HID nicht geflasht werden kann. Sie verschwindet als USB-Gerät in der Arduino IDE. Um die Platine wieder in den Flash-Modus zu versetzen, musst du:
- Die BOOT (B) Taste gedrückt halten
- Während du BOOT (B) hältst, drücke und lasse RESET (R) los
- Lasse die BOOT (B) Taste los
Da die BOOT (B) und RESET (R) Tasten am ESP32-S3 sehr klein sind, kann das ziemlich knifflig sein.
Wi-Fi
Das folgende Beispiel zeigt, wie du den XIAO ESP32 mit einem Wi-Fi-Netzwerk verbindest. Das funktioniert auch ohne externe Antenne, wenn du nahe am Wi-Fi-Router bist. Für bessere Reichweite solltest du jedoch die Antenne installieren.
#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() {
}
Webserver
Du kannst das Wi-Fi-Beispiel erweitern und einfach einen Webserver bauen. Der folgende Code erstellt einen Webserver, gibt die IP-Adresse aus, unter der der Webserver erreichbar ist, und zeigt auf der Root-Seite den Text „Hello from XIAO ESP32-S3!“ an:
#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();
}
Lade den Code auf deinen ESP32-S3, öffne den Serial Monitor und kopiere die dort angezeigte IP-Adresse (z.B. „192.168.1.160“) in die Adresszeile deines Browsers. Du solltest die Nachricht sehen:
Webscanner
Wenn du dein lokales Wi-Fi-Netzwerk scannen möchtest, um verfügbare Netzwerke zu erkennen, hier ein Code-Beispiel:
#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);
}
Du kannst ohne angeschlossene Wi-Fi-Antenne starten und findest nur die stärksten Netzwerke. Mit Antenne entdeckst du wahrscheinlich mehr Netzwerke. Ohne Antenne erhalte ich z.B. ein schwaches Signal (-77 dB) und nur ein Netzwerk:
scan start scan done 1 networks found 1: maetasus (-77)*
Sobald ich die Antenne anschließe, werden mehr Netzwerke erkannt und die Signalstärke meines lokalen Netzwerks (maetasus) steigt von -77 dB auf -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
Dieses Beispiel zeigt, wie man einen einfachen Bluetooth Low Energy (BLE) Server erstellt.
#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() {
}
Du kannst prüfen, ob der Server aktiv ist, indem du einen BLE-Scanner auf deinem Handy verwendest. Übliche Apps sind nRF Connect oder LightBlue. Wenn du einen Scan startest, erscheint „XIAO-ESP32-S3“.
Druck- und Temperatursensor (BME280) via I2C
Dieses Code-Beispiel zeigt, wie du einen Sensor über I2C an den XIAO ESP32-S3 anschließt. Wir verwenden den BME280. Weitere Informationen zu diesem Sensor findest du im How To Use BME280 Pressure Sensor With Arduino und im Weather Station on e-Paper Display Tutorial.
Die I2C-Schnittstelle des XIAO ESP32-S3 befindet sich an den Pins 5 (SDA) und 6 (SCL). Das folgende Schaltbild zeigt, wie du den BME280 mit dem XIAO ESP32-S3 verbindest.
Der folgende Code liest Druck-, Temperatur-, Feuchtigkeits- und Höhendaten vom BME280-Sensor und gibt die Messwerte im Serial Monitor aus:
#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);
}
Wenn alles korrekt verdrahtet ist, solltest du ähnliche Daten wie unten sehen:
Temperature in degC = 22.93 Pressure in hPa = 1000.40 Altitude in m = 107.53 Humidity in %RH = 34.61
OLED via I2C
Im Code-Beispiel verwenden wir erneut die I2C-Schnittstelle, schließen aber ein OLED-Display an den XIAO ESP32-S3 an. Wie zuvor nutzen wir die Pins 5 (SDA) und 6 (SCL) für I2C. Das Bild unten zeigt die nötige Verbindung zum OLED:
Hier ist der Code. Er schreibt einfach den Text „make“ auf das Display. Beachte, dass du zuerst die Adafruit_SSD1306 library Bibliothek installieren musst.
#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);
}
E-Paper Display über SPI
Im nächsten Beispiel steuern wir ein E-Paper Display über die SPI-Schnittstelle des XIAO ESP32-S3. Die Hardware-SPI-Pins sind 8 (MISO), 9 (MOSI), 44 (CS/SS) und 7 (SCK). Die anderen Pins sind frei wählbar.
Das folgende Schaltbild zeigt, wie du ein 4.2″ e-Paper Display an die SPI-Pins anschließt:
Zur Übersicht hier eine Tabelle mit allen Verbindungen. Beachte, dass du das Display mit 3,3 V oder 5 V versorgen kannst, die SPI-Datenleitungen aber 3,3 V benötigen! Zur Sicherheit solltest du 3,3 V als Versorgungsspannung verwenden.
| E-Paper Display | XIAO ESP32-S3 |
|---|---|
| CS/SS | GPIO44 |
| CLK/SCL/SCK | GPIO7 |
| SDA/DIN/MOSI | GPIO9 |
| BUSY | GPIO1 |
| RES/RST | GPIO2 |
| DC | GPIO3 |
| VCC | 3,3 V |
| GND | G |
Bevor du auf dem E-Paper Display zeichnen kannst, musst du die GxEPD2 Bibliothek installieren, die den Grafiktreiber für das E-Paper Display bereitstellt. Das folgende Code-Beispiel nutzt die Bibliothek, um den Text „Makerguides“ auf dem Display anzuzeigen:
#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() {}
Wenn du etwas Interessanteres umsetzen möchtest, schau dir das Monthly Calendar on E-Paper Display oder das Analog Clock on e-Paper Display Tutorial an.
Deep Sleep
Der folgende Code zeigt, wie du den Deep-Sleep-Modus mit dem ESP32-S3 nutzt. Alle 10 Sekunden versetzt er den ESP32-S3 für 5 Sekunden in den Deep-Sleep und weckt ihn dann wieder auf:
#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() {}
Achte darauf, die Deep-Sleep-Dauer nicht zu lang zu wählen. Während Deep-Sleep trennt die Platine die USB-Verbindung, und du kannst keine neue Software flashen. Um die Platine wieder in den Flash-Modus zu versetzen, musst du:
- Die BOOT (B) Taste gedrückt halten
- Während du BOOT hältst, drücke und lasse RESET (R) los
- Lasse die BOOT Taste los
OTA (Over The Air) Update
Im letzten Code-Beispiel zeige ich dir, wie du ein Over The Air (OTA) Update des Codes auf dem XIAO ESP32-S3 durchführst. Der Vorteil ist, dass du deinen ESP32 nicht zum Flashen anstecken musst.
#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);
}
Der ESP32 erscheint unter Tools -> Ports -> Network Ports mit dem Hostnamen „my-xiao-esp32-s3“. Wenn du auf diesen Host flashst, fragt die Arduino IDE nach einem Passwort („1234“) und überträgt dann den neuen Code per Wi-Fi. Natürlich solltest du ein besseres Passwort als „1234“ wählen ; )
Im Code-Beispiel ist der Hauptcode das einfache Blink-Programm. Ändere die Verzögerung, flashe den neuen Code und prüfe, ob sich die Blinkfrequenz geändert hat, um das OTA-Update zu testen.
Fazit
Dieser Beitrag zeigte dir, wie du mit dem Seeed Studio XIAO ESP32-S3 startest. Seeed Studio bietet weitere Informationen in seinem Wiki.
Beachte, dass es eine XIAO ESP32-S3-Plus Version mit mehr Flash (16 MB) und GPIO-Pins gibt. Außerdem gibt es das XIAO-ESP32-S3-Sense, das mit Kamera und Mikrofon ausgestattet ist. Wenn du Audio aufnehmen oder Video streamen möchtest, wähle das XIAO-ESP32-S3-Sense. Brauchst du mehr Speicher oder IO, nimm das XIAO ESP32-S3-Plus.
Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.
Viel Spaß beim Tüfteln 😉
