Raspberry Pi Pico Projekte: 20 Ideen für Einsteiger mit Code
20 Raspberry Pi Pico Projekte für Einsteiger: LED, Taster-Interrupt, PWM, Sensoren, OLED und Servo, mit Tabelle zu Sprache, Bauteilen und Schwierigkeit.
Du suchst Raspberry Pi Pico Projekte und weißt nicht, wo du anfangen sollst? Dann ist diese Liste genau richtig: Wir haben 20 Projekte von leicht bis schwer zusammengestellt, von einer einzelnen blinkenden LED und dem Taster-Interrupt über den PWM-Atemeffekt und das Auslesen von Sensoren bis zu OLED-Display und Servomotor. In einer Tabelle siehst du für jedes Projekt die passende Sprache (MicroPython oder C/C++), die nötigen Bauteile und den Schwierigkeitsgrad; für das lehrreichste Projekt jeder Stufe gibt es funktionierenden Code.
Drei Gründe machen den Pico zum idealen Einsteigerboard: Er ist günstig, mit MicroPython läuft dein Code ohne Kompilieren sofort, und jeder seiner 26 GPIO-Pins kann PWM ausgeben. Wenn du den Pico gerade erst ausgepackt hast, geh zuerst die Einrichtung in Was ist der Raspberry Pi Pico? durch; hier setzen wir voraus, dass dein Board in Thonny läuft und du die eingebaute LED blinken lassen kannst.

Bevor du startest: das brauchst du
- Board: Raspberry Pi Pico, Pico W oder Pico 2. Für das Funkprojekt (Nummer 19) brauchst du einen Pico W.
- Steckbrett und Jumperkabel: damit du ohne Löten aufbauen kannst; achte darauf, dass die Stiftleisten am Pico angelötet sind.
- LEDs und Widerstände: 5–10 LEDs sowie Widerstände mit 220 Ω und 330 Ω; den passenden Vorwiderstand findest du mit dem LED-Vorwiderstandsrechner.
- Eingaben: 2–3 Taster, ein 10-kΩ-Potentiometer, ein LDR und ein 10-kΩ-Widerstand.
- Sensoren und Ausgänge: HC-SR04, DHT11, HC-SR501 PIR, ein passiver Summer, ein SG90-Servo, ein 0,96-Zoll-OLED mit SSD1306 und ein WS2812B-Ring mit 8–12 LEDs.
- Software: Thonny für MicroPython, die Arduino IDE mit dem RP2040-Core von Earle Philhower für C/C++.
MicroPython oder C/C++?
Der Pico beherrscht beide Welten, und die meisten Projekte dieser Liste lassen sich in beiden Sprachen schreiben. In MicroPython tippst du den Code in Thonny, klickst auf Ausführen und siehst das Ergebnis in einer Sekunde; bei einem Fehler bekommst du eine klare Meldung mit Zeilennummer. C/C++ (Arduino IDE oder Pico SDK) muss erst kompiliert werden, läuft dafür aber 10- bis 100-mal schneller und gibt dir Zugriff auf Tausende Arduino-Bibliotheken. Als Einsteiger machst du die ersten 19 Projekte in MicroPython und wechselst zu C/C++, wenn du Tempo oder eine fertige Bibliothek brauchst.
| Kriterium | MicroPython | C/C++ (Arduino IDE) |
|---|---|---|
| Einstieg | Leicht, Python-Grundlagen reichen | Vertraut, wenn du Arduino kennst |
| Code ausführen | Sofort (mit Thonny) | Kompilieren und Hochladen: 10–30 Sekunden |
| Geschwindigkeit | Langsamer, für die meisten Projekte genug | 10- bis 100-mal schneller |
| Bibliotheken | Eingebaute Module wie machine, neopixel, dht | Großteil der Arduino-Bibliotheken |
| Ideal für | Lernen, Sensoren auslesen, schnelle Tests | Genaues Timing, USB-Tastatur, viel Rechenarbeit |
20 Raspberry Pi Pico Projekte: Sprache, Bauteile und Schwierigkeit
| # | Projekt | Empfohlene Sprache | Benötigte Bauteile | Schwierigkeit |
|---|---|---|---|---|
| 1 | Eingebaute LED blinken lassen (Blink) | MicroPython | Nur der Pico | Leicht |
| 2 | Externe LED (GP14) | MicroPython | LED, 220-Ω-Widerstand | Leicht |
| 3 | Ampel | MicroPython | Rote, gelbe und grüne LED, 3 Widerstände | Leicht |
| 4 | Blaulicht-Effekt | MicroPython | Rote und blaue LED, 2 Widerstände | Leicht |
| 5 | Lauflicht (Knight Rider) | MicroPython | 6 LEDs, 6 Widerstände | Leicht |
| 6 | LED mit Taster ein- und ausschalten | MicroPython | Taster, LED, Widerstand | Leicht |
| 7 | Taster-Interrupt (IRQ) und Entprellen | MicroPython | Taster, LED, Widerstand | Mittel |
| 8 | PWM-Atemeffekt | MicroPython | LED, Widerstand | Leicht |
| 9 | RGB-LED-Farbwechsel | MicroPython | RGB-LED, 3 Widerstände | Leicht |
| 10 | Melodie mit passivem Summer | MicroPython | Passiver Summer | Leicht |
| 11 | LED-Helligkeit per Potentiometer | MicroPython | 10-kΩ-Potentiometer, LED | Leicht |
| 12 | Eingebauter Temperatursensor | MicroPython | Nur der Pico | Leicht |
| 13 | Automatisches Nachtlicht mit LDR | MicroPython | LDR, 10-kΩ-Widerstand, LED | Leicht |
| 14 | Bewegungsalarm mit PIR | MicroPython | HC-SR501, aktiver Summer | Leicht |
| 15 | Entfernungsmesser mit HC-SR04 | MicroPython | HC-SR04, Widerstände 1 kΩ und 2 kΩ | Mittel |
| 16 | OLED-Thermometer | MicroPython | SSD1306-OLED, DHT11 | Mittel |
| 17 | Servo per Potentiometer steuern | MicroPython | SG90-Servo, 10-kΩ-Potentiometer | Mittel |
| 18 | Animation auf einem WS2812B-Ring | MicroPython | WS2812B-Ring (8–12 LEDs) | Mittel |
| 19 | LED per WLAN mit dem Pico W schalten | MicroPython | Pico W, LED | Schwer |
| 20 | USB-Makro-Tastatur | C/C++ (Arduino IDE) | 3–4 Taster | Schwer |
Die Reihenfolge ist kein Zufall: Jedes Projekt setzt einen Schritt auf das, was du im vorherigen gelernt hast. Die ersten sechs zeigen digitale Ausgänge und Eingänge, 7–10 Interrupts und PWM, 11–15 analoge und digitale Sensoren, 16–18 Display, Servo und per PIO angesteuerte LEDs, und die letzten beiden Pico-typische Fähigkeiten wie WLAN und USB. Unten erklären wir jede Stufe mit ihrer Schaltung und geben dir den Code der lehrreichsten Projekte.
Stufe 1: LED- und Taster-Projekte (1–6)
Im ersten Projekt lässt du die eingebaute LED mit Pin(25) blinken (beim Pico W und Pico 2 W mit Pin("LED")). Im zweiten schließt du eine externe LED über einen 220-Ω-Widerstand an GP14 (physischer Pin 19) an; der Widerstand darf an der Anode oder an der Kathode sitzen, Hauptsache in Reihe. Die Ampel schaltet die drei LEDs an GP11, GP12 und GP13 nacheinander, das Blaulicht lässt eine rote und eine blaue LED in kurzen Salven aufblitzen, und das Lauflicht schickt einen Lichtpunkt über sechs LEDs an GP9–GP14 hin und her. Wenn du die Pins in einer Liste speicherst und mit einer for-Schleife durchgehst, wird der Code in diesen drei Projekten nur halb so lang.
Im sechsten Projekt kommt der Taster an GP2, sein anderes Bein an GND, und der interne Pull-up-Widerstand des Pico wird eingeschaltet: Losgelassen liest der Pin 1, gedrückt 0. Damit jeder Druck die LED umschaltet, speicherst du den vorherigen Tasterzustand in einer Variablen und zählst nur den Wechsel von 1 auf 0. Warum Taster prellen und wie Pull-ups funktionieren, steht in Taster am Arduino anschließen; dieselben Regeln gelten für den Pico.
Stufe 2: Taster-Interrupt, PWM und Ton (7–10)
Den Taster in der Schleife ständig abzufragen (Polling) reicht für einfache Projekte, aber wenn dein Code gerade mit etwas anderem beschäftigt ist, kann er Tastendrücke verpassen. Mit einem Interrupt (IRQ) ruft der Pico deine Funktion genau in dem Moment auf, in dem sich der Pegel am Pin ändert. Der folgende Code ist Projekt 7 komplett: Jeder Druck schaltet die LED an GP14 um, und ein Zeitfilter von 200 ms verhindert, dass das mechanische Prellen als Doppeldruck zählt.
1from machine import Pin
2import time
3
4led = Pin(14, Pin.OUT) # GP14 + 220 Ω direnç / GP14 + 220 Ω resistor
5button = Pin(2, Pin.IN, Pin.PULL_UP) # butonun diğer ucu GND / other leg to GND
6last_ms = 0 # son geçerli basış / last valid press
7
8def on_press(pin):
9 global last_ms
10 now = time.ticks_ms()
11 if time.ticks_diff(now, last_ms) > 200: # 200 ms sıçrama filtresi / 200 ms debounce
12 led.toggle()
13 last_ms = now
14
15button.irq(trigger=Pin.IRQ_FALLING, handler=on_press) # basınca 1→0 / press pulls 1→0
16
17while True:
18 time.sleep(1) # ana döngü boşta, iş kesmede / main loop idle, work in the IRQProjekt acht ist das klassische PWM-Beispiel. Jeder GPIO-Pin des Pico kann PWM ausgeben, und in MicroPython stellst du das Tastverhältnis mit duty_u16() zwischen 0 und 65535 ein. Steigerst du die Helligkeit linear, wirkt das fürs Auge unnatürlich: Unten ändert sie sich zu schnell, oben zu langsam. Der Code unten erzeugt mit einer Kosinuskurve einen weichen Atemrhythmus und quadriert den Wert, damit die Helligkeitskurve eher unserer Wahrnehmung entspricht. Die Grundlagen findest du in Was ist PWM?
1from machine import Pin, PWM
2import math, time
3
4led = PWM(Pin(14))
5led.freq(1000) # 1 kHz, titreme görünmez / 1 kHz, no visible flicker
6
7while True:
8 for step in range(200):
9 level = (1 - math.cos(step / 200 * 2 * math.pi)) / 2 # 0 → 1 → 0 yumuşak / smooth 0 → 1 → 0
10 led.duty_u16(int(level * level * 65535)) # kare alma göze doğal gelir / squaring looks natural
11 time.sleep_ms(15) # 200 × 15 ms = 3 s bir nefes / one 3 s breathIn Projekt neun überträgst du die Idee auf drei Kanäle: Schließ den roten, grünen und blauen Anschluss einer RGB-LED über je einen Widerstand an GP11, GP12 und GP13 an und verschiebe die drei Duty-Werte gegeneinander, dann fließen die Farben ineinander. Bei LEDs mit gemeinsamer Anode musst du die Werte umkehren; die Details stehen in RGB-LED verwenden. In Projekt zehn änderst du dagegen die PWM-Frequenz: Hängst du einen passiven Summer an einen Pin und schreibst freq(440), erklingt der Kammerton A; ein Duty von 32768 (50 Prozent) ist am lautesten, und eine Schleife über eine Notenliste ergibt eine Melodie.
Stufe 3: Sensor-Projekte (11–15)
Die analogen Eingänge des Pico sind GP26, GP27 und GP28, und read_u16() liefert einen Wert von 0 bis 65535 (intern misst der Chip mit 12 Bit, MicroPython skaliert auf 16 Bit). In Projekt elf verbindest du den Schleifer eines Potentiometers mit GP26 und schreibst den Messwert direkt als Duty-Wert in die LED. Projekt zwölf braucht kein zusätzliches Bauteil: Kanal 4 des ADC hängt an einem Temperatursensor im Chip, und die Temperatur ergibt sich aus T = 27 − (U − 0,706) / 0,001721. Weil er die Chip- und nicht die Raumtemperatur misst, kann er ein paar Grad danebenliegen. In Projekt dreizehn baust du aus LDR und 10-kΩ-Widerstand einen Spannungsteiler und schaltest eine LED ein, sobald der Messwert eine Dunkelschwelle überschreitet; mit dem Spannungsteiler-Rechner ist die Rechnung schnell erledigt.
Der PIR-Sensor HC-SR501 aus Projekt vierzehn wird mit 5 V versorgt, sein Ausgang liefert aber 3,3 V und darf deshalb direkt an einen GPIO; erkennt er Bewegung, geht der Pin für ein paar Sekunden auf 1. Zu den Reglern für Zeit und Empfindlichkeit siehe PIR-Bewegungsmelder. Projekt fünfzehn erfordert etwas mehr Sorgfalt: Der HC-SR04 läuft mit 5 V, und sein ECHO-Pin gibt einen 5-V-Impuls aus. Der Code unten schickt einen 10-Mikrosekunden-Impuls an TRIG, misst mit time_pulse_us() die Dauer des Echos und berechnet daraus über die Schallgeschwindigkeit die Entfernung.
1from machine import Pin, time_pulse_us
2import time
3
4trig = Pin(17, Pin.OUT) # GP17 → TRIG
5echo = Pin(16, Pin.IN) # GP16 ← ECHO (1 kΩ + 2 kΩ bölücüyle / through a 1k + 2k divider)
6
7def distance_cm():
8 trig.low()
9 time.sleep_us(2)
10 trig.high()
11 time.sleep_us(10) # 10 µs tetik darbesi / 10 µs trigger pulse
12 trig.low()
13 t = time_pulse_us(echo, 1, 30000) # en çok 30 ms bekle (~5 m) / wait up to 30 ms (~5 m)
14 if t < 0:
15 return None # yankı yok / no echo
16 return t * 0.0343 / 2 # 343 m/s, gidiş-dönüş / round trip
17
18while True:
19 d = distance_cm()
20 print("Mesafe / Distance:", "---" if d is None else "%.1f cm" % d)
21 time.sleep_ms(200)Stufe 4: OLED-Display, Servo und NeoPixel (16–18)
In Projekt sechzehn zeigst du Temperatur und Luftfeuchtigkeit eines DHT11 auf einem 0,96-Zoll-OLED an. Das dht-Modul für den DHT11 ist in der MicroPython-Firmware des Pico bereits enthalten; für das OLED kopierst du die Treiberdatei ssd1306.py auf den Pico. Das Display hängt per I2C an GP4 (SDA) und GP5 (SCL). Den Display-Code erklärt OLED-Display SSD1306 verwenden, den Sensor DHT11 Temperatur- und Feuchtigkeitssensor.
In Projekt siebzehn drehst du einen SG90-Servo mit einem Potentiometer. Ein Servo erwartet ein 50-Hz-Signal und liest den Winkel aus der Impulsbreite: etwa 500 Mikrosekunden entsprechen 0 Grad, 2500 Mikrosekunden 180 Grad. In MicroPython kannst du mit duty_ns() die Impulsbreite direkt in Nanosekunden angeben, was die Rechnung sehr einfach macht:
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15)) # GP15 → servo sinyal (turuncu) / signal (orange)
5servo.freq(50) # 50 Hz = 20 ms periyot / 20 ms period
6pot = ADC(26) # GP26 (ADC0) ← potansiyometre orta ucu / pot wiper
7
8def set_angle(angle):
9 pulse_us = 500 + angle * 2000 // 180 # 0° = 500 µs, 180° = 2500 µs
10 servo.duty_ns(pulse_us * 1000)
11
12while True:
13 angle = pot.read_u16() * 180 // 65535 # 0–65535 → 0–180°
14 set_angle(angle)
15 time.sleep_ms(20) # her periyotta bir güncelleme / one update per periodIn Projekt achtzehn steuerst du einen WS2812B-LED-Ring mit dem eingebauten neopixel-Modul von MicroPython. Diese LEDs verlangen ein Timing auf die Mikrosekunde genau; der Pico erledigt das, ohne den Prozessor zu blockieren, mit seinen programmierbaren I/O-Blöcken, der PIO. Wie du PIO und den zweiten Kern nutzt, zeigen wir Schritt für Schritt in Pico PIO und zwei Kerne. Ein kleiner Ring mit 8–12 LEDs läuft am VBUS-Pin; längere Streifen brauchen ein eigenes 5-V-Netzteil.
Stufe 5: WLAN und USB-Tastatur mit dem Pico W (19–20)
In Projekt neunzehn verbindet sich der Pico W mit deinem Heimnetz und schaltet eine LED über Schaltflächen auf einer Webseite, die du am Handy öffnest. Mit den MicroPython-Modulen network und socket schreibst du einen funktionierenden Webserver in 40–50 Zeilen; die Einrichtung Schritt für Schritt steht in Pico W WLAN-Webserver. In Projekt zwanzig meldet sich dein Pico am Computer als Tastatur an: Gib jedem Taster ein Tastenkürzel oder einen Text, und schon hast du dein eigenes Makro-Pad. Hier ist C/C++ der einfachere Weg, denn der Pico-Core für die Arduino IDE bringt die Keyboard-Bibliothek gleich mit.
Dasselbe Projekt in C/C++: der Pico in der Arduino IDE
Sobald du in der Arduino IDE über den Boardverwalter das Paket Raspberry Pi Pico/RP2040 von Earle Philhower installiert hast, programmierst du den Pico mit den gewohnten Arduino-Befehlen. Als Pinnummer verwendest du die GP-Nummer (14 für GP14), analogWrite() arbeitet standardmäßig im Bereich 0–255 und attachInterrupt() funktioniert an jedem Pin. Beim ersten Hochladen musst du den Pico eventuell mit gedrückter BOOTSEL-Taste einstecken. Der Code unten verbindet die Projekte 7 und 8: Die LED atmet, stoppt beim Tastendruck und macht beim nächsten Druck weiter.
1// Arduino IDE + Raspberry Pi Pico (Earle Philhower çekirdeği / core)
2const int LED_PIN = 14; // GP14 (fiziksel pin 19 / physical pin 19)
3const int BUTTON_PIN = 2; // GP2, diğer ucu GND / other leg to GND
4
5volatile bool breathing = true; // kesmede değişir / changed in the interrupt
6volatile unsigned long lastPress = 0;
7
8void onPress() {
9 unsigned long now = millis();
10 if (now - lastPress > 200) { // 200 ms sıçrama filtresi / 200 ms debounce
11 breathing = !breathing;
12 lastPress = now;
13 }
14}
15
16void setup() {
17 pinMode(LED_PIN, OUTPUT);
18 pinMode(BUTTON_PIN, INPUT_PULLUP);
19 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onPress, FALLING);
20}
21
22void loop() {
23 if (!breathing) { // butonla durdurulduysa LED sönük / paused by the button
24 analogWrite(LED_PIN, 0);
25 return;
26 }
27 for (int v = 0; v <= 255; v++) { analogWrite(LED_PIN, v); delay(4); } // yavaşça yan / fade in
28 for (int v = 255; v >= 0; v--) { analogWrite(LED_PIN, v); delay(4); } // yavaşça sön / fade out
29}Häufige Fehler und ihre Lösung
- Falsche Pinnummer: Im Code steht die GP-Nummer, nicht die physische Pinnummer. GP14 ist Pin 19 am Board; die komplette Belegung siehst du im Pinout-Tool.
- Die eingebaute LED leuchtet am Pico W nicht: Beim Pico W hängt die LED am Funkchip; schreib Pin("LED") statt Pin(25).
- Der Code läuft nicht mehr, sobald der Computer getrennt ist: Speichere die Datei auf dem Pico als main.py; nur diese Datei startet der Pico beim Einschalten von selbst.
- Der Servo zittert oder der Pico startet neu: Der Servo hängt an 3V3 oder die Massen sind nicht verbunden; versorge ihn mit 5 V und setz einen 470-µF-Kondensator an die Versorgung.
- Der Analogwert ist immer 0 oder immer 65535: Der Sensor hängt an einem anderen Pin als GP26–GP28, oder du liest einen äußeren Anschluss des Potentiometers statt des Schleifers.
- duty() aus älteren Beispielen erzeugt einen Fehler: Auf dem Pico nutzt MicroPython für PWM duty_u16() oder duty_ns().
- Ein Tastendruck wird mehrfach erkannt: Das ist Prellen; ergänze einen Zeitfilter von 150–200 ms wie im Interrupt-Code.
Wenn du diese 20 Projekte der Reihe nach gebaut hast, hast du die digitalen Ein- und Ausgänge, Interrupts, PWM, den ADC, I2C, PIO und WLAN des Pico genutzt, und damit fast alles, was du zum Entwerfen eigener Projekte brauchst. Um in MicroPython sicherer zu werden, ist MicroPython Grundlagen ein guter nächster Schritt. In der BlueGrays App findest du Pico-Projekte wie die eingebaute LED, die Ampel, das Blaulicht, das Lauflicht, den Taster-Interrupt, den PWM-Atemeffekt und den RGB-Farbwechsel Schritt für Schritt mit Schaltplan und Code.
Häufige Fragen
Was kann man mit einem Raspberry Pi Pico machen?
Du kannst LED-Effekte, Messgeräte mit Sensoren, OLED-Thermometer, Servo- und Motorsteuerungen, USB-Tastaturen und Gamecontroller bauen, mit dem Pico W auch Hausautomation, die du vom Handy aus steuerst. Der Pico ist ein Mikrocontroller und kein Computer, für Videos oder Desktop-Programme ist er also nicht gedacht.
Ist der Raspberry Pi Pico für Anfänger geeignet?
Ja. Mit MicroPython nutzt du dein Python-Wissen direkt und führst Code ohne Kompilieren aus. Wichtig ist vor allem, dass die Pins mit 3,3 V arbeiten; Sensoren mit 5-V-Ausgang schließt du über einen Spannungsteiler oder Pegelwandler an.
Soll ich für den Pico MicroPython oder C++ lernen?
Wenn Programmieren und Elektronik für dich neu sind, fang mit MicroPython an: Die Fehlermeldungen sind verständlich und du testest schneller. Zu C/C++ wechselst du, wenn du genaues Timing, mehr Tempo oder eine reine Arduino-Bibliothek brauchst; der Pico kann beides.
Kann der Raspberry Pi Pico einen Servo direkt ansteuern?
Beim Signal ja: Jeder GPIO-Pin steuert einen Servo wie den SG90 mit 50-Hz-PWM. Die Versorgung des Servos sollte aber von VBUS oder einem externen 5-V-Netzteil kommen und nicht vom 3V3-Pin, und die Massen müssen verbunden sein.
Was ist der Unterschied zwischen Pico und Pico W?
Beide nutzen denselben RP2040-Chip; der Pico W hat zusätzlich einen Chip für 2,4-GHz-WLAN und Bluetooth. Alle Projekte ohne WLAN laufen auf beiden, nur die eingebaute LED steuerst du beim Pico W mit Pin("LED").
Läuft Arduino-Code auf dem Raspberry Pi Pico?
Mit dem RP2040-Paket von Earle Philhower in der Arduino IDE laufen die meisten Arduino-Sketche mit kleinen Änderungen, wobei die Pins mit GP-Nummern angegeben werden. Code mit AVR-spezifischen Registern oder Schaltungen, die 5-V-Logik voraussetzen, musst du anpassen.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Raspberry Pi Pico Onboard-LED Blinken (Pico und Pico W)
Das Auftaktprojekt der Raspberry-Pi-Pico-Reihe! Wir lassen die grüne eingebaute LED des Pico blinken und prüfen so, ob das Board funktioniert: das klassische "Hello World" als erstes Experiment. Keine externen Bauteile nötig, nur der Pico und ein USB-Kabel. Der Code ist in MicroPython geschrieben, der Sprache, die die Raspberry Pi Foundation offiziell unterstützt.

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.

Raspberry Pi Pico Ampel-Simulator (3 LEDs sequenziell)
Wir simulieren eine echte Ampel mit roten, gelben und grünen LEDs. Grün 4 Sek "gehen", gelb 1,5 Sek "bereit", rot 3 Sek "stopp" und rot+gelb 1 Sek "starten" (europäisches Ampelmuster). Lerne Funktionsdefinition, Zustandsmaschinen-Logik und Multi-GPIO-Synchronisation. Sehr einfache Schaltung: 3 LEDs an GP11/GP12/GP13, jeweils mit 220Ω Widerstand.

Raspberry Pi Pico Polizeilicht-Effekt (Rot + Blau Strobe)
Wir simulieren das Blaulicht eines Polizeiautos mit einem Raspberry Pi Pico in seiner einfachsten Form! Die rote und die blaue LED leuchten abwechselnd (Flip-Flop): Leuchtet Rot, ist Blau aus, alle 0,3 Sekunden tauschen sie, endlos. Der Code schreibt die zwei Schritte direkt in eine einzige while True-Schleife; die Geschwindigkeit legt die Konstante WAIT_MS fest.

Raspberry Pi Pico Knight Rider LED-Scanner (6 LED Hin-Zurück)
Klassischer "Knight Rider"-LED-Scanner-Effekt mit Pico! 6 LEDs gehen von links nach rechts, dann von rechts nach links, für immer. Lerne reversed() und zwei getrennte for-Schleifen für Hin-Zurück-Muster.

Raspberry Pi Pico Taster Debounce: IRQ vs Software Polling
Einmal Taster gedrückt, Code zählt 3-4? Das ist Contact Bounce! Vergleiche 2 Zählmethoden in Serial: RAW Polling (fängt Bounce, zählt falsch) vs IRQ + Software Debounce (genau). Lerne Contact Bounce Physik, Software Debounce, Pin.irq() Interrupt, IRQ_FALLING Trigger, ISR Handler, global Variablen ISR-Sicherheit.

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

Raspberry Pi Pico RGB-LED Farbwechsel (3-Kanal-PWM)
Eine LED, Millionen Farben! Eine RGB-LED enthält 3 LEDs: Rot, Grün und Blau. Mit je einem PWM-Kanal des Pico mischst du Farben: Rot + Grün = Gelb, Grün + Blau = Cyan, alle drei = Weiß. Die LED wechselt durch 8 Farben. Lerne mehrere PWM-Kanäle, Funktionen (def), RGB-Farbmischung, 8-Bit → 16-Bit-Umrechnung (x257) und gemeinsame Kathode vs. Anode.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

