Als Maker, der immer auf der Suche nach erschwinglichen und dennoch leistungsstarken Mikrocontroller-Boards ist, habe ich mich in den Raspberry Pi Pico verliebt. Seine kompakte Größe, beeindruckende Leistung und vielseitigen Programmieroptionen machen ihn perfekt für eine Vielzahl von Projekten. In diesem Beitrag stelle ich einige meiner Lieblingsprojekte mit dem Pico vor, die seine Fähigkeiten demonstrieren, von einfachen Anfängerprojekten bis hin zu fortgeschritteneren Anwendungen.
Projekt 1: Blinkende LED mit benutzerdefinierten Mustern (für Anfänger geeignet)
Hardware-Einrichtung
Für dieses Projekt benötigen Sie einen Raspberry Pi Pico, ein Steckbrett, eine LED, einen 220-Ohm-Widerstand und Überbrückungskabel. Verbinden Sie die Anode der LED über den Widerstand mit dem GPIO-Pin 25 und die Kathode mit dem Massepin des Pico. Diese Konfiguration stellt sicher, dass die LED durch den Widerstand vor Überstrom geschützt ist und zur Steuerung ordnungsgemäß mit dem GPIO-Pin des Pico verbunden ist.
Code-Implementierung
Mit MicroPython erstellen wir ein Programm, das die LED in verschiedenen Mustern blinken lässt. Importieren Sie zunächst die erforderlichen Module:
from machine import Pin, Timer
Dann initialisieren Sie den LED-Pin:
led = Pin(25, Pin.OUT)
Erstellen Sie ein Timer-Objekt, um die Blinkintervalle zu steuern. Der folgende Codeausschnitt richtet einen Timer ein, der die LED alle 500 Millisekunden umschaltet:
tim = Timer()
def tick(timer):
led.toggle()
tim.init(freq=2, mode=Timer.PERIODIC, callback=tick)
Testen und Anpassen
Sobald der Code auf den Pico hochgeladen wurde (indem Sie ihn als main.py speichern und den Pico anschließen), sollte die LED zu blinken beginnen. Sie können die Blinkmuster anpassen, indem Sie die Timer-Periode ändern oder komplexere Funktionen erstellen, um die Ein- und Ausschaltzeiten der LED zu steuern. Sie könnten beispielsweise eine Funktion erstellen, die die LED in einem Morsezeichenmuster blinken lässt, oder ein Muster, das sich basierend auf einer externen Eingabe ändert. Dieses Projekt ist eine großartige Möglichkeit, sich mit der GPIO-Pin-Steuerung und MicroPython auf dem Pico vertraut zu machen.
Projekt 2: Temperaturüberwachungssystem (Mittelstufe)
Hardwareanforderungen
Besorgen Sie sich einen Raspberry Pi Pico, einen DS18B20-Temperatursensor, einen 4,7-kOhm-Widerstand, ein Steckbrett und Überbrückungskabel. Der DS18B20 verwendet eine 1-Wire-Schnittstelle, verbinden Sie also seinen VCC mit 3,3 V, GND mit Masse und den DATA-Pin mit dem GPIO-Pin 18 des Pico. Der Widerstand wird zwischen dem DATA-Pin und VCC angeschlossen, um das Signal anzuheben. Diese Konfiguration gewährleistet eine stabile Kommunikation zwischen dem Pico und dem Temperatursensor, da das 1-Wire-Protokoll einen geeigneten Pull-up-Widerstand für eine zuverlässige Datenübertragung erfordert.
Code-Entwicklung
Verwenden Sie in MicroPython die Bibliotheken „onewire“ und „ds18x20“, um mit dem Sensor zu kommunizieren. Importieren Sie zunächst die Bibliotheken und initialisieren Sie den 1-Wire-Bus:
import machine
import onewire
import ds18x20
import time
Richten Sie dann den Bus auf dem ausgewählten GPIO-Pin ein:
ds_pin = machine.Pin(18)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
Nach Geräten suchen und ein DS18B20-Objekt erstellen:
roms = ds_sensor.scan()
print('Found DS devices: ', roms)
Der folgende Code liest die Temperatur und gibt sie auf der Konsole aus:
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
print(ds_sensor.read_temp(rom))
time.sleep(2)
Datenerfassung und Anzeige
Um das System noch nützlicher zu machen, können Sie ein kleines OLED-Display (über I2C angeschlossen) hinzufügen, um die Temperatur in Echtzeit anzuzeigen, oder die Daten in einer Datei auf einem angeschlossenen Computer protokollieren. Für das OLED-Display können Sie die Bibliothek ssd1306 verwenden. Importieren Sie zunächst die erforderlichen Module und initialisieren Sie die I2C-Schnittstelle:
from machine import I2C, Pin
import ssd1306
i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000)
oled = ssd1306.SSD1306_I2C(128, 32, i2c)
Ändern Sie dann die Temperatur-Leseschleife, um die Temperatur auf dem OLED anzuzeigen:
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
print(temp)
oled.fill(0)
oled.text(f"Temp: {temp} C", 0, 0)
oled.show()
time.sleep(2)
Für die Datenprotokollierung können Sie den folgenden Code verwenden, um die Temperaturdaten in eine Datei im internen Dateisystem des Pico zu schreiben:
file = open('temperatures.txt', 'w')
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
print(temp)
file.write(f"{time.time()},{temp}\n")
file.flush()
time.sleep(2)
Dieses Projekt zeigt, wie man mit den GPIO-Pins des Pico externe Sensoren anschließen kann, und demonstriert dessen Fähigkeit, Sensordaten zu erfassen.
Projekt 3: IoT-Daten-Uploader (Fortgeschrittene)
Hardware-Einrichtung
Sie benötigen einen Raspberry Pi Pico W (mit integriertem WLAN), einen BME280-Umgebungssensor (misst Temperatur, Luftfeuchtigkeit und Druck), ein Steckbrett und Überbrückungskabel. Verbinden Sie den BME280 über I2C mit dem Pico: SDA mit GPIO 8, SCL mit GPIO 9, VCC mit 3,3 V und GND mit Masse. Diese Verbindung ermöglicht es dem Pico, über den I2C-Bus mit dem BME280-Sensor zu kommunizieren und so Umgebungsdaten abzurufen.
Code und IoT-Integration
Verwenden Sie MicroPython auf dem Pico W und verbinden Sie sich zunächst mit einem WLAN-Netzwerk. Richten Sie die WLAN-Anmeldedaten ein:
import network
ssid = 'your_SSID'
password = 'your_PASSWORD'
Verbindung über die Netzwerkschnittstelle herstellen:
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, password)
while not wlan.isconnected():
pass
print('Connected to WiFi')
Initialisieren Sie anschließend den BME280-Sensor mit der Klasse „bme280”. Möglicherweise müssen Sie die Bibliothek „bme280” installieren, falls diese noch nicht installiert ist. So können Sie sie initialisieren:
import bme280_i2c
i2c = machine.I2C(0, sda=machine.Pin(8), scl=machine.Pin(9))
bme = bme280_i2c.BME280_I2C(i2c)
Der Code liest die Sensordaten und lädt sie mithilfe der HTTP-POST-Methode auf eine IoT-Plattform wie Ubidots oder Thingspeak hoch. Hier ist eine vereinfachte Version der Daten-Upload-Funktion:
import urequests
def upload_data(temperature, humidity, pressure):
url = 'https://industrial.api.ubidots.com/api/v1.6/devices/your_device_label'
headers = {'X-Auth-Token': 'your_token', 'Content-Type': 'application/json'}
data = '{"temperature": %s, "humidity": %s, "pressure": %s}' % (temperature, humidity, pressure)
response = urequests.post(url, headers=headers, data=data)
if response.status_code == 200:
print('Data uploaded successfully')
else:
print('Error uploading data')
response.close()
while True:
temperature, pressure, humidity = bme.values
temperature = float(temperature.strip(' C'))
humidity = float(humidity.strip(' %'))
pressure = float(pressure.strip(' hPa'))
upload_data(temperature, humidity, pressure)
time.sleep(60)
Testen und Skalierbarkeit
Sobald der Code ausgeführt wird, verbindet sich der Pico W mit dem Internet, liest Daten vom BME280 und lädt sie auf die ausgewählte IoT-Plattform hoch. Sie können die Daten in Echtzeit auf dem Dashboard der Plattform anzeigen. Dieses Projekt unterstreicht die drahtlosen Fähigkeiten des Pico W und zeigt, wie man mit dem Pico skalierbare IoT-Lösungen entwickelt, die den Weg für Smart-Home-Anwendungen, Umweltüberwachung und vieles mehr ebnen. Wenn Sie dieses Projekt skalieren möchten, können Sie weitere Sensoren hinzufügen, die Datenerfassungsintervalle anpassen oder sogar eine robustere IoT-Plattform mit erweiterten Analysefunktionen verwenden.
Pico-Projekte für PIO, USB, Sensorik und Regelung
Sinnvolle Projekte vermitteln jeweils ein Hardwareprinzip und ermöglichen eine messbare Funktionsprüfung. Zuerst die genaue Platine der Pico-Familie wählen, da Prozessor, Funk, Speicher, Pinbelegung und Softwareunterstützung variieren; externe Schnittstellen anschließend nach den dokumentierten 3,3-V-Logikgrenzen auslegen.
- Mit Erfassung beginnen: kalibrierten Sensor mit Zeitstempeln und festem Abtastintervall protokollieren.
- PIO erkunden: zeitkritische eigene Schnittstelle erzeugen oder erfassen und an Prüfpins verifizieren.
- USB-Gerät bauen: kleine Bedien- oder serielle Funktion mit definiertem Wiederverbinden umsetzen.
- Regelkreis ergänzen: Drehzahl, Licht oder Temperatur an einer sicheren, begrenzten Strecke regeln.
- Prototyp entwickeln: Entkopplung, Pegelanpassung, Steckerschutz, Prüfpunkte und reproduzierbaren Build vorsehen.
Fazit
Der Raspberry Pi Pico ist ein fantastisches Werkzeug für Maker aller Erfahrungsstufen und bietet unendliche Möglichkeiten für kreative Projekte. Ganz gleich, ob Sie gerade erst mit einem einfachen LED-Blinkprojekt beginnen oder ein fortschrittliches IoT-System aufbauen – dank seiner Erschwinglichkeit, Leistungsfähigkeit und Benutzerfreundlichkeit ist der Pico die erste Wahl. Ich hoffe, diese Projekte inspirieren Sie dazu, mit Ihren eigenen Pico-Konstruktionen zu experimentieren. Teilen Sie Ihre Projekte in den Kommentaren unten mit – ich würde mich sehr freuen, Ihre Kreationen zu sehen!
