Erste Schritte mit XIAO-ESP32-S3-Sense

Das Seeed Studio XIAO-ESP32-S3 Senseist ein kompaktes Microcontroller-Entwicklungsboard, das für Edge-AI- und IoT-Anwendungen konzipiert wurde. Es basiert auf dem ESP32-S3Chip und vereint Dual-Core-Leistung, Wi-Fi- und Bluetooth-5-Konnektivität sowie integrierte AI-Beschleunigung mit einer Vielzahl von Peripheriegeräten – alles in einem winzigen 21×17,5 mm Formfaktor.

Was das XIAO-ESP32-S3 Sensebesonders macht, ist die integrierte 2MP-Kamera (OV2640)und das digitale Mikrofon (MP34DT06JTR), die Computer Vision und Audioverarbeitung direkt ab Werk ermöglichen. Außerdem verfügt es über 8 MB PSRAM, 8 MB Flash und einen SD-Kartensteckplatz für externe 32 GB, was es ideal für leichte AI-Workloads mit Frameworks wie TensorFlow Lite Micro oder Edge Impulse macht.

Dieses kurze Tutorial führt dich durch die Grundlagen der Einrichtung des Boards, das Flashen deines ersten Programms und den Zugriff auf Kamera und Mikrofon, um mit deinen eigenen AI-basierten Projekten zu starten. Für weitere Informationen siehe auch das umfangreiche Getting Started Wiki by Seeed Studio.

Benötigte Teile

Natürlich benötigst du ein XIAO ESP32 S3 Sense Board von Seeed Studio, um die Codebeispiele auszuprobieren. Beachte, dass das Board sehr heiß werden kann, z. B. beim Streamen von Video mit hoher Bildrate. Ich empfehle, einen kleinen Heatsink am Rückseite des Boards anzubringen (siehe unten aufgeführtes Teil).

Wenn du das Codebeispiel zum Aufnehmen von Audio verwenden möchtest, benötigst du außerdem eine SD-Karte. Ich habe eine 32-GB-Karte aufgeführt, aber eine kleinere (8 GB) reicht zum Ausprobieren ebenfalls aus.

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.

Eigenschaften des XIAO-ESP32-S3-Sense Boards

Das XIAO-ESP32-S3 Senseist Teil der ultrakompakten XIAO-Serie von Seeed Studio. Es basiert auf dem ESP32-S3R8, einem SoC von Espressif Systems, der speziell für AI- und Edge-Computing-Aufgaben entwickelt wurde. Es vereint die Leistung des ESP32-S3SoC mit integrierten Peripheriegeräten in einem kompakten Formfaktor und ergänzt es um integrierte Vision- und Audiosensoren.

Das XIAO-ESP32-S3 Sense besteht aus vier Teilen: dem Mainboard, dem Sense Hat, der Kamera und der Wi-Fi-Antenne:

Das Sense Hat kann auf das Mainboard gesteckt werden und verfügt über einen SD-Kartensteckplatz, eine Buchse für die Kamera und ein Mikrofon. Zusammengebaut ergibt sich eine sehr kompakte Einheit mit den Abmessungen eines 20-mm-Würfels. Das Bild unten zeigt das zusammengebaute XIAO-ESP32-S3-Sense Board ohne Wi-Fi-Antenne:

Die Stromversorgung des Boards kann über den 5V Type-C USB-Anschluss oder über die Batterie-Ladeschnittstelle erfolgen, die an eine 3,7V LiPo-Batterie angeschlossen werden kann. Der Stromverbrauch des Boards reicht von 64 μA im Deep-Sleep-Modus ohne Peripherie bis zu 340 mA beim Fotografieren.

Die Wi-Fi-Reichweite des Boards ohne externe Wi-Fi-Antenne ist relativ kurz, mit Antenne kann sie bis zu 100 m betragen. Der Nachteil der Antenne ist natürlich, dass sie Platz beansprucht.

Mainboard

Das Mainboard verfügt über einen kleinen Reset- und einen kleinen Button-Taster. Neben den Tastern befinden sich kleine LEDs für Laden/Stromversorgung und eine orangefarbene, benutzersteuerbare LED an GPIO21. Neben den GPIO-Pins hat das Mainboard auch Anschlüsse für die externe Wi-Fi-Antenne und das Sense Hat.

Die folgende Liste zeigt die technischen Merkmale des Mainboards:

• Microcontroller: Espressif ESP32-S3R8 SoC
  • CPU: Dual-Core Xtensa® LX7, bis zu 240 MHz
  • Befehlssatz: 32-Bit, mit Vektor-Erweiterungen für Machine Learning und DSP-Workloads
  • AI-Beschleunigung: Enthält Vektor-Instruktionenfür leichte neuronale Netzwerkverarbeitung
  • ROM: 384 KB
  • SRAM: 512 KB
  • Externer RAM: 8 MB PSRAM
  • Flash: 8 MB QSPI NOR Flash

• Wi-Fi: IEEE 802.11 b/g/n (nur 2,4 GHz)
• Bluetooth® LE 5.0: Unterstützt BLE Mesh und Langstreckenmodus
• Antenne Optionen:
  • Onboard PCB-Antenne
  • U.FL-Anschlussfür externe Antenne (bessere Reichweite und Signalabstimmung)

• GPIOs: 11 multifunktionale GPIO-Pins (alle unterstützen PWM, digitale I/O und einige analoge Funktionen)
• ADC: 6 Kanäle 12-Bit ADC
• I2C: 1 × I2C-Schnittstelle
• SPI: 1 × SPI-Schnittstelle
• UART: 1 × UART-Schnittstelle
• I2S: für Audioanwendungen
• USB:
  • Native USB 1.1 mit Full-SpeedUnterstützung (12 Mbps)
  • Unterstützt USB-OTG (Host/Device-Modus)
  • Onboard USB Type-C Anschluss für Stromversorgung, Programmierung und serielle Kommunikation

Sense Hat

Wie bereits erwähnt, trägt das Sense Hat auf dem Mainboard die Kamera, das Mikrofon und einen Micro-SD-Kartensteckplatz:

• Kameramodul:
  • Modell: OV2640
  • Auflösung: Bis zu 1600 × 1200 (UXGA)
  • Schnittstelle: 24-poliger Anschluss (8-Bit paralleles DVP + I2C)
  • Sichtfeld (FOV): ~60–65°
  • Bildrate: Bis zu 30 FPS bei niedrigeren Auflösungen
• Digitales Mikrofon:
  • Modell: MP34DT06JTR (MEMS digitales Mikrofon)
  • Schnittstelle: PDM (Pulsdichtemodulation)
  • Empfindlichkeit: −26 dBFS
  • Signal-Rausch-Verhältnis: 61 dB(A)
• SD-Kartensteckplatz
  • bis zu 32GB FAT

Pinbelegung des XIAO-ESP32-S3-Sense Boards

Das folgende Bild zeigt die Pinbelegung des XIAO-ESP32-S3-Sense Boards:

Der 5V-Pin ist die 5V-Versorgung vom USB-Port. Der 3V3-Pin liefert die Ausgangsspannung des onboard-Reglers und kann bis zu 700 mA liefern. GND ist Masse.

Was die GPIOs betrifft: Das Board bietet 11 digitale/analoge GPIOs, aber GPIO0, GPIO3, GPIO43und GPIO44sind Strapping-Pins, die beim Start in einem bestimmten Zustand sein müssen. Sobald der Mikrocontroller läuft, funktionieren die Strapping-Pins als normale IO-Pins, aber du solltest sie wenn möglich meiden. Für mehr Details siehe Getting Started Wiki by Seeed Studio.

Das Sense Hat bietet zwei weitere GPIO-Pins (GPIO41, GPIO42), die als GPIOs verfügbar sind, wenn das Mikrofon nicht verwendet wird.

Schaltpläne

Für detailliertere Informationen wirf auch einen Blick auf die Schaltpläne des XIAO-ESP32-S3-Sense Boards, die du unter folgendem Link findest.

ESP32 Core installieren

Wenn du das Board mit der Arduino IDE programmieren möchtest (wie wir es tun), musst du zuerst den ESP32 Core installieren, um die Unterstützung für ESP32 Boards in der Arduino IDE zu aktivieren. Öffne deine Arduino IDE und folge den unten beschriebenen Schritten. Bei Problemen findest du ausführlichere Anleitungen in unserem Tutorial How to Program ESP32 with Arduino IDE.

Zusätzliche URLs für den Boards Manager

Öffne zuerst den Preferences-Dialog, indem du im „File“-Menü „Preferences…“ auswählst:

Es öffnet sich der unten gezeigte Preferences-Dialog. Unter dem Tab „Settings“ findest du unten im Dialog ein Eingabefeld mit der Bezeichnung „Zusätzliche URLs für den Boards Manager„:

In dieses Eingabefeld kopiere die folgende URL: „https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json„

Damit 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 Board-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 Boards sehen: die „Arduino ESP32 Boards“ und die „esp32 von Espressif“ Boards. Wir wollen die esp32 Bibliotheken von Espressif. Klicke auf den INSTALL Button 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.0.0-a) abweichen kann.

Im nächsten Schritt zeige ich dir, wie du das ESP32 Board für das XIAO-ESP32-S3-Sense auswählst.

XIAO_ESP32S3 Board auswählen

Du kannst ein Board aus dem Dropdown-Menü unter der Menüleiste auswählen: Im Beispiel unten ist z. B. ein Arduino Uno als Board ausgewählt:

Ein Klick auf den Namen des aktuell ausgewählten Boards (Arduino Uno) öffnet den Board-Auswahldialog. Gib im Suchfeld „xiao s3“ ein und wähle „XIAO_ESP32S3“ wie unten gezeigt aus:

Wenn das Board per USB mit deinem PC verbunden ist, solltest du auch den COM-Port auswählen können. Im Screenshot oben ist es COM9, bei dir kann es ein anderer COM-Port sein.

Codebeispiele

In diesem Abschnitt gebe ich dir einige Codebeispiele, wie du das Mikrofon und die Kamera des Boards nutzen kannst. Wir starten jedoch mit dem üblichen Blink-Beispiel, um die Installation des Boards und die USB-Kommunikation zu testen.

Blink Onboard-LED

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 Senseist an GPIO21 angeschlossen, aber invertiert. LOW bedeutet LED an, HIGH bedeutet LED aus. Das siehst du im folgenden Codebeispiel:

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 sehr kurzen Beispielen lesen und schreiben wir GPIO. Zum Angeben von Pins im Code kannst du die GPIO xNummer oder die DxNummer verwenden. Zum Beispiel identifizieren gemäß Pinbelegung D3 oder GPIO4 denselben Pin, und im Code kannst du entweder verwenden. Die folgenden zwei Codebeispiele sind funktional identisch und setzen GPIO4 auf HIGH:

digitalWrite(D3, HIGH);  // D3 == GPIO4

digitalWrite(4, HIGH);  // D3 == GPIO4

Wenn du analoge Signalelesen 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 reichen von 0 bis 4095, was einer Eingangsspannung zwischen 0 und 3,3 V entspricht.

Mikrofonsignal lesen

Das nächste Beispiel nutzt das eingebaute Mikrofon, um Audiodaten über I2S zu erfassen und zeigt die Audiodaten im Serial Monitor und Serial Plotter an:

#include "ESP_I2S.h"

const int8_t I2S_CLK = 42;
const int8_t I2S_DIN = 41;
const uint32_t SAMPLERATE = 16000;

I2SClass I2S;

void setup() {
  Serial.begin(115200);

  I2S.setPinsPdmRx(I2S_CLK, I2S_DIN);
  if (!I2S.begin(I2S_MODE_PDM_RX, SAMPLERATE, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO)) {
    Serial.println("Can't find microphone!");
    while (1)
      ;
  }
}

void loop() {
  int sample = I2S.read();
  if (sample > 1) {
    Serial.println(sample);
  }
}

Wenn du den Code ausführst, den Serial Plotter öffnest und mit konstanter Frequenz pfeifst, siehst du eine schöne Sinuswelle im Serial Plotter:

Wenn du die Frequenz durch höheres oder tieferes Pfeifen variierst, ändert sich die Frequenz der angezeigten Sinuswelle entsprechend. Ziemlich cool ; )

Audio aufnehmen

Das folgende Beispiel zeigt, wie du 20 Sekunden Audio aufnimmst und die Daten als WAV-Audiodatei auf der SD-Karte speicherst. Du benötigst eine formatierte SD-Karte.

Sobald du den Serial Monitor öffnest, gibt der Code „20 SEC RECORDING STARTED …“ aus und startet die Aufnahme. Nach 20 Sekunden wird die Audiodatei geschrieben und „COMPLETE.“ ausgegeben. Du kannst dann die SD-Karte entfernen und die Aufnahme auf deinem Computer anhören.

#include "ESP_I2S.h"
#include "FS.h"
#include "SD.h"

void setup() {
  I2SClass i2s;
  uint8_t *wav_buffer;
  size_t wav_size;

  Serial.begin(115200);
  while (!Serial) {
    delay(10);
  }

  i2s.setPinsPdmRx(42, 41);
  if (!i2s.begin(I2S_MODE_PDM_RX, 16000, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO)) {
    Serial.println("Can't find microphone!");
    while (1); // do nothing
  }

  if(!SD.begin(21)){
    Serial.println("Failed to mount SD Card!");
    while (1) ;
  }

  Serial.println("20 SEC RECORDING STARTED ...");
  wav_buffer = i2s.recordWAV(20, &wav_size);

  File file = SD.open("/audio.wav", FILE_WRITE);
  if (!file) {
    Serial.println("Failed to open file for writing!");
    return;
  }

  if (file.write(wav_buffer, wav_size) != wav_size) {
    Serial.println("Failed to write audio data to file!");
    return;
  }

  file.close();
  Serial.println("COMPLETE.");
}

void loop() {
  delay(1000);
}

Wenn du mehr Informationen zum Aufnehmen von Audio möchtest, schau dir das Record Audio with XIAO-ESP32-S3-Sense Tutorial an.

Video streamen

Als letztes Beispiel streamen wir Videodaten an den Webbrowser deines Computers. Der Code benötigt jedoch die esp32cam Bibliothek, die du über den Library Manager in der Arduino IDE installieren kannst. Suche einfach nach „esp32cam“ und klicke auf INSTALL. Das Bild unten zeigt die abgeschlossene Installation:

Außerdem musst du im Code SSID und PASSWORD durch die tatsächlichen Zugangsdaten deines Wi-Fi-Netzwerks ersetzen.

Als nächstes solltest du unter dem Tools-Menü folgende Parameter für das Board einstellen:

• enable: OPI PSRAM
• set Partition Scheme: Maximum APP

Damit solltest du den Code kompilieren und ausführen können. Er gibt die URL für den Videostream im Serial Monitor aus, z. B. „Stream at: http://192.168.2.40/stream“. Wenn du diese URL in die Adresszeile deines Webbrowsers kopierst, solltest du das Video sehen.

#include "WebServer.h"
#include "WiFi.h"
#include "esp32cam.h"

const char* WIFI_SSID = "SSID";
const char* WIFI_PASS = "PASSWORD";
const char* URL = "/stream";
const auto RESOLUTION = esp32cam::Resolution::find(800, 600);
const int FRAMERATE = 10;

WebServer server(80);

void handleStream() {
  static char head[128];
  WiFiClient client = server.client();

  server.sendContent("HTTP/1.1 200 OK\r\n"
                     "Content-Type: multipart/x-mixed-replace; "
                     "boundary=frame\r\n\r\n");

  while (client.connected()) {
    auto frame = esp32cam::capture();
    if (frame) {
      sprintf(head,
              "--frame\r\n"
              "Content-Type: image/jpeg\r\n"
              "Content-Length: %ul\r\n\r\n",
              frame->size());
      client.write(head, strlen(head));
      frame->writeTo(client);
      client.write("\r\n");
      delay(1000/FRAMERATE);
    }
  }
}

void initCamera() {
  using namespace esp32cam;
  Config cfg;
  cfg.setPins(pins::XiaoSense);
  cfg.setResolution(RESOLUTION);
  cfg.setBufferCount(2);
  cfg.setJpeg(80);
  Camera.begin(cfg);
}

void initWifi() {
  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }
  Serial.printf("Stream at: http://%s%s\n",
                WiFi.localIP().toString().c_str(), URL);
}

void initServer() {
  server.on(URL, handleStream);
  server.begin();
}

void setup() {
  Serial.begin(115200);
  initWifi();
  initCamera();
  initServer();
}

void loop() {
  server.handleClient();
}

Für detailliertere Informationen schau dir das Stream Video with with XIAO-ESP32-S3-Sense Tutorial an.

Und das war’s! Jetzt solltest du genug Informationen haben, um Kamera, Mikrofon und GPIO des XIAO-ESP32-S3 Sense Boards zu nutzen.

Fazit

Dieser Beitrag zeigte dir, wie du schnell mit dem Seeed Studio XIAO-ESP32-S3 Sense startest. Seeed Studio bietet noch viel mehr Informationen in seinem Getting Started Wiki.

Im Vergleich zu anderen ähnlichen Boards wie dem ESP32-CAM oder dem ESP32-WROVER CAM, die ebenfalls Kameras haben, sind die Vorteile des XIAO-ESP32-S3 Sense die deutlich kleinere Größe, das zusätzliche Mikrofon und ein Mikrocontroller mit spezieller Unterstützung für AI-Anwendungen wie Objekterkennung, Gesichtserkennung und mehr.

Du findest verschiedene pretrained modeled auf der Seeed Studio Seite, wo die SenseCraft AI Plattform die einfache Bereitstellung dieser Modelle ermöglicht. Und wenn du an sprachgesteuerten Anwendungen interessiert bist und dein eigenes Modell trainieren möchtest, schau dir unsere Voice control with XIAO-ESP32-S3-Sense and Edge Impulse und Train an Object Detection Model with Edge Impulse for ESP32-CAM Tutorials an.

Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.

Viel Spaß beim Tüfteln 😉