# XIAO ESP32S3 mit MicroPython und Thonny

Diese Anleitung erklärt die ersten Schritte mit einem **Seeed Studio XIAO ESP32S3**. Sie richtet sich an Schülerinnen und Schüler der 10. Klasse, die zum ersten Mal mit einem Mikrocontroller arbeiten.

Ziele:

- MicroPython mit Thonny auf das Board flashen
- testen, ob Board und Verbindung funktionieren
- eine externe rote LED anschließen und blinken lassen
- ein Programm so speichern, dass es nach dem Einschalten automatisch startet

> **Wichtig:** Der XIAO ESP32S3 arbeitet mit **3,3 V**. Niemals 5 V direkt an einen GPIO-Pin anschließen.

---

## 1. Benötigte Materialien

- Seeed Studio XIAO ESP32S3
- USB-C-**Daten**kabel (ein reines Ladekabel genügt nicht)
- PC mit Windows und Thonny
- Breadboard und Jumperkabel
- rote Low-Current-LED
- Widerstand: **1 kΩ** (1000 Ω, Farbringe braun–schwarz–rot–gold)

---

## 2. MicroPython mit Thonny flashen

Beim Flashen wird die MicroPython-Firmware auf den internen Flash-Speicher des Mikrocontrollers geschrieben. Erst danach kann der XIAO Python-Programme ausführen.

In dieser Anleitung lädt Thonny das **generische ESP32-S3-MicroPython-Image** selbst herunter. Wir wählen also nicht manuell eine heruntergeladene `.bin`-Datei aus.

### 2.1 Board anschließen

1. Den XIAO mit dem USB-C-Datenkabel direkt am PC anschließen.
2. Falls Windows einen COM-Port anlegt, diesen später merken, zum Beispiel `COM5`.
3. Wenn kein Port erscheint: zuerst ein anderes USB-C-Kabel ausprobieren. Viele USB-C-Kabel übertragen nur Strom.

### 2.2 Flash-Modus starten

Damit eine neue Firmware geschrieben werden kann, muss der XIAO im **Bootloader- oder Flash-Modus** sein.

Die beiden sehr kleinen Taster liegen direkt beim USB-C-Anschluss:

- **B / BOOT:** hält den Mikrocontroller beim Start im Flash-Modus
- **R / RST:** startet den Mikrocontroller neu

#### Standardmethode: BOOT und RST

Das Board ist bereits per USB angeschlossen.

1. Taste **BOOT** gedrückt halten.
2. Während BOOT weiterhin gedrückt ist: Taste **RST** kurz drücken und wieder loslassen.
3. Jetzt die Taste **BOOT** loslassen.
4. Der XIAO befindet sich jetzt im Flash-Modus.

Kurzform:

```text
BOOT gedrückt halten → RST kurz drücken → RST loslassen → BOOT loslassen
```

#### Alternative: Beim Einstecken

Diese Methode hilft besonders dann, wenn kein COM-Port erkannt wird.

1. USB-C-Kabel vom XIAO abziehen.
2. Taste **BOOT** gedrückt halten.
3. BOOT weiter gedrückt halten und das USB-C-Kabel wieder einstecken.
4. Erst danach BOOT loslassen.

> Beim Flashen muss BOOT **nicht** die ganze Zeit gedrückt bleiben. Nach der oben beschriebenen Tastenkombination kann die Taste losgelassen werden.

### 2.3 Thonny einstellen und flashen

1. Thonny starten.
2. Im Menü **Ausführen → Interpreter konfigurieren…** öffnen. Alternativ kann unten rechts auf die aktuelle Python-/Interpreter-Anzeige geklickt werden.
3. Bei **Interpreter** auswählen: `MicroPython (ESP32)`.
4. Den passenden seriellen Anschluss auswählen, zum Beispiel `COM5`.
5. Auf **MicroPython installieren oder aktualisieren (esptool)** klicken.
6. Im Installationsfenster einstellen:

| Einstellung | Auswahl |
|---|---|
| Ziel-Port | Der COM-Port des XIAO, zum Beispiel `COM5` |
| MicroPython-Familie | `ESP32-S3` |
| Variante | `Espressif ESP32-S3` bzw. `ESP32_GENERIC_S3` |
| Version | Neueste **stabile** Version |
| Flash vorher löschen | Aktivieren, wenn die Option angeboten wird |

7. Auf **Installieren** klicken und warten, bis Thonny Erfolg meldet.
8. Nach dem Flashen die Taste **RST** einmal kurz drücken. Jetzt startet der XIAO normal mit MicroPython.
9. In Thonny erneut prüfen: Interpreter `MicroPython (ESP32)` und derselbe COM-Port.

> Falls das Flashen nicht startet: Noch einmal in den Flash-Modus wechseln: **BOOT halten → RST kurz drücken → beide loslassen**. Danach die Installation erneut beginnen.

---

## 3. Erster Funktionstest

Dieser Test prüft drei Dinge:

1. MicroPython wurde gestartet.
2. Thonny kann über USB mit dem XIAO sprechen.
3. Die gelbe LED auf dem Board kann geschaltet werden.

Die eingebaute gelbe LED des XIAO ESP32S3 liegt an **GPIO21**.

### Quellcode: Onboard-LED testen

In Thonny eine neue Datei anlegen, den folgenden Code einfügen und mit dem grünen Start-Knopf ausführen:

```python
from machine import Pin
import time
import sys

print("MicroPython läuft auf dem XIAO ESP32S3.")
print("MicroPython-Version:", sys.implementation.version)

# Gelbe LED auf dem XIAO ESP32S3
led = Pin(21, Pin.OUT)

for nummer in range(1, 7):
    led.value(not led.value())
    print("Blink", nummer)
    time.sleep(0.5)

led.off()
print("Test erfolgreich.")
```

### Erwartetes Ergebnis

- In der Thonny-Shell erscheinen Textzeilen wie `Blink 1`, `Blink 2` und am Ende `Test erfolgreich.`
- Die gelbe LED auf dem XIAO blinkt sechsmal.

Wenn die Textausgabe erscheint, ist die MicroPython-Verbindung grundsätzlich erfolgreich – auch wenn die LED ausnahmsweise nicht sichtbar blinkt.

---

## 4. Programme auf dem XIAO speichern

Ein Programm kann auf zwei verschiedene Arten ausgeführt werden:

| Art | Was passiert? | Wann geeignet? |
|---|---|---|
| **Nur ausführen** | Thonny sendet den Code zum Testen an den XIAO. Nach Reset oder Ausschalten ist der Code nicht automatisch aktiv. | Beim Ausprobieren und Fehlersuchen |
| **Auf MicroPython device speichern** | Die Datei wird im Flash-Dateisystem des XIAO gespeichert. | Wenn das Programm später ohne PC verfügbar sein soll |

### So speicherst du eine Datei auf dem Board

1. In Thonny **Datei → Speichern unter…** wählen.
2. Im Dateidialog **MicroPython device** auswählen, nicht `Dieser Computer`.
3. Einen Dateinamen vergeben, zum Beispiel `led_test.py`.
4. Speichern.

Im Dateibrowser von Thonny sollte die Datei anschließend im Bereich **MicroPython device** erscheinen.

### Automatischer Programmstart: `main.py`

Soll dein Programm nach einem Reset oder nach dem Einschalten automatisch starten, muss es auf dem Board **genau** so heißen:

```text
main.py
```

MicroPython startet zuerst – falls vorhanden – `boot.py` und danach `main.py`.

- `boot.py` ist für grundlegende Einstellungen gedacht, zum Beispiel Netzwerk- oder Dateisystem-Konfiguration.
- `main.py` ist das normale Hauptprogramm eines Projekts.

### Wichtige Vorsichtsregeln

- Teste ein neues Programm zuerst mit **Ausführen**, bevor du es als `main.py` speicherst.
- Eine Endlosschleife mit `while True:` ist normal, kann aber die Arbeit in Thonny erschweren.
- Wenn ein gespeichertes `main.py` stört: In Thonny den **Stop**-Knopf drücken, dann die Datei im Bereich **MicroPython device** öffnen, umbenennen oder löschen.
- Bei schwierigen Fällen beim Anstecken die Taste **BOOT** gedrückt halten. So kann der Start des normalen Programms umgangen und die Firmware bei Bedarf neu geflasht werden.
- Änderungen werden nicht automatisch auf dem Board gespeichert. Nach jeder Änderung wieder **Speichern** wählen und als Ziel `MicroPython device` kontrollieren.

---

## 5. Pinbelegung des XIAO ESP32S3

Auf dem Board stehen Beschriftungen wie `D0`, `D1` oder `D10`. Im MicroPython-Code braucht man jedoch normalerweise die **GPIO-Nummer**.

Beispiel:

- Aufdruck auf dem Board: `D1`
- zugehöriger Mikrocontroller-Pin: `GPIO2`
- im Code: `Pin(2, Pin.OUT)`

### Pin-Tabelle

| Beschriftung auf dem XIAO | GPIO im ESP32-S3 | Typische Funktion | Für eine LED geeignet? |
|---|---:|---|---|
| `D0` / `A0` | GPIO1 | GPIO, ADC, Touch | Ja |
| `D1` / `A1` | GPIO2 | GPIO, ADC, Touch | **Ja – Empfehlung** |
| `D2` / `A2` | GPIO3 | GPIO, ADC, Touch | Möglich, für den ersten Versuch lieber vermeiden |
| `D3` / `A3` | GPIO4 | GPIO, ADC, Touch | Ja |
| `D4` / `A4` | GPIO5 | GPIO, ADC, I²C-SDA | Ja, wenn kein I²C benutzt wird |
| `D5` / `A5` | GPIO6 | GPIO, ADC, I²C-SCL | Ja, wenn kein I²C benutzt wird |
| `D6` | GPIO43 | GPIO, UART-TX | Möglich, besser für UART freihalten |
| `D7` | GPIO44 | GPIO, UART-RX | Möglich, besser für UART freihalten |
| `D8` | GPIO7 | GPIO, ADC, SPI-SCK | Ja, wenn kein SPI benutzt wird |
| `D9` | GPIO8 | GPIO, ADC, SPI-MISO | Ja, wenn kein SPI benutzt wird |
| `D10` | GPIO9 | GPIO, ADC, SPI-MOSI | Ja, wenn kein SPI benutzt wird |
| `3V3` | — | geregelte 3,3-V-Versorgung | Nicht als GPIO verwenden |
| `GND` | — | Masse / Rückleitung | Für die Schaltung erforderlich |
| `VIN` / `5V` | — | Versorgungseingang | Nicht mit GPIO verwechseln |

> **Einfacher Merksatz:** Für den ersten LED-Versuch nimm `D1`. Im MicroPython-Code ist das `GPIO2` und damit `Pin(2, ...)`.

### Abbildung und vollständige Übersicht

Die offizielle, vollständige Pin-Multiplexing-Übersicht von Seeed Studio enthält eine Abbildung sowie weitere Spezialfunktionen der Pins:

<https://wiki.seeedstudio.com/xiao_esp32s3_pin_multiplexing/>

Zusätzliche Übersicht des Boards mit Pinout:

<https://wiki.seeedstudio.com/xiao_esp32s3_getting_started/>

---

## 6. Externe rote LED anschließen

### Geeigneter Pin

Wir verwenden:

- `D1` auf dem Board
- das ist `GPIO2` im ESP32-S3
- im MicroPython-Code: `Pin(2, Pin.OUT)`

### LED richtig herum anschließen

Eine LED hat eine feste Richtung:

- **Anode (+):** meistens das längere Bein. Sie kommt über den Widerstand an den GPIO-Pin.
- **Kathode (−):** meistens das kürzere Bein. Die abgeflachte Seite am LED-Gehäuse markiert ebenfalls die Kathode. Sie kommt an `GND`.

### Schaltbild als Mermaid

```mermaid
flowchart LR
    D1["XIAO: D1 / GPIO2"] --> R["Vorwiderstand: 1 kΩ"]
    R --> A["LED-Anode +\nlanges Bein"]
    A --> LED["Rote LED"]
    LED --> K["LED-Kathode −\nkurzes Bein / flache Seite"]
    K --> GND["XIAO: GND"]
```

Vereinfacht als Text:

```text
XIAO D1 / GPIO2 ── Widerstand 1 kΩ ── Anode (+) LED Kathode (−) ── XIAO GND
```

Die Reihenfolge von Widerstand und LED darf auch vertauscht werden. Entscheidend ist: **Widerstand und LED liegen in Reihe**, und die LED ist richtig gepolt.

> Niemals eine LED ohne Widerstand direkt an einen GPIO-Pin anschließen. Zu hoher Strom kann LED oder Mikrocontroller beschädigen.

---

## 7. Schutzwiderstand berechnen

Der Widerstand begrenzt den Strom durch die LED. Für eine rote LED nehmen wir näherungsweise an:

- Ausgangsspannung des XIAO: \(U_{GPIO} = 3{,}3\,\text{V}\)
- Durchlassspannung einer roten LED: \(U_F \approx 2{,}0\,\text{V}\)
- gewünschter LED-Strom für eine Low-Current-LED: \(I_{LED} \approx 1\,\text{mA} = 0{,}001\,\text{A}\)

Formel nach dem Ohmschen Gesetz:

\[
R = \frac{U_{GPIO} - U_F}{I_{LED}}
\]

Einsetzen:

\[
R = \frac{3{,}3\,\text{V} - 2{,}0\,\text{V}}{0{,}001\,\text{A}}
= \frac{1{,}3\,\text{V}}{0{,}001\,\text{A}}
= 1300\,\Omega
\]

Das rechnerische Ergebnis ist also ungefähr \(1{,}3\,\text{k}\Omega\). In der Praxis sind Widerstände mit festen Normwerten verfügbar. Gute Werte sind:

| Widerstand | ungefährer Strom | Beurteilung |
|---:|---:|---|
| 1,5 kΩ | 0,9 mA | Sehr sparsam, bei Low-Current-LED meist gut sichtbar |
| **1 kΩ** | 1,3 mA | **Empfohlener Standardwert für diesen Versuch** |
| 680 Ω | 1,9 mA | Heller, weiterhin gut geeignet |
| 220 Ω | ca. 6 mA | Nicht nötig für eine Low-Current-LED |

Für den ersten Versuch verwenden wir **1 kΩ**. Das ist sicher, einfach und die rote LED ist in normalem Raumlicht meist gut zu sehen.

---

## 8. MicroPython-Programm für die externe LED

Dieses Programm ist absichtlich ähnlich aufgebaut wie der erste Test mit der eingebauten LED. Es blinkt die externe rote LED sechs Mal.

```python
from machine import Pin
import time

print("Test der externen LED an D1 / GPIO2")

# D1 auf dem XIAO entspricht GPIO2 im ESP32-S3
led = Pin(2, Pin.OUT)

for nummer in range(1, 7):
    led.on()
    print("LED an: ", nummer)
    time.sleep(0.5)

    led.off()
    print("LED aus:", nummer)
    time.sleep(0.5)

print("LED-Test beendet.")
```

### Ablauf

1. Verdrahtung noch einmal kontrollieren: `D1 → 1 kΩ → LED-Anode`, LED-Kathode → `GND`.
2. Code in Thonny einfügen.
3. Grünen **Start**-Knopf drücken.
4. Die LED sollte sechs Mal blinken.
5. Wenn sie nicht leuchtet:
   - LED umdrehen (Polung prüfen).
   - Prüfen, ob wirklich `D1 / GPIO2` benutzt wurde.
   - Prüfen, ob der Widerstand in Reihe geschaltet ist.
   - Prüfen, ob das Kabel von der LED-Kathode wirklich zu `GND` führt.

### Programm automatisch beim Einschalten starten

Wenn die LED nach jedem Einschalten automatisch blinken soll:

1. Das Programm zuerst erfolgreich testen.
2. **Datei → Speichern unter…** wählen.
3. Ziel: **MicroPython device**.
4. Als Dateiname exakt `main.py` eingeben.
5. Reset-Taste `RST` kurz drücken oder USB kurz trennen und wieder verbinden.

---

## 9. Quellen und weiterführende Links

- Offizielle MicroPython-Einführung für ESP32: <https://docs.micropython.org/en/latest/esp32/tutorial/intro.html>
- Offizielle MicroPython-Dokumentation zu `boot.py` und `main.py`: <https://docs.micropython.org/en/latest/reference/reset_boot.html>
- Offizielle Seeed-Pinübersicht für XIAO ESP32S3: <https://wiki.seeedstudio.com/xiao_esp32s3_pin_multiplexing/>
- Seeed-Startseite zum XIAO ESP32S3: <https://wiki.seeedstudio.com/xiao_esp32s3_getting_started/>