Ratgeber · 14 Min. Lesezeit

Wokwi Simulator Anleitung: ESP32, Arduino und Pico im Browser

Wokwi Simulator für ESP32, Arduino und Pico: Verdrahtung mit diagram.json, WLAN, MicroPython, Logikanalysator, VS-Code-Erweiterung und Vergleich mit Tinkercad.

Der Wokwi Simulator ist ein kostenloser Elektronik-Simulator, mit dem du ESP32-, Arduino- und Raspberry-Pi-Pico-Projekte im Browser ausführst, ohne ein einziges Bauteil zu kaufen. Du schreibst deinen Code, setzt LEDs, Taster, Displays und Sensoren neben das virtuelle Board und drückst den grünen Start-Button: Der Code wird kompiliert, die LED leuchtet, auf dem OLED erscheint Text und der serielle Monitor läuft los. Der größte Unterschied zu Tinkercad ist die Unterstützung für ESP32 und Pico; du kannst den ESP32 sogar über ein virtuelles WLAN ins echte Internet bringen und auf dem Pico MicroPython ausführen.

In dieser Anleitung öffnest du zuerst dein erstes Projekt auf wokwi.com. Dann lernst du, Bauteile mit der Maus und mit der Datei diagram.json zu verbinden, Bibliotheken hinzuzufügen, WLAN und Internetzeit mit dem ESP32 auszuprobieren, MicroPython auf dem Pico laufen zu lassen, ein PWM-Signal mit dem Logikanalysator zu messen und dieselbe Simulation in VS Code zu nutzen. Am Ende siehst du, welche Sensoren unterstützt werden, wo sich die Simulation von einer echten Schaltung unterscheidet und wie du dein Projekt teilst.

ESP32-Entwicklungsboard
Die größte Stärke von Wokwi ist die ESP32-Unterstützung: WLAN, PWM, ADC, I2C und SPI werden wie auf dem echten Board simuliert.

Was ist Wokwi und wie funktioniert es?

Wokwi kompiliert deinen Code in der Cloud mit echten Compilern und übergibt den erzeugten Maschinencode an einen Prozessor-Emulator, der in deinem Browser läuft. In einer Arduino-Uno-Simulation werden also die Befehle des ATmega328P einzeln ausgeführt; für ESP32 und RP2040 gilt dasselbe Prinzip. Deshalb verhalten sich Hardwarefunktionen wie millis(), Interrupts, Timer, PWM, I2C und SPI wie auf dem echten Board, und echte Bibliotheken laufen ohne Änderungen. Wokwi berechnet keine Ströme und Spannungen in deiner Schaltung; es modelliert die digitalen Pegel der Pins und die Werte an den analogen Eingängen. Damit ist es ein starkes Werkzeug, um Embedded-Software auszuprobieren, weniger um Elektronik-Grundlagen zu lernen.

EigenschaftWokwi
Läuft inBrowser (wokwi.com) und VS-Code-Erweiterung
BoardsArduino Uno, Nano, Mega; ESP32, ESP32-S3, ESP32-C3; Raspberry Pi Pico und Pico W
SprachenArduino C++, MicroPython, CircuitPython (Pico), ESP-IDF
BibliothekenDie meisten Bibliotheken aus dem Arduino-Bibliotheksverwalter (libraries.txt)
NetzwerkVirtuelles WLAN für ESP32 und Pico W: Wokwi-GUEST
Messwerkzeug8-Kanal-Logikanalysator; keine elektrischen Messungen
KontoZum Ausprobieren nicht nötig, zum Speichern anmelden
PreisGrundfunktionen kostenlos; Zusatzfunktionen im kostenpflichtigen Tarif

Welche Boards unterstützt Wokwi?

Jedes Bauteil in Wokwi hat einen Typnamen, den du in der Datei diagram.json siehst. Die Tabelle zeigt die Wokwi-Entsprechungen der drei Plattformen, auf die sich dieser Blog konzentriert. In älteren Projekten siehst du für den ESP32 eventuell auch wokwi-esp32-devkit-v1; beide simulieren denselben ESP32-Chip, nur die Pinbelegung des Boards unterscheidet sich.

BoardWokwi-TypnameSprachenHinweis
Arduino Unowokwi-arduino-unoArduino C++ATmega328P, 5-V-Logik, schnellste Simulation
Arduino Nanowokwi-arduino-nanoArduino C++Gleicher Chip wie der Uno, kleineres Board
Arduino Megawokwi-arduino-megaArduino C++8 KB SRAM, Projekte mit vielen Pins
ESP32 DevKitboard-esp32-devkit-c-v4Arduino C++, MicroPython, ESP-IDFWLAN ja, Bluetooth nein
ESP32-S3 / ESP32-C3board-esp32-s3-devkitc-1 / board-esp32-c3-devkitm-1Arduino C++, MicroPython, ESP-IDFNeuere ESP32-Familien
Raspberry Pi Picowokwi-pi-picoMicroPython, CircuitPython, Arduino C++RP2040, 3,3-V-Logik
Raspberry Pi Pico Wboard-pi-pico-wMicroPython, Arduino C++Mit WLAN

Dein erstes Wokwi-Projekt im Browser, Schritt für Schritt

  1. Öffne wokwi.com in deinem Browser. Auf der Startseite gibt es die Bereiche Arduino, ESP32 und Raspberry Pi Pico; wähle einen aus, um fertige Vorlagen und Beispielprojekte zu sehen.
  2. Für einen leeren Start wählst du unter Arduino die Vorlage Arduino Uno. Der Bildschirm teilt sich: links der Code-Editor (sketch.ino), rechts der Diagramm-Bereich, in dem die Schaltung gezeichnet wird.
  3. Klicke auf den blauen +-Button über dem rechten Bereich und tippe LED ins Suchfeld. Das gewählte Bauteil erscheint in der Nähe des Boards; zieh es mit der Maus an die gewünschte Stelle.
  4. Füge auf dieselbe Weise einen Resistor und einen Pushbutton hinzu. Ein Klick auf ein Bauteil öffnet ein kleines Feld, in dem du Farbe oder Wert änderst; stelle den Widerstand auf 220 Ω.
  5. Für eine Leitung klickst du auf das Ende eines Pins und dann auf den Ziel-Pin. Mit einem Klick auf eine freie Stelle dazwischen knickst du die Leitung. Klickst du eine Leitung an, kannst du ihre Farbe ändern oder sie mit der Entf-Taste löschen.
  6. Schreib deinen Code links oder füge das Beispiel unten ein und drücke den grünen Start-Button. Der erste Build dauert ein paar Sekunden; dann startet die Simulation und, wenn du Serial.begin verwendest, öffnet sich unten der serielle Monitor.
  7. Klicke während der Simulation mit der Maus auf den Taster. Mit dem Quadrat-Button stoppst du. Zum Aufbewahren drückst du Save; beim ersten Mal musst du dich anmelden und dein Projekt erhält einen dauerhaften Link.
Ein Projekt, das du ohne Anmeldung erstellst, wird nicht gespeichert; es verschwindet, wenn du den Tab schließt. Öffnest du das Projekt eines anderen, werden deine Änderungen nicht in sein Projekt geschrieben; mit Save a copy kopierst du es in dein eigenes Konto.

Erste Schaltung: LED mit einem Taster umschalten

Das klassische erste Experiment mit Taster und LED baust du auf allen drei Boards nach derselben Logik. Das lange Bein der LED (Anode, in Wokwi A) geht über den Widerstand an den Ausgangspin, das kurze Bein (Kathode, C) an GND. Eine Seite des Tasters kommt an den Eingangspin, die andere an GND; der Code schaltet den internen Pull-up-Widerstand ein. Den LED-Vorwiderstand für deine eigene Schaltung berechnest du mit dem LED-Vorwiderstandsrechner.

VerbindungArduino UnoESP32Raspberry Pi Pico
LED-Anode (A), über 220-Ω-WiderstandD13GPIO 18GP14
LED-Kathode (C)GNDGNDGND
Taster Bein 1D2GPIO 4GP2
Taster Bein 2GNDGNDGND
Logikpegel5 V3,3 V3,3 V
C++ (Arduino IDE)
1// Wokwi ilk proje: buton ile LED aç/kapat / Wokwi first project: toggle an LED with a button
2const int LED_PIN = 13;     // ESP32'de 18 / 18 on ESP32
3const int BUTON_PIN = 2;    // ESP32'de 4, diğer uç GND / 4 on ESP32, other leg to GND
4
5bool ledDurum = false;           // LED durumu / LED state
6bool oncekiOkuma = HIGH;         // önceki buton okuması / previous button reading
7unsigned long sonDegisim = 0;    // son kabul edilen değişim / last accepted change
8
9void setup() {
10  pinMode(LED_PIN, OUTPUT);
11  pinMode(BUTON_PIN, INPUT_PULLUP);   // dahili pull-up: basılınca LOW / internal pull-up: LOW when pressed
12  Serial.begin(115200);
13  Serial.println("Wokwi hazir / ready");
14}
15
16void loop() {
17  bool okuma = digitalRead(BUTON_PIN);
18  if (okuma != oncekiOkuma && millis() - sonDegisim > 50) {   // 50 ms debounce
19    sonDegisim = millis();
20    oncekiOkuma = okuma;
21    if (okuma == LOW) {                                       // basıldı / pressed
22      ledDurum = !ledDurum;
23      digitalWrite(LED_PIN, ledDurum ? HIGH : LOW);
24      Serial.print("LED: ");
25      Serial.println(ledDurum ? "ACIK / ON" : "KAPALI / OFF");
26    }
27  }
28}

Der Wokwi-Taster prellt wie ein echter: Bei einem einzigen Druck öffnet und schließt sich der Kontakt einige Millisekunden lang. Deshalb wartet der Code 50 ms; löschst du das, schaltet die LED manchmal zweimal um. Ein schönes Detail, denn so ist das, was du in der Simulation lernst, auch in der echten Schaltung nützlich. Die Zeitlogik ist im Artikel millis statt delay ausführlich erklärt.

diagram.json: Bauteile per Datei verbinden

Alles, was du mit der Maus zeichnest, landet in der Datei diagram.json des Projekts. Du öffnest sie über die Tabs über dem Code-Editor, kannst sie von Hand bearbeiten oder in ein anderes Projekt kopieren. Die Datei hat drei wichtige Abschnitte: parts (die Bauteile mit Typ, Position und Einstellungen), connections (die Leitungen) und das optionale dependencies. So sieht die diagram.json der Uno-Schaltung oben aus:

Code
1{
2  "version": 1,
3  "author": "BlueGrays",
4  "editor": "wokwi",
5  "parts": [
6    { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} },
7    { "type": "wokwi-led", "id": "led1", "top": -96, "left": 172, "attrs": { "color": "red" } },
8    { "type": "wokwi-resistor", "id": "r1", "top": -24, "left": 120, "rotate": 90, "attrs": { "value": "220" } },
9    { "type": "wokwi-pushbutton", "id": "btn1", "top": -110, "left": 260, "attrs": { "color": "green", "bounce": "1" } }
10  ],
11  "connections": [
12    [ "uno:13", "r1:1", "green", [] ],
13    [ "r1:2", "led1:A", "green", [] ],
14    [ "led1:C", "uno:GND.1", "black", [] ],
15    [ "uno:2", "btn1:1.l", "blue", [] ],
16    [ "btn1:2.l", "uno:GND.2", "black", [] ]
17  ],
18  "dependencies": {}
19}
FeldWozu dient es?Beispiel
typeTyp des Bauteilswokwi-led, wokwi-dht22, board-ssd1306
idName des Bauteils; Leitungen verwenden diesen Namenled1, uno, esp
top / left / rotatePosition auf dem Bildschirm (Pixel) und Drehwinkel"rotate": 90
attrsBauteilspezifische Einstellungen"color": "red", "value": "220"
connectionsJede Leitung: [Start-Pin, End-Pin, Farbe, Pfad]["uno:13", "r1:1", "green", []]
Format der Pinnamenbauteil-id:pin-nameuno:GND.1, esp:18, pico:GP14, btn1:1.l

Pinnamen lernst du am einfachsten, indem du im Diagramm mit der Maus über einen Pin fährst; Wokwi zeigt dann seinen Namen in einem kleinen Etikett. Die vier Beine des Tasters heißen 1.l, 2.l, 1.r, 2.r: Beine mit gleicher Nummer sind innen verbunden, beim Drücken werden 1 und 2 verbunden. Setzt du das Attribut bounce des Tasters auf "0", ist das Prellen aus; gibst du dem Attribut key einen Wert wie "1", kannst du ihn auch über die Tastatur drücken. Bei großen Schaltungen ist das Bearbeiten der diagram.json von Hand viel schneller, als Dutzende Leitungen einzeln zu zeichnen.

Bibliotheken hinzufügen: libraries.txt

Um in Wokwi eine Arduino-Bibliothek zu installieren, öffnest du über dem Code-Editor den Tab Library Manager, klickst auf + und suchst nach dem Namen der Bibliothek. Die gewählte Bibliothek wird als Zeile in die Datei libraries.txt des Projekts eingetragen und beim Build automatisch in der Cloud installiert. Du kannst die Datei auch von Hand schreiben; jede Zeile enthält eine Bibliothek mit dem Namen, den sie im Arduino-Bibliotheksverwalter trägt:

Code
1# Wokwi Library List
2Adafruit SSD1306
3Adafruit GFX Library
4DHT sensor library
5Adafruit NeoPixel
Zeigt der Build den Fehler No such file or directory, fehlt die Bibliothek in libraries.txt oder ihr Name ist falsch geschrieben. Wie du die Bibliothek in der echten Arduino IDE installierst, erfährst du im Artikel Arduino-Bibliothek installieren.

Mit Sensoren interagieren: Werte während der Simulation ändern

Am lehrreichsten an Wokwi ist, dass du Sensorwerte mit der Maus einstellen kannst. Klickst du während der Simulation auf den DHT22, öffnen sich Schieberegler für Temperatur und Luftfeuchtigkeit; beim HC-SR04 wählst du eine Entfernung zwischen 2 und 400 cm. Der PIR-Sensor hat einen Button, der Bewegung simuliert, das Potentiometer einen drehbaren Knopf und das LDR-Modul einen Schieberegler für die Helligkeit (Lux). So testest du eine Bedingung wie "Lüfter an, wenn die Temperatur 30 °C übersteigt" in Sekunden und prüfst die Schwellwerte deines Codes ohne echten Sensor.

WLAN-Simulation mit dem ESP32

Der ESP32 in Wokwi verbindet sich mit einem virtuellen Access Point namens Wokwi-GUEST. Dieses Netz hat kein Passwort und läuft auf Kanal 6; die Angabe des Kanals beschleunigt die Verbindung. Über das Gateway von Wokwi erreicht das Netz das echte Internet: Du kannst die Zeit per NTP holen, HTTP-Anfragen an einen Server schicken oder Daten an einen MQTT-Broker senden. Der folgende Code verbindet den ESP32, gibt seine IP-Adresse aus und holt die Istanbuler Uhrzeit aus dem Internet.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <time.h>
3
4void setup() {
5  Serial.begin(115200);
6  WiFi.begin("Wokwi-GUEST", "", 6);          // Wokwi sanal ağı: şifresiz, kanal 6 / Wokwi virtual network: open, channel 6
7  Serial.print("Baglaniyor / Connecting");
8  while (WiFi.status() != WL_CONNECTED) {
9    delay(250);
10    Serial.print(".");
11  }
12  Serial.println();
13  Serial.print("IP: ");
14  Serial.println(WiFi.localIP());
15  configTime(3 * 3600, 0, "pool.ntp.org");   // UTC+3 İstanbul, yaz saati yok / UTC+3 Istanbul, no DST
16}
17
18void loop() {
19  struct tm zaman;                            // saat bilgisi / time info
20  if (getLocalTime(&zaman)) {
21    Serial.printf("%02d:%02d:%02d\n", zaman.tm_hour, zaman.tm_min, zaman.tm_sec);
22  } else {
23    Serial.println("Saat alinamadi / Time not ready");
24  }
25  delay(1000);
26}

Auf einem echten ESP32 trägst du einfach deinen Netzwerknamen und dein Passwort ein; den Kanal-Parameter kannst du weglassen. In der kostenlosen Nutzung kann der ESP32 nach außen verbinden, aber der Browser auf deinem Computer erreicht einen Webserver im ESP32 nicht direkt. Dafür brauchst du die Portweiterleitung der VS-Code-Erweiterung oder das private Gateway im kostenpflichtigen Tarif. Details zu NTP und Zeitzonen findest du unter ESP32 NTP-Uhrzeit, bei Verbindungsproblemen mit einem echten Board hilft ESP32 verbindet sich nicht mit dem WLAN.

Wokwi simuliert das WLAN des ESP32, aber Bluetooth und BLE werden nicht simuliert. Code mit BLE oder klassischem Bluetooth kompiliert zwar, doch es erscheint kein Gerät, mit dem du dich vom Handy aus verbinden könntest; diese Teile musst du auf einem echten Board testen.

Raspberry Pi Pico und MicroPython-Unterstützung

Raspberry Pi Pico
In Wokwi kannst du den Pico mit MicroPython betreiben und deinen Code im Browser testen, bevor du zu Thonny wechselst.

Wählst du auf der Startseite für den Pico die Vorlage MicroPython, öffnet sich das Projekt mit einer Datei main.py. Nach dem Start lädt der MicroPython-Interpreter, main.py läuft und du siehst die print-Ausgaben in der Konsole unten. Endet das Programm, landet dieselbe Konsole in der REPL, wo du Befehle eintippen und sofort ausprobieren kannst. Brauchst du zusätzliche Module wie den SSD1306-Treiber, legst du im Dateimenü eine neue Datei an und fügst den Inhalt des Moduls ein. Für den ESP32 gilt dasselbe: Wähl einfach im ESP32-Bereich die MicroPython-Vorlage.

MicroPython
1from machine import Pin, ADC
2import time
3
4led = Pin(14, Pin.OUT)                  # LED + 220 ohm direnç / LED + 220 ohm resistor
5buton = Pin(2, Pin.IN, Pin.PULL_UP)     # diğer uç GND / other leg to GND
6pot = ADC(26)                           # potansiyometre orta ucu GP26 / pot wiper on GP26
7
8durum = False
9onceki = 1
10son = time.ticks_ms()                   # son pot yazdırma zamanı / last pot print time
11while True:
12    okuma = buton.value()
13    if okuma == 0 and onceki == 1:      # yeni basış / new press
14        durum = not durum
15        led.value(durum)
16        print("LED:", "ACIK" if durum else "KAPALI")
17        time.sleep_ms(50)               # debounce
18    onceki = okuma
19    if time.ticks_diff(time.ticks_ms(), son) >= 500:
20        son = time.ticks_ms()
21        gerilim = pot.read_u16() * 3.3 / 65535   # 16 bit okuma -> volt / 16-bit reading -> volts
22        print("Pot: {:.2f} V".format(gerilim))
23    time.sleep_ms(10)

Im Code hängt die LED an GP14, der Taster an GP2 und der Schleifer des Potentiometers an GP26 (ADC0); die äußeren Beine des Potis gehen an 3V3 und GND. Der ADC des Pico hat 12 Bit, aber read_u16() liefert in MicroPython einen auf 0–65535 skalierten Wert. Wenn du neu bei MicroPython bist, erklärt der Artikel MicroPython Grundlagen die Befehle für Pin, ADC, PWM und Timing einzeln.

Signale mit dem Logikanalysator sehen

Wokwi hat kein Multimeter, aber ein viel stärkeres Werkzeug: den Logic Analyzer. Du fügst ihn aus der Bauteilliste hinzu, und er zeichnet 8 digitale Kanäle (D0–D7) auf. Verbinde die Kanäle mit den Pins, die du messen willst, und seinen GND mit dem GND des Boards. Stoppst du die Simulation, wird die Aufzeichnung als .vcd-Datei heruntergeladen; in kostenlosen Programmen wie PulseView oder GTKWave liest du daraus Frequenz und Pulsbreite ab und kannst sogar UART-, I2C- oder SPI-Bytes dekodieren.

C++ (Arduino IDE)
1// Mantık analizörü D0 -> Uno D9, D1 -> Uno D1 (TX), GND -> GND
2// Logic analyzer D0 -> Uno D9, D1 -> Uno D1 (TX), GND -> GND
3void setup() {
4  Serial.begin(9600);
5  analogWrite(9, 64);            // %25 doluluk, yaklaşık 490 Hz / 25% duty, about 490 Hz
6}
7
8void loop() {
9  Serial.write('A');             // TX hattında çözülecek bayt / byte to decode on the TX line
10  delay(100);
11}

Öffnest du die Aufzeichnung, zeigt Kanal D0 ein Rechtecksignal mit einer Periode von etwa 2,04 ms (490 Hz); der Puls bleibt ein Viertel der Periode lang high, also etwa 0,51 ms. Denn analogWrite(9, 64) entspricht einem Tastverhältnis von 64/255 ≈ 25 %. Beim Uno erzeugen die Pins 5 und 6 980 Hz, die übrigen PWM-Pins 490 Hz; das kannst du mit dem Analysator selbst überprüfen. Fügst du in PulseView auf Kanal D1 einen UART-Decoder hinzu, liest du alle 100 ms das Byte 0x41 (A). Wie PWM funktioniert, erfährst du unter Was ist PWM?.

Die Wokwi-Erweiterung für VS Code

Willst du bei größeren Projekten lieber deinen eigenen Editor als den Browser nutzen, installierst du die Erweiterung Wokwi Simulator in VS Code. Die Erweiterung kompiliert nicht selbst; sie simuliert die Firmware-Datei, die du mit PlatformIO, ESP-IDF oder arduino-cli erzeugst. Für die private Nutzung gibt es eine kostenlose Lizenz, die du in regelmäßigen Abständen erneuerst. Die Einrichtung besteht aus diesen Schritten:

  1. Such in VS Code in der Erweiterungsansicht nach Wokwi Simulator und installiere sie.
  2. Öffne mit F1 die Befehlspalette, führe Wokwi: Request a New License aus und bestätige die Lizenz auf der Seite, die sich im Browser öffnet.
  3. Leg im Stammverzeichnis deines Projekts eine Datei wokwi.toml und eine Datei diagram.json an. Die diagram.json kannst du aus einem im Browser gezeichneten Projekt kopieren.
  4. Kompiliere das Projekt wie gewohnt (Build in PlatformIO). Die Pfade in wokwi.toml müssen auf die erzeugten .bin- und .elf-Dateien zeigen.
  5. Drücke F1 und führe Wokwi: Start Simulator aus. Die Simulation öffnet sich in einem VS-Code-Tab; änderst du den Code und kompilierst neu, startet die Simulation neu.
Code
1# wokwi.toml (PlatformIO, esp32dev ortamı / environment)
2[wokwi]
3version = 1
4firmware = ".pio/build/esp32dev/firmware.bin"
5elf = ".pio/build/esp32dev/firmware.elf"
6
7# ESP32 web sunucusunu bilgisayardan açmak: http://localhost:8180
8# Open the ESP32 web server from your computer: http://localhost:8180
9[[net.forward]]
10from = "localhost:8180"
11to = "target:80"

Der Abschnitt net.forward leitet den Webserver auf Port 80 des ESP32 an Port 8180 deines Computers weiter. So öffnest du Projekte wie ESP32 Webserver und WebSocket in deinem eigenen Browser, ohne ein Board zu flashen. Außerdem unterstützt die Erweiterung schrittweises Debuggen mit GDB; dazu fügst du in wokwi.toml eine Zeile gdbServerPort hinzu und verbindest den Debugger von VS Code.

Unterschiede zwischen Wokwi und Tinkercad

Beide Simulatoren sind kostenlos und laufen im Browser, beantworten aber unterschiedliche Fragen. Tinkercad berechnet die Schaltung elektrisch: Du misst den Strom durch einen Widerstand oder die Spannung an einer LED mit einem Multimeter, und es gibt Blockprogrammierung. Wokwi emuliert den Prozessor des Boards und bietet ESP32, Pico, WLAN, MicroPython und breite Bibliotheksunterstützung. Am effizientesten lernst du Elektronik-Grundlagen in Tinkercad und ESP32- sowie IoT-Projekte in Wokwi. Tinkercad im Detail stellt die Anleitung Tinkercad Arduino Simulation vor.

EigenschaftWokwiTinkercad Circuits
BoardsUno, Nano, Mega, ESP32-Familie, Pico, Pico WArduino Uno R3, ATtiny, micro:bit
Elektrische BerechnungKeine; digitale Pegel und ein Modell für analoge WerteJa; Multimeter und Oszilloskop
WLAN und InternetJa, mit ESP32 und Pico WNein
MicroPythonJa, auf Pico und ESP32Nein
BibliothekenDie meisten aus dem BibliotheksverwalterEtwa elf eingebaute Bibliotheken
BlockprogrammierungNeinJa
Schaltungsdateidiagram.json, von Hand bearbeitbarNur grafischer Editor
MessungLogikanalysator (.vcd)Multimeter, Oszilloskop
DesktopVS-Code-ErweiterungNein

Unterstützte Sensoren und Module

GruppeIn Wokwi vorhandenFehlt oder eingeschränkt
Licht und DisplaysLED, RGB-LED, NeoPixel-Streifen und -Ring, 16x2- und 20x4-LCD (auch I2C), SSD1306 OLED, ILI9341 TFT, MAX7219-Matrix, TM1637, 7-SegmentE-Paper und die meisten farbigen OLEDs
EingabeTaster, Schalter, DIP-Schalter, Potentiometer, Drehgeber (KY-040), Joystick, Folientastatur, IR-Empfänger und FernbedienungTouchscreen
SensorenDHT22, DS18B20, HC-SR04, PIR, MPU6050, LDR-Modul, NTC-Modul, HX711 und Wägezelle, MQ-2 Gas, Flamme, Schall, NeigungDHT11 (stattdessen DHT22), Farb- und Fingerabdrucksensoren
BewegungServo, Schrittmotor, A4988-Treiber, Relaismodul, SummerDC-Motor und Motortreiber wie der L298N
Kommunikation und SpeicherDS1307 RTC, microSD-Karte, 74HC595, I2C, SPI, UARTRC522 RFID, nRF24L01, HC-05, SIM800L, GPS
Analoge SchaltungenPotentiometer und analoge SensormoduleEchte analoge Berechnung von Transistoren, OPVs, Kondensatoren

Für ein Bauteil, das nicht in der Liste steht, gibt es zwei Wege. Der erste ist ein Bauteil mit ähnlichem Verhalten; zum Beispiel testest du DHT11-Code mit dem DHT22. Der zweite ist die Funktion Custom Chips: Ein kleines Programm, das du in C schreibst, wird zu WebAssembly kompiliert und als neues Bauteil mit eigenen Pins in die Schaltung eingefügt. So kannst du einen einfachen I2C-Sensor oder ein Modul, das über UART spricht, selbst nachbilden.

Grenzen der Simulation: Unterschiede zur echten Schaltung

  • Keine elektrische Berechnung: Eine LED ohne Vorwiderstand leuchtet weiter, und 5 V an einem ESP32-Pin zerstören nichts. In einer echten Schaltung kostet dich beides Bauteile. Rechne Strom und Spannung selbst mit dem ohmschen Gesetz nach.
  • Geschwindigkeit: Die Anzeige in der Ecke des Diagrammbereichs zeigt, mit wie viel Prozent der Echtzeit die Simulation läuft. ESP32-Projekte mit WLAN oder vielen Bauteilen können langsamer als in Echtzeit laufen; bedenke das bei Code, der Zeiten misst.
  • Ideale Sensoren: Virtuelle Sensoren rauschen nicht und brauchen keine Kalibrierung. Ein echter DHT22 weicht um ±0,5 °C ab, ein HC-SR04 misst an weichen Oberflächen falsch; schreib Filter und Fehlerprüfungen trotzdem.
  • Keine Stromversorgung, kein Akku: Stromaufnahme, Spannungsabfall, Erwärmung des Spannungsreglers und Brownouts tauchen in der Simulation nicht auf.
  • Kein Bluetooth: BLE und klassisches Bluetooth des ESP32 werden nicht simuliert.
  • Verdrahtungsfehler: Probleme aus dem echten Leben wie ein lockerer Jumper, eine falsche Breadboard-Reihe oder eine kalte Lötstelle gibt es nicht; eine Schaltung, die in der Simulation läuft, funktioniert in echt vielleicht nicht beim ersten Versuch.

Projekt teilen und auf ein echtes Board übertragen

Jedes gespeicherte Projekt erhält eine dauerhafte Adresse; mit dem Button Share kopierst du den Link und schickst ihn an Freunde, Lehrkräfte oder in ein Forum. Wer den Link öffnet, startet das Projekt mit einem Klick und kann es in sein eigenes Konto kopieren, um es zu ändern. Damit ist Wokwi der schnellste Weg, Schaltung und Code gemeinsam zu zeigen, wenn du mit "mein Code funktioniert nicht" um Hilfe bittest. Über das Menü neben dem Save-Button lädst du das Projekt als ZIP-Datei herunter; darin sind sketch.ino, diagram.json und libraries.txt.

  1. Füge den Code, der in der Simulation läuft, in einen neuen Sketch der Arduino IDE ein oder öffne sketch.ino aus dem heruntergeladenen ZIP.
  2. Installiere jede Bibliothek aus libraries.txt über den Bibliotheksverwalter der Arduino IDE.
  3. Ersetze im WLAN-Code Wokwi-GUEST durch deinen eigenen Netzwerknamen und dein Passwort.
  4. Übertrage die Verbindungen aus diagram.json in eine Pintabelle und bau die Schaltung danach auf dem Breadboard auf. Vergiss nicht die Widerstände, die Wokwi nicht brauchte (LED-Vorwiderstand, I2C-Pull-ups).
  5. Wähle Board und Port und lade hoch. Klappt etwas nicht, folge den Schritten aus Arduino Sketch lässt sich nicht hochladen.

Projektideen zum Ausprobieren in Wokwi

  • Wetterstation mit OLED: Zeig Temperatur und Luftfeuchtigkeit mit ESP32, DHT22 und SSD1306 an; ändere die Werte mit den Schiebereglern. Den Display-Code findest du im Artikel OLED-Display SSD1306.
  • Einparkhilfe: Ändere die Piep-Frequenz des Summers je nach HC-SR04-Abstand und teste jede Schwelle mit dem Entfernungsregler. Details im Artikel HC-SR04 Ultraschallsensor.
  • NeoPixel-Animationen: Probiere Farbübergänge auf einem WS2812B-Ring oder einer Matrix und entwirf die Effekte, bevor du dir Gedanken über das Netzteil eines echten Streifens machst. Siehe WS2812B NeoPixel LED.
  • Hausautomation mit MQTT: Sende die Temperatur vom virtuellen ESP32 an einen MQTT-Broker. Folge für die Einrichtung der Anleitung ESP32 MQTT und Home Assistant.
  • Codeschloss mit Tastenfeld: Bau ein Türschloss mit Folientastatur, Servo und LCD und beobachte falsche Codeeingaben im seriellen Monitor.
  • Interrupt-Experimente: Lies den Taster mit attachInterrupt und sieh mit dem Logikanalysator, wie das Prellen die Zahl der Interrupts erhöht. Siehe Arduino Interrupts.

Häufige Fehler und ihre Lösungen

SymptomMögliche UrsacheLösung
ESP32 verbindet sich nicht mit dem WLAN, Punkte laufen endlosFalscher Netzwerkname oder ein Passwort eingetragenWiFi.begin("Wokwi-GUEST", "", 6) verwenden; der Netzwerkname unterscheidet Groß- und Kleinschreibung
Fehler No such file or directoryBibliothek fehlt in libraries.txtBibliothek im Tab Library Manager hinzufügen
LED leuchtet nichtLED verkehrt herum (A und C vertauscht) oder GND-Leitung fehltLanges Bein A an den Widerstand, C an GND
Ein Tastendruck erhöht den Zähler zweimalDas Prellen des Tasters wird simuliertEntprellung in den Code einbauen oder beim Testen "bounce": "0" setzen
Simulation sehr langsamDauerhafte Serial-Ausgabe ohne Pause in der SchleifeKurzes delay in loop einfügen, unnötige Ausgaben reduzieren
ImportError: no module named in MicroPythonDie Moduldatei fehlt im ProjektIm Dateimenü eine neue Datei anlegen und das Modul einfügen
ESP32-Webserver öffnet sich nicht im BrowserDas kostenlose Gateway erlaubt nur Verbindungen von innen nach außenIn der VS-Code-Erweiterung net.forward nutzen
Projekt verschwundenOhne Anmeldung gearbeitetMit Save speichern; bei fremden Projekten Save a copy wählen
Bevor du ein Projekt erweiterst, dupliziere die funktionierende Version mit Save a copy und probiere die neue Funktion an der Kopie aus. Geht etwas kaputt, bist du mit einem Klick zurück bei der laufenden Version; diese Gewohnheit ist auch eine gute Vorbereitung auf git in echten Projekten.

Wokwi ist der praktischste Weg, eine Idee vor dem Bauteilkauf zu testen, einen Fehler samt Schaltung zu teilen und WLAN-Code gefahrlos auszuprobieren, besonders mit ESP32 und Pico. Die meisten Projekte in der BlueGrays-App enthalten ein Simulationsvideo, das aufgenommen wurde, während die Schaltung in Wokwi läuft; du siehst also, wann die LED angeht und wie sich das Display aktualisiert, bevor du mit dem Aufbau beginnst, und baust dasselbe Projekt dann mit Schaltplan und Code Schritt für Schritt auf deinem echten Board nach.

Häufige Fragen

Ist Wokwi kostenlos?

Ja, die Browserversion von Wokwi ist für die Grundnutzung kostenlos: Du kannst Projekte anlegen, speichern und teilen und einen ESP32 über virtuelles WLAN ins Internet bringen. Zusatzfunktionen wie das private Gateway und schnellere Builds gibt es im kostenpflichtigen Tarif. Auch die VS-Code-Erweiterung läuft für die private Nutzung mit einer kostenlosen Lizenz.

Wie verbinde ich einen ESP32 in Wokwi mit dem WLAN?

Verwende in deinem ESP32-Code Wokwi-GUEST als Netzwerknamen und einen leeren Text als Passwort: WiFi.begin("Wokwi-GUEST", "", 6). Der letzte Parameter, Kanal 6, beschleunigt die Verbindung. Danach erreicht der ESP32 das echte Internet per NTP, HTTP und MQTT.

Wokwi oder Tinkercad: Was ist besser?

Für Elektronik-Grundlagen, das Messen von Strom und Spannung mit dem Multimeter und Blockprogrammierung ist Tinkercad besser geeignet. Wokwi glänzt bei Projekten, die ESP32, Raspberry Pi Pico, WLAN, MicroPython und viele Bibliotheken brauchen. Viele Schüler nutzen beide.

Wie füge ich in Wokwi eine Bibliothek hinzu?

Öffne über dem Code-Editor den Tab Library Manager, klicke auf +, such die Bibliothek und wähle sie aus. Sie wird in die Datei libraries.txt eingetragen und beim Build automatisch installiert. Du kannst den Bibliotheksnamen auch von Hand in die Datei schreiben, genau so, wie er im Arduino-Bibliotheksverwalter erscheint.

Gibt es in Wokwi einen DHT11?

Die Bauteilliste von Wokwi enthält den DHT22, aber keinen DHT11. Um Code für einen DHT11 zu testen, setzt du ein DHT22-Bauteil in die Schaltung und stellst den Sensortyp in der Bibliothek auf DHT22. Auf dem echten Board stellst du den Typ einfach wieder auf DHT11.

Kann ich Wokwi-Code auf ein echtes Board hochladen?

Ja. Da Wokwi normalen Arduino- und MicroPython-Code ausführt, lädst du denselben Code mit der Arduino IDE oder Thonny auf ein echtes Board. Du musst nur die Bibliotheken installieren, WLAN-Name und Passwort ändern und die Widerstände ergänzen, die Wokwi nicht brauchte.

Alle Projekte ansehen
LED Blinken mit ESP32
ES-1Anfänger

LED Blinken mit ESP32

Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

4.7(37)
108
ESP32 LED-Steuerung mit Drucktaste (Push)
ES-2Anfänger

ESP32 LED-Steuerung mit Drucktaste (Push)

Die LED leuchtet auf, wenn die Taste gedrückt wird und geht aus, wenn sie losgelassen wird. Zeigt, wie der digitale Eingangspin des ESP32 und der interne Pull-up-Widerstand verwendet werden. Dank des INPUT_PULLUP-Modus ist kein externer Widerstand erforderlich.

4.6(36)
57
ESP32 LED Steuerung mit Taster (Toggle)
ES-3Anfänger

ESP32 LED Steuerung mit Taster (Toggle)

Jedes Mal, wenn die Taste gedrückt wird, ändert sich der Zustand der LED: ist sie an, schaltet sie aus, ist sie aus, schaltet sie ein. Klassisches Toggle-Muster. Mit der Entprellung wird das mechanische Geräusch des Tasters beseitigt, um ein einmaliges Umschalten mit einem einzigen Druck zu gewährleisten.

4.6(39)
59
Messung der Lichtintensität mit dem ESP32-LDR-Modul
ES-11Anfänger

Messung der Lichtintensität mit dem ESP32-LDR-Modul

Echtzeit-Anzeige des ADC-Rohwerts des LDR-Moduls und des anhand von Dunkel- und Hellreferenzwerten berechneten relativen Lichtwerts in Prozent im Serial Monitor. Dieser Prozentwert ist keine Lux-Messung. Vermittelt die Kalibrierungslogik des Moduls. Sollte idealerweise vor Projekt 10 durchgeführt werden, da es zur Festlegung des Schwellenwerts dient.

4.6(36)
55
Raspberry Pi Pico: Externe LED zum Leuchten bringen (Steckbrett)
PI-2Anfänger

Raspberry Pi Pico: Externe LED zum Leuchten bringen (Steckbrett)

Der nächste Schritt nach der eingebauten LED des Pico: eine externe LED auf dem Steckbrett anschließen und über Pin GP14 steuern. Du lernst, jeden GPIO-Pin des Pico als Ausgang zu nutzen, die Polung der LED (langes Bein = Anode/+, kurzes Bein = Kathode/–) und warum ein Vorwiderstand (220Ω) Pflicht ist. Ohne ihn fließt zu viel Strom durch die LED und sie kann durchbrennen.

4.5(2)
7
Raspberry Pi Pico Taster-gesteuerte LED (Push)
PI-9Anfänger
Premium

Raspberry Pi Pico Taster-gesteuerte LED (Push)

Erstes Eingabe-Projekt mit Pico — Taster lesen! LED leuchtet solange der Taster gedrückt ist. Lerne Pin.IN, Pin.PULL_UP und button.value(). GP14 LED, GP2 Taster mit internem PULL_UP. Gedrückt = 0, losgelassen = 1 — Standard.

11
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

ESP32-WLAN-STA-Verbindung (mit LCD-Display)

In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

4.4(21)
38
ESP32: Echtzeit aus dem Internet per NTP
ES-26Fortgeschritten
Premium

ESP32: Echtzeit aus dem Internet per NTP

Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.

4.5(13)
22