Embedded-Entwicklung bedeutet oft harte Echtzeitanforderungen, knappe Ressourcen und komplexes Multithreading. Traditionell gelöst mit klassischen Echtzeitbetriebssystemen wie FreeRTOS. Rust Embassy bietet einen innovativen Ansatz, der Sicherheit, Effizienz und einfache Nebenläufigkeit vereint. Embassy nutzt die Stärken der Rust-Programmiersprache, wie Speicher- und Threadsicherheit ohne Garbage Collector und ersetzt klassische RTOS-Konzepte durch ein eventbasiertes System. Das Ergebnis: Weniger Bugs, besser testbarer Code und eine klarere Architektur, besonders in komplexen, nebenläufigen Anwendungen.
In diesem Blogbeitrag werden wir die Schritte zur Einrichtung einer Entwicklungsumgebung für Rust auf einem Raspberry Pi Pico mithilfe von Windows Subsystem for Linux (WSL) und dem Pico SDK durchgehen. Dabei werden wir die erforderlichen Befehle erläutern, die dir helfen, deine Entwicklungsumgebung erfolgreich zu konfigurieren.
Um mit der Einrichtung zu beginnen, musst du zunächst usbipd installieren, ein Tool, das es dir ermöglicht, USB-Geräte über das WSL zu verwenden. Dies kannst du entweder durch den Download von usbipd-win oder durch den folgenden Befehl in der PowerShell tun
winget install --interactive --exact dorssel.usbipd-win
Für das Beispiel wurde die Ubuntu-22.04 Distribution verwendet. Dieser kann auch einen Namen gegeben werden. Mit diesem Namen kann mit folgendem Befehl die WSL-Instanz gestartet werden.
wsl -d Ubuntu-22.04
Nun kommen wir zum Grossteil der Installationen. Diese werden auf dem WSL vorgenommen. Als erstes wird git installiert.
sudo apt-get install git
Mit git werden die Aktuellen Versionen der verschiedenen Repos auf das WSL geklont. Das erste Repo, dass geklont wird, ist das Pico-sdk. unter folgendem Link kann die URL abgerufen werden (pico-sdk). Das Pico-sdk umfasst verschiedene Header und libraries, die zum bauen von Programmen für die Raspberry Pi Pico Serie ermöglichen. Wir müssen uns nicht weiter mit dem Inhalt des SDK beschäftigen, da es vom Picotool verwendet wird, welches uns das flashen des Pico ermöglicht. Bevor wir das Picotool installieren, beginnen wir zuerst mit der Installation der Pico-sdk!
Das Pico-sdk Repo wird in das Home Verzeichnis geklont.
git clone https://github.com/raspberrypi/pico-sdk.git
Zusätzlich müssen wir auch das Submodul mbedtls updaten. Hierzu müssen wir aber zuerst in den Ordner des Pico-sdk (cd pico-sdk) und dann folgenden Befehl ausführen.
git submodule update --init lib/mbedtls
Vor wir das SDK kompilieren können, müssen noch einige Abhängigkeiten installiert werden. Diese sind auf der GitHub Seite von pico-sdk zu finden. Der Einfachheit halber sind die Abhängigkeiten in folgendem Befehl zusammengefasst.
sudo apt install cmake python3 build-essential gcc-arm-none-eabi libnewlib-arm-none-eabi libstdc++-arm-none-eabi-newlib -y
Anschliessend kann das SDK aus dem pico-sdk Verzeichnis gebaut werden.
sudo cmake . sudo make
Das Picotool in Kombination mit der pico-sdk ermöglichen das Flashen des Pico. Es werden auch andere Befehle für die Interaktion mit dem Pico zur Verfügung gestellt. Die volle liste der Befehle kann auf der GitHub Seite von picotool nachgesehen werden.
Als erstes wird das Repo in den home Ordner geklont.
git clone https://github.com/raspberrypi/picotool.git
Abhängikeiten installieren…
sudo apt install libusb-1.0-0-dev build-essential pkg-config
Es muss ein Ordner für den Buildprozess erstellt werden. Die Navigation geht vom Home Verzeichnis aus.
cd picotool mkdir build cd build sudo cmake -DPICO_SDK_PATH=/home/nick/pico-sdk .. sudo make sudo make install
Das das Picotool ohne «sudo» ausgeführt werden kann, müssen die udev rules ergänzt werden.
sudo cp udev/99-picotool.rules /etc/udev/rules.d/
Nun muss noch Embassy auf dem WSL installiert werden. Die Dateien werden auf dem Hostpc bearbeitet und dann mit einem Script in die selbe umgebeung auf dem WSL geladen, kompiliert und auf das Pico geflasht.
Die Rust Installation wir nach Anleitung auf der Rust Webseite vorgenommen. Im home Verzeichnis wird dann Embassy geklont.
Das Skript kopiert die Dateien vom Windows System auf das WSL. Das Skript wird in das Embassy Projekt Verzeichnis gelegt (Stufe Cargo.toml, Cargo-lock usw.).
mkdir script cd script nano build_on_wsl.ps1
$WSL_INSTANCE = "Ubuntu" $BIN_NAME = "blinky" $WSL_PROJECT_PATH = "/home/nick/embassy/examples/rp235x" $BUILD_DIR = $WSL_PROJECT_PATH + "/target/thumbv8m.main-none-eabihf/release" # Get the current directory in Windows $LOCATION_PATH = Get-Location $WINDOWS_PATH = Join-Path $LOCATION_PATH "src\bin" # Set the destination path in WSL $WSL_BIN_PATH = Join-Path $WSL_PROJECT_PATH "src/bin" # Copy files from Windows to WSL robocopy $WINDOWS_PATH "\\wsl.localhost\$WSL_INSTANCE$WSL_BIN_PATH" /E /MIR # Print success message Write-Host "Successfully synced $WINDOWS_PATH to WSL at $WSL_BIN_PATH" # Compile the code using cargo wsl -d $WSL_INSTANCE -- bash -c "source ~/.profile && cd '$WSL_PROJECT_PATH' && cargo build --bin '$BIN_NAME' --release" # Flash the files to RP wsl -d $WSL_INSTANCE -- bash -c "picotool load -t elf $BUILD_DIR/$BIN_NAME" wsl -d $WSL_INSTANCE -- bash -c "picotool reboot"
Für das File müssen noch die korrekten Berechtigungen gesetzt werden.
chmod +x build_on_wsl.ps1
Die Installation ist geschafft! Nun sollte das WSL neu gestartet werden, dass wir anschliessend die Verbindung zum Pico testen können.
Nun ist es an der Zeit die Verbindung zum Pico zu testen! Momentan hat das WSL noch keinen Zugriff auf die USB Ports des Hostsystems (in meinem Fall Windows). Diesen Zugriff müssen wir an das WSL weiterleiten. Für die Weiterleitung der USB-Schnittstelle wird usbipd verwendet. Die Installation auf Windows wird mit folgendem Befehl gemacht.
winget install --interactive --exact dorssel.usbipd-win
Auf dem Windows System wird dann auch die Installation überprüft und die Schnittstelle an das WSL weitergeleitet. Diese Befehle werden in Powershell ausgeführt. Das Powershell Fenster muss offen bleiben! Ansonsten wird das Pico im WSL nicht erkannt.
usbipd list usbipd bind --busid <BUSID PICO> usbipd attach -a --wsl --busid <BUSID PICO>
Falls diese Installation und Freigabe geklappt haben, kann auf dem WSL geprüft werden, ob das Pico erkannt wird. Hierzu muss das Pico im Bootselect-Modus angeschlossen werden. Während das Pico eingesteckt wird, muss der Knopf auf dem Pico gedrückt gehalten werden (mit BOOTSEL angeschrieben). Das Pico befindet sich nun im Bootselect-Modus und der Knopf kann wieder losgelassen werden. Das Pico befindet sich im Bootselect-Modus, bis es neu gestartet wird.
picotool info -d
Wenn alles bis jetzt gut gelaufen ist, sollte die Ausgabe ungefähr so aussehen:
Device Information type : RP2350 package : QFN60 chipid : <Chip ID> flash devinfo: <devinfo> current cpu: ARM available cpus: ARM, RISC-V default cpu: ARM secure boot: 0 debug enable: 1 secure debug enable: 1 flash size: 4096K
Perfekt! Das Pico gibt Informationen an das WSL!
Für dieses Beispiel wird VS-Code als IDE und das Terminal in VS-Code verwendet. In meinem Fall werde ich das blinky Beispiel für das rp235x verwenden. Das Skript ist ins Projektverzeichnis kopiert, die WSL ist gestartet und die USB Schnittstelle ist für das WSL freigegeben. Nun kommt der Moment der Wahrheit…
.\build_on_wsl.ps1
Perfekt! Das Pico blinkt!
Im Powershell Fenster ist zu sehen, dass das WSL keinen Zugriff mehr auf das Pico hat. Das ist gut so, da das Pico von Skript neu gestartet wird und sich nicht mehr im Bootselect-Modus befindet. Das Log zeigt auch, dass das Programm erfolgreich in den Flash geladen wurde. Falls das Programm zum ersten Mal ausgeführt wird, werden noch einige Abhängigkeiten heruntergeladen und kompiliert.
Mit Embassy und Rust lassen sich robuste, sichere Embedded-Anwendungen entwickeln. Wie du gesehen hast, ist der Weg vom Windows-Entwicklungssystem bis auf den Raspberry Pi Pico gut machbar. Sobald die Toolchain eingerichtet ist, geht das Flashen schnell und du profitierst von einem modernen, asynchronen Ansatz ganz ohne klassisches RTOS! Ideal für alle, die Performance wollen, aber keine Kompromisse bei Sicherheit und Wartbarkeit eingehen möchten.
Schreiben Sie einen Kommentar