9,99 €
Mehr erfahren.
- Herausgeber: Selbstverlag
- Kategorie: Fachliteratur
- Sprache: Deutsch
Hallo Arduino-Entwickler! Dieses Buch führt dich Schritt für Schritt in die Welt von Rust ein, speziell für die Entwicklung auf dem Arduino Uno. Du erhältst eine solide Grundlage in Rust und lernst, wie du sichere, performante und speichereffiziente Programme für Mikrocontroller schreibst. Was dich erwartet Wir starten mit den Grundlagen von Ownership, Borrowing und Modulen und zeigen dir, warum Rust hier neue Maßstäbe in Sachen Speichersicherheit und Effizienz setzt. Danach tauchen wir in die no_std-Welt ein, die für den Arduino Uno essenziell ist. Du wirst lernen, wie du Rust ohne die Standardbibliothek nutzt und deine erste Embedded-Anwendung entwickelst. Natürlich kommt die Praxis nicht zu kurz! Gemeinsam richten wir die Toolchain unter Windows und Linux ein und erarbeiten echte Projekte, die dich fit für die Rust-Entwicklung machen. Themen & Praxisprojekte - Toolchain einrichten – Rust-Installation & Konfiguration für Embedded-Entwicklung - Von C++ zu Rust – Datenstrukturen, Ownership, Module, Funktionen und Methoden - Rust Exercise CLI – Nutzerinteraktion, CSV-Verarbeitung und Cross-Compiling - Arduino Uno mit Rust – LEDs blinken lassen & mit arduino-hal arbeiten - GPIOs effizient steuern – Pins verwalten, ohne Verzögerungen (Delays) - Taster entprellen – Debounce-Logik in Rust umsetzen & modularisieren Nach der Lektüre wirst du die Rust-Syntax sicher beherrschen, eigene Rust-Projekte effizient strukturieren und wissen, wie du Rust optimal für Mikrocontroller nutzt. Du erkennst die Unterschiede zu C++ und kannst Rust auch für größere Projekte einsetzen. - Starte jetzt durch und entdecke Rust für Embedded-Entwicklung!
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Veröffentlichungsjahr: 2025
Ähnliche
Rust Basics für Arduino Uno: Der Einstieg
Lerne Schritt für Schritt die Grundlagen von Rust, um spannende Projekte mit deinem Arduino zu realisieren.
Markus Edenhauser, MA MSc
2025-04-01
Rust Basics für Arduino Uno: Der Einstieg
Rust Basics für Arduino Uno: Der EinstiegVorwortEinleitungBenötigte Hardware für Rust auf Arduino UnoCode und MateriallisteWarum Denglisch?Welches Kapitel zuerst?ZielgruppeMIT-Lizenz und HaftungsausschlussToolchain für RustAlles für die Rust-EntwicklungInstallation von Rust unter WindowsInstallation von Rust unter LinuxInstallation von Rust unter macOSIDE VSCodiumRust-Analyzer und Dracula-Theme installierenErstes Hello WorldOrdnerstruktur von einem Rust ProjektVon Arduino C++ zu RustWarum Rust die Zukunft der Embedded-Entwicklung istNachteile von Rust im Embedded-Bereichstd und no_stdCargo und CratesVorbereitung für die ÜbungenAlternative mit WokWiData TypesDie Notwendigkeit von Deklaration und InitialisierungMutableStringsArrays fixe DatentypenVektorenStructEnumFunktionenMethoden-Implementierung statt OOPOwnershipmatch statt iffor while und loopModuleGenerische StrukturenError handlingUnittests in RustFazit zu Rust BasicsDIY Rust Exercise CLIProjektvorstellungProjekt anlegenCodebesprechungAusführungsbeispielBinärdatei und Cross CompilingToolchain für Arduino AVR Entwicklungavr-hal was ist dasavr-hal Library im ÜberblickGit InstallationEinrichten Toolchain avr-hal WindowsEinrichten Toolchain avr-hal LinuxHello World mit Windows oder LinuxBinärdatei mit ravedude uploadenGrundlagen arduino-halVerdrahtungWarum die Cargo.toml nicht immer gezeigt wirdDigitalread und SerialMonitorPWM mit Timer und PrescalerAnalogread mit 10k Potimillis implementierenMillis Wert mit Oszi überprüfenInterruptSerialMonitor Baudrate ändernSteuern mehrerer GPIOs mit MethodenVerdrahtungmillis als ModulMehrere GPIOs mit millis und ohne delays steuernEntprellen und Auswertung von Tastern mit MethodenBTN Debounce LogikHauptlogikI2C mit dem BH1750-SensorBH1750 Lichtsensor über I2C ansteuern und auswertenI2C Ansteuerung und AuswertungUART mit dem HC-05 Bluetooth-ModulVerdrahtungBluetooth Serial via Android oder iOS mit HC ModulUART AuswertungAusblickAbschließende Worte und weiterführende RessourcenWie der Einstieg in Rust gelingtÜber den AutorWeiteres vom AutorDownloadlinksStichwortverzeichnisRust Basics für Arduino Uno: Der Einstieg
Copyright © April 2025 1. Auflage Selbstverlag
Markus Edenhauser, MA MSc Völser Straße 41 6020 Innsbruck Österreich pixeledi.eu/impressum
Ohne dich wäre dieser Weg nicht derselbe gewesen. Dieses Buch ist ein kleines Zeichen meiner Dankbarkeit für all die unsichtbaren Fäden, die du gesponnen hast.
Vorwort
Rust ist heutzutage ein Begriff, den man immer häufiger in der Embedded-Entwicklung hört, insbesondere im Zusammenhang mit Mikrocontrollern (MCUs) wie dem beliebten Arduino Uno. Während C und C++ lange Zeit die dominierenden Sprachen in diesem Bereich waren, hat Rust in den letzten Jahren einen bemerkenswerten Aufschwung erlebt. Was früher als exotische Sprache galt, wird nun von immer mehr Entwicklern als eine ernstzunehmende Alternative zu den traditionellen Sprachen gesehen.
Dieser Trend ist nicht nur auf den Embedded-Bereich beschränkt. Rust findet zunehmend Eingang in Projekte, die man nicht sofort mit Mikrocontrollern in Verbindung bringt. Ein besonders prominentes Beispiel ist der Linux-Kernel, der zunehmend Rust-Code integriert, um die Sicherheit und Effizienz des Betriebssystems zu verbessern. Diese Entwicklung zeigt deutlich, dass Rust von vielen als eine der vielversprechendsten Programmiersprachen für die Zukunft der Softwareentwicklung angesehen wird. Besonders die Community spielt hier eine entscheidende Rolle – sie trägt mit vielen Treibern, Bibliotheken und Tools maßgeblich dazu bei, Rust immer weiter zu etablieren. Dabei ist der Entwicklungsstand im Embedded-Bereich zwar noch dynamisch und einige Tools und Bibliotheken befinden sich in ständiger Weiterentwicklung, aber das Potenzial ist längst klar erkennbar.
Im Zusammenhang mit dem Arduino Uno, besonders im Hinblick auf die AVR-Plattform, ist Rust noch nicht so weit verbreitet wie C oder C++, jedoch kann man schon jetzt viele wichtige Aufgaben problemlos umsetzen. Das Ziel dieses Buches ist es, dir einen Einstieg in die Welt von Rust auf dem Arduino Uno zu ermöglichen und dir zu zeigen, wie du die Vorteile dieser modernen Sprache für die Programmierung von Mikrocontrollern nutzen kannst.
Wir werden uns gemeinsam durch verschiedene Kapitel arbeiten, in denen du nicht nur die Grundlagen von Rust kennenlernst, sondern auch praktische Übungen machst, die dir helfen, das Gelernte direkt anzuwenden. Zu Beginn schauen wir uns die benötigte Hardware an und richten die Toolchain ein. Danach geht es darum, mit den grundlegenden Konzepten von Rust zu arbeiten und schrittweise komplexere Projekte zu entwickeln, angefangen bei einfachen GPIO-Steuerungen bis hin zur Kommunikation mit Sensoren und Bluetooth-Modulen.
Im Laufe des Buches wirst du unter anderem die folgenden Themen behandeln:
Einführung in Rust auf dem Arduino Uno – Wir sehen uns die Hardware an, die du für das Programmieren benötigst, und klären die Grundlagen.Die Toolchain für Rust auf Arduino – Du lernst, wie du die benötigten Tools installierst und konfigurierst, um Rust-Code für den Arduino Uno zu kompilieren.Von C++ zu Rust – Ein Vergleich der beiden Sprachen, um dir zu zeigen, warum Rust für Embedded-Entwicklung so vorteilhaft sein kann.Praktische Übungen – Mit einfachen Projekten wirst du Rust in Aktion sehen: von der Steuerung von LEDs bis hin zu komplexeren Aufgaben wie dem Arbeiten mit Sensoren.Erweiterte Themen – Vom Debugging über Interrupts bis hin zur Kommunikation mit anderen Geräten über I2C und UART.Am Ende dieses Buches wirst du ein solides Verständnis dafür haben, wie du Rust für die Programmierung von Arduino Uno-basierten Projekten einsetzen kannst. Rust bietet nicht nur moderne Sprachfeatures, die die Entwicklung sicherer und effizienter machen, sondern auch eine wachsende Community, die kontinuierlich dazu beiträgt, das Ökosystem zu verbessern. Rust ist eine Sprache, die in der Embedded-Welt zunehmend an Bedeutung gewinnt – und du bist dabei, ein Teil dieser aufregenden Entwicklung zu werden!
Markus Edenhauser, MA MSc
Einleitung
Bevor wir beginnen, möchte ich dir einen Überblick geben, wie du dich am besten durch dieses Buch navigieren kannst. Starte mit diesem Kapitel, in dem du Informationen darüber findest, wo der Code zu finden ist und welche Software sowie Hardware benötigt wird.
Wichtig ist, die Rust-Toolchain für dein Betriebssystem zu installieren, sei es auf Linux, Mac oder Windows. Als Windows-Nutzer empfehle ich dir, ab und zu in die Linux-Welt hineinzuschauen – es könnte sogar Spaß machen! Ich werde immer wieder ein paar kurze Videos verlinken, die dir beim Einrichten und mit Codebeispielen weiterhelfen sollen.
Danach beginnst du mit dem Praxisteil des Buches. Zuerst schauen wir uns ausführlich die C++-Konzepte und Grundlagen an und übersetzen sie anschließend in die Rust-Welt, um ein Gefühl dafür zu bekommen. Dabei nutzen wir auch die Standardbibliothek von Rust.
Im nächsten Kapitel geht es darum, erste praktische Erfahrungen mit Rust zu sammeln, indem wir ein einfaches CLI-Tool programmieren.
Anschließend steigen wir in die ersten Rust-Programmierprojekte für Arduino ein. Du kannst dir dann ein Kapitel aussuchen und die Projekte umsetzen – die Bauelemente bauen nicht aufeinander auf.
Benötigte Hardware für Rust auf Arduino Uno
Um Rust erfolgreich mit dem Arduino Uno zu verwenden, benötigst du einige grundlegende Hardwarekomponenten. Zuerst einen Arduino Uno oder Nano. Natürlich kannst du auch einen Klon oder andere Arduino AVR-Modelle nutzen. Ich habe alle Beispiele mit dem ATmega328P ausprobiert, da dieser Mikrocontroller mit dem Rust-Framework kompatibel ist.
Außerdem benötigst du ein Breadboard mit ein paar Litzen. Für die praktische Demonstration solltest du mindestens zwei LEDs verwenden. Bei einer Betriebsspannung von 5 Volt empfehle ich Vorwiderstände von 200 bis 250 Ohm, bei 3,3 Volt reichen 100 bis 150 Ohm. Beachte dabei, dass höhere Vorwiderstände bei niedrigeren Spannungen zu einer weniger hellen Beleuchtung führen.
Die unterschiedlichen Spannungsbereiche sind wichtig, da verschiedene Sensoren nur mit 5 Volt arbeiten können. Es ist daher immer ratsam, die Spezifikationen der verwendeten Komponenten im Datenblatt zu überprüfen.
Für das Projekt benötigst du auch mindestens zwei Buttons. Zum Testen und zum Verknüpfen der Buttons mit dem Arduino brauchst du einen Pulldown-Widerstand von 10 Kiloohm auf der Ground-Schiene sowie zusätzliche Drähte zur einfachen Verkabelung.
Als Letztes benötigst du ein Bluetooth-Modul HC-05 für die UART-Steuerung. Als Beispiel für ein I2C-basiertes Modul kannst du den BH1750-Lichtsensor verwenden. Dieser ermöglicht eine einfache und überschaubare I2C-Auswertung.
Wobei ich auch hier sagen muss: Es ist im Grunde egal, welches Modul du verwendest – hauptsache, die Schnittstelle wird unterstützt und du weißt, wie es zu verwenden ist. Das Bluetooth-Modul ist sehr einfach zu steuern, und auch das BH1750-Modul lässt sich ohne weitere Bibliothek prinzipiell einfach auswerten. Deshalb habe ich mich für diese Modelle entschieden.
Die genauen Details zu den Modulen und der Hardware findest du in der Materialliste, die es im Download-Bereich zum Herunterladen gibt.
Code und Materialliste
Die Links sind am Ende des Dokuments zu finden (Link für PDF und E-Book), da in der Vorschau vieler Online-Portale die ersten Seiten des Buches angezeigt werden. Um sicherzustellen, dass du trotzdem von Anfang an Zugriff auf alle wichtigen Ressourcen hast, wurde dieses Kapitel bewusst an dieser Stelle platziert.
Dort sind stets die aktuellen Code-Beispiele verfügbar, auch falls sich in der Zwischenzeit Änderungen ergeben haben.
Um Zugriff auf die Lernmaterialien zu erhalten, kannst du das Repository entweder mit Git klonen oder den gesamten Ordner als ZIP-Datei herunterladen. Eine Registrierung ist dafür nicht erforderlich. Falls du Fehler findest oder Verbesserungsvorschläge hast, kannst du mir gerne einen Pull-Request senden.
Struktur der GitHub Repository:
Unter dem Verzeichnis “Basics” befinden sich die einzelnen Ordner, die wir im Kurs Schritt für Schritt behandeln. Beachte dabei, dass es innerhalb des Hauptordners “Basics” auch Unterordner gibt, wie z.B. “Data Types” oder “My Strings”. Um die Beispiele in deinem Code-Editor zu öffnen, musst du immer den Unterordner auswählen. Die Struktur mit dem Hauptverzeichnis dient dazu, eine übersichtlichere Organisation der Lernmaterialien zu gewährleisten und verhindert Fehlermeldungen beim Kompilieren mit Cargo.
Unter “Exercise” findest du die Aufgaben zur praktischen Anwendung des Gelernten. Hier sind auch die Fragen zum Testen enthalten.
Ich wünsche dir viel Spaß beim Ausprobieren!
Warum Denglisch?
Ein häufiger Kritikpunkt an meinen Kursen und Fachbüchern ist, dass ich oft zwischen Deutsch und Englisch wechsele. Diese Kritik ist vollkommen gerechtfertigt. Dennoch möchte ich einen Aspekt ansprechen, der die Verwendung von Deutsch in der technischen Kommunikation erschwert: Ich verwende überwiegend die englischen Begriffe für Programmiersprachen und technische Fachbegriffe.
Der Grund dafür ist, dass die offizielle Rust-Dokumentation hervorragend ist, aber in erster Linie auf Englisch verfasst wurde. Zwar gibt es eine deutsche Übersetzung, die dem Originalaufbau folgt, aber viele Begriffe sind im Englischen präziser und häufiger anzutreffen. Es gibt allerdings auch einige Begriffe, die ins Deutsche übernommen wurden, wie etwa „Stapelspeicher“ und „Haldenspeicher“. Die Frage ist jedoch, ob diese Übersetzungen tatsächlich in der täglichen Kommunikation verwendet werden. Ich persönlich bezweifle das.
Ich finde diese Übersetzungen eher umständlich und bevorzuge es, bei den englischen Bezeichnungen wie „Stack“ und „Heap“ zu bleiben. Ebenso werde ich den Begriff „Ownership“ verwenden, anstatt ihn ins Deutsche zu übersetzen. Der Grund für diese Entscheidung ist einfach:
Die offizielle Dokumentation und viele Ressourcen sind größtenteils auf Englisch.Bei tiefergehenden technischen Diskussionen wird in der Regel ebenfalls Englisch verwendet.Welches Kapitel zuerst?
Anmerkung: Die Mermaid-Diagramme sind ebenfalls im GitHub-Repo, damit man die Inhalte besser ablesen kann.
Zielgruppe
Dieses Buch richtet sich an Entwickler, die sich für die Nutzung von Rust auf dem Arduino Uno (AVR) interessieren. Vorkenntnisse im Umgang mit Arduino und der Programmierung in C/C++ sind von Vorteil. Wenn du bereits Erfahrungen mit dem Programmieren von Mikrocontrollern im Arduino-Umfeld hast, wirst du in diesem Buch viele neue Ansätze und Techniken entdecken, die du direkt in deinen Projekten anwenden kannst.
Für absolute Anfänger im Bereich Arduino und Mikrocontroller ist es hilfreich, wenn du dich vorab mit den Grundlagen von Arduino und der Entwicklungsumgebung vertraut machst. Das Buch konzentriert sich darauf, Rust auf der Arduino-Plattform einzuführen, sodass grundlegende Kenntnisse über die Funktionsweise von Mikrocontrollern vorausgesetzt werden. Auf meinem YouTube-Kanal (www.pixeledi.eu/@pixeledi) findest du viele Videos, in denen du den Start mit der Arduino IDE bzw. PlatformIO nachvollziehen kannst.
Fortgeschrittene Nutzer, die bereits mit Arduino und C/C++ arbeiten, können sich darauf freuen, Rust als Alternative kennenzulernen und die Vorteile dieser modernen Programmiersprache für ihre Projekte zu nutzen. Das Buch bietet dir eine praktische Einführung in die Verwendung von Rust auf dem Arduino Uno (AVR) und zeigt, wie du Rust effektiv für Embedded-Entwicklung einsetzen kannst.
MIT-Lizenz und Haftungsausschluss
Hinweis zu den Code-Beispielen in diesem Buch: Der gesamte Code steht unter der MIT-Lizenz und kann somit frei wiederverwendet werden. Beachte bitte den Haftungsausschluss: Die Beispiele wurden sorgfältig erstellt, dennoch können Fehler enthalten sein. Es ist ratsam, den Code gründlich zu überprüfen, bevor du ihn anwendest, um Schäden an deinen Geräten zu vermeiden. Viel Erfolg und Freude beim Umsetzen der Projekte!
Toolchain für Rust
In diesem Kapitel lernen wir die Rust-Toolchain kennen, also die Programme, die wir auf unserem Betriebssystem benötigen, um mit Rust für Arduino Uno und Nano (AVR-Serie) zu programmieren. Wir schauen uns an, wie man Rust installiert, einschließlich des Compilers rustc und des Projektverwaltungstools Cargo.
Es ist möglich, Rust sowohl unter Windows, Mac als auch unter Linux zu installieren. Wenn ihr euch für die Möglichkeiten von Linux interessiert, empfehle ich einen Blick auf die Installation dort – es ist einfacher und schneller als unter Windows :) und macht eventuell sogar mehr Spaß.
Für die Programmierung mit Rust benötigt ihr eine IDE. Ich verwende VS-Codium, die freie Version von Visual Studio Code, aber jede andere IDE oder sogar ein einfacher Texteditor funktioniert. Die Kompilierung erfolgt immer über das Terminal.
Zum Schluss dieses Kapitels schreiben wir unser erstes “Hello World”-Programm, um sicherzustellen, dass die Toolchain auf eurem System korrekt installiert und funktionsfähig ist.
Alles für die Rust-Entwicklung
Beginnen wir mit der Installation von Rust auf einem frischen Windows 11 System. Um den Prozess bestmöglich zu erläutern, greifen wir zunächst auf rust-lang.org zurück. Dort finden wir unter dem Reiter Install eine ausführliche Dokumentation zu allen benötigten Inhalten.
Es ist hilfreich, die verschiedenen Programme zu kennen, die bei der Installation heruntergeladen werden:
Rustup, rustc und Cargo. Rustup dient als Tool zur Verwaltung der Rust-Installation und vereinfacht den Prozess auf jedem System, egal ob Linux, macOS oder Windows. Es erledigt im Hintergrund alle notwendigen Schritte.
rustc ist der eigentliche Rust-Compiler, mit dem wir unsere ersten Schritte in Rust unternehmen können. Dieser Compiler transformiert unseren Rust-Code in ausführbaren Programmcode (Binärcode). So können wir überprüfen, ob unser Code kompiliert und ausgeführt werden kann.
Cargo hingegen ist der offizielle Paket- und Build-Manager für Rust. Er hilft uns bei der Verwaltung von Abhängigkeiten, der Erstellung von Projekten und der Kompilation unseres Programms – sowohl in Debug- als auch in Release-Versionen.
Cargo nutzt den rustc-Compiler und vereinfacht somit den gesamten Prozess. Da Cargo bereits den Compiler enthält, wird es für die meisten Anwendungsfälle verwendet. Die Kompilierung und Ausführung unserer Programme erfolgt über die Kommandozeile mit Cargo. Mehr zu Cargo folgt in den kommenden Kapitel.
Installation von Rust unter Windows
Damit die Installation auf jeden Fall klappt, gibt es hier zwei Videoanleitungen von mir:
https://youtu.be/njVwO82PODMhttps://youtu.be/SXyXqJTE5d8Nachdem wir RustUp von der Website www.rust-lang.org/tools/install heruntergeladen haben, starten wir das Programm. Dadurch öffnet sich ein Terminalfenster, in dem verschiedene Informationen angezeigt werden. Es wird empfohlen, die “Quick Install via Visual Studio Community Installer”-Option auszuwählen. Diese Option installiert alle notwendigen Komponenten automatisch im Hintergrund, einschließlich des Rust-Compilers, Cargo, Debugging-Tools und aller erforderlichen Abhängigkeiten für die Entwicklung mit Rust.
Folge den Anweisungen des Installationsprogramms, der Download kann einige Zeit dauern. Perfekt für eine kurze Kaffe-Pause.
Ein Tipp am Rande: Für Entwickler ist es empfehlenswert, sich einmal mit Linux auseinanderzusetzen. Ein System wie Linux Mint lässt sich leicht installieren und konfigurieren. Die Tools und die Arbeitsweise unter Linux sind meiner Meinung nach einfacher zu erlernen. Selbstverständlich benötigt man in vielen beruflichen Kontexten Windows. Dennoch kann ein Einblick in die Open-Source-Welt von Linux einen großen Mehrwert bieten.
Nach dem Download wird die Path Variable gesetzt. Dadurch können wir Rustc und Cargo im Terminal jederzeit verwenden, unabhängig davon, wo wir uns befinden.
Überprüfung der Installation: Wir überprüfen nun, ob die Installation erfolgreich war. Gib im Terminal den Befehl rustc ein. Es sollte eine Versionsinformation angezeigt werden. Der gleiche Schritt gilt für cargo, das später als Build-System verwendet wird. In der Regel sollten diese Programme nach erfolgreicher Installation direkt verfügbar sein, ohne dass wir einen kompletten Pfad zur Binärdatei angeben müssen.
Installation von Rust unter Linux
Zu diesem Abschnitt gibt es wieder ein Video von mir: https://youtu.be/cnnI3QHA-NY
Zuerst einmal möchte ich dir Gratulieren, dass du auf der guten Seite der Betriebssysteme gelandet bist. Wenn du als Windows-User dieses Kapitel liest, bist du schon auf den richtigen Weg, nämlich zum Linux User :).
Um mit dem Projekt zu beginnen, benötigen wir drei Programme: Rust-Up, Rust-C und Cargo. Diese Installationen laufen unter Linux reibungslos ab.
Für die Installation kopiere einfach den folgenden Curl-Befehl und führe ihn in deinem Terminal aus. Anschließend wird eine Setup.rs heruntergeladen und automatisch ausgeführt.
Beachte, dass der Befehl je nach System unterschiedlich sein kann. Im Folgenden erkläre ich die Schritte anhand eines Debian-Systems, da dies von den meisten Nutzern verwendet wird. Die Installation unter Arch erfolgt auf die gleiche Weise (I use Arch btw.).
Kopiere den folgenden Code: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shÖffne dein Terminal und navigiere zum Downloads-Ordner.Gib den Code ein, drücke Enter und bestätige die Installation mit “1”.Der Prozess dauert einige Sekunden. Nach Abschluss der Installation ist Rust auf deinem System verfügbar. Die Tools werden im System integriert und du kannst die Befehle von überall im Terminal ab jetzt nutzen.
Als Nachweis, dass die Installation erfolgreich war, kannst du den Befehl rustc --version eingeben.
Mit diesen Schritten sind deine Programme bereit, mit dem Projekt zu starten!
Installation von Rust unter macOS
Die Installation von Rust unter macOS verläuft ähnlich wie unter Linux. Auch hier wird rustup verwendet, um Rust und die benötigten Tools (rustc und cargo) zu installieren. Die Schritte sind nahezu identisch mit denen im Linux-Kapitel.
Für detaillierte Anweisungen zur Installation folge den Schritten im Linux-Kapitel. Der Prozess unter macOS sollte genauso reibungslos ablaufen.
IDE VSCodium
Für Rust Basics auf dem Arduino Uno brauchen wir eine geeignete IDE, also einen Texteditor. Glücklicherweise können wir fast jeden Texteditor verwenden, den wir haben, da wir die Inhalte über das Terminal kompilieren und ausführen. Für diese Beispiele habe ich VSCodium verwendet.
Um euch zu zeigen, wie VSCodium funktioniert, bleibe ich jetzt beim Windows-System. Aber VSCodium gibt es natürlich auch für macOS, Linux und alle Derivate.
Was ist nun VSCodium? Es ist eine Open-Source-Software, die vom Source-Code von VSCode abgeleitet wurde. Nun, VSCode selbst ist von Microsoft, und der Source-Code ist unter der MIT-Lizenz. Das Produkt selbst, die Binary, ist aber kein FOSS mehr, da Telemetrie und Tracking enthalten sind. Man kann das gesamte Tracking zwar teilweise ausschalten, aber eben nicht ganz.
Daher haben die Entwickler von VSCodium den Source-Code geforkt und geben Binaries ohne Telemetrie aus. So haben wir eine großartige IDE, frei von Microsoft, mit der wir einige Extensions nutzen können und ein VSCode-Feeling haben. Man könnte natürlich direkt VSCode verwenden, doch ich bevorzuge Free and Open Source Software (FOSS).
Für PlattformIO-Projekte verwende ich in meinen Kursen und Fachbüchern noch immer VSCode, da die Integration und der Einstieg in die Mikrocontroller-Welt damit einfacher ist und alles out of the box unterstützt wird. Ganz generell muss man immer schauen, ob die Toolchain passt. Es gibt zwar Kniffe, um auch PlattformIO unter VSCodium zu verwenden, aber davon bin ich momentan kein Fan.
Zu diesem Abschnitt gibt es wieder ein Video von mir: https://youtu.be/7JAH_FJ506M
So installieren wir nun VSCodium: Wir gehen auf “Download Latest Releases” und sehen auf der GitHub-Release-Seite viele Einträge. Nach Abschluss öffnen wir VSCodium. Das Fenster sieht aus wie VSCode – und das ist es ja auch. Jetzt haben wir einen Editor, frei von Tracking!
Abseits von VSCodium bin ich ein großer Nvim-Fan, aber Vorsicht, das ist ein neues Rabbit Hole und mit der Konfiguration und Einstellung kann man einige Stunden verbringen. Es macht jedoch richtig Spaß, es zu benutzen. Aber das ist ein anderes Thema, hier soll es ja um Rust gehen.
Rust-Analyzer und Dracula-Theme installieren
Eine der wichtigsten Erweiterungen für die Rust-Entwicklung in Visual Studio Code oder VSCodium ist der Rust Analyzer. Dieses Tool bietet Funktionen wie Code-Vervollständigung (IntelliSense), Echtzeit-Fehlerprüfung und Unterstützung bei der Verwaltung von Abhängigkeiten. Mit über 850.000 Downloads ist es eine der beliebtesten Rust-Erweiterungen.
Installation des Rust-Analyzers
Visual Studio Code oder VSCodium öffnenErweiterungs-Manager aufrufenEntweder mit Strg + Shift + X oder über das seitliche Menü.Rust Analyzer suchenIn das Suchfeld rust-analyzer eingeben.Erweiterung installierenAuf „Installieren“ klicken.Nach der Installation wird der Rust Analyzer automatisch aktiviert, wenn eine .rs-Datei geöffnet wird.
Dracula-Theme installieren
Um das Aussehen von Visual Studio Code oder VSCodium anzupassen, kann das Dracula Theme Official installiert werden: 1. Erweiterungs-Manager öffnen (Strg + Shift + X) 2. Nach „Dracula Theme Official“ suchen 3. Erweiterung installieren 4. Theme aktivieren - Strg + Shift + P drücken - Theme: Color Theme eingeben und auswählen - „Dracula“ aus der Liste wählen
Die grundlegenden Funktionen von Visual Studio Code und VSCodium sind meist selbsterklärend. Weitere benötigte Einstellungen und Werkzeuge werden im Praxisteil des Buchs besprochen.
Erstes Hello World
Um mit Rust auf dem Arduino Uno zu starten, programmieren wir unser erstes „Hello World“-Beispiel. Die hier gezeigten Befehle sind sowohl unter Windows als auch unter Linux/macOS gleich, vorausgesetzt, die Installation wurde wie zuvor mit rustup durchgeführt.
Projektverzeichnis erstellen
Zuerst navigieren wir zu dem Ordner, in dem wir unsere Projekte speichern möchten. Ich lege dazu einen neuen Ordner unter Dokumente an und nenne ihn Rust-Projekte.
Neues Rust-Projekt mit Cargo anlegen
Jetzt erstellen wir unser erstes Rust-Projekt mit Cargo. Dazu öffnen wir ein Terminal und geben folgenden Befehl ein:
Nach dem Bestätigen mit Enter wird ein neuer Ordner mein_erstes_Projekt angelegt. In diesem befinden sich mehrere Dateien, darunter auch der src-Ordner mit der Datei main.rs.
Den Code anpassen
Wir öffnen die Datei main.rs mit unserer IDE und sehen dort bereits die Funktion fn main(), die das Programm ausführt. Diesen Code ersetzen wir durch:
Das Programm ausführen
Nun öffnen wir das integrierte Terminal in VSCodium oder navigieren über das Terminal in den Projektordner. Wichtig ist, dass wir uns im Verzeichnis befinden, in dem auch die Cargo.toml-Datei liegt.
Mit dem Befehl
können wir überprüfen, ob wir im richtigen Ordner sind (unter Windows funktioniert auch dir in der PowerShell).
Jetzt kompilieren wir unser Programm mit:
Falls Fehler auftreten, gibt der Compiler eine entsprechende Meldung aus. Ist alles in Ordnung, starten wir unser Programm mit:
Im Terminal erscheint nun die Ausgabe:
Hello pixeledi!Damit haben wir erfolgreich unser erstes Rust-Programm aufgesetzt! 🚀
Ordnerstruktur von einem Rust Projekt
Die Struktur eines Rust-Projekts ist darauf ausgelegt, eine klare Trennung zwischen verschiedenen Komponenten des Codes und der Konfiguration zu ermöglichen. Diese Trennung sorgt dafür, dass das Projekt übersichtlich und einfach zu handhaben bleibt, besonders wenn es wächst. Zu den wichtigsten Bestandteilen gehören Dateien wie Cargo.toml, Cargo.lock, der src-Ordner und spezifische Konfigurationen für die verwendete Hardware wie die avr-specs. Jede dieser Komponenten hat eine spezielle Aufgabe und trägt dazu bei, dass das Projekt effizient gebaut, gewartet und ausgeführt werden kann.
cargo.toml
Die cargo.toml ist eine Konfigurationsdatei, die von Cargo, dem Build-System und Paketmanager von Rust, verwendet wird. Sie definiert die Abhängigkeiten eines Projekts, die Versionen der verwendeten Crates (Rust-Bibliotheken), und enthält Informationen zu anderen Projektmetadaten wie Name, Version und Autoren. Cargo nutzt diese Datei, um das Projekt zu bauen, Abhängigkeiten zu verwalten und die richtigen Versionen von externen Bibliotheken zu installieren. Durch die cargo.toml wird also die gesamte Projektkonfiguration und das Management von externen Crates vereinfacht, sodass Entwickler sich auf den Code selbst konzentrieren können, ohne sich manuell um die Verwaltung der Abhängigkeiten kümmern zu müssen.
Ein Beispiel für eine cargo.toml-Datei zeigt, wie die Konfiguration eines Rust-Projekts aussieht:
