Tools, die zur Programmierung benötigt werden

Aus C und Assembler mit Raspberry

Allgemeine Einführung in gängige Tools: Assembler (as), Linker (ld), Compiler (gcc) und Make

Assembler (as)

Der GNU Assembler as wird verwendet, um Assembler-Code in Maschinen-Code zu übersetzen.

Verwendung: 

as -o output.o input.s

Für mehr Informationen zum Assembler findest du unter GNU Assembler

Linker (ld)

Der GNU Linker ld wird verwendet, um Object-Files zu einem ausführbaren Programm zu verknüpfen.

Verwendung: 

ld -o output output.o

Mehr Informationen erhältst du unter Ld (Linker)

Compiler (gcc)

Der GNU Compiler Collection gcc kann auch verwendet werden, um C und Assembler-Code zu mischen und zu kompilieren.

Verwendung: 

gcc -o output input.c input.s

Mehr informationen erhälts du unter GNU C Compiler

Debugging-Tool (gdb)

Der GNU Debugger gdb ist ein leistungsfähiges Tool zur Fehlersuche in Programmen.

Verwendung: 

gdb ./output

Nützliche GDB-Befehle:

break (b): Setzt einen Haltepunkt.
Beispiel: break main -> Setzt einen Haltepunkt bei "main".
run (r): Startet das Programm.
step (s): Führt den nächsten Befehl aus.
print <variable>: Zeigt den Wert einer Variable an.
continue (c): Läuft bis zum nächsten Haltepunkt weiter.
quit (q or control-d): Beendet gdb.
control-c: Interrupt das laufende Programm.
info registers (i r): Druckt die Register aus.
info break: Zeigt die Breakpoints an.
delete n: Löscht den Breakpoint "n".
x /Nuf expression: Zeigt den Inhalt des Speichers an.

Weitere Informationen erhälts du unter GNU Debugger

MAKE

make ist ein Build-Automatisierungstool, das häufig in Softwareprojekten verwendet wird, um Programme aus Quellcode zu kompilieren. Dazu wird ein "makefile" erstellt, welches Make verwendet, um einen Sourcecode in eine Ausführbaren Datei zu wandeln.

Weitere Informationen findest du unter Make

IDEs und Texteditoren, die Assembler unterstützen

Unter Linux gibt es mehrere Möglichkeiten, einen Sourcecode zu schreiben. Mein bevorzugter Editor ist Kate, welcher auch auf Windows und MacOS verfügbar ist. Dieser unterstützt die Syntaxhervorhebung und kann mit Klammern umgehen.

Installation:
sudo apt install kate

Mehrere IDEs und Texteditoren sind auch gut für die Arbeit mit Assembler-Code geeignet:

  • IDEs:
Visual Studio Code: Mit Erweiterungen wie „C/C++“ und „Arm Assembly“ für Syntax-Highlighting und Debugging-Unterstützung.
Installation:
sudo apt install code
Eclipse: Auch geeignet für Assembler-Entwicklung und Debugging.
Installation:
sudo apt install eclipse
  • Texteditoren:
Vim: Leistungsfähiger Texteditor mit Syntax-Highlighting für Assembler.
Installation:
sudo apt install vim
Emacs: Ein Klassiker unter den Texteditoren, der ebenfalls gut für Assembler geeignet ist.
Installation:
sudo apt install emacs

Gross-Compiling

In diesem Kapitel werde ich das Konzept des Cross-Compilings für die ARM64-Bit-Programmierung mit Assembler erläutern, speziell für das Zielsystem Raspberry Pi 5. Cross-Compiling bezeichnet den Prozess des Compilierens von Code auf einem System, der auf einem anderen ausgeführt werden soll. Dies ist besonders nützlich, wenn das Zielsystem (in diesem Fall der Raspberry Pi 5) im Vergleich zum Entwicklungssystem begrenzte Ressourcen hat. Cross-Compiling ermöglicht es uns, die Leistung und den Komfort leistungsfähigerer Entwicklungsmaschinen zu nutzen, um Programme für den Raspberry Pi zu erstellen.

Warum einen Cross-Compiler verwenden?

  • Ressourcenbeschränkungen: Der Raspberry Pi, obwohl ein leistungsfähiges Gerät, erreicht nicht die Rechenleistung eines typischen Desktops oder Servers. Ressource-intensive Kompilierungen können viel Zeit in Anspruch nehmen und erhebliche Systemressourcen verbrauchen, was die direkte Entwicklung auf dem Pi unpraktisch machen kann.
  • Geschwindigkeit: Das Kompilieren auf einer leistungsfähigeren Maschine ist erheblich schneller. Dies kann die Entwicklungszykluszeit drastisch verkürzen.
  • Flexibilität: Die Verwendung eines Cross-Compilers ermöglicht es Entwicklern, auf vielen verschiedenen Plattformen zu erstellen und zu testen, ohne physisch zwischen Maschinen oder Geräten wechseln zu müssen.

Beste Werkzeuge für Cross-Compiling

  • GCC (GNU Compiler Collection): Das am weitesten verbreitete und unterstützte Werkzeug für Cross-Compiling. Es unterstützt eine Vielzahl von Zielarchitekturen, einschließlich ARM.
  • Binutils: Eine Sammlung von Binärwerkzeugen, die zusammen mit GCC arbeiten, um Binärdateien zu assemblieren, zu linken und zu manipulieren.
  • Make: Ein Build-Automatisierungstool, das ausführbare Programme und Bibliotheken aus Quellcode automatisch erstellt, indem es Dateien namens Makefiles liest.

Installation der Werkzeuge

Unter Linux:

Installiere den Cross-Compiler: 

sudo apt update
sudo apt install gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu

Umgebung einrichten: Stelle sicher, dass die Cross-Compiler-Binärdateien vom PATH aus zugänglich sind. Dies kann durch Hinzufügen der folgenden Zeilen zu .bashrc oder .zshrc erledigt werden: 

export PATH=$PATH:/usr/bin/aarch64-linux-gnu

Beispiel-Makefile für Cross-Compiling: Erstelle ein Makefile, um den Build-Prozess zu automatisieren: 

CC=aarch64-linux-gnu-gcc
AS=aarch64-linux-gnu-as
LD=aarch64-linux-gnu-ld

all: program

program: program.o
    $(LD) -o program program.o

program.o: program.s
    $(AS) -o program.o program.s

clean:
    rm -f program program.o

Unter Windows:

  • Installiere MSYS2: Lade MSYS2 von MSYS2.org herunter und installiere es. Folge den Installationsanweisungen auf der Website.
  • Installiere den Cross-Compiler: Öffne die MSYS2-Shell und installiere die notwendigen Werkzeuge:
pacman -Syu
pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-binutils
  • Umgebung einrichten: Füge die Pfadumgebungsvariable innerhalb der MSYS2-Shell hinzu, um sicherzustellen, dass die Cross-Compiler-Binärdateien zugänglich sind:
export PATH=$PATH:/mingw64/bin
  • Beispiel-Makefile für Cross-Compiling in MSYS2: Verwende ein Makefile ähnlich dem für Linux, um den Build-Prozess zu automatisieren.

Transfer und Ausführung des Programms auf dem Raspberry Pi 5:

Nachdem der Cross-Compiler die Binärdateien erstellt hat, übertrage sie auf den Raspberry Pi 5. Dies kann mit Tools wie scp (secure copy) oder einem USB-Laufwerk erfolgen. Beispielsweise: 

scp program pi@raspberrypi:/home/pi/program

Nach dem Übertragen, melde dich beim Raspberry Pi an und führe das Programm aus: 

ssh pi@raspberrypi
chmod +x /home/pi/program
/home/pi/program

Durch die Nutzung von Cross-Compiling kannst du deinen Entwicklungsprozess erheblich rationalisieren und die leistungsfähigere Hardware nutzen, während du immer noch auf die spezifische Architektur und Einschränkungen deines Raspberry Pi 5 zielst.

Emulation

Wenn man keinen physischen Raspberry Pi zur Verfügung hat oder Cross-Compiling nicht möglich ist, können Emulatoren eine wertvolle Alternative bieten. Emulatoren ermöglichen es, den Raspberry Pi und seine ARM-Architektur auf anderen Systemen zu simulieren, was die Entwicklung und das Testen von Programmen erheblich erleichtern kann.

Was ist ein Emulator?

Ein Emulator ist ein Software- oder Hardware-Tool, das die Funktionen eines Computer- oder Mikrokontrollersystems auf einem anderen System nachbildet. Auf diese Weise können Entwickler Code für das Zielsystem erstellen und testen, ohne die entsprechende Hardware zur Verfügung zu haben.

Vorteile der Verwendung von Emulatoren

  • Bequemer Zugang: Entwickler können Programme für den Raspberry Pi erstellen und testen, ohne das tatsächliche Gerät zu benötigen.
  • Flexibilität: Emulatoren können auf verschiedenen Systemen und Betriebssystemen (Windows, macOS, Linux) ausgeführt werden.
  • Fehlersuche und Debugging: Emulatoren bieten komfortable Möglichkeiten zur Fehlersuche und Debugging, was die Entwicklung erleichtert.
  • Isolierte Umgebung: Tests können in einer isolierten Umgebung durchgeführt werden, ohne dass das Risiko besteht, die tatsächliche Hardware zu beschädigen.

Beliebte Emulatoren für ARM und Raspberry Pi

QEMU (Quick EMUlator)

QEMU ist ein weit verbreiteter Emulator zur Virtualisierung von Systemen und ist besonders flexibel. Es kann verschiedene Architekturen, einschließlich ARM64, emulieren.

  • Installation:
    • Unter Linux:
sudo apt update
sudo apt install qemu qemu-system-arm
    • Unter Windows: Lade den QEMU-Installer von der offiziellen Website herunter: QEMU Downloads. Folge den Anweisungen zur Installation.
Grundlegende Verwendung: Um ein Raspberry Pi-Image zu starten:
  • Unter Linux:
qemu-system-aarch64 \
-M raspi3b \
-kernel kernel8.img \
-dtb bcm2710-rpi-3-b-plus.dtb \
-sd your_image.img \
-m 1G \
-serial stdio
  • Unter Windows:
qemu-system-aarch64.exe -M raspi3b -kernel kernel8.img -dtb bcm2710-rpi-3-b-plus.dtb -sd your_image.img -m 1G -serial stdio

Raspberry Pi Emulator (RPi-Emulator)

Es gibt spezialisierte Emulatoren, die darauf abzielen, die Raspberry Pi-Hardware so genau wie möglich zu emulieren.

  • PiBox: Dieser Emulator kann heruntergeladen und wie jede andere Anwendung installiert werden: PiBox

Verschiedene Konfigurationen und Images: Weitere Informationen zur Konfiguration von RPi-Emulatoren und die Verfügbarkeit bestimmter vorkonfigurierter Images können in den entsprechenden Repositories und Dokumentationen gefunden werden.

Installation und Konfiguration von Emulatoren

Bei der Arbeit mit Emulatoren für den Raspberry Pi gibt es einige gemeinsame Schritte für die Einrichtung und Verwendung:

  • Download der Emulator-Software: Lade die benötigte Emulator-Software von den offiziellen Websites oder Repositories herunter.
  • Vorbereitete Raspberry Pi Images: Lade ein vorkonfiguriertes Image von einer vertrauenswürdigen Quelle herunter oder erstelle ein eigenes Image.
  • Konfiguration der Emulatorparameter: Passe die Emulationsparameter an, wie z. B. den zu emulierenden Raspberry Pi-Typ, die Menge an zugewiesenem RAM, Netzwerk-Schnittstellen und Speicheroptionen.
  • Start des Emulators: Verwende die Emulatorkonsole, um den simulierten Raspberry Pi zu starten und das Entwicklungs- und Testverfahren durchzuführen.

Schlussfolgerung

Emulatoren sind wertvolle Werkzeuge für Entwickler, die auf den Raspberry Pi abzielen, insbesondere wenn die Hardware nicht verfügbar oder Cross-Compiling nicht praktikabel ist. Mit Tools wie QEMU und speziellen Raspberry Pi-Emulatoren können die Programmierer in verschiedenen Umgebungen effizient entwickeln und testen. Die Installation und Konfiguration dieser Emulatoren ist in der Regel einfach und ermöglicht eine flexible und leistungsstarke Entwicklungsplattform, die nahezu jede Anforderung abdecken kann.

Abgerufen von „https://satyria.de/arm/index.php?title=Tools,_die_zur_Programmierung_benötigt_werden&oldid=894“