Raspberry Pi Pico W Projekte: 15 Ideen mit WLAN und Bluetooth
15 Raspberry Pi Pico W Projekte: Webserver, MQTT, NTP-Uhr, Wetteranzeige, Telegram und BLE. MicroPython-Code, Speichergrenzen und Vergleich Pico W oder ESP32.
Suchst du Raspberry Pi Pico W Projekte, findest du in dieser Liste 15 realistische Projekte, mit denen du die WLAN- und Bluetooth-Funktionen des Boards von leicht bis schwer nutzt: ein Webserver, der per Handy eine LED schaltet, eine NTP-Uhr, die ihre Zeit aus dem Internet holt, eine Station, die Sensordaten per MQTT veröffentlicht, ein Alarm, der beim Öffnen der Tür eine Telegram-Nachricht schickt, und ein BLE-Temperatursensor, den du mit dem Handy ausliest, sind nur einige davon. Alle Projekte laufen mit demselben Code auf dem Pico W und dem neuen Pico 2 W.
Bauteile, Verbindungsart und Schwierigkeit jedes Projekts haben wir in einer Tabelle gesammelt, und für die fünf wichtigsten gibt es vollständigen MicroPython-Code. Danach folgen die Speichergrenzen des Pico W unter MicroPython, häufige Fehler und eine Vergleichstabelle, welches Projekt besser mit dem Pico W und welches besser mit einem ESP32 gelingt. Nutzt du das Board zum ersten Mal, wirf vorher einen Blick in den Beitrag Was ist ein Raspberry Pi Pico.

Pico W und Pico 2 W: Was ist der Unterschied?
Der Pico W ist der klassische Pico mit zusätzlichem Funkchip CYW43439 von Infineon: Er bietet 2,4-GHz-WLAN (802.11n) und Bluetooth 5.2 (Classic und BLE). Der Pico 2 W kombiniert denselben Funkchip mit dem stärkeren Prozessor RP2350; der RAM verdoppelt sich, der Flash wächst auf 4 MB. Pinbelegung, Größe und der meiste MicroPython-Code sind bei beiden Boards gleich. Da der Funkchip einige interne Pins belegt, sitzt die Onboard-LED nicht mehr an GP25, sondern am Funkchip und wird mit Pin("LED") gesteuert.
| Eigenschaft | Pico W | Pico 2 W |
|---|---|---|
| Prozessor | RP2040, 2 × Cortex-M0+, 133 MHz | RP2350, 2 × Cortex-M33 (oder RISC-V), 150 MHz |
| RAM | 264 KB | 520 KB |
| Flash | 2 MB | 4 MB |
| Funk | CYW43439: 2,4-GHz-WLAN 4, Bluetooth 5.2 | CYW43439: 2,4-GHz-WLAN 4, Bluetooth 5.2 |
| GPIO / ADC | 26 GPIO, 3 Analogeingänge (12 Bit) | 26 GPIO, 3 Analogeingänge (12 Bit) |
| Onboard-LED | Pin("LED") | Pin("LED") |
| MicroPython-Firmware | RPI_PICO_W | RPI_PICO2_W |
Bevor du anfängst: MicroPython und Bibliotheken
- Richtige Firmware flashen: Nimm für den Pico W die MicroPython-UF2-Datei RPI_PICO_W und für den Pico 2 W RPI_PICO2_W. Die normale Pico-Firmware hat kein network-Modul, WLAN-Code bricht dann mit "no module named network" ab.
- Thonny verwenden: Wähle in Thonny unten rechts "MicroPython (Raspberry Pi Pico)"; Thonny führt Code aus, kopiert Dateien aufs Board und gleicht die Uhr des Boards mit deinem Computer ab. Die Grundbefehle von MicroPython erklärt der Beitrag MicroPython-Grundlagen.
- Zusatzpakete mit mip installieren: Nach der WLAN-Verbindung tippst du in der Shell import mip; mip.install("umqtt.simple") oder mip.install("aioble") und lädst das Paket direkt aufs Board. Das Menü Extras > Pakete verwalten in Thonny macht dasselbe.
- Nur 2,4 GHz: Der Pico W verbindet sich nicht mit 5-GHz-Netzen; senden beide Bänder des Routers unter demselben Namen, kann die Verbindung Probleme machen.
- Stromversorgung: Beim Senden über WLAN kann der Spitzenstrom 100 mA überschreiten. Nimm ein gutes USB-Kabel und ein Netzteil mit mindestens 500 mA.
| Modul | Wofür? | Eingebaut? |
|---|---|---|
| network | WLAN-Verbindung, Access Point, Netzwerkscan | Ja (in der W-Firmware) |
| socket / asyncio | Webserver, UDP, parallele Aufgaben | Ja |
| requests | HTTP- und HTTPS-Anfragen, JSON | Ja |
| ntptime | Uhrzeit aus dem Internet | Ja |
| bluetooth | BLE auf niedriger Ebene | Ja |
| aioble | Einfaches BLE: Services, Characteristics, Advertising | Je nach Version; sonst mip.install("aioble") |
| umqtt.simple | MQTT-Client | Je nach Version; sonst mip.install("umqtt.simple") |
Der WLAN-Code für alle Projekte
Speichere die folgende Datei in Thonny als wifi.py auf dem Pico W. Dann reichen in allen anderen Projekten import wifi und wifi.connect(). Die Onboard-LED blinkt beim Verbinden und leuchtet dauerhaft, sobald die Verbindung steht; so siehst du den Verbindungsstatus am einfachsten, wenn das Board nicht am Computer hängt.
1# wifi.py: Pico W'ye bu adla kaydet / save it to the Pico W with this name
2import network, time
3from machine import Pin
4
5SSID = "AgAdi" # Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
6PASSWORD = "Sifre123" # Wi-Fi şifren / your Wi-Fi password
7led = Pin("LED", Pin.OUT) # Pico W ve Pico 2 W dahili LED / onboard LED
8
9
10def connect(timeout=20):
11 network.country("TR") # ülke kodu: kanal ve güç sınırları / country code
12 wlan = network.WLAN(network.STA_IF)
13 wlan.active(True)
14 if not wlan.isconnected():
15 wlan.connect(SSID, PASSWORD)
16 for _ in range(timeout * 2):
17 if wlan.status() < 0 or wlan.status() == 3:
18 break
19 led.toggle() # bağlanırken yanıp söner / blinks while connecting
20 time.sleep(0.5)
21 if wlan.status() != 3:
22 led.off()
23 raise RuntimeError("Wi-Fi hatasi / error: %d" % wlan.status())
24 led.on() # bağlandı / connected
25 print("IP:", wlan.ifconfig()[0], "RSSI:", wlan.status("rssi"), "dBm")
26 return wlanwlan.status() verrät, in welcher Phase die Verbindung ist: 3 heißt verbunden mit IP-Adresse, 1 verbindet gerade, −2 Netz nicht gefunden, −3 falsches Passwort und −1 aus anderem Grund fehlgeschlagen. Sobald der Code einen Wert unter 0 sieht, hört er auf zu warten und meldet den Fehler klar. RSSI ist die Signalstärke: −50 dBm ist sehr gut, −70 dBm akzeptabel, −80 dBm und weniger eine Verbindung mit Aussetzern. Die Zeile network.country("TR") stellt Kanäle und Sendeleistung des Funkchips nach den Regeln des Landes ein; in Deutschland schreibst du "DE", in Österreich "AT".
15 Raspberry Pi Pico W Projekte: Tabelle
| # | Projekt | Verbindung | Zusätzliche Teile | Schwierigkeit |
|---|---|---|---|---|
| 1 | Mit dem WLAN verbinden und den Status per Onboard-LED zeigen | WLAN | Keine | Leicht |
| 2 | Webserver, der LED und Relais per Handy steuert | WLAN, HTTP | LED, Relaismodul | Leicht |
| 3 | Live aktualisierte Temperaturanzeige im Browser | WLAN, HTTP + JSON | Interner Sensor oder DHT22 | Mittel |
| 4 | NTP-Uhr mit Zeit aus dem Internet (mit OLED) | WLAN, NTP | 0,96"-OLED | Leicht |
| 5 | Access-Point-Modus (AP) für die Steuerung ohne Router | WLAN-AP | Keine | Mittel |
| 6 | WLAN-Scanner und Signalmesser | WLAN | OLED (optional) | Leicht |
| 7 | Sensordaten per MQTT veröffentlichen | WLAN, MQTT | Interner Sensor | Mittel |
| 8 | Sensor, der sich per MQTT mit Home Assistant verbindet | WLAN, MQTT | DHT22 | Mittel |
| 9 | Wetteranzeige | WLAN, HTTPS + JSON | OLED | Mittel |
| 10 | Telegram-Nachricht beim Öffnen der Tür | WLAN, HTTPS | Reedkontakt oder PIR | Mittel |
| 11 | Nachrichten zwischen zwei Pico W per UDP | WLAN, UDP | Zweiter Pico W, Taster, LED | Mittel |
| 12 | Datenaufzeichnung und Diagramme bei ThingSpeak | WLAN, HTTP | Beliebiger Sensor | Leicht |
| 13 | BLE-Temperatursensor, den das Handy ausliest | BLE | Keine | Mittel |
| 14 | BLE-Fernbedienung für LED oder Servo per Handy | BLE (UART-Service) | LED oder Servo | Schwer |
| 15 | Bluetooth-Tastatur und Präsentationsfernbedienung | BLE HID (Arduino IDE) | 2 Taster | Schwer |
Stufe 1: WLAN- und Webprojekte (1–6)
Das erste Projekt ist die obige wifi.py selbst; die LED, die beim Verbinden blinkt und danach leuchtet, ist eine kleine, aber sehr praktische Anzeige. Im zweiten Projekt wird der Pico W zum Webserver: Öffnest du seine IP-Adresse auf dem Handy, senden die Schaltflächen EIN und AUS auf der Seite /on oder /off in der Adresse; der Code liest das aus und schaltet LED oder Relais. Ein vollständiges Socket-Beispiel und den Relaisanschluss findest du im Beitrag Pico-W-Webserver. Im dritten Projekt lädt die Seite nicht neu; ein kleines JavaScript im Browser holt alle zwei Sekunden JSON von /data, und der Pico W liest den internen Temperatursensor (ADC4) oder einen DHT22 und liefert den Wert dort aus. So aktualisiert sich die Seite live und ohne Flackern.
Das vierte Projekt ist eine Tischuhr, die ihre Zeit aus dem Internet holt. ntptime.settime() stellt die interne Uhr des Boards auf UTC; für Deutschland musst du eine Stunde und während der Sommerzeit zwei Stunden addieren, die Umstellung rechnest du im Code aus. Im fünften Projekt verbindet sich der Pico W nicht mit einem Router, sondern baut sein eigenes Netz auf: Du verbindest das Handy mit dem per network.WLAN(network.AP_IF) erstellten Netz "PicoW" und öffnest die Steuerseite unter 192.168.4.1; das ist im Garten oder in der Schule praktisch, überall dort, wo kein Router ist. Das sechste Projekt listet mit wlan.scan() die Netze in der Nähe samt Kanal und Signalstärke; trag den Pico W in verschiedene Ecken der Wohnung und entscheide anhand des RSSI-Werts, wo ein Sensor hin soll.
1import time, ntptime
2import wifi
3
4UTC_OFFSET = 3 * 3600 # Türkiye UTC+3; kendi saat dilimin / your own time zone
5wifi.connect()
6ntptime.settime() # dahili saati UTC'ye ayarla / set the internal clock to UTC
7
8while True:
9 t = time.localtime(time.time() + UTC_OFFSET)
10 print("%02d:%02d:%02d %02d.%02d.%04d" % (t[3], t[4], t[5], t[2], t[1], t[0]))
11 if t[4] == 0 and t[5] == 0: # her saat başı yeniden eşitle / resync every hour
12 try:
13 ntptime.settime()
14 except OSError:
15 pass
16 time.sleep(1)Stufe 2: Internetdienste: MQTT, Wetter, Telegram (7–12)
MQTT ist der verbreitetste Kommunikationsweg für IoT-Geräte: Der Pico W schickt seinen Messwert an ein Topic auf einem Broker-Server, und Handy, Computer oder Home Assistant, die das Topic abonniert haben, erhalten die Nachricht sofort. Du musst weder die IP-Adresse des Boards kennen noch Ports im Router öffnen. Im siebten Projekt veröffentlichen wir den internen Temperatursensor alle zehn Sekunden; im achten erscheint ein DHT22-Sensor, der nach demselben Prinzip eine MQTT-Discovery-Nachricht sendet, von selbst in Home Assistant. Die Einrichtung auf Home-Assistant-Seite erklärt der Beitrag ESP32, MQTT und Home Assistant, und sie gilt für den Pico W genauso.
1import time
2from machine import ADC
3from umqtt.simple import MQTTClient
4import wifi
5
6BROKER = "test.mosquitto.org" # kendi broker'ın / your own broker
7TOPIC = b"bluegrays/picow/sicaklik"
8sensor = ADC(4) # dahili sıcaklık sensörü / internal temperature sensor
9
10
11def read_temp():
12 volts = sensor.read_u16() * 3.3 / 65535
13 return 27 - (volts - 0.706) / 0.001721
14
15
16wifi.connect()
17client = MQTTClient("picow-bluegrays", BROKER, keepalive=60)
18client.connect()
19
20while True:
21 msg = "%.1f" % read_temp()
22 client.publish(TOPIC, msg.encode()) # her 10 sn yayınla / publish every 10 s
23 print("gonderildi / sent:", msg)
24 time.sleep(10)Das neunte Projekt ist eine Wetteranzeige: Der Pico W schickt mit requests eine HTTPS-Anfrage an einen kostenlosen Wetterdienst ohne API-Schlüssel, nimmt aus der JSON-Antwort Temperatur und Wettercode und schreibt sie aufs OLED. Hier zählt der Speicher: Damit die Antwort klein bleibt, fragst du nur die Felder ab, die du brauchst. Das zehnte Projekt gehört zu den nützlichsten im Haushalt: Öffnet sich ein Reedkontakt an der Tür, schickt der Pico W über einen Telegram-Bot sofort eine Nachricht aufs Handy. Wie du den Bot anlegst und Token und Chat-ID bekommst, steht im Beitrag ESP32-Telegram-Bot; am Ende desselben Beitrags gibt es auch eine erweiterte Pico-W-Version, die Befehle annimmt.
1import time, requests
2from machine import Pin
3import wifi
4
5TOKEN = "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # BotFather token'ı / token from BotFather
6CHAT_ID = 123456789 # kendi Telegram ID'n / your Telegram ID
7URL = "https://api.telegram.org/bot%s/sendMessage" % TOKEN
8door = Pin(15, Pin.IN, Pin.PULL_UP) # reed röle -> GND; kapı açılınca 1 / reed switch, 1 when open
9
10
11def send(text):
12 try:
13 r = requests.post(URL, json={"chat_id": CHAT_ID, "text": text})
14 r.close() # belleği geri ver / free the memory
15 except OSError as e:
16 print("gonderilemedi / failed:", e)
17
18
19wifi.connect()
20last = door.value()
21while True:
22 now = door.value()
23 if now != last:
24 send("Kapi acildi / door opened" if now else "Kapi kapandi / door closed")
25 last = now
26 time.sleep_ms(100)Im elften Projekt schicken sich zwei Pico W im selben Netz UDP-Pakete: Drückst du den Taster am einen, leuchtet die LED am anderen. UDP arbeitet ohne Verbindungsaufbau, ist sehr schnell und in wenigen Zeilen geschrieben, garantiert aber nicht, dass das Paket ankommt; bei wichtigen Befehlen ist es eine gute Gewohnheit, auf eine kurze "angekommen"-Antwort der Gegenseite zu warten. Im zwölften Projekt werden die Messwerte alle 20 Sekunden per HTTP-Anfrage an einen kostenlosen IoT-Dienst wie ThingSpeak geschickt; der Dienst speichert die Daten und zeichnet fertige Diagramme im Browser. Denk daran, dass kostenlose Tarife die Sendehäufigkeit begrenzen.
Stufe 3: Bluetooth-Projekte (13–15)
Unter MicroPython nutzt der Pico W Bluetooth als BLE (Bluetooth Low Energy). Ein BLE-Gerät bietet einen oder mehrere Services an, und jeder Service enthält Characteristics, die gelesen werden oder Benachrichtigungen senden. Im dreizehnten Projekt nutzen wir den standardisierten Environmental-Sensing-Service (0x181A) und die Temperature-Characteristic (0x2A6E), damit allgemeine BLE-Apps wie nRF Connect den Wert direkt in °C anzeigen. Der Code basiert auf dem Paket aioble; fehlt es auf deinem Board, installierst du es zuerst mit mip. Die BLE-Begriffe erklärt der Beitrag ESP32, Bluetooth und BLE ausführlich.
1import asyncio, struct, bluetooth, aioble
2from machine import ADC
3
4ENV_SENSE = bluetooth.UUID(0x181A) # Environmental Sensing servisi / service
5TEMP_CHAR = bluetooth.UUID(0x2A6E) # Temperature karakteristiği / characteristic
6sensor = ADC(4)
7
8service = aioble.Service(ENV_SENSE)
9temp_char = aioble.Characteristic(service, TEMP_CHAR, read=True, notify=True)
10aioble.register_services(service)
11
12
13def read_temp():
14 volts = sensor.read_u16() * 3.3 / 65535
15 return 27 - (volts - 0.706) / 0.001721
16
17
18async def measure():
19 while True:
20 t = int(read_temp() * 100) # 0,01 °C birimi / unit of 0.01 °C
21 temp_char.write(struct.pack("<h", t), send_update=True)
22 await asyncio.sleep(2)
23
24
25async def advertise():
26 while True:
27 async with await aioble.advertise(
28 250_000, name="PicoW-Temp", services=[ENV_SENSE], appearance=768
29 ) as connection:
30 print("baglandi / connected:", connection.device)
31 await connection.disconnected(timeout_ms=None)
32
33
34async def main():
35 await asyncio.gather(measure(), advertise())
36
37
38asyncio.run(main())Im vierzehnten Projekt ahmt der Pico W ein verbreitetes BLE-Schema nach, den Nordic UART Service (NUS); Texte wie "on", "off" oder "90" aus einer BLE-Terminal-App auf dem Handy schalten am Pico W die LED oder drehen den Servo. Das fünfzehnte Projekt entsteht in der Arduino IDE: Die Bibliothek KeyboardBLE im Raspberry Pi Pico/RP2040-Core von Earle Philhower lässt den Pico W bei Computer und Handy als Bluetooth-Tastatur erscheinen. Nachdem du im Menü Werkzeuge den Bluetooth-Stack aktiviert hast, baust du mit zwei Tastern eine Fernbedienung, die in Präsentationen zur nächsten und vorherigen Folie springt.
Speichergrenzen und Stabilität
Der Speicher, den MicroPython auf dem Pico W nutzen kann, ist nur ein Teil der 264 KB RAM des Boards; Firmware, WLAN-Treiber und Netzwerkpuffer belegen den Rest. Für einfache Projekte reicht das locker, kommen aber HTTPS-Anfragen, große JSON-Antworten und lange HTML-Seiten zusammen, kann ein MemoryError auftreten. Jede HTTPS-Verbindung reserviert für die Verschlüsselung vorübergehend 30–50 KB, und eine JSON-Antwort von 20 KB belegt den Speicher doppelt, erst als Text und dann als Dictionary. Der doppelte RAM des Pico 2 W entschärft diese Grenze deutlich.
| Ressource | Pico W | Pico 2 W | Hinweis |
|---|---|---|---|
| RAM gesamt | 264 KB | 520 KB | Ein Teil gehört Firmware und WLAN |
| Freier Speicher beim Start (gc.mem_free) | Etwa 150–190 KB | Etwa 400 KB und mehr | Je nach Version verschieden; auf dem eigenen Board messen |
| Flash / Dateisystem | 2 MB / etwa 850 KB | 4 MB / über 2 MB | Hier liegen Code, HTML und Logdateien |
| Eine HTTPS-Verbindung | Vorübergehend 30–50 KB | Vorübergehend 30–50 KB | Nach Gebrauch mit r.close() freigeben |
| WLAN und BLE gleichzeitig | Funktioniert, Speicher wird noch knapper | Läuft entspannt | Erst einzeln testen, dann kombinieren |
Pico W oder ESP32? Welches Projekt passt zu welchem Board?
| Projektart | Pico W | ESP32 | Empfehlung |
|---|---|---|---|
| Einfacher Webserver, LED- und Relaissteuerung | Kein Problem | Kein Problem | Beide; Pico W, wenn du MicroPython lernst |
| MQTT-Sensor und Home Assistant | Funktioniert gut | Sehr gut, mit ESPHome ganz ohne Code | ESP32 |
| Kamera und Bildübertragung | Nicht vorhanden | Mit dem ESP32-CAM möglich | ESP32 |
| Sensor, der monatelang mit Batterie läuft | Unter MicroPython bleibt der Schlafstrom hoch | Mit Deep Sleep im Mikroamperebereich | ESP32 |
| Bluetooth-Classic-Audio (A2DP-Lautsprecher) | Eingeschränkte Unterstützung | Vom klassischen ESP32 unterstützt | ESP32 |
| BLE-Tastatur, Fernbedienung | Mit arduino-pico einfach | Mit Bibliotheken einfach | Beide |
| WS2812B, genaues Timing, eigene Protokolle | Mit PIO sehr stark | Mit RMT gut | Pico W |
| Analoge Messung | 3 Kanäle, linearer 12-Bit-ADC | Viele Kanäle, aber nicht linear; ADC2 bei aktivem WLAN nicht nutzbar | Pico W, wenn wenige Kanäle reichen |
Kurz gesagt: Der Pico W ist hervorragend, um MicroPython zu lernen, für Hardwareaufgaben mit genauem Timing und für einfache Netzwerkprojekte; er ist gut dokumentiert, stabil und mit Thonny sehr leicht zu programmieren. Brauchst du eine Kamera, lange Akkulaufzeit, Bluetooth-Audio oder ein fertiges Ökosystem wie ESPHome, ist der ESP32 die bessere Wahl. Möchtest du die ESP32-Versionen von Projekten wie Internetuhr, Webserver und Wetteranzeige vergleichen, ist der Beitrag ESP32-NTP-Uhr ein guter Einstieg.
Häufige Fehler und Lösungen
- ImportError: no module named 'network': Auf dem Board ist die normale Pico-Firmware. Flashe die UF2-Datei RPI_PICO_W oder RPI_PICO2_W.
- Die Onboard-LED leuchtet nicht: Es wurde Pin(25) verwendet. Beim Pico W und Pico 2 W lautet es richtig Pin("LED", Pin.OUT).
- wlan.status() liefert −2: Netz nicht gefunden; prüf den Netzwerknamen inklusive Groß- und Kleinschreibung und ob das 2,4-GHz-Band eingeschaltet ist.
- OSError: [Errno 98] EADDRINUSE: Port 80 ist nach dem Neustart des Webservers noch belegt. Mach mit Strg+D einen Soft-Reset oder nutze SO_REUSEADDR am Socket.
- MemoryError: Große JSON- oder HTML-Daten haben den Speicher gefüllt. Antworten verkleinern, r.close() und gc.collect() nutzen, notfalls auf den Pico 2 W wechseln.
- Der Code läuft am Computer, aber nicht am Netzteil: Die Datei wurde nicht als main.py gespeichert oder der Code verlässt sich auf die von Thonny gestellte Uhr. Benenne die Datei main.py und stell die Uhr selbst mit ntptime.
Hast du diese 15 Projekte nacheinander umgesetzt, hast du mit dem Pico W WLAN, HTTP, NTP, MQTT, UDP und BLE genutzt und die Grundlage gelegt, um eigene IoT-Geräte zu entwerfen. In der BlueGrays-App findest du Schritt-für-Schritt-Schaltpläne und Code für einfache Pico-Projekte wie eine LED einschalten, eine Ampel, LED-Dimmen per PWM und einen RGB-Farbwechsel sowie für ESP32-Projekte wie WLAN-Verbindung, NTP-Uhr und Webserver, mit denen du jedes Projekt auch auf der Hardwareseite vervollständigst.
Häufige Fragen
Was kann man mit einem Raspberry Pi Pico W machen?
Mit dem Pico W baust du per Handy gesteuerte Webserver, NTP-Uhren mit Zeit aus dem Internet, Sensoren, die Daten per MQTT senden, Alarme mit Telegram-Nachricht und Geräte, die per BLE mit dem Handy sprechen. Dank 26 GPIO-Pins lassen sich Sensoren, Relais, Displays und LEDs leicht ergänzen. Programmiert wird in MicroPython oder in der Arduino IDE.
Was ist der Unterschied zwischen Pico W und Pico 2 W?
Beide nutzen denselben WLAN- und Bluetooth-Chip CYW43439. Der Pico 2 W hat den schnelleren RP2350, doppelt so viel RAM (520 KB) und 4 MB Flash. Die Pinbelegung ist identisch, und der meiste MicroPython-Code läuft ohne Änderungen.
Kann sich der Pico W mit einem 5-GHz-WLAN verbinden?
Nein, Pico W und Pico 2 W verbinden sich nur mit 2,4-GHz-Netzen. Senden beide Bänder des Routers unter demselben Namen, kann die Verbindung haken; dann hilft es, dem 2,4-GHz-Band einen eigenen Namen zu geben oder mit dem 2,4-GHz-Hotspot des Handys zu testen.
Warum leuchtet die Onboard-LED des Pico W nicht mit Pin(25)?
Beim Pico W dient GP25 als Auswahlleitung des Funkchips, und die Onboard-LED wurde an den Funkchip verlegt. Richtig ist Pin("LED", Pin.OUT). Diese Schreibweise funktioniert beim klassischen Pico, beim Pico W und beim Pico 2 W gleichermaßen.
Wird Bluetooth des Pico W in MicroPython unterstützt?
Ja, MicroPython unterstützt BLE auf dem Pico W. Das Low-Level-Modul bluetooth ist in der Firmware enthalten, für einfachere Nutzung lässt sich das Paket aioble mit mip installieren. Funktionen wie Bluetooth-Classic-Audio werden in MicroPython dagegen nicht unterstützt.
Ist für ein IoT-Projekt der Pico W oder der ESP32 besser?
Zum Lernen von MicroPython, für einfache Netzwerkprojekte und Aufgaben mit genauem Timing ist der Pico W eine sehr gute Wahl. Brauchst du eine Kamera, monatelangen Batteriebetrieb, Bluetooth-Audio oder ein fertiges Ökosystem wie ESPHome, passt der ESP32 besser. Einfache Webserver- und MQTT-Projekte schaffen beide mühelos.
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 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.

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.

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.

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.
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

