Arduino oder ESP32? Unterschiede, Vergleich und Kaufberatung

Arduino oder ESP32? Die kurze Antwort: Braucht dein Projekt WLAN, Bluetooth, Internet oder viel Rechenleistung, nimm den ESP32. Lernst du gerade die Grundlagen der Elektronik, willst problemlos mit 5-V-Sensoren und -Modulen arbeiten und jedes Tutorial genau nachbauen, nimm den Arduino Uno. Beide Boards werden in der Arduino IDE mit denselben Befehlen digitalWrite, analogRead und Serial programmiert. Der eigentliche Unterschied liegt in der Hardware: Geschwindigkeit, Speicher, Betriebsspannung, Pins und Funkverbindung.

In dieser Anleitung vergleichen wir den Arduino Uno R3 mit dem verbreitetsten ESP32-Board, dem ESP32 DevKit (mit ESP-WROOM-32-Modul), anhand echter Zahlen: Was bedeuten Prozessor- und Speicherunterschiede in der Praxis, welche Module betrifft der Unterschied zwischen 5 V und 3,3 V, wie verändern sich Analogeingänge und PWM, und wie viele Stunden hält welches Board mit einem Akku durch? Danach lassen wir denselben Sketch auf beiden Boards laufen, werfen einen kurzen Blick auf den Raspberry Pi Pico und fassen in einer Tabelle zusammen, welches Board zu welcher Projektart passt.

Kurze Antwort: Wann nimmst du welches Board?

Was sind Arduino Uno und ESP32?

Der Arduino Uno R3 ist das bekannteste Board der in Italien entwickelten Arduino-Plattform. Sein Herz ist der 8-Bit-Mikrocontroller ATmega328P mit 16 MHz. Das Board arbeitet mit 5 V, und seine Pinbelegung ist seit Jahren gleich; deshalb passen Hunderte Shields (aufsteckbare Erweiterungsplatinen), Bücher und Kurse dazu. Durch den einfachen Aufbau siehst du genau, was passiert: Schreibst du HIGH auf einen Pin, liegen dort wirklich 5 V an. Der neuere Uno R4 kommt mit einem 32-Bit-Arm-Prozessor mit 48 MHz und 32 KB RAM, und die Version R4 WiFi bringt mit einem ESP32-S3 auf der Platine auch Funk mit; mit "Uno" meinen wir in diesem Artikel den immer noch verbreitetsten R3. Mehr über die Plattform erfährst du in Was ist Arduino?.

Der ESP32 dagegen ist ein 32-Bit-System-on-Chip (SoC), das Espressif 2016 vorgestellt hat und das WLAN und Bluetooth auf demselben Chip vereint. Das Board in deiner Hand ist ein Entwicklungsboard, das diesen Chip trägt: Darauf sitzen ein USB-Seriell-Wandler, ein 3,3-V-Spannungsregler sowie die Taster EN und BOOT. Ein wichtiges Detail: Der ESP32 ist kein Arduino, aber dank des Arduino-Cores von Espressif wird er in der Arduino IDE genau wie einer programmiert. Für Einrichtung und erste Projekte ist Was ist der ESP32? ein guter Einstieg.

Die große Vergleichstabelle: Arduino Uno, ESP32 und Raspberry Pi Pico

Prozessor und Speicher: Was bedeuten die Zahlen in der Praxis?

Der Prozessor des Uno führt etwa 16 Millionen Befehle pro Sekunde aus und arbeitet jeweils mit 8-Bit-Zahlen; eine 32-Bit-Operation mit long oder float braucht Dutzende Befehle, und eine Gleitkommaeinheit (FPU) in Hardware gibt es nicht. Der ESP32 läuft mit 240 MHz, rechnet mit 32-Bit-Zahlen und hat eine FPU für einfache Genauigkeit. Deshalb kann der ESP32 bei float-lastigen Berechnungen zehn- bis hundertfach schneller sein als der Uno. Beim LED-Blinken oder wenn du einen Sensor ein paarmal pro Sekunde ausliest, merkst du davon nichts; bei Filtern, Audioverarbeitung, Verschlüsselung oder Animationen für Hunderte LEDs ist der Unterschied aber entscheidend. Ein kleiner Tipp: Die FPU des ESP32 kann nur float; double-Operationen laufen in Software und sind deutlich langsamer.

Den Speicherunterschied bemerkst du viel häufiger. Die 2 KB RAM des Uno teilen sich deine Variablen, die Serial-Puffer und der Platz, den Bibliotheken reservieren. Wenn das RAM voll ist, warnt der Compiler meistens nicht; das Programm hängt sich zufällig auf oder verhält sich seltsam. Typische Fälle, in denen dem Uno schnell das RAM ausgeht:

• OLED-Display: Allein der Bildpuffer eines 128×64-SSD1306-Displays belegt 1 KB, also die Hälfte des RAM (siehe OLED-Display verwenden).
• Adressierbare LEDs: Jede WS2812B-LED belegt 3 Byte; ein Streifen mit 300 LEDs braucht 900 Byte (siehe WS2812B NeoPixel).
• Daten aus dem Internet: Das JSON eines Wetterdienstes kann mehrere KB groß sein; auf den Uno passt es nicht, der ESP32 verarbeitet es mühelos.
• String-Verkettung: String-Objekte, die in einer Schleife wachsen, zerstückeln das kleine RAM und können Stunden später zum Absturz führen.
• SD-Karte: Die SD-Bibliothek reserviert einen 512-Byte-Sektorpuffer; zusammen mit Display- und Sensorbibliotheken ist die Grenze schnell erreicht.

Der Spannungsunterschied: 5 V und 3,3 V

Das ist der am häufigsten übersehene Unterschied. Die Pins des Uno arbeiten mit 5-V-Logik: Ein HIGH-Ausgang hat 5 V, und Eingänge über 3 V gelten als HIGH. Die Pins des ESP32 arbeiten mit 3,3-V-Logik und sind nicht 5-V-tolerant. 5 V an einem Pin töten den ESP32 vielleicht nicht sofort, belasten aber die internen Schutzdioden und können den Chip mit der Zeit oder auf einen Schlag dauerhaft zerstören. Die andere Richtung ist harmloser: Das 3,3-V-HIGH-Signal des ESP32 liegt knapp über der 3-V-Schwelle des Uno und wird deshalb meist als HIGH gelesen, ein sicheres Design ist das aber auch nicht. So verhalten sich gängige Module mit beiden Boards:

Pins, Analogeingänge und PWM

Beim Uno verhalten sich alle 20 Pins ungefähr gleich: Jeder kann Ein- oder Ausgang sein, liefert problemlos bis zu 20 mA und beeinflusst den Bootvorgang nicht. Das ESP32 DevKit hat auf dem Papier mehr Pins, aber nicht alle sind gleichwertig: GPIO 6–11 hängen am internen Flash und sind tabu, GPIO 34–39 sind reine Eingänge, und GPIO 0, 2, 5, 12 und 15 müssen beim Booten bestimmte Pegel haben. In der Praxis kannst du etwa 20–25 Pins bequem nutzen. Die Pinbelegung deines Boards findest du im Pinout-Werkzeug.

Beim Analogeingang teilt der 10-Bit-ADC des Uno den Bereich von 0–5 V in 1024 Stufen; jede Stufe entspricht etwa 4,9 mV, und die Messung ist ziemlich linear. Der 12-Bit-ADC des ESP32 liefert 4096 Stufen, kann aber in der Standardeinstellung Werte unter etwa 0,15 V und über 3,1 V nicht unterscheiden, rauscht und die ADC2-Pins funktionieren bei aktivem WLAN gar nicht. Brauchst du eine genaue Spannung, verwende am ESP32 analogReadMilliVolts() und schließe den Sensor an die ADC1-Pins (GPIO 32–39) an. Bei PWM liegt der ESP32 vorn: Der Uno bietet 8-Bit-PWM nur an 6 Pins mit 490 oder 980 Hz, der ESP32 kann 16 Kanäle mit einstellbarer Frequenz und Auflösung auf fast jeden Ausgangspin legen. Außerdem hat er 2 DACs (GPIO 25 und 26), die eine echte Analogspannung erzeugen. Die Grundlagen zu PWM findest du in Was ist PWM?.

Derselbe Sketch auf beiden Boards: Was ändert sich?

Die gute Nachricht: Alles, was du am Arduino gelernt hast, gilt auch für den ESP32. Der folgende Sketch liest ein Potentiometer, gibt die Spannung im seriellen Monitor aus und schaltet die Onboard-LED ein, sobald der Wert die Hälfte überschreitet. Die Zeile #if defined(ESP32) erkennt, für welches Board kompiliert wird, und ändert nur Pinnummer, Referenzspannung und ADC-Auflösung. Verbinde die äußeren Anschlüsse des Potentiometers beim Uno mit 5V und GND, beim ESP32 mit 3V3 und GND; den Schleifer steckst du beim Uno an A0, beim ESP32 an GPIO 34 und öffnest den seriellen Monitor mit 115200 Baud. Die wichtigsten Unterschiede außerhalb des Codes stehen in der Tabelle.

1// Aynı kod Uno ve ESP32'de çalışır / The same sketch runs on Uno and ESP32
2#if defined(ESP32)
3const int LED_PIN = 2;        // DevKit dahili LED / DevKit onboard LED
4const int POT_PIN = 34;       // ADC1 pini, Wi-Fi ile de çalışır / ADC1 pin, works with Wi-Fi too
5const float VREF = 3.3;       // ESP32 pinleri 3,3 V / ESP32 pins are 3.3 V
6const int ADC_MAX = 4095;     // 12 bit
7#else
8const int LED_PIN = 13;       // Uno dahili LED / Uno onboard LED
9const int POT_PIN = A0;
10const float VREF = 5.0;       // Uno referansı 5 V / Uno reference is 5 V
11const int ADC_MAX = 1023;     // 10 bit
12#endif
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17}
18
19void loop() {
20  int raw = analogRead(POT_PIN);
21  float volts = raw * VREF / ADC_MAX;
22  Serial.print("Ham / raw: ");
23  Serial.print(raw);
24  Serial.print("  Gerilim / voltage: ");
25  Serial.println(volts, 2);
26  digitalWrite(LED_PIN, raw > ADC_MAX / 2 ? HIGH : LOW);   // yarıdan fazlaysa LED yanar / LED on above half
27  delay(250);
28}

WLAN, Bluetooth und Internet

Was den ESP32 wirklich abhebt, ist die Funkverbindung. Das Board verbindet sich mit 2,4-GHz-WLANs, kann einen eigenen Access Point aufspannen, betreibt einen Webserver, schickt per MQTT Daten an ein Smart-Home-System, holt sich per NTP die Uhrzeit aus dem Internet und kann seine Firmware drahtlos (OTA) aktualisieren. Bei Bluetooth werden sowohl klassisches Bluetooth (Serial Port Profile) als auch das stromsparende BLE unterstützt, und mit ESP-NOW können mehrere ESP32 ganz ohne Router miteinander sprechen. Nichts davon ist beim Uno eingebaut: Für Bluetooth brauchst du ein Modul wie das HC-05, für WLAN einen separaten Chip wie den ESP-01 samt AT-Befehlen. Der folgende Sketch liest dasselbe Potentiometer, diesmal über WLAN: Öffne die im seriellen Monitor angezeigte Adresse im Browser eines Handys im selben Netz, und du siehst die Spannung in Millivolt; die Seite aktualisiert sich alle zwei Sekunden.

1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
5const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
6const int POT_PIN = 34;              // ADC1 pini / ADC1 pin
7
8WebServer server(80);
9
10void handleRoot() {
11  uint32_t mv = analogReadMilliVolts(POT_PIN);   // kalibre edilmiş mV / calibrated mV
12  String html = "<meta name='viewport' content='width=device-width'>"
13                "<meta http-equiv='refresh' content='2'>"
14                "<h1>ESP32</h1><p>Pot: ";
15  html += mv;
16  html += " mV</p>";
17  server.send(200, "text/html", html);
18}
19
20void setup() {
21  Serial.begin(115200);
22  WiFi.begin(ssid, password);
23  while (WiFi.status() != WL_CONNECTED) delay(500);
24  Serial.print("Telefonda aç / open on your phone: http://");
25  Serial.println(WiFi.localIP());
26  server.on("/", handleRoot);
27  server.begin();
28}
29
30void loop() {
31  server.handleClient();
32}

Stromverbrauch und Akkubetrieb

Auf dem Papier ist der ESP32 zugleich das hungrigste und das sparsamste Board. Beim Senden über WLAN zieht er Spitzen von bis zu 240 mA; deshalb startet er an einem schwachen USB-Port mit der Meldung "Brownout detector was triggered" neu. Im Tiefschlaf braucht der Chip dagegen nur etwa 10 µA. Das Uno-Board verbraucht im Leerlauf etwa 45 mA; selbst wenn der ATmega328P schläft, ziehen USB-Seriell-Chip, Spannungsregler und Power-LED weiter rund 30 mA. Rechnen wir ein Beispiel: Ein 2000-mAh-Akku versorgt einen dauerhaft laufenden Uno etwa 2000 / 45 ≈ 44 Stunden lang. Ein ESP32 mit ständig aktivem WLAN (im Schnitt 100 mA) hält etwa 20 Stunden. Wacht der ESP32 aber alle 10 Minuten für 3 Sekunden auf, sendet mit 120 mA einen Messwert und schläft die übrigen 597 Sekunden mit 10 µA, beträgt der mittlere Strom (3 × 120 + 597 × 0,01) / 600 ≈ 0,61 mA, und derselbe Akku hält theoretisch über 3000 Stunden, also mehr als vier Monate. Dafür brauchst du ein stromsparendes Board oder ein nacktes Modul; Regler und USB-Chip auf Standard-DevKits verbrauchen selbst im Schlaf einige mA. Dein eigenes Szenario berechnest du mit dem Werkzeug Akkulaufzeit.

Wo steht der Raspberry Pi Pico?

Die dritte starke Option ist der Raspberry Pi Pico. Sein RP2040-Chip hat zwei Cortex-M0+-Kerne mit 133 MHz, 264 KB RAM und 2 MB Flash und kostet etwa 4 Dollar. Wie der ESP32 arbeitet er mit 3,3 V und bietet 26 GPIOs, hat aber nur 3 Analogeingänge. Seine größten Stärken sind die sehr ausgereifte MicroPython-Unterstützung, das einfache Aufspielen der Firmware, weil er sich am Computer wie ein USB-Stick meldet, und die sogenannten PIO-Einheiten, die exakt getaktete Protokolle erzeugen, ohne den Prozessor zu belasten. Willst du Funk, nimm den Pico W (WLAN und Bluetooth); für mehr Leistung den Pico 2 mit RP2350-Chip. Details findest du in Was ist der Raspberry Pi Pico?. Dieselbe Potentiometer-Messung sieht auf dem Pico in MicroPython so aus (Schleifer an GP26, äußere Anschlüsse an 3V3 und GND):

1from machine import ADC, Pin
2import time
3
4pot = ADC(26)                  # GP26 = ADC0, potansiyometre orta ucu / pot wiper
5led = Pin("LED", Pin.OUT)      # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
6
7while True:
8    raw = pot.read_u16()                   # 0–65535 (12 bit ölçüm ölçeklenir / 12-bit reading, scaled)
9    volts = raw * 3.3 / 65535
10    print("Ham / raw:", raw, " Gerilim / voltage: {:.2f}".format(volts))
11    led.value(raw > 32767)                 # yarıdan fazlaysa yanar / on above half
12    time.sleep(0.25)

Preis und Einsteigerfreundlichkeit

Der Preis allein entscheidet selten. Ein originaler Uno R3 kostet etwa 25–30 $, Nachbauten mit CH340-USB-Chip gibt es für 5–10 $; DevKit-Nachbauten des ESP32 kosten 4–8 $, der Pico 4 $. Zwischen einem ESP32 und einem Uno-Nachbau gibt es also kaum einen Preisunterschied; die echten Kosten stecken im Zubehör: Für 5-V-Module am ESP32 brauchst du ein paar Widerstände oder einen Pegelwandler für 1–2 $, und für WLAN am Uno ein separates Modul. Beim Lernen liegt der Uno vorn: Du wählst das Board aus und klickst auf Hochladen, Fehlermeldungen und Beispiele sind seit Jahren dieselben, und mit 5-V-Modulen gibt es keine Pegelprobleme. Beim ESP32 installierst du zuerst das Boardpaket von Espressif und bei Bedarf den Treiber für den USB-Chip (CP2102 oder CH340), wählst das richtige Boardmodell und hältst bei manchen Boards beim Hochladen die BOOT-Taste gedrückt; außerdem wurden manche Beispiele im Netz für ältere Core-Versionen geschrieben und lassen sich nicht kompilieren (im Core 3.x ersetzt zum Beispiel ledcAttach die Funktion ledcSetup). Diese Hürden sind in ein paar Stunden genommen, aber wenn du zum ersten Mal Schaltungen baust, erkennst du am Uno leichter, ob ein Problem am Code oder an der Verdrahtung liegt.

Welches Board für welches Projekt?

Häufige Fehler und Irrtümer

• "Der ESP32 ist immer besser": Er ist leistungsfähiger, aber 3,3-V-Pins, bootkritische Pins, BOOT-Taste und Spannungseinbrüche können Einsteiger zermürben. Zum Lernen der Grundlagen bietet der Uno weniger Überraschungen.
• 5-V-Sensor direkt an den ESP32 anschließen: 5-V-Signale wie der ECHO-Ausgang des HC-SR04 ohne Spannungsteiler können den Pin beschädigen.
• ADC2-Pin bei aktivem WLAN auslesen: GPIO 0, 2, 4, 12–15 und 25–27 messen bei laufendem WLAN nichts; verlege den Sensor auf GPIO 32–39.
• Das RAM des Uno vergessen: Kompiliert der Code, aber das Board hängt sich zufällig auf, ist vielleicht das RAM voll; setze feste Texte in F("...") und vermeide String-Verkettung in Schleifen.
• ESP32 an schwachem USB betreiben: Startet das Board neu, sobald WLAN anspringt, nimm ein gutes Datenkabel und ein Netzteil mit mindestens 1 A.
• Pico und Pico W verwechseln: Der normale Pico hat kein WLAN; für ein Funkprojekt kaufst du das Modell mit dem W im Namen.

Kurz gesagt: Der Arduino Uno ist das Board zum Lernen, der ESP32 das Board zum Vernetzen und der Raspberry Pi Pico das Board zum Experimentieren mit Python. Wenn du wissen willst, welches Modell der Arduino-Familie zu dir passt, lies Welchen Arduino soll ich kaufen?. In der BlueGrays-App findest du Dutzende Projekte für Arduino, ESP32 und Pico, vom LED-Blinken bis zum WLAN-Webserver und von der NTP-Uhr bis zur Wetteranzeige, jeweils mit Schritt-für-Schritt-Schaltplan und Code.