Die Arduino-Plattform ist seit Jahren eine beliebte Wahl für Elektronikprojekte. Doch während C/C++ als Standard für die Programmierung von Mikrocontrollern gilt, bietet die Programmiersprache Rust eine moderne und sichere Alternative. Rust überzeugt durch seine Zuverlässigkeit, vor allem im Umgang mit Speicher und Nebenläufigkeit, was sie zu einer großartigen Option für Embedded-Entwicklung macht.
In diesem Beitrag zeige ich, wie du Visual Studio Code & PlatformIO einrichtest, um deinen Arduino UNO R3 in Rust zu programmieren. Wir werden Schritt für Schritt die Installation und Konfiguration durchgehen und ein einfaches Blink-Programm ausführen, um die grundlegenden Funktionen des Arduinos mit Rust zu testen.
Inhaltsverzeichnis
- Warum Rust eine starke Alternative für die Arduino-Programmierung ist
- Arduino UNO R3 – Ein Überblick
- Benötigte Ressourcen für diesen Beitrag
- Hinweise zum Aufbau des Beitrages
- Installieren von Git
- Einrichten von Visual Studio Code & PlatformIO
- Installieren der Microsoft Build Tools für C++
- Installieren von Rust
- Installieren von Scoop
- Installieren des AVR-GCC Compilers über Scoop
- Einrichten des Arduino-Projektes für Rust
- Quellenangabe
Warum Rust eine starke Alternative für die Arduino-Programmierung ist
- Speichersicherheit ohne Garbage Collection: Rust verhindert Speicherfehler wie Pufferüberläufe und unzulässige Speicherzugriffe zur Compile-Zeit, was im Embedded-Bereich entscheidend ist, wo Ressourcen begrenzt und Fehler schwer zu diagnostizieren sind.
- Null-Sicherheit und Fehlervermeidung: Im Gegensatz zu C/C++ eliminiert Rust das Risiko von Null-Zeigern und damit verbundene Abstürze. Stattdessen nutzt es das Option-Typ-System, um den Umgang mit fehlenden Werten sicherzumachen.
- Effizientes Multithreading: Rust bietet durch den Borrow-Checker und das Ownership-Modell eine sichere Handhabung von Threads und Nebenläufigkeit, ohne dabei klassische Race-Conditions zuzulassen.
- Hohe Performance: Rust liefert eine Performance auf dem Niveau von C/C++, da es direkt in Maschinencode kompiliert wird, ohne dabei auf Sicherheitsmechanismen zu verzichten. Das ist besonders wichtig bei ressourcenbeschränkten Mikrocontrollern wie dem Arduino.
- Moderne und lesbare Syntax: Rusts Syntax ist klar strukturiert und vermeidet viele der Fallstricke traditioneller Embedded-Sprachen, was den Einstieg für Entwickler erleichtert und gleichzeitig die Codewartung vereinfacht.
- Wachsende Embedded-Community: Rust hat in den letzten Jahren stark an Popularität im Embedded-Bereich gewonnen. Es gibt zahlreiche Bibliotheken und eine aktive Community, die spezifisch für Embedded-Projekte entwickelt.
- Cargo und starkes Tooling: Das integrierte Build-System Cargo erleichtert das Management von Abhängigkeiten, Tests und Cross-Compiling. Das macht die Entwicklung für Embedded-Systeme wie Arduino deutlich effizienter.
Arduino UNO R3 – Ein Überblick
Den Arduino UNO R3 habe ich auf diesem Blog bereits in mehreren Beiträgen vorgestellt, ebenso wie verschiedene Schaltungen und Anwendungsbeispiele. Obwohl dieser Mikrocontroller schon etwas älter ist, überzeugt er weiterhin durch seine einfache Handhabung und die Vielzahl an digitalen Ein- und Ausgängen sowie analogen Eingängen. Moderne Schnittstellen wie WiFi oder Bluetooth fehlen ihm zwar von Haus aus, doch lassen sich diese Funktionen problemlos mit entsprechenden Erweiterungsmodulen nachrüsten, was ihn nach wie vor zu einer flexiblen und praktischen Wahl für zahlreiche Projekte macht.
Die Mikrocontroller kannst du entweder direkt als Original von Arduino.cc im Shop erwerben oder als günstigere Clone-Versionen, zum Beispiel auf eBay.de oder AliExpress.com. In meinen Tests konnte ich keine nennenswerten Unterschiede in der Leistung feststellen, die die günstigen China-Kopien schlechter gemacht hätten. Lediglich bei den Nachbauten musste ich den CH340G Serial-USB-Treiber manuell installieren, was aber schnell erledigt war.
Vergleich der technischen Daten der Arduinos
Es gibt neben dem Arduino UNO R3 auch eine handvoll weiterer Mikrocontroller, nachfolgend beschränke ich mich auf die gängigen aus dem Hause Arduino welche du im Shop unter arduino.cc bestellen kannst.
| Arduino UNO R3 | Arduino Nano V3 | Arduino Mega 2560 R3 | |
|---|---|---|---|
| Mikrochip | ATmega328P | ATmega328 | ATmega2560 |
| Taktgeschwindigkeit | 16 MHz | 16 MHz | 16 MHz |
| Speicher | 32 KB, davon 0.5 KB für den Bootloader reserviert | 256 KB, davon 8 KB für den Bootloader reserviert | |
| SRAM | 2 KB | 2 KB | 8 KB |
| EEPROM | 1 KB | 1 KB | 4 KB |
| digitale I/O | 14 | 22 | 54 |
| PWM | 6 | 6 | 15 |
| analoge I/O | 6 | 8 | 16 |
| Abmaße (LxB) | 68,6 x 53,4 mm | 18 x 45 mm | 101,52 x 53,3 mm |
| Preis (zzgl. Versand) | 29,30 € | 26,80 € | 51,20 € |
Benötigte Ressourcen für diesen Beitrag
Wenn du das nachfolgende Beispiel ausführen möchtest, dann benötigst du:
- einen Mikrocontroller der Arduino-Familie
- ein passendes USB-Datenkabel
- Git
- Visual Studio Code, sowie
- die Erweiterung PlatformIO für VS-Code
- den aktuellen Rust Compiler
Hinweise zum Aufbau des Beitrages
Der Artikel basiert auf einer englischen Anleitung, die ich umfassend überarbeiten musste, da sie nicht mehr aktuell war und einige Schritte unvollständig waren. Die einzelnen Kapitel des Beitrags sind aufeinander abgestimmt und sollten der Reihenfolge nach durchgearbeitet werden, um ein reibungsloses Verständnis sicherzustellen.
Installieren von Git
Git ist ein Open-Source-System zur Verwaltung von Versionen, das für die schnelle und leistungsstarke Handhabung von Projekten jeglicher Größe konzipiert wurde. Wir benötigen dieses, um das Repository Rahix/avr-hal-template zu clonen, aber dazu später mehr.
Wenn du in Git noch nicht so lange unterwegs bist und alle Kommandozeilen befehle kennst, dann kann ich dir TortoiseGit empfehlen. Dieses Tool bietet dir eine GUI für den täglichen Einsatz von Git.
Einrichten von Visual Studio Code & PlatformIO
Wie du Visual Studio Code installierst, habe ich dir bereits im Beitrag Rust: Die Grundlagen – 1. Installation und Konfiguration ausführlich erläutert. Beim Installer gibt es jedoch nicht viel zu beachten, daher kannst du den Wizard mit den Standardeinstellungen durchlaufen.
Wenn du Visual Studio Code installiert hast, dann kannst du die Erweiterung PlatformIO mit nur einem Klick über die “Extensions” installieren.
Zusätzlich benötigen wir noch die Erweiterung für die Rust Programmierung.
Installieren der Microsoft Build Tools für C++
Für das Compilieren des Codes benötigen wir den Linker welchen wir über das Microsoft Build Tools für C++ installieren können.
Installieren von Rust
Den Rust Compiler kannst du unter https://www.rust-lang.org/tools/install kostenfrei als 32Bit & 64Bit Version herunterladen. In meinem Fall nehme ich die 64Bit Version.
Installieren von Scoop
Scoop ist ein Paketmanager für Windows-Systeme, welchem man mit dem nachfolgenden Befehl über PowerShell nachinstallieren kann:
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
irm get.scoop.sh | iex 
Installieren des AVR-GCC Compilers über Scoop
Nachdem Scoop installiert wurde, können wir nun den für unsere Arduino Projekte benötigte AVR-GCC Compiler installieren. Dazu geben wir wiederum über PowerShell nachfolgenden Befehl ein:
scoop install avr-gcc
Einrichten des Arduino-Projektes für Rust
Installieren von cargo-generate
Das Tool cargo-generate ist eine leistungsfähige Erweiterung für cargo, mit welcher man zum Beispiel GitHub Repos clonen kann.
cargo install cargo-generateErstellen eines lokalen Git Verzeichnisses
Für die Arduino Projekte erstelle ich unter C:\Rust ein extra Verzeichnis git in welchem ich dann die jeweiligen Projekte ablegen möchte.
Zunächst starten wir mit dem clonen eines GitHub Repositorys, welches ein Beispiel und alle benötigten Ressourcen enthält:
git clone https://github.com/Rahix/avr-hal-template.git
Eigentlich sollte man das Repository mit cargo-generate clonen, jedoch ist dieses Feature in der neuen Version als depricated markiert und somit entfällt es in zukunft. Hier weiche ich von der engl. Anleitung ab und verwende Git.
Anpassen der TOML Dateien
Der Entwickler des Projektes AVR-HAL-TEMPLATE hat eine Templateengine für seinen Code verwendet, mit welcher das Programm über Parameter konfigurierbar ist. Dieses Feature wird zunächst entfernt, dazu modifieren wir die Dateien:
- .cargo\config.toml
- src\main.rs
- Cargo.toml
In der Datei Cargo.toml passen wir noch die Felder für package.name, package.authors sowie bin.name an.
[package]
name = "ArduinoBlink"
authors = ["Stefan Draeger"]
[[bin]]
name = "ArduinoBlink"Aktualisieren der RUST-Toolchain
Das Projekt ist schon etwas älter, daher müssen wir zusätzlich den konfigurierten NightlyBuild von Rust aktualisieren. Dazu ändern wir den Wert toolchain.channel in der Datei rust-toolchain.toml in “nightly-2024-04-14”.
Installieren und Konfigurieren von ravedude
Das Tool ravedude wird benötigt, um das Kompilat auf den Mikrocontroller zu überspielen. Dieses Tool können wir über das Terminalfenster von Visual Studio Code mit dem Befehl “cargo install ravedude” installieren.
Im Anschluss der Installation von ravedude müssen wir die Umgebungsvariable “RAVEDUDE_PORT” anlegen. Der Wert der Umgebungsvariable ist der jeweilige Port, an welchem der Mikrocontroller angeschlossen ist.
Bauen und ausführen des Rust Projektes auf dem Arduino
Nachdem nun alles installiert und konfiguriert ist, können wir das Projekt bauen und ausführen. Dazu geben wir im Terminal zunächst “cargo build” und anschließend “cargo run” ein.
Es wird nun das Programm gebaut und auf den Mikrocontroller überspielt, wie bei Mikrocontroller üblich bleibt dieses Programm erhalten bis ein neues aufgespielt wird. Es wird also nicht beendet wenn du Strg+C im Terminal betätigst!
Quellenangabe
Für diesen Beitrag habe ich mich der englischen Anleitung von https://blog.logrocket.com/complete-guide-running-rust-arduino/ bedient und an einigen Stellen hier im Beitrag sinnvoll ergänzt.