#raspberrypipico

Mit dem Raspberry Pi Pico W lassen sich erstaunlich vielseitige Projekte realisieren – und das trotz seiner geringen Größe und des günstigen Preises. In diesem Beitrag zeige ich dir, wie du den Mikrocontroller in einen eigenen WLAN-Hotspot verwandelst, über den sich andere Geräte verbinden können. Sobald ein Gerät mit dem Netzwerk verbunden ist, wird es in einer übersichtlichen Weboberfläche angezeigt. Das Ganze wird komplett in MicroPython programmiert und kommt ohne zusätzliche Module oder Libraries aus – ideal also für Einsteiger und Bastler, die einen einfachen Einstieg in Netzwerkanwendungen mit dem Pico W suchen. https://youtu.be/jOVtYf6iNjY Hinweis aus der Community: Die Idee zu diesem Projekt stammt aus einem Kommentar von JoKa – vielen Dank an dieser Stelle für den spannenden Impuls! Ich freue mich jederzeit über Feedback, Ideen oder Anregungen zu meinen Projekten. Du kannst mir gern einen Kommentar hinterlassen oder direkt ein Support-Ticket über Support-Anfragen & Rückmeldung erstellen – ich nehme Vorschläge gerne auf und lasse sie in zukünftige Beiträge einfließen.

Ziel des Projekts

In diesem Beitrag verwandle ich den Raspberry Pi Pico W in einen einfachen WLAN-Hotspot (Access Point) mit einer integrierten Weboberfläche, auf der du sehen kannst, welche Geräte sich mit dem Netzwerk verbunden haben.

PiPico2W - AccessPoint Weboberfläche mit Geräteliste Das Projekt eignet sich ideal als Grundlage für eigene Anwendungen – zum Beispiel zur Konfiguration von Geräten im lokalen Netz oder zur Visualisierung von Statusinformationen. Die Umsetzung erfolgt komplett in MicroPython, sodass du den Code leicht anpassen oder erweitern kannst. Was ist ein Access Point? Ein Access Point (AP) ist ein Gerät, das ein eigenes WLAN-Netzwerk bereitstellt, mit dem sich andere Geräte verbinden können – ähnlich wie ein Router, nur ohne Internetverbindung. In unserem Fall übernimmt der Pico W diese Rolle und ermöglicht es z. B. einem Smartphone oder einer ESP32-CAM, sich direkt mit ihm zu verbinden. Was ist ein Webserver? Ein Webserver stellt Inhalte – meist HTML-Seiten – über das Netzwerk zur Verfügung. In diesem Projekt zeigt der Pico W eine einfache Webseite an, sobald ein Gerät im Browser seine IP-Adresse aufruft. Diese Seite listet z. B. die IP-Adressen aller verbundenen Geräte auf. Grenzen des Projekts Auch wenn der Pico W erstaunlich viel kann, gibt es technische Einschränkungen, die man kennen sollte: - WLAN-Reichweite: Die integrierte Antenne des Pico W reicht in der Praxis nur für kurze Distanzen. Für größere Reichweiten ist ein WLAN-Router oder ein ESP32-Modul mit externer Antenne besser geeignet. - Datenübertragung: Der Pico W eignet sich nicht für große Datenmengen, er reicht aber für kleine Geräte wie einer ESP32-CAM. - Mehrere Verbindungen: Der Pico W kann nur eine begrenzte Anzahl an gleichzeitigen Clients verarbeiten – perfekt für kleine DIY-Projekte, aber nicht für ein ganzes Smarthome-Netzwerk.

Technische Daten des Raspberry Pi Pico W

Der Raspberry Pi Pico W basiert auf dem bewährten RP2040-Chip und ist dank integrierter WLAN-Funktion ideal für einfache IoT- und Netzwerkprojekte geeignet. Hier ein Überblick über die wichtigsten technischen Merkmale: - Mikrocontroller: RP2040 (Dual-Core ARM Cortex-M0+ @ 133 MHz) - RAM: 264 KB SRAM - Flash-Speicher: 2 MB - WLAN: 2,4 GHz WiFi (802.11n), integriert über CYW43439 - GPIOs: 26 nutzbare Pins - Spannungsversorgung: 1,8–5,5 V über USB oder VSYS - Schnittstellen: I²C, SPI, UART, PWM, ADC, USB (Device)

Raspberry Pi Pico W verpackt

Raspberry Pi Pico W

Raspberry Pi Pico W

Rückseite des Raspberry Pi Pico W

WisdPi - ArduPico mit Raspberry Pi Pico W

DIY Extensionboard für den Raspberry Pi Pico Der Pico W eignet sich hervorragend für MicroPython-Projekte, bei denen WLAN eine Rolle spielt – z. B. als Access Point mit Weboberfläche, wie in diesem Beitrag gezeigt. Hinweis zum RP2350 Die Raspberry Pi Foundation hat mit dem RP2350 einen Nachfolger des RP2040 vorgestellt. Erste Boards mit integriertem WiFi und dem neuen Chip sind inzwischen erhältlich. Da sich der RP2350 in mehreren Punkten vom RP2040 unterscheidet, werde ich in einem separaten Beitrag ausführlich auf die technischen Unterschiede, Vorteile und Einsatzmöglichkeiten eingehen.

Benötigte Bauteile

Für dieses Projekt ist die Materialliste angenehm kurz, denn der Raspberry Pi Pico W bringt bereits alles mit, was wir brauchen – inklusive WLAN-Chip. Du benötigst lediglich: - 1× Raspberry Pi Pico W* - 1× USB-Datenkabel* (USB-A auf Micro-USB) – wichtig: kein reines Ladekabel! - Die Entwicklungsumgebung Thonny zur Programmierung mit MicroPython Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Die Einrichtung von Thonny sowie die ersten Schritte mit dem Raspberry Pi Pico habe ich bereits in einem separaten Beitrag beschrieben: 👉 Raspberry Pi Pico (1): Vorstellung und erste Schritte Damit bist du bestens vorbereitet, um mit dem Projekt zu starten!

Firmware-Update des Raspberry Pi Pico W

Da ich meinen Pico W längere Zeit nicht verwendet habe, aktualisiere ich zunächst die MicroPython-Firmware – von Version 1.20.0 auf 1.25.0. Ein Firmware-Update kann nicht nur neue Features mitbringen, sondern auch wichtige Bugfixes enthalten – daher ist es sinnvoll, vor Beginn eines neuen Projekts zu prüfen, ob eine aktuellere Version verfügbar ist.

aktualisieren der Firmware des Raspberry Pi Pico W mit der Thonny IDE Die aktuelle MicroPython-Firmware für den Raspberry Pi Pico W findest du hier: 👉 https://micropython.org/download/rp2-pico-w/ am einfachsten ist es jedoch wenn du die Thonny IDE verwendest, hier sind es nur wenige klicks. Wichtiger Hinweis: Beim Flashen der Firmware wird der komplette Speicher des Boards gelöscht. Alle Programme, Dateien und Einstellungen auf dem Pico W gehen dabei verloren! Stelle also sicher, dass du wichtige Skripte vorher gesichert hast.

Output MicroPython v1.25 Hinweis zur Firmware-Version (Stand: 25.06.2025) Beim Test mit der Firmware v1.25.0 trat auf meinem Raspberry Pi Pico W der folgende Fehler auf: Failed to start CYW43 In diesem Fall konnte der WLAN-Chip nicht korrekt initialisiert werden, wodurch sich der Access Point nicht starten ließ. Nach einem Wechsel auf die Vorgängerversion v1.24.1 funktionierte alles problemlos, und der AP wurde wie erwartet erstellt. 👉 Mein Tipp: Wenn du diesen Fehler ebenfalls bekommst, probiere es mit der Firmware v1.24.1, die du ebenfalls auf der offiziellen MicroPython-Seite findest: https://micropython.org/download/rp2-pico-w/ Ich beobachte das Verhalten weiter und aktualisiere diesen Beitrag, sobald es dazu neue Erkenntnisse oder eine Lösung gibt.

Access Point mit dem Pico W einrichten

Nachdem alle Vorbereitungen abgeschlossen sind und die Firmware auf dem aktuellen Stand ist, können wir mit der eigentlichen Programmierung beginnen. Im ersten Schritt richten wir den Raspberry Pi Pico W als WLAN-Access Point (AP) ein. Dadurch erzeugt der Mikrocontroller ein eigenes WLAN, mit dem sich beispielsweise ein Smartphone oder ein anderes WLAN-fähiges Gerät verbinden kann. Beispielcode: AP mit SSID „PicoAP“ und einfachem Passwort import network import time # Access Point konfigurieren ap = network.WLAN(network.AP_IF) # SSID = PicoAP # Passwort = 12345678 (muss min. 8 Zeichen enthalten!) ap.config(essid='PicoAP', password='12345678') ap.active(True) # Warten bis aktiv while not ap.active(): print(".", end="") time.sleep(1) print("Access Point aktiv!") print("IP-Adresse:", ap.ifconfig()) Wenn das kleine Script gestartet wird, wird ein AP mit dem Namen (SSID) PicoAP aufgebaut und man kann sich mit einem Handy, Table oder PC mit diesem verbinden.

aktiver AccessPoint vom Raspberry Pi Pico Webserver mit Liste der IP-Adressen Der folgende Code richtet einen einfachen Webserver im Access-Point-Modus ein. Er listet alle Geräte auf, die sich zumindest einmal mit dem WLAN verbunden und die IP-Adresse 192.168.4.1 im Browser aufgerufen haben. Denn genau dann sendet das Gerät einen HTTP-Request an den Pico W – und dieser wird vom Server erfasst.

Webseite mit IP-Adressen von verbundenen Geräten import network import socket import time # Access Point einrichten ap = network.WLAN(network.AP_IF) ap.config(essid='PicoAP', password='12345678') # Passwort muss min. 8 Zeichen sein ap.active(True) while not ap.active(): time.sleep(1) print("Access Point aktiv. IP:", ap.ifconfig()) # Set zur Speicherung der bekannten IP-Adressen clients = set() # Webserver starten addr = socket.getaddrinfo('0.0.0.0', 80) s = socket.socket() s.bind(addr) s.listen(1) print("Webserver läuft auf Port 80...") while True: conn, addr = s.accept() client_ip = addr print("Verbindung von:", client_ip) clients.add(client_ip) # HTML-Inhalt generieren html = """ Pico W Access Point

Willkommen beim PicoAP

Deine IP-Adresse: {}

Bekannte Geräte:

""".format(client_ip) for ip in clients: html += " - {}n".format(ip) html += """ """ # Antwort senden response = 'HTTP/1.1 200 OKrnContent-Type: text/htmlrnrn' + html conn.send(response.encode('utf-8')) conn.close()

Geräte automatisch identifizieren per HTTP-Header

Wenn du Zugriff auf den Code eines Geräts hast – etwa bei einer ESP32-CAM, die sich mit dem Pico-WLAN verbindet – kannst du direkt nach der Verbindung automatisch einen HTTP-Request mit einem benutzerdefinierten Header absenden. Dieser Header enthält z. B. den Gerätenamen, den der Pico W auswerten und anzeigen kann. Das hat den Vorteil, dass du auf dem Pico nicht nur die IP-Adresse des Geräts speichern kannst, sondern auch direkt einen zugeordneten Namen. So entsteht eine übersichtliche Geräteliste im Format:

Ausgabe - Verbundene Geräte Beispielcode für die ESP32-CAM in der Arduino IDE Damit das funktioniert, musst du im Code der ESP32-CAM die Library HTTPClient einbinden und am Ende der setup()-Funktion einmalig einen HTTP-Request an den Pico W senden: #include void sendDeviceHeader() { HTTPClient http; // IP des Pico W http.begin("http://192.168.4.1/"); // Gerätekennung http.addHeader("X-Device-Name", "ESP32-CAM"); // Senden des Requests int httpCode = http.GET(); // Verbindung schließen http.end(); } void setup() { ... // Direkt nach erfolgreicher Verbindung aufrufen sendDeviceHeader(); } Auswertung im MicroPython-Code Da du auf dem Webserver des Pico W ebenfalls den Code selbst kontrollierst, kannst du den Header sehr einfach im Request auslesen und zuordnen. In deinem Webserver prüfst du dazu jede eingehende Verbindung nach dem Header X-Device-Name: for line in request.split("rn"): if line.startswith("X-Device-Name:"): device_name = line.split(":", 1).strip() Damit ordnest du der IP-Adresse zuverlässig den Gerätenamen zu – ideal für Projekte mit mehreren bekannten Teilnehmern wie Sensoren, Kameras oder Aktoren.

Fertiger Code: Pico W als WLAN-Hotspot mit Geräteliste

Im folgenden Abschnitt findest du den vollständig lauffähigen MicroPython-Code für dieses Projekt. Er verwandelt deinen Raspberry Pi Pico W in einen eigenen WLAN-Hotspot und stellt eine einfache Weboberfläche bereit.

PiPico2W - AccessPoint Weboberfläche mit Geräteliste Sobald sich ein Gerät mit dem WLAN verbindet und einen HTTP-Request an http://192.168.4.1 sendet (z. B. automatisch durch einen Mikrocontroller oder manuell im Browser), wird dessen IP-Adresse zusammen mit einem benutzerdefinierten Gerätenamen angezeigt. Der Gerätename wird dabei über den HTTP-Header X-Device-Name übermittelt. # ------------------------------------------------------------ # Titel: Raspberry Pi Pico W – WLAN-Hotspot mit Weboberfläche # Beschreibung: # Dieser Code verwandelt den Raspberry Pi Pico W in einen Access Point (AP), # der eine einfache Webseite ausliefert. Alle Geräte, die sich mit dem WLAN # verbinden und einen HTTP-Request senden, werden mit ihrer IP-Adresse # und einem benutzerdefinierten Gerätenamen (per HTTP-Header) geloggt # und auf der Webseite angezeigt. # # Autor: Stefan Draeger # Blogbeitrag: # https://draeger-it.blog/raspberry-pi-pico-w-als-wlan-hotspot-mit-weboberflaeche-geraete-im-netzwerk-anzeigen/ # ------------------------------------------------------------ import network import socket import time # WLAN Access Point konfigurieren ap = network.WLAN(network.AP_IF) # AP_IF = Access Point Interface ap.config(essid='PicoAP', password='12345678') # WLAN-Name und Passwort (mind. 8 Zeichen) ap.active(True) # AP aktivieren # Warten, bis der Access Point aktiv ist while not ap.active(): time.sleep(1) print("Access Point aktiv. IP:", ap.ifconfig()) # Dictionary zur Speicherung von verbundenen Clients # Format: { "IP-Adresse": "Gerätename" } clients = {} # Webserver einrichten addr = socket.getaddrinfo('0.0.0.0', 80) # IPv4-Adresse, Port 80 s = socket.socket() s.bind(addr) s.listen(1) # Max. 1 gleichzeitige Verbindung (ausreichend für einfache Anzeige) print("Webserver läuft...") # Endlosschleife zur Verarbeitung eingehender Verbindungen while True: conn, addr = s.accept() # Verbindung akzeptieren request = conn.recv(1024).decode() # HTTP-Request empfangen ip = addr # IP-Adresse des Clients device_name = "Unbekannt" # Standardwert # HTTP-Header nach dem benutzerdefinierten Feld "X-Device-Name" durchsuchen for line in request.split("rn"): if line.startswith("X-Device-Name:"): device_name = line.split(":", 1).strip() break # Nur ersten passenden Header verarbeiten # IP-Adresse und Gerätename im Dictionary speichern oder aktualisieren clients = device_name print("Verbindung von {} – Name: {}".format(ip, device_name)) # Dynamisches HTML für die Antwort generieren html = """ Pico W Access Point

Geräteliste

„Arduino? Das nutzt doch heute keiner mehr…“ Wer sich in den letzten Jahren mit Mikrocontrollern beschäftigt hat, stolpert überall über den ESP32. Dual-Core, WLAN, Bluetooth, 240 MHz, massig Speicher – und das alles für ein paar Euro. Kein Wunder also, dass der gute alte Arduino UNO im Schatten der neuen Mikrocontroller-Generation zu stehen scheint. Die Kommentare in Foren und Social Media klingen dann auch oft so: „Warum noch einen Arduino benutzen, wenn es doch den ESP32 gibt?“ Aber ist das wirklich so? Hat der Arduino tatsächlich ausgedient? Oder gibt es gute Gründe, auch heute noch auf den betagten Klassiker zu setzen? Und vor allem: Wenn ich gerade erst einsteige – sollte ich dann überhaupt noch mit einem Arduino anfangen, oder direkt auf einen ESP32 setzen? Genau um diese Fragen geht es in diesem Beitrag. Und so viel sei schon mal verraten: Leistung ist nicht immer alles.

ESP32 – das moderne Powerpaket (aber nicht für alles nötig)

Wenn man sich heute in der Maker-Szene oder auf YouTube umschaut, könnte man fast glauben, es gäbe nur noch den ESP32. Und das ist auch gar nicht so abwegig: Der ESP32 bringt schon ab Werk eine ganze Menge beeindruckender Features mit, die früher nur mit viel zusätzlicher Hardware möglich waren. 🔥 Ein kurzer Blick auf die Highlights: - Dual-Core mit bis zu 240 MHz - WLAN und Bluetooth direkt integriert - Bis zu 520 kB RAM und mehrere Megabyte Flash - Viele GPIOs, PWM, ADC, DAC, I2C, SPI, CAN, Touch-Sensoren, … - Bereits ab ca. 3 € (je nach Ausführung und Händler)

ESP32-S3-Matrix

ESP32-C3 mit LiPo Batterie

zwei Elecrow CrowPanels 2,4" & 5.0"

Arduino Nano ESP32

Generic-ESP32 Mikrocontroller

ESP32-C3 Super Mini

ESP32-S3-Zero Und dann wäre da noch ein echter Publikumsliebling: die ESP32-CAM.

Vergleich ESP32-CAM und ESP32-S3 CAM

ESP32-CAM mit externer Antenne und Board

ESP32-CAM

ESP32-CAM Modelle Für rund 5 € bekommt man hier nicht nur die Rechenpower des ESP32, sondern auch gleich eine kleine Kamera mit bis zu 5 Megapixeln dazu. Damit sind Projekte wie: - Überwachungskamera, - QR-Code-Scanner, - Fotos per E-Mail oder Telegram senden ganz einfach umsetzbar – ohne zusätzliche Hardware. Der Raspberry Pi Pico (RP2040) mischt kräftig mit – und bekommt Verstärkung Doch der ESP32 ist nicht allein auf dem Platz. Der Raspberry Pi Pico mit seinem RP2040 Dual-Core Cortex-M0+ Prozessor (133 MHz) hat sich schnell als leistungsfähige und günstige Alternative etabliert – und das in mehreren Varianten: BoardWLANBluetoothBesonderheitenRaspberry Pi Pico❌❌Basisversion, ohne FunkRaspberry Pi Pico W✅✅ (per Firmware)WLAN onboard, BT aktivierbarRP2350-Boards❌❌Mehr Power, keine Funkmodule (derzeit)

RP2040:bit

Melopero Cookie RP2040

Sumolink Erhu RP240

Mikrocontroller - XIAO RP2040 & Raspberry PI Pico

Raspberry Pi Pico 2 - RP2350A

XIAO RP2350 Mit dem neuen RP2350-Chip steht mittlerweile ein leistungsstärkerer Nachfolger in den Startlöchern. Er wird derzeit auf einigen neuen Boards verbaut (z. B. auf Prototypen oder Dev-Boards asiatischer Hersteller) und bringt: - Höhere Taktraten (bis 200 MHz möglich), - Verbesserte Peripherie, - Und bleibt trotzdem kompatibel zur RP2040-Familie. Was aktuell noch fehlt: WLAN und Bluetooth sind (noch) nicht integriert – was den Chip für reine IoT-Projekte (noch) weniger attraktiv macht, aber für USB-HID oder Highspeed-Sensoranwendungen interessant sein kann.

Arduino – Der Klassiker mit Kultstatus (und vielen Gesichtern)

Wenn man „Arduino“ sagt, denken viele sofort an das gute alte Original: Arduino UNO R3, Made in Italy, stabil, bewährt – aber auch nicht ganz billig. Und genau da beginnt der kleine Konflikt, den vermutlich viele kennen: ➡️ Das originale Board unterstützt die Plattform, die Entwicklung und das Open-Source-Projekt. ➡️ Aber: Der Preis liegt oft bei 20 € und mehr – während Clones für 2–3 € zu haben sind. Doch: Genau das ist eben auch der Spirit von Open Source. Die Arduino-Plattform wurde so entwickelt, dass jeder (mit Einhaltung gewisser Auflagen) eigene Boards bauen und verkaufen darf. Und das tun viele Hersteller – vor allem in Asien. Dabei gibt es längst nicht nur einfache UNO- oder Nano-Kopien. Die Vielfalt an Arduino-kompatiblen Boards ist inzwischen riesig: Board / CloneBesonderheitPreisbereichNano Clone (CH340G)Klassiker für einfache Projekte2–4 €Pro MiniOhne USB, super klein und sparsam2–4 €Nano mit integriertem OLEDAnzeige direkt am Mikrocontroller4–8 €Nano mit 2,4 GHz Funk (nRF24L01) oder 433 MHz ModulIdeal für Funkprojekte ohne WLAN5–10 €Nano mit ESP8266-Modul onboardWLAN-fähig, bleibt aber Arduino-kompatibel5–10 €Nano mit Bluetooth HC-05 oder HM-10Kabellose Kommunikation über BT Classic oder BLE5–10 €

Arduino Nano mit nRF24L01 Erweiterungsboard

Microcontroller BLE-Nano von Keywish

Arduino UNO R3

Arduino UNO R3 Clone von der Firma Sunfounder

Arduino Nano V3 , ATmega328P

Arduino Mega 2560 Pro mini

Arduino Nano V3

Seeeduino Nano Gerade diese Vielfalt an spezialisierten Clones und Abwandlungen ist ein echter Vorteil: Man wählt sich für sein Projekt genau die Features, die man braucht – und spart sich den Ballast von Funktionen, die gar nicht benötigt werden. ➡️ Keine WLAN-Probleme, wenn das Projekt gar kein WLAN braucht. ➡️ Keine Bluetooth-Komplexität, wenn ein simples Relais geschaltet werden soll. ➡️ Aber: Wenn ein Display gewünscht ist, einfach ein Clone mit integriertem OLED nehmen. Teures Original oder günstiger Clone? Das Original aus Italien unterstützt natürlich die Entwickler, die die Plattform erst möglich gemacht haben. Gerade wenn es um professionelle Projekte, Support oder Weiterentwicklung geht, ist das ein guter Grund, auch mal bewusst zum Original zu greifen. Wer dagegen einfach ein kleines Hobby-Projekt umsetzt oder ein günstiges Board für Lernzwecke sucht, wird vermutlich bei einem Clone aus Fernost landen – und das ist auch okay so. Beides hat seine Berechtigung. Im nächsten Abschnitt schauen wir uns an, warum diese Einfachheit und Flexibilität dem Arduino einen Platz auf dem Basteltisch gesichert haben – auch wenn ESP32, RP2040 & Co. daneben liegen. Clone statt Frust: Warum gerade Anfänger mit günstigen China-Boards besser fahren Seien wir ehrlich: Wer mit Mikrocontrollern anfängt, wird früher oder später mal einen Fehler machen. Ein Kabel verpolt, einen Pin aus Versehen kurzgeschlossen, eine Lötstelle zu heiß… ➡️ Passiert. Gehört zum Lernen einfach dazu. Wenn dann das teure Original-Board abraucht, ist der Frust groß – und das Projekt vielleicht erst mal gestorben. Anders sieht es aus, wenn das eingesetzte Board nur 2–3 € gekostet hat. Dann bestellt man sich einfach ein neues und weiter geht’s. Genau deshalb finde ich: ➡️ Gerade Anfänger sind mit einem günstigen Clone gut beraten. Das senkt die Hemmschwelle, etwas auszuprobieren, und macht es viel leichter, aus Fehlern zu lernen. Ob Arduino Nano Clone, Pro Mini oder einer der vielen China-Nachbauten mit Zusatzfeatures wie OLED oder Funk – hier kann man für kleines Geld experimentieren, lernen und Spaß haben. Und wenn das Projekt später stabil läuft und vielleicht sogar „ernsthaft“ eingesetzt werden soll, kann man immer noch überlegen, ob man auf ein höherwertiges Original umsteigt.

Wann ESP32, wann Arduino? – Entscheidungshilfe für Projekte

Natürlich ist es immer verlockend, einfach zum leistungsstärksten Mikrocontroller zu greifen. Aber genau das ist oft gar nicht nötig – und manchmal sogar umständlicher. Denn: Der beste Mikrocontroller ist der, der genau das kann, was dein Projekt braucht – nicht mehr und nicht weniger. Um dir die Wahl etwas leichter zu machen, hier eine kleine Entscheidungshilfe: ProjektideeEmpfehlungWarum?Blinkende LEDs, Relais steuern, Taster abfragenArduino UNO, Nano, Pro MiniEinfach, stabil, günstig, kein OverkillLCD/OLED-Anzeige mit Temperatur-/FeuchtesensorArduino oder PicoWLAN meist nicht nötig, einfache UmsetzungDaten per WLAN ins Netz (z. B. ThingSpeak, MQTT)ESP32, Pico WWLAN/BT bereits integriert, viele Beispiele vorhandenMobile Projekte mit Akku und langer LaufzeitPro Mini (mit LowPower-Mod) oder ESP32 mit Deep SleepStromsparend, je nach FunkbedarfKamera-Projekte (Foto/Video-Streaming)ESP32-CAMKamera onboard, einfache EinbindungUSB-Tastatur-Emulation, MacroPads, HID-GeräteArduino Leonardo / Micro oder Raspberry Pi Pico (RP2040)Beide unterstützen native USB-HIDFunkprojekte ohne WLAN (z. B. 433 MHz, nRF24L01)Arduino Nano Clone mit FunkmodulKein unnötiges WLAN, einfache FunkanbindungEchtzeitkritische Anwendungen mit viel GPIO und TimingRP2040 oder RP2350Schnelles Realtime-Processing dank PIO, viele GPIOs 💡 Zusatz-Tipp: Für USB-Tastatur-Emulation (z. B. MacroPads oder automatisierte Eingaben) ist der Arduino Leonardo eine super Wahl, weil er den ATmega32u4 verwendet, der USB nativ unterstützt. Alternativ funktioniert das auch mit dem Arduino Micro oder dem Raspberry Pi Pico (RP2040), dort oft über die TinyUSB-Bibliothek.

Keyestudio Leonardo

Arduino Leonardo Clone

Mini RP2040 Developmentboard

Fazit: Alt, aber alles andere als nutzlos!

In diesem kurzen Beitrag beantworte ich zwei konkrete Fragen aus der Community zum RP2040:bit-Board, die mir als Kommentar unter meinem ursprünglichen Blogpost gestellt wurden. Ziel ist es, dir schnell und übersichtlich zu zeigen, welche GPIOs auf die Bananenstecker-Anschlüsse des Boards gelegt sind und welche Möglichkeiten es gibt, das Board alternativ zum Micro-USB-Port mit Strom zu versorgen. Der Beitrag richtet sich an alle, die das RP2040bit flexibel in eigenen Projekten oder im Bildungsbereich einsetzen möchten. https://youtu.be/RQHz4GcfwO0 Ein herzliches Dankeschön an Anton F. für den konstruktiven Kommentar und die gezielten Fragen zum RP2040bit! Genau solche Rückmeldungen aus der Community helfen dabei, wichtige Details zu ergänzen und den Beitrag für alle Leser noch wertvoller zu machen.

RP2040:bit

Rückseite des RP2040:bit

Pinout & Aufbau des RP2040:bit

Um das volle Potenzial des RP2040bit-Boards auszuschöpfen, lohnt sich ein genauer Blick auf den Aufbau und die Pinbelegung. In diesem Abschnitt zeige ich dir, wie die einzelnen GPIOs verteilt sind, welche Funktionen die Anschlüsse bieten und worauf du beim Anschluss von Sensoren oder Aktoren achten solltest. So behältst du stets den Überblick – egal ob im Experimentieraufbau oder beim Einsatz mit Erweiterungsmodulen.

Aufbau des RP2040:bit Mikrocontrollers Der RP2040bit orientiert sich nicht nur im Formfaktor am bekannten BBC micro:bit, sondern bietet auch eine kompatible Belegung der Schneidklemme (Edge Connector). Dadurch lassen sich viele Erweiterungen und Zubehörteile, die für den micro:bit entwickelt wurden, auch problemlos mit dem RP2040bit verwenden – ein großer Pluspunkt für alle, die bereits passendes Zubehör besitzen oder auf eine breite Auswahl an Erweiterungsboards zugreifen möchten.

RP2040bit - Pinout EdgeConnector

Features des RP2040:bit Mikrocontrollers

Der RP2040bit bringt alle grundlegenden Elemente mit, um direkt mit dem Programmieren loszulegen: Eine Micro-USB-Buchse zur Stromversorgung und Programmierung, zwei frei belegbare Tasten, eine 5x5 LED-Matrix in rot sowie eine Debug-Schnittstelle auf der Rückseite. Darüber hinaus bietet das Board zahlreiche GPIO-Pins – sowohl über die Schneidklemme (Edge Connector) als auch über zusätzliche Lötpunkte auf der Rückseite.

RP2040:bit

Rückseite des RP2040:bit Im Vergleich zum BBC micro:bit fällt auf, dass der RP2040bit auf zusätzliche Sensoren wie Kompass, Beschleunigungssensor oder Bluetooth verzichtet. Wer diese Funktionen benötigt, ist mit dem micro:bit besser ausgestattet. Für reine GPIO-Projekte oder zum Einstieg in die RP2040-Welt bietet der RP2040bit jedoch eine solide Basis mit großem Potenzial.

Alternative Stromversorgung

Der einfachste Weg, den RP2040bit mit Strom zu versorgen, ist über die Micro-USB-Buchse. Du kannst dazu ein USB-Netzteil, eine Powerbank oder auch deinen PC verwenden. Falls in deinem Projekt jedoch keine USB-Stromversorgung möglich ist, lässt sich der Mikrocontroller auch über eine externe Spannungsquelle betreiben. Nutze hierfür den VSYS-Pin auf der Rückseite des Boards. An diesem Pin kannst du eine Spannung zwischen 1,8 V und 5,5 V einspeisen.

Pins für die externe Spannungsversorgung 🔋 Meine Empfehlung: Verwende eine stabile 5V-Spannungsquelle – damit konnte ich den RP2040bit im Test zuverlässig betreiben. ⚠️ Wichtig: Wenn die Stromversorgung über VSYS erfolgt, steht am VBUS-Pin keine 5V-Spannung mehr zur Verfügung. Du kannst darüber dann keine externen Komponenten mehr mitversorgen.

RP2040:bit mit zwei Breadboardkabel für externe Stromversorgung

Betrieb des RP2040:bit über eine externe Stromversorgung

Um zu zeigen, dass der RP2040bit auch ohne USB-Verbindung zuverlässig läuft, habe ich eine einfache Schaltung mit einer blinkenden LED aufgebaut. Die Besonderheit: Die Stromversorgung erfolgt nicht über die Micro-USB-Buchse, sondern über eine externe 5V-Spannungsquelle, die direkt am VSYS-Pin angeschlossen wird. Ideal eignet sich hierfür ein Batteriefach mit 3× AA-Batterien. Für den Aufbau der Schaltung verwende ich folgende Komponenten: - einen RP2040:bit Mikrocontroller* - ein 400-Pin Breadboard* - ein Power-Supply-Modul* für Breadboards - ein Batterieclip für 9V Block Batterie*, mit Jack Adapter - zwei 5 mm LEDs* - zwei 220 Ohm Vorwiderstände* für die LEDs - vier Breadboardkabel*, männlich - männlich - zwei Prüfkabel mit Krokoklemmen* Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Die LED wird über einen Vorwiderstand an GPIO 26 angeschlossen und blinkt im Sekundentakt. Damit lässt sich sehr gut demonstrieren, dass der RP2040bit auch autark und mobil betrieben werden kann – ideal für Projekte ohne festen USB-Anschluss oder für den Einsatz unterwegs. - 🔧 Wichtig: Der Mikrocontroller wird weiterhin über die Micro-USB-Buchse programmiert. Achte darauf, dass während des Programmierens die externe Stromquelle vom VSYS-Pin getrennt ist, um Schäden an Board oder Computer zu vermeiden.

In diesem Beitrag möchte ich dir zeigen, wie du deinen Quellcode auf dem Raspberry Pi Pico in BASIC organisieren kannst.

Raspberry Pi Pico BASIC #2 - Quellcode organisieren Im letzten Beitrag Raspberry Pi Pico BASIC #1 - Überblick habe ich dir gezeigt, wie du dich im Fullscreen-Editor bewegen kannst und deinen Quellcode ausführst. Hier soll es nun darum gehen, wie du auf der Konsole mit Befehlen deinen Quellcode organisierst.

Speicherplatz

Mit dem Befehl memory kannst du dir die aktuelle Speicherauslastung anzeigen lassen. In meinem Fall habe ich Code mit einer Größe von 1 KB und 15 Zeilen geschrieben und noch 115 KB frei. Der flüchtige Speicher von 148 KB ist derzeit nicht belegt (es wird gerade kein Programm ausgeführt).

Befehle zum Speichern des Quellcodes in Slots

Du hast für deinen Quellcode 5 freie Slots mit maximal 100 KB freien Platz frei.

Raspberry Pi Pico BASIC Quellcode organisieren Wenn du deinen Code geschrieben hast, dann kannst du diesen mit dem Befehl FLASH organisieren. Es stehen dir nachfolgende Funktionen zur Verfügung: BefehlBeschreibungBeispielFLASH SAVE nspeichert den Code in einen Slotflash save 0FLASH LOAD nlädt den Code aus dem Slotflash load 0FLASH RUN nführt den Code aus dem Slot ausflash run 0FLASH LIST zeigt eine Liste der Slots an und wie diese belegt sind anflash listFLASH ERASE nleert den Slot flash erase 0FLASH ERASE ALLleert alle Slotsflash eraseFLASH CHAIN nführt das Programm vom Slot aus, behält jedoch alle Variablen mit Werten im Speicherflash chain 0FLASH OVERWRITE nüberschreibt den Slot mit neuem Inhaltflash overwrite 0 Quellcode verbinden mit FLASH CHAIN Das Speichern, Laden und Löschen ist recht unspektakulär. Jedoch das Verbinden von zwei Code Slots ist schon etwas tricky. Denn dieser Befehl wird nicht auf der Kommandozeile ausgeführt, sondern wird als letzter Befehl vom ersten Programm geschrieben. PRINT "Programm 1" a = 1 b = 2 PRINT a + b flash chain 2

kleines BASIC Programm mit einfacher Addition zweier Werte Im zweiten Programm können wir nun die Variablen aus dem ersten übernehmen und weiterverwenden. PRINT "Programm 2" c = 5 d = 7 PRINT a + b + c + d

kleines BASIC Programm mit einfacher Addition von vier Werten Die Ausgabe auf der Konsole sieht in meinem Beispiel wie folgt aus:

Ausgabe auf der Konsole von zwei verbundenen Code Slots

Speichern in Dateien auf dem Pi Pico

Wie du dir ein MacroPad mit dem Raspberry Pi Pico aufbaust und programmierst, zeige ich dir hier in meinem neuen Beitrag. Dieses MacroPad kann ein echter Effizenz-Booster sein und dich bei deiner täglichen Arbeit unterstützen. https://youtu.be/GCuJPVpsVTY In der ersten Version hatte mein MacroPad lediglich sechs Tasten und lief schon recht gut, die zweite Version habe ich um drei weitere Tasten und drei Rotary Encoder erweitert und somit auf das nächste Level gehoben. Ein zusätzliches Feature ist ein einfacher Schiebeschalter, mit welchen man programmatisch die Tasten doppelt belegen kann.

Warum kann ein MacroPad ein Effizienz-Booster sein?

Ein MacroPad kann die Produktivität erheblich steigern, indem es wiederkehrende PC-Aktionen auf einfache Weise automatisiert. Hier sind die wichtigsten Vorteile: - Zeitersparnis: Ein Knopfdruck ersetzt wiederholte Tastenkombinationen und Menüaktionen. - Personalisierte Steuerung: Es lässt sich individuell programmieren, um häufig genutzte Funktionen direkt auszuführen. - Vereinfachung komplexer Prozesse: Mehrere Arbeitsschritte können in einem Makro zusammengefasst werden. - Fehlerreduktion: Automatisierte Abläufe minimieren menschliche Fehler. - Ergonomische Vorteile: Weniger wiederholte Handbewegungen reduzieren körperliche Belastung. - Anpassung für verschiedene Programme: Das MacroPad kann je nach Software unterschiedliche Befehle übernehmen. - Multitasking-Unterstützung: Es erleichtert das parallele Arbeiten mit mehreren Programmen. Insgesamt wird die Arbeit schneller, einfacher und komfortabler.

Was wird für den Aufbau eines MacroPad's benötigt?

Für das hier vorgestellte MacroPad habe ich nachfolgende Bauteile benötigt: - einen Raspberry Pi Pico* - zwei 26 Pin Buchsenleisten*, 2,54 mm Rastermaß - sechs 12x12mm Printtaster* mit farbigen Köpfen - eine Lochrasterplatine* - diverse Litzen 20 AWG* Statt dem alten Raspberry Pi Pico könntest du auch das Model mit WiFi nutzen und so ggf. mit etwas mehr Aufwand ein drahtloses Modell erstellen.

Bauteile - MacroPad Raspberry Pi Pico Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Werkzeuge Neben einer vernünftigen Lötstation oder Lötkolben benötigst du noch: - einen Seitenschneider - eine Abisolierzange - eine Flachzange Die Flachzange benötigst du, um die starren 20 AWG Kabel zu biegen. Natürlich geht dieses auch mit der Hand nur so, hast du schöne 90° Winkel. Warum nicht den neuen Raspberry Pi Pico 2?

Der neue Raspberry Pi Pico 2 hat derzeit (Stand 10.10.2024) einen Hardware-Bug welcher die Verwendung für dieses Projekt derzeit ausschließt. Siehe https://github.com/adafruit/circuitpython/issues/9541.

Flashen des Mikrocontrollers für die Programmierung in CircuitPython

Um automatisierte Aktionen ausführen zu können, sind spezielle Features erforderlich, die nur CircuitPython bietet. Dazu muss der Mikrocontroller zunächst mit einer speziellen UF2-Datei bespielt werden, die es ermöglicht, CircuitPython auf dem Raspberry Pi Pico auszuführen. Diese Datei wird auf den Pico übertragen, indem man ihn in den Bootloader-Modus versetzt und die UF2-Datei auf das erscheinende Laufwerk kopiert. Die UF2-Datei bekommst du unter https://circuitpython.org/board/raspberry_pi_pico/. Zunächst musst du deinen Pico vom Computer trennen, um anschließend die Taste BOOT gedrückt zu halten und die Verbindung wieder herzustellen. Wenn dieses geschehen ist, dann solltest du ein neues Laufwerk im Explorer finden. Im nächsten Schritt musst du dann die UF2-Datei auf dieses Laufwerk kopieren oder per Drag'n Drop ziehen. Der Mikrocontroller wird dann automatisch geflasht und neu gestartet.

Aufbau der Schaltung - Taster am Raspberry Pi Pico

Auf dem MacroPad kannst du einfache Taster, Touchsensoren, analoge Joysticks und auch Rotary Encoder verbauen. Im Nachfolgenden zeige ich dir zunächst eine Schaltung mit einem Taster.

Schaltung - Raspberry Pi Pico mit zwei Taster Statt einfache Taster kannst du ebenso auch Touchsensoren verwenden, diese gibt es sehr günstig im 10er-Pack auf Aliexpress bereits ab 1,15 € zzgl. Versandkosten. Im Nachfolgenden verwende ich den kleinen XIAO RP2040 welchen ich dir bereits im Beitrag Seeed Studio XIAO RP2040 – ein Zwerg mit großer Leistung vorgestellt habe. Dieser hat denselben Chip wie der originale Raspberry Pi Pico und kann somit problemlos eingesetzt werden.

XIAO RP2040 mit drei Taster auf Breadboard

XIAO RP2040 mit drei Touchsensoren auf Breadboard

Programmierung des MacroPad in CircuitPython

Für die Programmierung verwende ich die Entwicklungsumgebung Thonny, diese kannst du dir unter https://thonny.org/ kostenfrei für Windows, Linux und macOS herunterladen. Du könntest ebenso auch den MU-Editor verwenden oder auch Visual Studio etc. jedoch ist die Thonny IDE schlank und trotzdem sehr mächtig und daher meine erste Wahl bei der Entwicklung von kleinen Programmen auf dem Mikrocontroller. Schritt 1 - programmieren eines Tasters mit CircuitPython am RP2040 Als Erstes erstellen wird ein Programm, welches das Event eines Tasters auswertet. Da wir in der Schaltung die Taster ohne PullUp / PullDown Widerstand angeschlossen haben, müssen wir dieses programmatisch lösen. import board from digitalio import DigitalInOut, Direction, Pull import time taster = DigitalInOut(board.D0) taster.direction = Direction.INPUT taster.pull = Pull.UP def main(): while True: if not taster.value: print("Taster wurde gedrückt!") time.sleep(0.5) main() Schritt 2 - ausführen einer Tastaturaktion via Taster Damit eine Aktion über die Tastatur oder Maus ausgeführt werden kann, benötigen wir das Modul Adafruit HID welches wir vom GitHub Repository Adafruit / Adafruit_CircuitPython_HID als ZIP-Datei herunterladen können. Auf der Seite https://docs.circuitpython.org/projects/hid/en/latest/ findest du eine sehr ausführliche Übersicht in englischer Sprache zum Funktionsumfang des Moduls. Im nachfolgenden Beispiel wird bei Tastendruck der kleine Buchstabe a an der Position des Cursors geschrieben. import board from digitalio import DigitalInOut, Direction, Pull import time import usb_hid from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode from adafruit_hid.keyboard_layout_win_de import KeyboardLayout kbd = Keyboard(usb_hid.devices) taster = DigitalInOut(board.D0) taster.direction = Direction.INPUT taster.pull = Pull.UP def main(): while True: if not taster.value: kbd.press(Keycode.A) time.sleep(0.09) kbd.release(Keycode.A) main() Möchte man einen großen Buchstaben schreiben, so muss man wie beim Schreiben auf der Tastatur die Shift-Taste gedrückt halten. kbd.press(Keycode.SHIFT) kbd.press(Keycode.A) time.sleep(0.09) kbd.release(Keycode.A) kbd.release(Keycode.SHIFT) Der Funktion press & release können auch mehr als nur ein Parameter vom Typ Keycode übergeben werden, somit können wir den obigen Code auch deutlich schlanker schreiben. kbd.press(Keycode.SHIFT, Keycode.A) time.sleep(0.09) kbd.release(Keycode.SHIFT, Keycode.A) Schritt 2.1 - deutsches Tastaturlayout verwenden Per Default verwendet das Adafruit Modul ein englisches / amerikanisches Tastaturlayout, somit fehlen die Umlaute und auch verschiedene Tasten sind umbelegt, zum Beispiel liegt auf der Taste Z der Buchstabe Y usw. Um dieses zu lösen, gibt es eine Python-Datei, welche wir vom GitHub Repository Neradoc / Circuitpython_Keyboard_Layouts unter /libraries/layouts/ herunterladen können. import board from digitalio import DigitalInOut, Direction, Pull import time import usb_hid from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode from adafruit_hid.keyboard_layout_win_de import KeyboardLayout kbd = Keyboard(usb_hid.devices) kbd_layout = KeyboardLayout(kbd) taster = DigitalInOut(board.D0) taster.direction = Direction.INPUT taster.pull = Pull.UP def main(): while True: if not taster.value: kbd_layout.write("Hier steht ein sehr langer Text!") time.sleep(0.5) main() Schritt 3 - Schreiben von Texten via Tasteraktion Möchte man längere Texte ausgeben, so kann man die zuvor bereits gezeigte Funktion write am Keyboard_Layout Objekt verwenden. kbd_layout.write("Hier steht ein sehr langer Text!") Schritt 3.1 - Dictionary für unterschiedliche Taster Wenn du mehrere Taster an deinen Mikrocontroller angeschlossen hast, dann empfiehlt es sich die Texte auszulagern. Hier bietet sich wiederum ein Dictionary an in welchem man die Texte in Schlüssel / Wertepaare auslagern kann. Im nachfolgenden Code verwende ich Touchsensoren vom Typ TTP223 welche ich dir bereits im Beitrag Arduino Lektion 92: kapazitiver Touch Sensor für den Arduino vorgestellt habe. Der Vorteil ist zusätzlich das man noch eine Rückmeldung via aufleuchten einer LED erhält und man diese Taster unter Abdeckungen anbringen kann.

XIAO RP2040 mit drei Touchsensoren auf Breadboard import board from digitalio import DigitalInOut, Direction, Pull import time import usb_hid from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode from adafruit_hid.keyboard_layout_win_de import KeyboardLayout textbausteine = { "taster1":"Taster 1 wurde betätigt!", "taster2":"Der Taster 2 wurde gedrückt!", "taster3":"Am Taster 3 wurde ine Aktion ausgelöst!" } kbd = Keyboard(usb_hid.devices) kbd_layout = KeyboardLayout(kbd) taster1 = DigitalInOut(board.D0) taster1.direction = Direction.INPUT taster1.pull = Pull.DOWN taster2 = DigitalInOut(board.D1) taster2.direction = Direction.INPUT taster2.pull = Pull.DOWN taster3 = DigitalInOut(board.D2) taster3.direction = Direction.INPUT taster3.pull = Pull.DOWN def main(): while True: if taster1.value: kbd_layout.write(textbausteine) if taster2.value: kbd_layout.write(textbausteine) if taster3.value: kbd_layout.write(textbausteine) main()

Fazit - MacroPad mit Raspberry Pi Pico

Im letzten Beitrag Schieberegister 74HC164D: Programmierung und Einsatz am Arduino Nano habe ich dir gezeigt, wie einfach es ist, das Schieberegister 74HC164D am Arduino Nano zu programmieren. Hier soll es nun darum gehen, wie du das Schieberegister 74HC164D in MicroPython programmierst. https://youtu.be/R0jV7th1C_k Du kannst dieses Beispiel mit dem Pi Pico 2 und natürlich auch mit dem Vorgängermodell, dem Pi Pico, mit und ohne WiFi Support nachbauen. Beide Mikrocontroller sind baugleich und somit voll kompatibel.

CJMCU-164 / Schieberegister 74HC164D

CJMCU-164 - Lieferumfang

Bezug des Schieberegisters 74HC164D / CJMCU-164

Du bekommst dieses Schieberegister als einfachen Baustein oder auf einer Platine mit Pinbeschriftungen. Die zuletzt genannte Variante habe ich mir von aliexpress.com für günstige 0,96 € besorgt. Die Versandkosten betrugen jedoch knapp 3,6 € somit war dieses vermeintliche Schnäppchen nicht viel günstiger als wenn man es bei einem deutschen Händler kauft. ebay.dealiexpress.comandroegg.de4,87 €*0,96 € (3,62 €)2,87 € (1,64 €) Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Lieferumfang Zum Lieferumfang des CJMCU-164 gehört neben der Platine lediglich noch zwei Stiftleisten, welche du noch anlöten musst.

Aufbau der Schaltung - Raspberry Pi Pico mit Schieberegister 74HC164D

Der Aufbau ist im Grunde dieselbe wie beim Arduino Nano, du benötigst eine Spannungsversorgung von 3.3V oder 5V und zwei digitale Pins.

Schaltung - Raspberry Pi Pico 2 mit Schieberegister 74HC164D und 7 Segmentanzeige Anschluss des Schieberegisters an den Pi Pico Das Schieberegister arbeitet mit einer Spannung zwischen 2V und 6V, der Pi Pico liefert dir an dem Pin "VBUS" 5V und der Pin "3V3(OUT)" liefert 3,3V.

RPiPico2 RP2350 Pinout PinRaspberry Pi PicoVCCVBUS (Pin 40)GNDGND (Pin 23)AGP16 (Pin 21)BVBUS (Pin 40)CLKGP17 (Pin 22)CLRVBUS (Pin 40) Anschluss der 7 Segmentanzeige an das Schieberegister Die 7 Segmentanzeige bekommst du in zwei Varianten, zum einen mit einer gemeinsamen Kathode und gemeinsame Anode. Das bedeutet, dass du am Pin 8 entweder VCC oder GND anschließen musst. In meinem Fall habe ich eines mit gemeinsamer Kathode und schließe dort GND über einen 220 Ohm Vorwiderstand an.

7 Segmentanzeige Pinout Pin7 SegmentanzeigeQ07Q16Q24Q32Q41Q59Q610Q75GND220 Ohm Widerstand > 8

Programmieren des Schieberegisters 74HC164D in MicroPython

Das kleine Arduino Programm lässt sich sehr einfach nach MicroPython portieren. Statt eines mehrdimensionalen Arrays nutze ich hier ein mehrdimensionales Tupel, ansonsten gibt es auch hier nicht viel Besonderes.

In dem inneren 8-stelligen Tupel sind die LEDs jeweils über die Indexe belegt. Über die Matrix links kannst du dir Zahlen und Buchstaben (begrenzt) aufbauen und hinterlegen. Im nachfolgenden Code werden die Zahlen von 0 bis 9 und die Buchstaben A, C und E auf der 7 Segmentanzeige angezeigt. Programm - Anzeigen der Zahlen 0 bis 9 und Buchstaben A,C & E an der 7 Segmentanzeige mit MicroPython & Schieberegister 74HC164DHerunterladen #Module zum ansteuern der GPIOs, sowie import machine #zum einlegen einer kleinen Pause import time #DataPin am GPIO16 als Ausgang angeschlossen dataPin = machine.Pin(16, machine.Pin.OUT) #ClockPin am GPIO17 als Ausgang angeschlossen clockPin = machine.Pin(17, machine.Pin.OUT) #Tupel mit mehreren Tupeln #Jede Stelle in dem inneren Tupel #repräsentiert den Zustand einer LED #auf der 7 Segmentanzeige digits = ( (1, 1, 1, 1, 1, 1, 0, 0), #Zahl 0 (0, 1, 1, 0, 0, 0, 0, 0 ), #Zahl 1 (1, 1, 0, 1, 1, 0, 1, 0 ), #Zahl 2 (1, 1, 1, 1, 0, 0, 1, 0 ), #Zahl 3 (0, 1, 1, 0, 0, 1, 1, 0 ), #Zahl 4 (1, 0, 1, 1, 0, 1, 1, 0 ), #Zahl 5 (0, 0, 1, 1, 1, 1, 1, 0 ), #Zahl 6 (1, 1, 1, 0, 0, 0, 0, 0 ), #Zahl 7 (1, 1, 1, 1, 1, 1, 1, 0 ), #Zahl 8 (1, 1, 1, 0, 0, 1, 1, 0 ), #Zahl 9 (1, 1, 1, 0, 1, 1, 1, 0 ), #Buchstabe A (1, 0, 0, 1, 1, 1, 0, 0 ), #Buchstabe C (1, 0, 0, 1, 1, 1, 1, 0 ) #Buchstabe E ) #Funktion zum anzeigen einer Zahl #Als Parameter wird ein Tupel mit #den Zuständen der LEDs erwartet. def displayValue(tpl): #Für jede Stelle im Tupel mache... #Die Liste wird Rückwärts durchlaufen! for idx in reversed(tpl): #den ClockPin deaktivieren clockPin.value(0) #den DataPin aktivieren/deaktivieren, #je nach Status dataPin.value(idx) #aktivieren des ClockPins clockPin.value(1) #eine Pause von 100 Millisekunden time.sleep(0.1) #Starten der Endlosschleife while True: #Für jedes Tupel mache... for idx in digits: #Aufrufen der funktion zum anzeigen einer Zahl displayValue(idx) #eine kleine Pause von 800 Millisekunden time.sleep(0.8) LED-Lauflicht programmieren Statt einer 7 Segmentanzeige kannst du auch recht einfach ein LED-Lauflicht programmieren, dazu ersetzen wir lediglich die Anzeige durch die LEDs, welche wir nacheinander aktivieren. Die Kathode (der Minuspol) der LED wird dazu an den GND Pin auf der Seite der Q0 bis Q7 Pins angeschlossen!

In diesem kurzen Beitrag möchte ich dir zeigen, wie du deinen BASIC Code im Autostart sofort auf dem Raspberry Pi Pico ausführen kannst, sobald dieser Strom erhält.

Wie du in BASIC auf dem Raspberry Pi Pico mit PicoMite programmierst, habe ich dir bereits in den nachfolgenden Beiträgen gezeigt. - BASIC Programmierung am Raspberry Pi Pico W, - Raspberry Pi Pico BASIC #1 - Überblick, - Raspberry Pi Pico BASIC #2 - Speicherverwaltung

Ein kleines Beispiel

Erstellen wir zuerst eine kleine Schaltung am Raspberry Pi Pico mit zwei LEDs, welche lediglich im Wechsel blinken sollen. Benötigte Ressourcen für das Beispiel Wenn du das kleine Beispiel nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico* oder Pico W*, - ein Micro-USB Datenkabel*, - eine Powerbank*, - zwei 5 mm, LEDs*, - zwei 220 Ohm Vorwiderstände*, - ein 400 Pin Breadboard* oder - ein GPIO Expander Board*, - diverse Breadboardkabel* Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Schaltung - Raspberry Pi Pico mit zwei LEDs Aufbau der Schaltung Der Aufbau der Schaltung ist sehr einfach und wenn du meinen Blog schon länger verfolgst, dann kennst du diese bestimmt bereits.

Schaltung - Wechselblinker am Raspberry Pi Pico Die beiden LEDs sind wie folgt am Raspberry Pi Pico angeschlossen LEDRaspberry Pi PicoLED - grünKathode (-)220 Ohm Widerstand > GNDAnode (+)GP16LED - blauKathode (-)220 Ohm Widerstand > GNDAnode (+)GP17 Aufbau und Programmieren in BASIC mit PicoMite Im nachfolgenden YouTube-Video erläutere ich dir, wie du die Schaltung aufbaust und in BASIC auf dem Raspberry Pi Pico programmierst. https://youtu.be/kOlrDn8a19M Programmieren von einem Wechselblinker mit zwei LEDs in BASIC Wie man eine LED in BASIC programmiert, hatte ich bereits in meinem ersten Beitrag gezeigt. Hier nun der Code um die beiden LEDs abwechselnd im Intervall von 250 ms. Blinken lässt. SetPin GP16, DOUT SetPin GP17, DOUT For index = 0 To 20 Step 1 Pin(GP16) = 1 Pin(GP17) = 0 Pause 250 Pin(GP16) = 0 Pin(GP17) = 1 Pause 250 Next index Pin(GP16) = 0 Pin(GP17) = 0 Der Quellcode sieht im Fullscreen-Editor folgendermaßen aus:

Autostart per Befehl aktivieren

Der Raspberry Pi Pico hat eine bemerkenswerte Historie und ist seit mehreren Jahren auf dem Markt. Ab Juli 2022 wurde er sogar mit integriertem WiFi ausgestattet, und in diesem Jahr kam die Bluetooth-Funktion hinzu. Trotz dieser Hardware-Upgrades bleibt eines konstant: das Pinout. In diesem Artikel werde ich detailliert auf das Pinout des Raspberry Pi Pico eingehen und es ausführlich erklären.

Der Raspberry Pi Pico (im nachfolgenden einfach nur als Pi Pico bezeichnet) verfügt über 40 Pins, an welchen diversen Funktionen anliegen.

Pinout des Raspberry Pi Pico

Hier nun zunächst das Pinout des Pi Pico.

Pinout des Raspberry PI Pico GPIOs Die Pins, welche in der Grafik mit GP gekennzeichnet sind, dienen als Ein- und Ausgang. Du findest an deinem Pi Pico von GP0 bis GP28 wobei die Pin GP 23,24,25 und 29 extern nicht verfügbar sind. ADCx Pins Zusätzlich findest du noch drei Pins, welche mit ADCx gekennzeichnet sind. Diese Pins sind an einen Analog-Digital-Wandler angeschlossen und somit dienen diese als Analog-IN. Stromversorgung von externen Sensoren / Aktoren Für die Stromversorgung hast du am Pi Pico acht GND Pins sowie einen 3.3V (3V3(OUT)) Pin und einen 5V Pin (VBUS) zur Verfügung. Über diese beiden Pins kannst du externe Sensoren und Aktoren mit Spannung versorgen, jedoch musst du beachten, dass maximal 300 mA am 3V3(OUT) Pin anliegen dürfen. Stromversorgung des Pi Pico Der Pi Pico kann über die Micro-USB Schnittstelle mit Strom versorgt werden, oder aber auch über den Pin VSYS. An den Pin VSYS kannst du eine Spannung zwischen 1,8 V und 5,5 V anlegen. Jedoch kannst du dann den zuvor genannten Pin VBUS welcher eigentlich 5 V liefert nicht mehr benutzen! Pins zum Ein-Ausschalten und RESET des Pi Pico Wenn du den Pin 3V3_EN mit GND verbindest, dann wird der Mikrocontroller ausgeschaltet. Um an deinem Pi Pico einen RESET durchzuführen, musst du lediglich den Pin RUN mit GND verbinden.

Anlegen einer externen Spannungsversorgung an den Raspberry Pi Pico via VSYS

Über den Pin VSYS kannst du wie erwähnt eine externe Stromversorgung anschließen, diese darf lediglich zwischen 1,8 V und maximal 5,5 V liegen.

Neustarten des Pi Pico mit einem Taster über Pin RUN

Wenn du deinen Pi Pico neu starten möchtest, dann musst du dir einen kleinen Taster zwischen GND und RUN schalten. Denn der Mikrocontroller verfügt leider über keinen eigenen RESET Taster, wie es andere Mikrocontroller hat.