Raspberry Pi oder Arduino? Unterschiede und Entscheidungshilfe

Der Unterschied zwischen Raspberry Pi und Arduino passt in einen Satz: Der Raspberry Pi ist ein Computer im Scheckkartenformat, auf dem ein Linux-Betriebssystem läuft; der Arduino ist ein Mikrocontroller-Board, das ein einziges hochgeladenes Programm immer wieder ausführt. An den Pi kannst du Tastatur, Maus und Monitor anschließen, im Internet surfen, mit Python Kamerabilder verarbeiten oder zu Hause einen kleinen Server betreiben. Der Arduino legt los, sobald er Strom bekommt, liest Sensoren mikrosekundengenau aus, steuert Motoren und LEDs ohne jedes Stocken und läuft tagelang mit Batterien.

Kurz gesagt: Für Projekte mit Kamera, Bildverarbeitung, grafischer Oberfläche oder Netzwerkdiensten ist der Raspberry Pi die bessere Wahl; bei Sensoren, Motoren, präzisem Timing und geringem Stromverbrauch gewinnt der Arduino. In dieser Anleitung vergleichen wir beide Plattformen mit echten Zahlen: Bootzeit, Stromverbrauch, GPIO und Analogeingänge, Programmiersprache, Echtzeitverhalten und Preis. Danach zeigen wir dir in einer Tabelle, welches Board zu welchem Projekt passt, geben dir Beispielcode, mit dem beide über ein USB-Kabel zusammenarbeiten, und erklären, wo der Raspberry Pi Pico einzuordnen ist, der trotz seines Namens eher einem Arduino ähnelt.

Was ist ein Raspberry Pi, was ist ein Arduino?

Der Raspberry Pi ist ein Einplatinencomputer (SBC), entwickelt von der britischen Raspberry Pi Foundation. Der Raspberry Pi 5 hat einen Vierkern-Prozessor Arm Cortex-A76 mit 2,4 GHz, 1 bis 16 GB RAM, zwei 4K-HDMI-Ausgänge, USB 3.0, Gigabit-Ethernet, WLAN und Bluetooth. Statt einer Festplatte nutzt er eine microSD-Karte (oder mit Zusatzplatine eine NVMe-SSD), und darauf läuft das Debian-basierte Raspberry Pi OS. Du hast also einen kleinen, günstigen Bruder deines Desktop-PCs vor dir; der einzige Unterschied ist die 40-polige GPIO-Leiste am Rand, über die du LEDs, Taster und Sensoren direkt anschließen kannst.

Der Arduino dagegen ist eine in Italien entstandene Open-Source-Mikrocontroller-Plattform. Im Herzen des verbreitetsten Boards, des Arduino Uno R3, arbeitet ein 8-Bit-ATmega328P mit 16 MHz: Prozessor, 2 KB RAM, 32 KB Programmspeicher und Analog-Digital-Wandler stecken alle in einem kleinen Chip. Es gibt kein Betriebssystem, kein Dateisystem und keinen Bildschirmausgang. Der Code, den du in der Arduino IDE auf deinem Rechner schreibst, wird kompiliert und im Flash-Speicher des Boards abgelegt; bei jedem Start läuft zuerst setup() einmal und danach loop() endlos. Mehr über die Plattform erfährst du im Artikel Was ist Arduino?.

Kurze Antwort: Welches Board wofür?

Vergleichstabelle: Raspberry Pi 5, Arduino Uno und Raspberry Pi Pico

Ein kurzer Hinweis zu den Preisen: Weil die Kosten für die LPDDR4-Speicherchips im Raspberry Pi 4 und 5 durch die Nachfrage von KI-Rechenzentren stark gestiegen sind, hat Raspberry Pi die Preise seit Dezember 2025 mehrfach erhöht; im Oktober 2026 liegt der Listenpreis des Pi 5 mit 2 GB bei 77,50 $. Der Pi Zero 2 W mit älterem Speicher ist bei 15 $ geblieben. Dazu braucht ein Pi eine microSD-Karte, ein 27-W-USB-C-Netzteil und am besten einen Kühler, was weitere 20–30 $ ausmacht. Ein Arduino Uno oder ein Pico braucht dagegen nur ein USB-Kabel.

Der grundlegende Unterschied zwischen Linux-Computer und Mikrocontroller

Auf dem Raspberry Pi ist dein Python-Programm nur einer von Hunderten Prozessen, die Linux gleichzeitig verwaltet. Der Kernel teilt den Prozessor reihum der Netzwerkverbindung, dem Bildschirm, den USB-Geräten, den Hintergrunddiensten und deinem Programm zu. Das ist sehr mächtig: Du kannst in Dateien loggen, gleichzeitig einen Webserver und einen Kamerastream laufen lassen und deinen Code per SSH aus einem anderen Raum bearbeiten. Auf dem Arduino läuft dagegen nur dein Code auf dem Prozessor. Da kein Betriebssystem dazwischensitzt, ändert ein digitalWrite-Befehl den Pin innerhalb weniger Mikrosekunden, und das jedes Mal gleich schnell. In der Praxis bedeutet das:

• Multitasking: Der Pi führt Browser, Python-Skript und Datenbank gleichzeitig aus; der Arduino arbeitet mit einer einzigen loop(), und mehrere Aufgaben planst du selbst mit millis().
• Speicher: Auf dem Pi kannst du Gigabytes an Fotos, Logs und Datenbanken ablegen; beim Uno muss dein Programm in 32 KB und müssen deine Variablen in 2 KB RAM passen.
• Netzwerk: Der Pi geht direkt per WLAN und Ethernet ins Internet; der Uno hat keine Netzwerkverbindung, dafür brauchst du einen ESP32 oder ein Zusatzmodul.
• Wartung: Weil der Pi ein Computer ist, braucht er Updates, ein Benutzerpasswort und etwas Sicherheitspflege; auf den Arduino lädst du einmal Code hoch, und er läuft jahrelang gleich.
• Im Fehlerfall: Stürzt auf dem Pi ein Programm ab, läuft das System weiter und du kannst die Fehlermeldung lesen; hängt der Code auf dem Arduino, bleibt das Board still stehen, kann sich aber mit einem Watchdog-Timer selbst neu starten.

Bootzeit und plötzlicher Stromausfall

Sobald der Arduino Strom bekommt, startet dein Programm in weniger als einer Sekunde; selbst nach einem Druck auf den Reset-Taster wartet der Bootloader nur einen Moment. Der Raspberry Pi lädt zuerst seinen Bootloader, dann den Linux-Kernel und die Dienste; je nach Modell und Geschwindigkeit der SD-Karte dauert es 15–40 Sekunden bis zum Desktop. Bei Geräten, die nach einem Stromausfall sofort wieder funktionieren müssen, etwa einer Türklingel, einer Alarmanlage oder einer Bewässerung, ist das wichtig. Noch kritischer ist das Ausschalten: Linux schreibt ständig auf die SD-Karte, und fällt der Strom mitten in einem Schreibvorgang aus, kann das Dateisystem beschädigt werden, sodass der Pi nicht mehr startet. Da das Programm des Arduino unverändert im Flash liegt, kannst du ihm jederzeit den Stecker ziehen.

Stromverbrauch und Batteriebetrieb

Beim Stromverbrauch liegt der Unterschied beim Faktor 10 bis 30. Ein Raspberry Pi 5 braucht im Leerlauf etwa 3 W und bei voller CPU-Last 7–8 W, mit USB-Laufwerk und Kamera noch mehr. Ein Arduino Uno zieht etwa 50 mA, also 0,25 W bei 5 V, ein Pico rund 0,1 W. Die Tabelle unten zeigt ungefähre Laufzeiten mit einer 10.000-mAh-Powerbank. So wird gerechnet: Die 10.000 mAh auf dem Etikett beziehen sich auf 3,7-V-Zellen, das sind etwa 37 Wh; nach den Verlusten der Wandlung auf 5 V bleiben rund 30 Wh nutzbar. Diesen Wert teilst du durch den Verbrauch des Boards in Watt. Für deine eigene Schaltung kannst du den Akkulaufzeit-Rechner verwenden.

GPIO-Pins und Analogeingänge

Die 40-polige Leiste des Raspberry Pi hat 28 GPIOs; GPIO 0 und 1 sind für das ID-EEPROM von HAT-Platinen reserviert und werden meist nicht benutzt. Diese Pins arbeiten mit 3,3 V, sind nicht 5-V-tolerant und liefern pro Pin nur wenige Milliampere (höchstens etwa 16 mA); eine LED mit Vorwiderstand geht, ein Relais oder einen Motor solltest du aber nicht direkt treiben. Die größte Lücke sind die fehlenden Analogeingänge: Auf dem Pi gibt es kein Gegenstück zu analogRead, und um einen analogen Sensor wie ein Potentiometer, einen LDR oder einen Bodenfeuchtesensor auszulesen, brauchst du einen externen ADC-Chip. Der Arduino Uno hat 6 Analogeingänge, und fast jeder 5-V-Sensor lässt sich direkt anschließen.

Es gibt zwei Wege, einen analogen Sensor an den Pi anzuschließen. Der erste ist ein ADC-Modul wie der 8-Kanal-MCP3008 mit 10 Bit am SPI-Bus oder der 4-Kanal-ADS1115 mit 16 Bit am I2C-Bus; die Bibliothek gpiozero unterstützt den MCP3008 direkt. Der zweite: Du schließt die Sensoren an einen Arduino oder Pico an und schickst die Messwerte per USB an den Pi; den Code dafür findest du weiter unten. Wie analoges Messen funktioniert, erklärt der Artikel Was ist ein ADC?, die Pinbelegungen der Boards findest du im Pinout-Tool.

Programmiersprache und Entwicklungsumgebung

Der Arduino wird in der C/C++-basierten Arduino-Sprache programmiert: Du schreibst den Code in der Arduino IDE auf deinem Rechner, er wird kompiliert und per USB auf das Board geladen. Auf dem Raspberry Pi schreibst und startest du den Code direkt auf dem Pi, einen separaten Upload-Schritt gibt es nicht. Die beliebteste Sprache ist Python, und Raspberry Pi OS bringt den Editor Thonny und die Bibliothek gpiozero schon mit. Du kannst aber auch jede andere Sprache nutzen, die unter Linux läuft, etwa C, C++, Node.js, Go oder Java. So sieht ein Programm "LED leuchtet, solange der Taster gedrückt ist" in Python auf dem Pi aus:

1from gpiozero import LED, Button
2from signal import pause
3
4led = LED(17)       # GPIO17 = fiziksel pin 11 / GPIO17 = physical pin 11
5buton = Button(27)  # GPIO27 = fiziksel pin 13, dahili pull-up açık / physical pin 13, internal pull-up on
6
7buton.when_pressed = led.on    # Basınca LED yanar / LED on when pressed
8buton.when_released = led.off  # Bırakınca söner / LED off when released
9
10pause()  # Programı açık tut, olayları bekle / keep running and wait for events

Schließe den Taster zwischen GPIO27 und GND an und die LED über einen 220-Ω-Widerstand an GPIO17; die Klasse Button schaltet den internen Pull-up-Widerstand selbst ein. Speichere die Datei als buton_led.py und starte sie im Terminal mit python3 buton_led.py. Achtung: Beim Raspberry Pi 5 laufen die GPIOs über den neuen RP1-Chip, deshalb funktioniert die alte Bibliothek RPi.GPIO nicht mehr und bricht mit "RuntimeError: Cannot determine SOC peripheral base address" ab; nimm für neue Projekte gpiozero. Meldet pip install auf aktuellem Raspberry Pi OS den Fehler "externally-managed-environment", installiere das Paket mit sudo apt install python3-... oder lege eine virtuelle Umgebung (venv) an. Auf dem Raspberry Pi Pico nutzt du dasselbe Python-Wissen mit MicroPython.

Echtzeit: Warum der Arduino bei Motoren und Sensoren?

Weil Linux den Prozessor zwischen Programmen aufteilt, kann dein Python-Code gelegentlich für einige Millisekunden pausiert werden, und wann das passiert, lässt sich nicht vorhersagen. Für eine Webseite ist das egal, für zeitkritische Hardware aber ein ernstes Problem. Ein paar konkrete Beispiele:

• Ultraschallsensor HC-SR04: Der Schall braucht pro Zentimeter Abstand etwa 58 µs für Hin- und Rückweg. Schleicht sich beim Messen der Echo-Zeit eine Verzögerung von 100 µs ein, liegt das Ergebnis 1,7 cm daneben; auf dem Pi sind solche Abweichungen häufig.
• Servomotor: Ein Servo wird über einen 1–2 ms breiten Impuls in einem 50-Hz-Signal positioniert, und 1 Grad entspricht etwa 5,5 µs. Ein per Software-PWM vom Pi angesteuerter Servo zittert, am Arduino steht er ruhig.
• LED-Streifen WS2812B: Jedes Bit dauert 1,25 µs, und das Timing verlangt eine Genauigkeit von 0,15 µs; der Pi schafft das nur mit SPI- oder PWM-Hardware plus DMA, Arduino und Pico steuern ihn direkt.
• Schrittmotoren und Encoder: Tausende Schrittimpulse pro Sekunde oder schnelle Encoder-Signale erfasst der Arduino per Interrupt, ohne einen zu verpassen.

Welches Board für welches Projekt?

Kamera und Bildverarbeitung sind die größte Stärke des Raspberry Pi. Die 12-MP-Camera Module 3 mit Autofokus wird per Flachbandkabel an den Kameraanschluss gesteckt; mit rpicam-still -o foto.jpg machst du ein Foto, und mit den Bibliotheken Picamera2 und OpenCV gelingen in Python Bewegungserkennung, Farbverfolgung, QR-Code-Lesen oder Gesichtserkennung. Für anspruchsvollere KI-Modelle gibt es Beschleunigerplatinen wie das AI HAT+ oder die AI Camera, die das Bild direkt in der Kamera verarbeitet. Die Kameraanschlüsse des Raspberry Pi 5 sind kleiner (22-polig) als bei älteren Modellen, ältere Kameras brauchen deshalb ein passendes Adapterkabel. Die 2 KB RAM des Arduino Uno reichen dagegen nicht einmal für ein kleines Foto; willst du nur Bilder aufnehmen und per Telegram verschicken, ist die günstige ESP32-CAM ein guter Mittelweg.

Bei Sensoren und Motoren hat der Arduino dagegen praktisch keinen Konkurrenten. Da er mit 5 V arbeitet, lassen sich die meisten Module auf dem Markt, etwa der HC-SR04, Relaismodule, der Motortreiber L298N oder Zeichen-LCDs, ohne Zusatzschaltung anschließen, und Shields für Motoren, Relais und Sensoren werden direkt aufgesteckt. In einem Roboterauto liest der Arduino den Abstandssensor Dutzende Male pro Sekunde und stoppt die Motoren in dem Moment, in dem er ein Hindernis sieht; diese Reaktionszeit hängt nie davon ab, wie ausgelastet ein Betriebssystem gerade ist. Aus demselben Grund laufen auch Servomotoren und Schrittmotoren am Arduino sauber.

Beide zusammen nutzen: Raspberry Pi + Arduino

Bei den meisten anspruchsvollen Projekten ist die beste Lösung, beide zu kombinieren. Stell es dir wie den menschlichen Körper vor: Der Raspberry Pi ist das Gehirn; er verarbeitet das Kamerabild, geht ins Internet, speichert Daten und trifft Entscheidungen. Der Arduino ist Rückenmark und Muskeln; er liest die Sensoren, treibt die Motoren und reagiert im Notfall reflexartig, ohne den Pi zu fragen. In einem Roboterauto mit Kamera erkennt der Pi zum Beispiel die Linie im Bild und schickt den Befehl "links abbiegen"; der Arduino setzt ihn in Motorgeschwindigkeiten um und hält von selbst an, wenn ein Hindernis auftaucht. Die üblichen Verbindungswege sind:

1. Lade den Arduino-Code unten von deinem Rechner auf das Board (alternativ geht das auch vom Pi aus mit arduino-cli).
2. Verbinde den Arduino per USB-Kabel mit dem Pi und finde den Portnamen mit ls /dev/ttyACM* /dev/ttyUSB* im Terminal. Ein originaler Uno erscheint meist als /dev/ttyACM0, Klone mit CH340-Chip als /dev/ttyUSB0.
3. Ist die Bibliothek pyserial nicht installiert, installiere sie mit sudo apt install python3-serial.
4. Hat dein Benutzer keinen Zugriff auf die serielle Schnittstelle, gib sudo usermod -a -G dialout $USER ein und melde dich danach ab und wieder an.
5. Speichere den Python-Code als pi_arduino.py und starte ihn mit python3 pi_arduino.py; ist der serielle Monitor der Arduino IDE offen, schließe ihn vorher.

1// Arduino Uno: A0 değerini Pi'ye gönderir, Pi'den gelen komutla LED'i yönetir
2// Arduino Uno: sends the A0 reading to the Pi and drives the LED on the Pi's command
3const int SENSOR_PIN = A0;      // LDR ya da potansiyometre / LDR or potentiometer
4const int LED_PIN = 13;         // Dahili LED / built-in LED
5unsigned long sonGonderim = 0;  // Son gönderim zamanı / time of the last send
6
7void setup() {
8  Serial.begin(115200);         // Pi tarafıyla aynı hız / same baud rate as the Pi
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  // Pi'den komut geldi mi? / has a command arrived from the Pi?
14  if (Serial.available()) {
15    String komut = Serial.readStringUntil('\n');  // Satır sonuna kadar oku / read up to the newline
16    komut.trim();                                  // Boşluk ve \r karakterlerini sil / strip spaces and \r
17    if (komut == "LED1") digitalWrite(LED_PIN, HIGH);
18    else if (komut == "LED0") digitalWrite(LED_PIN, LOW);
19  }
20
21  // 500 ms'de bir ölçüm gönder, loop'u bekletmeden / send a reading every 500 ms without blocking
22  if (millis() - sonGonderim >= 500) {
23    sonGonderim = millis();
24    int deger = analogRead(SENSOR_PIN);  // 0-1023
25    Serial.print("A0:");
26    Serial.println(deger);               // Örnek: A0:512 / example: A0:512
27  }
28}

1import time
2import serial  # sudo apt install python3-serial
3
4# Orijinal Uno: /dev/ttyACM0, CH340'lı klon: /dev/ttyUSB0 / genuine Uno: /dev/ttyACM0, CH340 clone: /dev/ttyUSB0
5ser = serial.Serial("/dev/ttyACM0", 115200, timeout=1)
6time.sleep(2)             # Port açılınca Arduino yeniden başlar / opening the port resets the Arduino
7ser.reset_input_buffer()  # Eski verileri temizle / drop stale data
8
9ESIK = 300                # Karanlık eşiği, sensörüne göre ayarla / darkness threshold, tune it for your sensor
10led_durum = None
11
12while True:
13    satir = ser.readline().decode("utf-8", errors="ignore").strip()
14    if not satir.startswith("A0:") or not satir[3:].isdigit():
15        continue          # Boş ya da yarım satırı atla / skip empty or partial lines
16    deger = int(satir[3:])
17    print("Sensor:", deger)
18
19    yeni = "LED1" if deger < ESIK else "LED0"  # Karanlıkta LED'i yak / LED on in the dark
20    if yeni != led_durum:                      # Yalnız değişince gönder / send only on change
21        ser.write((yeni + "\n").encode())
22        led_durum = yeni

Der Arduino schickt alle 500 ms eine Zeile wie "A0:512" und wartet auf die Befehle "LED1" oder "LED0" mit Zeilenende; da er millis() verwendet, bremst das Warten auf Befehle die Messungen nie aus. Auf der Python-Seite ist die Zeile time.sleep(2) wichtig: Öffnet der Pi die serielle Schnittstelle, startet der Arduino automatisch neu, und alles, was in den ersten zwei Sekunden gesendet wird, geht verloren. Passe den Schwellwert 300 an deinen Sensor an; je nachdem, wie herum du den LDR angeschlossen hast, steigt oder fällt der Wert bei Dunkelheit. Mehr zur seriellen Kommunikation findest du in Serielle Kommunikation zwischen Arduino und Python und Was ist UART?.

Wo der Raspberry Pi Pico hingehört: Raspberry Pi im Namen, Mikrocontroller im Wesen

Hier entsteht die meiste Verwirrung. Obwohl er von Raspberry Pi stammt, ist der Raspberry Pi Pico kein Computer, sondern ein Mikrocontroller-Board wie der Arduino: Er hat kein Betriebssystem, startet sofort, verbraucht etwa 0,1 W und arbeitet in Echtzeit. Im Inneren steckt der von Raspberry Pi selbst entwickelte Zweikern-Chip RP2040 (beim Pico 2 der RP2350 mit 150 MHz). Gegenüber dem Arduino Uno hat er viel mehr RAM (264 KB), einen 12-Bit-ADC und PIO-Blöcke für zeitkritische Aufgaben, und du programmierst ihn in MicroPython, C/C++ oder mit der Arduino IDE. Mit 4 $ ist er günstiger als ein Arduino Uno, arbeitet aber mit 3,3 V, weshalb du bei 5-V-Modulen aufpassen musst. Details liefert der Artikel Was ist der Raspberry Pi Pico?.

Der größte Vorteil des Pico in diesem Vergleich: Er arbeitet mit demselben 3,3-V-Pegel wie der Raspberry Pi. Du kannst seine UART-Pins ohne Pegelwandler direkt mit dem Pi verbinden oder ihn per USB anstecken und wie einen Arduino nutzen. Der MicroPython-Code unten sendet Daten im selben Format "A0:Wert" wie der Arduino-Code oben und hört auf dieselben LED-Befehle, sodass das Python-Skript auf dem Pi ohne jede Änderung funktioniert. Speichere den Code mit Thonny als main.py auf dem Pico und schließe Thonny danach, damit die serielle Schnittstelle für das Skript auf dem Pi frei ist.

1import sys, select, time
2from machine import ADC, Pin
3
4sensor = ADC(26)        # GP26 = ADC0 (fiziksel pin 31) / GP26 = ADC0 (physical pin 31)
5led = Pin(25, Pin.OUT)  # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; use Pin("LED") on Pico W
6poll = select.poll()
7poll.register(sys.stdin, select.POLLIN)  # USB'den gelen veriyi dinle / listen for data over USB
8son = time.ticks_ms()
9
10while True:
11    # Pi'den komut var mı? / is there a command from the Pi?
12    if poll.poll(0):
13        komut = sys.stdin.readline().strip()
14        if komut == "LED1":
15            led.on()
16        elif komut == "LED0":
17            led.off()
18
19    # 500 ms'de bir, Arduino ile aynı biçimde gönder / every 500 ms, same format as the Arduino
20    if time.ticks_diff(time.ticks_ms(), son) >= 500:
21        son = time.ticks_ms()
22        deger = sensor.read_u16() >> 6  # 0-65535 -> 0-1023
23        print("A0:" + str(deger))

Die Grenzen verschwimmen zudem immer mehr. 2025 hat Arduino den Arduino UNO Q vorgestellt, der beide Welten auf einer Platine vereint: Auf dem Board im Uno-Format sitzen ein Vierkern-Prozessor von Qualcomm, auf dem Debian Linux läuft, und ein STM32U585-Mikrocontroller, der Arduino-Sketches in Echtzeit ausführt. Die Architektur "Pi + Arduino" passt also inzwischen auf ein einziges Board. Das Prinzip bleibt aber gleich: Die Linux-Seite kümmert sich um Netzwerk, Bild und Anwendung, die Mikrocontroller-Seite um Pins und Timing. Wer die Unterschiede aus diesem Artikel kennt, holt auch aus solchen Hybrid-Boards deutlich mehr heraus.

Häufige Fehler und Irrtümer

• "Der Raspberry Pi Pico ist ein kleiner Raspberry Pi": Ist er nicht; er führt kein Linux aus und hat keinen HDMI-Ausgang. Der Pico ist ein Mikrocontroller und gehört in dieselbe Klasse wie der Arduino.
• 5-V-Signale an den Pi anschließen: Wird der ECHO-Pin des HC-SR04 oder die TX-Leitung des Arduino direkt an einen GPIO gelegt, können der Pin oder sogar der Prozessor dauerhaft Schaden nehmen; nimm einen Spannungsteiler.
• analogRead auf dem Pi suchen: Der Raspberry Pi hat keine Analogeingänge; verwende einen MCP3008, einen ADS1115 oder einen Arduino bzw. Pico als Helfer.
• Ausschalten durch Stecker-Ziehen: Das ist der schnellste Weg, eine SD-Karte zu beschädigen; nutze jedes Mal sudo poweroff.
• Pi 5 am Handy-Ladegerät betreiben: Mit einem Netzteil, das keine 5 V 5 A liefert, begrenzt der Pi 5 den Gesamtstrom der USB-Ports auf 600 mA und kann unter Last neu starten.
• Fehler "Permission denied: '/dev/ttyACM0'": Dein Benutzer ist nicht in der Gruppe dialout; führe den usermod-Befehl aus und melde dich neu an. Bei "Device or resource busy" blockiert ein anderes Programm (serieller Monitor oder Thonny) den Port.
• Der Gedanke "Arduino ist veraltet, es gibt ja den Pi": Die beiden sind keine Konkurrenten, sondern Werkzeuge für verschiedene Aufgaben; die meisten Geräte, von der Waschmaschine bis zum Auto, laufen bis heute mit Mikrocontrollern.

Kurz gesagt: Der Raspberry Pi ist ein Computer, der denkt und sieht, der Arduino ein Controller, der Wahrgenommenes sofort in Aktion umsetzt; ein gutes Projekt verbindet oft die Stärken beider. In der BlueGrays-App findest du Dutzende Projekte mit Arduino, ESP32 und Raspberry Pi Pico, von LEDs und Sensoren bis zu Robotern und WLAN-Projekten, jeweils mit Schritt-für-Schritt-Schaltplan und fertigem Code, und du kannst mit den kostenlosen beginnen.