Mit Rust die GPIO des Raspberry Pi ansteuern

C ist bei vielen Geeks wegen seines komplexen Speichermanagements und des Fehlens moderner Programmierkonzepte in Ungnade gefallen. Rust bietet eine Alternative für Programme, die schnell sein müssen.

Im Jahr 2015 erschien die erste stabile Version von Rust. Die Programmiersprache zielt auf effizientes Speichermanagement und hohe Ausführungsgeschwindigkeit. Besonderen Wert legen die Entwickler auf das Erzeugen sicherer Programme. Der Compiler weist potenziell bei der Ausführung problematischen Code direkt ab.

Rust möchte als moderne Alternative zu C/C++ punkten und kommt oft im Betriebssystemumfeld oder für Embedded-Systeme zum Einsatz. Eine Reihe von Kommandozeilenwerkzeugen gewährleistet, dass die Arbeit mit Rust möglichst unkompliziert ausfällt. Für Konfigurationsaufgaben aller Art gibt es das Tool Rustup, der interne Paketmanager heißt Cargo. Weiterreichende Informationen zu Rust bietet die Homepage der Projekts [1].

Installation

Für unseren Testaufbau verwenden wir einen Raspberry Pi 4 aus der Bastelkiste und spielen per RPi Imager Raspberry Pi OS (64 Bit) auf eine über den USB-3-Port angeschlossene Festplatte mit 1 TByte Kapazität. Nach dem Booten des RasPi verbinden wir uns per SSH auf dessen Konsole und installieren Rust über die Kommandos aus Listing 1. Das Installationsskript fragt nach, wie die Installation laufen soll; für uns ist die erste Option die richtige Wahl. Danach dauert es etwas, bis alle Komponenten heruntergeladen und eingebunden sind. Um die Umgebungsvariablen korrekt zu setzen, müssen wir uns noch einmal neu anmelden.

$ sudo apt update
$ sudo apt upgrade
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Hello World

Um den Traditionen der Softwareentwicklung treu zu bleiben, starten wir mit dem altbekannten “Hello World”. Dazu erstellen wir mit dem Kommando cargo new hello_world über den Paketmanager ein neues Projekt. Dabei entsteht das neue Verzeichnis hello_world/ mit dem Unterverzeichnis src/ für die Quelldateien des Projekts.

Außerdem legt der Paketmanager die Datei Cargo.toml an, in der die Abhängigkeiten und Metadaten für das Projekt definiert sind. Freundlicherweise hat Cargo außerdem in src/ die Datei main.rs erzeugt. Werfen Sie einen Blick hinein, stellen Sie fest, dass es sich dabei bereits um ein “Hello-World”-Programm handelt. Der Befehl cargo run führt es direkt aus, woraufhin der Text “Hello, world!” in der Konsole erscheint.

GPIO

Nun geht es ans Einbinden der GPIO des Raspberry Pi. Wir nutzen für unseren Test eine RGB-LED, die wir über drei Vorwiderstände an die GPIO-Header-Pins 8, 10 und 12 (BCM: GPIO14, GPIO15, GPIO18) anschließen. Den Testaufbau samt Diode veranschaulicht Abbildung 1.

Abbildung 1: Der Testaufbau besteht unter anderem aus einem Raspberry Pi 4 und einer über den USB-3-Port angeschlossenen Festplatte.

Der Zugriff erfordert eine passende Bibliothek. Im Netz tummeln sich dafür einige infrage kommende Kandidaten. Wir entscheiden uns für die Raspberry Pi Peripheral Access Library (RPPAL [2]). Sie unterstützt alle RasPi-Modelle sowie die Schnittstellen GPIO, I²C, PWM, SPI und UART. Zudem wirkt das Github-Repository recht lebendig.

Listing 2 zeigt die Kommandos zum Anlegen eines neuen Rust-Projekts mit RPPAL. Werfen Sie nach deren Absetzen einen Blick in die Cargo.toml: Dort stoßen Sie nun auf die hinzugefügte Abhängigkeit zu RPPAL. Merken Sie sich, dass Cargo von allein für die Pflege der Datei sorgt.

$ cargo new blink
$ cd blink/
$ cargo add rppal

Als Nächstes wenden wir uns dem Blink-Programm aus Listing 3 zu. Auf den ersten Blick mutet dessen Syntax etwas ungewohnt an, aber prinzipiell finden sich alle Teile eines Blink-Programms wieder: Da sind zunächst die nötigen Importe, eingeleitet mit dem Schlüsselwort use (Zeile 1 bis 4). Danach folgt die Definition einiger Konstanten für die LED-Pins. Hier könnten Sie die Datentypen (u8) zwar weglassen, doch dann sucht der Compiler einen ihm passend erscheinenden, möglicherweise suboptimalen Typ aus. Die Bibliothek RPPAL verwendet die BCM-Nummern 14, 15 und 18 für die GPIO-Pins.

use std::error::Error;
use std::thread;
use std::time::Duration;
use rppal::gpio::Gpio;
const LED_RED: u8 = 18;
const LED_GREEN: u8 = 15;
const LED_BLUE: u8 = 14;
fn main() -> Result<(), Box<dyn Error>> {
  let mut led_red = Gpio::new()?.get(LED_RED)?.into_output();
  let mut led_green = Gpio::new()?.get(LED_GREEN)?.into_output();
  let mut led_blue = Gpio::new()?.get(LED_BLUE)?.into_output();
  loop {
    led_red.set_low();
    thread::sleep(Duration::from_millis(200));
    led_red.set_high();
    thread::sleep(Duration::from_millis(200));
    led_green.set_low();
    thread::sleep(Duration::from_millis(200));
    led_green.set_high();
    thread::sleep(Duration::from_millis(200));
    led_blue.set_low();
    thread::sleep(Duration::from_millis(200));
    led_blue.set_high();
    thread::sleep(Duration::from_millis(200));
  }
}