C und Assembler mit Raspberry - Letzte Änderungen [de]

Professionelle GUI mit Debugging für Bare-Metal (64-Bit) auf dem Raspberry Pi 4

Satyria — Wed, 24 Jun 2026 08:51:43 GMT

Umgebungsvariable „Path“ anpassen

Professionelle GUI mit Debugging für Bare-Metal (64-Bit) auf dem Raspberry Pi 4

Satyria — Fri, 05 Jun 2026 13:08:33 GMT

Die Seite wurde neu angelegt: „Viele Entwickler wünschen sich eine professionelle Möglichkeit, die Bare-Metal-Entwicklung direkt in einer grafischen Benutzeroberfläche (GUI) zu realisieren. In dieser Anleitung zeige ich Ihnen, wie Sie eine solche Entwicklungsumgebung aufsetzen können. Als IDE (Integrated Development Environment) nutzen wir Visual Studio Code von Microsoft, das unter der Open-Source-Lizenz MIT veröffentlicht ist. Um direkt mit dem Raspberry Pi 5 zu kommunizieren u…“

Neue Seite

Viele Entwickler wünschen sich eine professionelle Möglichkeit, die Bare-Metal-Entwicklung direkt in einer grafischen Benutzeroberfläche (GUI) zu realisieren. In dieser Anleitung zeige ich Ihnen, wie Sie eine solche Entwicklungsumgebung aufsetzen können. Als IDE (Integrated Development Environment) nutzen wir Visual Studio Code von Microsoft, das unter der Open-Source-Lizenz MIT veröffentlicht ist.

Um direkt mit dem Raspberry Pi 5 zu kommunizieren und Programme zu debuggen, wird zusätzlich eine '''Raspberry Pi Debug Probe''' benötigt. Diese wird über USB mit einem Windows-Rechner und über die Debug-Pins mit dem Raspberry Pi 5 verbunden.

== Software-Voraussetzungen ==
Wie eingangs erwähnt, nutzen wir als GUI Visual Studio Code. Die Software kann kostenlos von der offiziellen Website heruntergeladen werden:

👉 https://code.visualstudio.com/

Zusätzlich benötigen wir die offizielle Toolchain von ARM, um Code für die AArch64-Architektur des Raspberry Pi 5 kompilieren zu können. Diese steht hier zum Download bereit:

👉 [https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads ARM GNU Toolchain Downloads]

Hinweis: Zum Zeitpunkt der Erstellung dieses Tutorials wurde die Version ''arm-gnu-toolchain-15.2.rel1-mingw-w64-x86_64-aarch64-none-elf.zip'' verwendet. Da die Toolchain kontinuierlich weiterentwickelt wird, kann sich die Versionsnummer bei Ihrem Download leicht unterscheiden.

Für die Verbindung zwischen dem PC und der Debug Probe verwenden wir OpenOCD (Open On-Chip Debugger). Eine vorkompilierte Windows-Version wird über das xPack-Projekt bereitgestellt:

👉 [https://xpack-dev-tools.github.io/openocd-xpack/ xPack OpenOCD Website]

Direkter Download-Link der verwendeten Version: [https://github.com/xpack-dev-tools/openocd-xpack/releases/download/v0.12.0-7/xpack-openocd-0.12.0-7-win32-x64.zip xPack OpenOCD v0.12.0-7]

Zuletzt benötigen wir noch das Build-Werkzeug '''GNU Make''', welches wir im nächsten Schritt direkt über die Windows-Konsole installieren.

== Installation und Einrichtung ==
=== Toolchain einrichten ===
Da Windows gelegentlich Probleme mit sehr langen Pfadnamen haben kann, benennen wir das heruntergeladene Archiv der Toolchain zunächst in '''toolchain.zip''' um.

Entpacken Sie das ZIP-Archiv vollständig.

Erstellen Sie ein neues Verzeichnis direkt auf Ihrem Systemlaufwerk: '''C:\tools'''.

Kopieren Sie den gesamten Inhalt des entpackten Toolchain-Ordners in dieses Verzeichnis, sodass die Ordnerstruktur direkt mit '''C:\tools\bin''' beginnt.

=== OpenOCD einrichten und konfigurieren ===
Entpacken Sie das OpenOCD-ZIP-Archiv.

Im entpackten Ordner finden Sie das Unterverzeichnis '''xpack-openocd-0.12.0-7''' (bzw. Ihre aktuellere Version). Benennen Sie diesen Ordner einfach in '''openocd''' um.

Verschieben Sie den gesamten Ordner '''openocd''' nach '''C:\tools''', sodass der Pfad '''C:\tools\openocd''' entsteht.

Überprüfen Sie anschließend, ob die Datei '''C:\tools\openocd\openocd\scripts\interface\cmsis-dap.cfg''' existiert. Diese wird in der Regel standardmäßig mitgeliefert. Sollte sie fehlen, erstellen Sie diese Datei neu mit folgendem Inhalt:
<syntaxhighlight>
adapter driver cmsis-dap
</syntaxhighlight>
Da in älteren oder Standard-OpenOCD-Releases ein passendes Target-Profil für den neuen Broadcom-Chip BCM2712 des Raspberry Pi 5 fehlt, müssen wir dieses manuell anlegen. Erstellen Sie dazu eine neue Datei unter dem Pfad '''C:\tools\openocd\openocd\scripts\target\bcm2712.cfg''' und fügen Sie folgenden Inhalt ein:
<syntaxhighlight>
if { [info exists CHIPNAME] } {
set _CHIPNAME $CHIPNAME
} else {
set _CHIPNAME bcm2712
}

if { [info exists CHIPCORES] } {
set _cores $CHIPCORES
} else {
set _cores 4
}

if { [info exists USE_SMP] } {
set _USE_SMP $USE_SMP
} else {
set _USE_SMP 0
}

if { [info exists DAP_TAPID] } {
set _DAP_TAPID $DAP_TAPID
} else {
set _DAP_TAPID 0x4ba00477
}

transport select swd

swd newdap $_CHIPNAME cpu -expected-id $_DAP_TAPID -irlen 4
adapter speed 4000

dap create $_CHIPNAME.dap -chain-position $_CHIPNAME.cpu

# MEM-AP für direkten Zugriff
target create $_CHIPNAME.ap mem_ap -dap $_CHIPNAME.dap -ap-num 0

# Diese Adressen wurden aus der ROM-Table via 'dap info 0'-Befehl ausgelesen
set _DBGBASE {0x80010000 0x80110000 0x80210000 0x80310000}
set _CTIBASE {0x80020000 0x80120000 0x80220000 0x80320000}

set _smp_command "target smp"

for { set _core 0 } { $_core < $_cores } { incr _core } {
set _CTINAME $_CHIPNAME.cti$_core
set _TARGETNAME $_CHIPNAME.cpu$_core

cti create $_CTINAME -dap $_CHIPNAME.dap -ap-num 0 -baseaddr [lindex $_CTIBASE $_core]
target create $_TARGETNAME aarch64 -dap $_CHIPNAME.dap -ap-num 0 -dbgbase [lindex $_DBGBASE $_core] -cti $_CTINAME

set _smp_command "$_smp_command $_TARGETNAME"
}

if {$_USE_SMP} {
eval $_smp_command
}

# Standard-Target ist cpu0
targets $_CHIPNAME.cpu0
</syntaxhighlight>
=== GNU Make installieren ===
Unter Windows stellt Microsoft ein Paket für '''GNU Make''' bereit, das sich komfortabel über den integrierten Paketmanager installieren lässt. Öffnen Sie ein Terminal (Eingabeaufforderung oder PowerShell) und geben Sie folgenden Befehl ein:
<syntaxhighlight>
winget install GnuWin32.Make
</syntaxhighlight>
Das Programm wird standardmäßig in das Verzeichnis '''C:\Program Files (x86)\GnuWin32\bin''' installiert. Damit '''Make''' reibungslos mit unseren anderen Tools zusammenarbeitet, kopieren Sie den gesamten Inhalt dieses bin-Ordners in unser zuvor angelegtes Verzeichnis '''C:\tools\bin'''.

=== Umgebungsvariable „Path“ anpassen ===
Damit Windows und Visual Studio Code die installierten Tools (Compiler, Make und OpenOCD) systemweit über die Konsole finden können, müssen wir die ausführbaren Dateien dem Systempfad hinzufügen.

Drücken Sie die '''Windows-Taste''' und tippen Sie im Suchfeld „''Umgebungsvariable''“ ein.

Wählen Sie den Punkt „''Systemumgebungsvariablen bearbeiten''“ und klicken Sie im nächsten Fenster unten auf den Button „''Umgebungsvariablen...''“.
[[Datei:Path1.png|300x300px]]

Suchen Sie im Bereich „''Benutzervariablen''“ oder „''Systemvariablen''“ nach dem Eintrag '''Path''' (oder PATH) und wählen Sie Bearbeiten.

[[Datei:Path2.png|300x300px]]

Fügen Sie der Liste die folgenden zwei Pfade als separate, neue Zeilen hinzu:
<syntaxhighlight>
C:\tools\bin
C:\tools\openocd\bin
</syntaxhighlight>
Bestätigen Sie alle geöffneten Fenster mit '''OK'''.

[[Datei:Path3.png|300x300px]]

Die grundlegende Toolchain ist damit erfolgreich installiert und eingerichtet. Im nächsten Teil widmen wir uns der Konfiguration von Visual Studio Code für das eigentliche Bare-Metal-Projekt.

=== Visual Studio Code einrichten ===
Nachdem die grundlegende Toolchain installiert ist, richten wir nun die Entwicklungsumgebung in Visual Studio Code ein.

Zunächst installiere Visual Studio Code komplett aus dem vorhergehenden Download.

==== VS Code Erweiterungen (Extensions) installieren ====
Öffnen Sie Visual Studio Code. Um die Bare-Metal-Entwicklung so komfortabel wie möglich zu gestalten, installieren wir zunächst einige essenzielle Erweiterungen. Klicken Sie dazu auf das Erweiterungs-Icon auf der linken Menüleiste (oder drücken Sie STRG + UMSCHALT + X) und suchen Sie nach folgenden Extensions:

* C/C++ (von Microsoft): Bietet Syntax-Highlighting und Code-Vervollständigung (IntelliSense) für C/C++.
* C/C++ Extension Pack (optional): Bringt zusätzliche nützliche Werkzeuge für die C-Entwicklung mit.
* Cortex-Debug (von marus25): Die Schlüssel-Erweiterung, die es uns ermöglicht, via OpenOCD direkt auf dem Raspberry Pi 5 zu debuggen.
* Arm Assembly (von dan-c-underwood): Bietet exzellente Unterstützung und Highlighting für ARM-Assembler-Code.

[[Datei:Erw1.png|200x200px]]
[[Datei:Erw2.png|200x200px]]
[[Datei:Erw3.png|200x200px]]
[[Datei:Erw4.png|200x200px]]

==== Optional: Sprache der Benutzeroberfläche auf Deutsch umstellen ====
Falls Ihr VS Code englischsprachig ist und Sie zum Beispiel die deutsche Oberfläche bevorzugen:

Drücken Sie '''STRG + UMSCHALT + P''', um die Befehlspalette zu öffnen. Tippen Sie ''Configure Display Language'' ein und drücken Sie '''Enter'''.

Wählen Sie „Deutsch“ aus (falls nicht aufgelistet, können Sie es darüber direkt nachinstallieren).

Starten Sie VS Code neu.

[[Datei:Lang1.png|200x200px]]
[[Datei:Lang2.png|200x200px]]
[[Datei:Lang3.png|200x200px]]
[[Datei:Lang4.png|200x200px]]

==== Projektverzeichnis erstellen und öffnen ====
Erstellen Sie nun ein Verzeichnis auf Ihrer Festplatte, in dem Ihr Bare-Metal-Projekt leben soll. In diesem Beispiel verwenden wir den Pfad '''D:\projekt1'''. Wählen Sie in VS Code ''Datei -> Ordner öffnen...'' und wählen Sie das Verzeichnis '''D:\projekt1''' aus. Bestätigen Sie die Sicherheitsabfrage, ob Sie den Autoren des Ordners vertrauen, mit „''Ja, ich vertraue den Autoren''“.

[[Datei:Proj1.png|200x200px]]
[[Datei:Proj2.png|200x200px]]

==== Die .vscode Konfigurationsdateien anlegen ====

Damit VS Code weiß, welchen Compiler es nutzen soll und wie der Debugger gestartet wird, legen wir ein Konfigurationsverzeichnis an. Erstellen Sie im Hauptverzeichnis Ihres Projekts einen neuen Ordner mit dem exakten Namen '''.vscode''' (den Punkt am Anfang nicht vergessen!). Klicken Sie mit der rechten Maustaste auf den neu erstellten Ordner '''.vscode''' und legen Sie nacheinander die folgenden drei Dateien an.

[[Datei:Konf1.png|200x200px]]
[[Datei:Konf2.png|200x200px]]

Kopieren Sie jeweils den entsprechenden JSON-Code hinein:

* '''c_cpp_properties.json''': Diese Datei konfiguriert die Code-Vervollständigung (IntelliSense), damit VS Code die ARM-spezifischen Befehle und Header versteht.
<syntaxhighlight lang="json">
{
"configurations": [
{
"name": "Bare-Metal (Pi 5)",
"includePath": [
"${workspaceFolder}/include",
"${workspaceFolder}/src"
],
"compilerPath": "C:/tools/bin/aarch64-none-elf-gcc.exe",
"cStandard": "c11",
"cppStandard": "c++14",
"intelliSenseMode": "windows-gcc-arm64"
}
],
"version": 4
}
</syntaxhighlight>
* '''launch.json''': Diese Datei steuert den Debugger (Cortex-Debug). Sie sorgt dafür, dass Ihr Code via OpenOCD auf den Raspberry Pi 5 geladen und der Prozessor exakt an der Startadresse gestoppt wird.
<syntaxhighlight lang="json">
{
"version": "0.2.0",
"configurations": [
{
"name": "Bare-Metal Debug (Pi 5)",
"cwd": "${workspaceFolder}",
"executable": "${workspaceFolder}/kernel_2712.elf",
"request": "launch",
"type": "cortex-debug",
"runToEntryPoint": "0x80000",
"servertype": "openocd",
"searchDir": [
"C:/tools/openocd/openocd/scripts"
],
"configFiles": [
"interface/cmsis-dap.cfg",
"target/bcm2712.cfg"
],
"gdbPath": "C:/tools/bin/aarch64-none-elf-gdb.exe",
"serverpath": "C:/tools/openocd/bin/openocd.exe",

"openOCDLaunchCommands": [
"transport select swd",
"adapter speed 1000"
],

// Überschreibt den standardmäßigen "reset halt" Befehl von VS-Code
"overrideResetCommands": [
"monitor halt"
],

// Befehle, die direkt nach dem Verbinden ausgeführt werden
"overrideLaunchCommands": [
"monitor halt",
"load",
"monitor reg pc 0x80000" // Zwingt den Prozessor direkt auf die Startadresse
],

"preLaunchTask": "Kompilieren"
}
]
}
</syntaxhighlight>
* '''tasks.json''': Hier wird der automatisierte Build-Prozess definiert. Bevor der Debugger startet, wird über diese Task automatisch make aufgerufen.
<syntaxhighlight lang="json">
{
"version": "2.0.0",
"tasks": [
{
"label": "Kompilieren",
"type": "shell",
"command": "make",
"args": ["all"],
"options": {
"env": {
"PATH": "${env:PATH};C:\\tools\\bin"
}
},
"group": {
"kind": "build",
"isDefault": true
},
"problemMatcher": ["$gcc"]
}
]
}
</syntaxhighlight>
Speichern Sie alle Konfigurationen ab, indem Sie im Menü auf ''Datei -> Alles speichern'' klicken.

[[Datei:AllesSpeichern.png|200x200px]]
[[Datei:Konfübersicht.png|200x200px]]

==== Important: Hinweis zu vermeintlichen Fehlermeldungen ====
Nach dem Speichern der '''c_cpp_properties.json''' fällt Ihnen im Datei-Explorer oder im Reiter „Probleme“ (unten in VS Code) vermutlich eine kleine rote „'''2'''“ auf. Dies deutet auf aktive Warnungen hin. Wenn Sie auf die Meldung klicken, sehen Sie den Grund: VS Code beschwert sich, dass die beiden Verzeichnis-Pfade '''${workspaceFolder}/include''' und '''${workspaceFolder}/src''' nicht existieren.

[[Datei:Prob1.png|200x200px]]

💡Keine Sorge: Das ist völlig korrekt! Da wir ein leeres Projekt gestartet haben, gibt es diese Ordner einfach noch nicht. Sobald Sie im weiteren Verlauf Ihres Projekts die Ordner '''src''' und '''include''' anlegen, verschwindet diese Warnung von selbst.

Tipp: Sollte VS Code neu erstellte Ordner einmal nicht sofort registrieren, können Sie die Entwicklungsumgebung schnell aktualisieren. Drücken Sie dazu '''F1''', tippen Sie ''Reload Window'' ein und bestätigen Sie mit '''Enter'''. Das lädt die Oberfläche neu, ohne Ihre Arbeit zu unterbrechen.

== Sourcecode, Linkerscript und Makefile ==
=== Das Quellcode-Verzeichnis (src/) ===
Um unser Setup praktisch zu testen, verwenden wir ein minimalistisches LED-Blinkbeispiel in C und Assembler ([[Lass die LED leuchten in C (PI5)]]). Dieses Projekt nutzt die Aufteilung in verschiedene Dateien, damit Sie die Querverweise im Code und den Komfort einer professionellen GUI direkt erleben können.

Erstellen Sie im Hauptverzeichnis Ihres Projekts (z. B. '''D:\projekt1''') einen neuen Ordner namens '''src'''.

💡 Wichtiger Hinweis für Assembler-Dateien: Achten Sie darauf, dass Assembler-Dateien, die den C-Präprozessor nutzen (wie das Einbinden von Header-Dateien via '''#include'''), zwingend die Dateiendung mit einem großen „'''S'''“ ('''.S''') haben müssen. Ein kleines „s“ führt dazu, dass der Compiler die Includes ignoriert.

Erstellen Sie im Ordner '''src/''' die folgenden sechs Dateien:
'''src/boot.S''':
<syntaxhighlight lang="asm">
// boot.S
//

#include "config.h"

.section .init // Stellt sicher, dass der Linker dies an den Anfang des Kernel-Images setzt
.globl _start // Hier beginnt die Ausführung

_start:
ldr x0, =MEM_KERNEL_STACK
mov sp, x0 // Stack-Pointer initialisieren
b sysinit
</syntaxhighlight>

'''src/kernel.c''':
<syntaxhighlight lang="C">
// kernel.c
//

#include "led.h"
#include "time.h"

int main (void)
{
while(1)
{
LED_off();
wait(0x3F0000);
LED_on();
wait(0x3F0000);
}
}
</syntaxhighlight>

'''src/led.c''':
<syntaxhighlight lang="C">
// led.c
//

#include "base.h"
#include "util.h"
#include "types.h"

void LED_off(void)
{
u32 reg = read32(ARM_GPIO2_DATA0);
reg &= ~0x200; // Bit 9 auf 0 setzen
write32(ARM_GPIO2_DATA0, reg);
}

void LED_on(void)
{
u32 reg = read32(ARM_GPIO2_DATA0);
reg |= 0x200; // Bit 9 auf 1 setzen
write32(ARM_GPIO2_DATA0, reg);
}
</syntaxhighlight>

'''src/sysinit.S''':
<syntaxhighlight lang="asm">
// sysinit.S
//

.section .text
.globl sysinit

sysinit:
b main
</syntaxhighlight>

'''src/time.c''':
<syntaxhighlight lang="C">
// time.c
//

#include "types.h"

void wait(u32 zyklen)
{
volatile u32 i;
for (i = 0; i < zyklen; i++)
{
// Leere Schleife zur Verzögerung
}
}
</syntaxhighlight>

'''src/util.S''':
<syntaxhighlight lang="asm">
// util.S
//

.globl write32
write32:
stp x29, x30, [sp, -16]!
mov x29, sp
str w1, [x0]
ldp x29, x30, [sp], 16
ret

.globl read32
read32:
stp x29, x30, [sp, -16]!
mov x29, sp
ldr w0, [x0]
ldp x29, x30, [sp], 16
ret
</syntaxhighlight>

'''Hinweis''': Sobald Sie diese Dateien gespeichert haben, wird Ihnen VS Code im „Probleme“-Tab diverse Fehler anzeigen. Der Code ist mit roten, gewellten Linien unterlegt. Das ist völlig normal, da dem Compiler aktuell die Header-Dateien (.h) fehlen und er die Verweise nicht auflösen kann.

[[Datei:Source prob.png|200x200px]]

=== Das Include-Verzeichnis (include/) ===
Um die Fehler zu beheben, legen wir nun die Header-Dateien an. Erstellen Sie dazu im Hauptverzeichnis Ihres Projekts einen neuen Ordner namens '''include'''. Legen Sie darin die folgenden sechs Dateien ab:

'''include/base.h''':
<syntaxhighlight lang="C">
// base.h
//

#ifndef _base_h
#define _base_h

#define RPI_BASE 0x107C000000UL

// GPIO-Definitionen für den Pi 5
#define ARM_GPIO2_BASE (RPI_BASE + 0x1517C00)
#define ARM_GPIO2_DATA0 (ARM_GPIO2_BASE + 0x04)

#endif
</syntaxhighlight>

'''include/config.h''':
<syntaxhighlight lang="C">
// config.h
//

#ifndef _config_h
#define _config_h

#define MEGABYTE 0x100000

#define MEM_KERNEL_START 0x80000 // Startadresse des Hauptprogramms
#define KERNEL_MAX_SIZE (2 * MEGABYTE)
#define MEM_KERNEL_END (MEM_KERNEL_START + KERNEL_MAX_SIZE)
#define KERNEL_STACK_SIZE 0x20000
#define MEM_KERNEL_STACK (MEM_KERNEL_END + KERNEL_STACK_SIZE)

#endif
</syntaxhighlight>

'''include/led.h''':
<syntaxhighlight lang="C">
// led.h
//

#ifndef _ms_led_h
#define _ms_led_h

void LED_off(void);
void LED_on(void);

#endif
</syntaxhighlight>

'''include/time.h''':
<syntaxhighlight lang="C">
// time.h
//

#ifndef _ms_time_h
#define _ms_time_h

#include "types.h"

void wait(u32 zyklen);

#endif
</syntaxhighlight>

'''include/types.h''':
<syntaxhighlight lang="C">
// types.h
//

#ifndef _ms_types_h
#define _ms_types_h

typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;

typedef signed char s8;
typedef signed short s16;
typedef signed int s32;

typedef unsigned long u64;
typedef signed long s64;

typedef long intptr;
typedef unsigned long uintptr;

typedef unsigned long size_t;
typedef long ssize_t;

typedef char boolean;

#define ALIGN(n) __attribute__((aligned (n)))

#define FALSE 0
#define TRUE 1

#endif
</syntaxhighlight>

'''include/util.h''':
<syntaxhighlight lang="C">
// util.h
//

#ifndef _ms_util_h
#define _ms_util_h

#include "types.h"

void write32(u64 a, u32 b);
u32 read32(u64 a);

#endif
</syntaxhighlight>

Sobald alle Header-Dateien im include-Ordner abgespeichert sind, verschwinden die roten Linien in VS Code automatisch. Die GUI hat die Bezüge erfolgreich erkannt.

[[Datei:Null prob.png|200x200px]]

=== Linkerscript und Makefile erstellen ===

Damit aus dem Quellcode ein ausführbares Bare-Metal-Image für den Raspberry Pi 5 gebaut werden kann, benötigen wir ein ''Linkerscript'' und die Steuerungsdatei für '''GNU Make'''. Beide Dateien werden direkt im Hauptverzeichnis (Root) Ihres Projekts angelegt.
==== linker.ld ====
Dieses Skript definiert die genaue Anordnung der Code-Segmente im Arbeitsspeicher des Raspberry Pi 5.
<syntaxhighlight lang="C">
ENTRY(_start)

SECTIONS
{
.init : {
*(.init)
}
.text : {
*(.text)
*(.text.*)
_etext = .;
}

.rodata : {
*(.rodata)
*(.rodata.*)
}
.init_array : {
__init_start = .;
KEEP(*(.init_array*))
__init_end = .;
}
.ARM.exidx : {
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
}
.eh_frame : {
*(.eh_frame*)
}
.data : {
*(.data)
}
.bss : {
__bss_start = .;
*(.bss)
*(COMMON)
__bss_end = .;
}
}
__bss_size = (__bss_end - __bss_start) >> 3;
</syntaxhighlight>
==== Makefile ====
Das '''Makefile''' automatisiert den Aufruf des Compilers und Linkers. Beachten Sie, dass hier explizit die Architektur des Raspberry Pi 5 ('''-mcpu=cortex-a76''') angesprochen wird.
<syntaxhighlight lang="make">
CSRCS := $(wildcard src/*.c)
CPPSRCS := $(wildcard src/*.cpp)
ASRCS := $(wildcard src/*.S)
COBJS := $(CSRCS:.c=.o)
CPPOBJS := $(CPPSRCS:.cpp=.o)
AOBJS := $(ASRCS:.S=.o)
AllOBJS := $(COBJS) $(CPPOBJS) $(AOBJS)
LOADADDR = 0x80000

GCCFLAGS = -mcpu=cortex-a76 -mlittle-endian -Wall -O0 -ffreestanding \
-nostartfiles -nostdlib -nostdinc -g -I ./include

AFLAGS = -mcpu=cortex-a76 -mlittle-endian -I ./include -O0 -g

CFLAGS = -mcpu=cortex-a76 -mlittle-endian -Wall -fsigned-char -ffreestanding -g \
-I ./include -O0 -fno-exceptions

CPPFLAGS = -fno-exceptions -fno-rtti -nostdinc++ -mcpu=cortex-a76 -mlittle-endian -Wall -fsigned-char \
-ffreestanding -g -I ./include -O0 -mstrict-align -std=c++14 -Wno-aligned-new

all: clean new kernel_2712.img

%.o: %.S
@echo "as $@"
@aarch64-none-elf-gcc $(AFLAGS) -c $< -o $@

%.o: %.c
@echo "gcc $@"
@aarch64-none-elf-gcc $(CFLAGS) -c $< -o $@

%.o: %.cpp
@echo "g++ $@"
@aarch64-none-elf-g++ $(CPPFLAGS) -c $< -o $@

kernel_2712.img: $(AllOBJS)
@echo "============================================================================="
@echo "Linking..."
@aarch64-none-elf-ld -o kernel_2712.elf -Map kernel_2712.map -nostdlib \
--section-start=.init=$(LOADADDR) --no-warn-rwx-segments \
-g -T linker.ld $(AllOBJS)
aarch64-none-elf-objcopy -O binary kernel_2712.elf kernel_2712.img

clean:
@if exist kernel_2712.elf del /q /f kernel_2712.elf
@if exist kernel_2712.img del /q /f kernel_2712.img
@if exist kernel_2712.map del /q /f kernel_2712.map
@if exist src\*.o del /q /f src\*.o

new:
@cls
</syntaxhighlight>

'''Wichtiger Hinweis''' zu Makefiles: Verwende keine Leerzeichen um Einrückungen zu erstellen. Dies mag '''make''' nicht. Verwende stattdessen immer ein '''TAB'''.

Vergessen Sie am Ende nicht, alle geöffneten Dateien im VS-Code-Menü über ''Datei -> Alles speichern'' zu sichern. Das Projekt ist nun vollständig konfiguriert und bereit für den ersten Build- und Debugging-Lauf!

== Hardware vorbereiten und Debugging in der GUI ==
=== Hardware vorbereiten und SD-Karte einrichten ===
Da wir den Code direkt auf der echten Hardware testen, müssen wir die SD-Karte des Raspberry Pi 5 vorbereiten. Das Betriebssystem (EEPROM/Firmware) des Pi 5 muss wissen, dass wir ein Bare-Metal-Programm via JTAG/SWD debuggen möchten.

Formatieren Sie eine MicroSD-Karte auf FAT32 und kopieren Sie folgende drei Dateien in das Hauptverzeichnis (Root) der Karte:

'''kernel_2712.img''' (Diese Datei wird gleich beim ersten Kompilieren erzeugt).
'''bcm2712-rpi-5-b.dtb''' (Der originale Device-Tree-Blob aus der offiziellen Raspberry Pi Firmware)
'''.config.txt''' (Die Konfigurationsdatei für die Firmware).

Erstellen Sie die '''config.txt''' mit exakt folgendem Inhalt:
<syntaxhighlight>
arm_64bit=1
kernel_address=0x80000
enable_jtag_gpio=1
kernel=kernel_2712.img
framebuffer_depth=32
</syntaxhighlight>

💡 Was bewirkt diese Konfiguration?

'''kernel_address=0x80000''' setzt die Startadresse im RAM fest, an die unser Kernel geladen wird.

'''enable_jtag_gpio=1''' schaltet die GPIO-Pins des Raspberry Pi 5 in den JTAG-/SWD-Modus um. Dadurch wird die Kommunikation mit der Raspberry Pi Debug Probe überhaupt erst möglich.



Hardware verbinden:
* Stecken Sie die vorbereitete SD-Karte in den Raspberry Pi 5.
* Verbinden Sie die Raspberry Pi Debug Probe über das mitgelieferte 3-Pol-UART/Debug-Kabel mit dem dedizierten Debug-Port des Raspberry Pi 5 (befindet sich zwischen den Micro-HDMI-Ports).
* Schließen Sie die Debug Probe per USB-Kabel an Ihren Windows-Rechner an.
* Schalten Sie den Raspberry Pi 5 ein (Stromversorgung anschließen).

Durch das aktivierte JTAG-Interface wartet der Prozessor nun an der Startadresse auf die Verbindung und Befehle des Debuggers.

=== Programm kompilieren und Debugger starten ===
Dank unserer Vorbereitungen in Visual Studio Code können wir den gesamten Build- und Flash-Prozess mit Tastenkombinationen steuern.

'''Schritt 1:'''

''Kompilieren'': Drücken Sie die Tastenkombination '''STRG + UMSCHALT + B'''. VS Code führt nun im Hintergrund das Makefile aus ('''make all'''). Im Projektverzeichnis entstehen dadurch die Dateien '''kernel_2712.elf''' (für den Debugger inklusive Symbolen) und '''kernel_2712.img''' (das reine Binärformat).

'''Schritt 2:'''

''Debugger starten'': Drücken Sie die Taste '''F5'''.

Nun passiert Folgendes vollautomatisch:

* OpenOCD baut die Verbindung zum Raspberry Pi 5 über die Debug Probe auf.
* Der GDB-Debugger wird gestartet.
* Das neu kompilierte Programm wird direkt in den RAM des Raspberry Pi 5 geladen (load).
* Der Programmzähler des Prozessors wird auf die Startadresse 0x80000 gezwungen.

Da wir in der '''launch.json''' festgelegt haben, dass der Debugger beim Start anhalten soll, stoppt die Ausführung exakt am ersten Befehl. In unserem Sourcecode springt der Cursor direkt in die Datei '''boot.S''' zum Label '''_start:'''

[[Datei:Debug1.png|300x300px]]

=== Bedienung des Debuggers in VS Code ===
Sobald der Debugger aktiv ist, verändert sich die Benutzeroberfläche von VS Code. Am oberen Bildschirmrand erscheint eine schwebende Debug-Steuerungsleiste.

[[Datei:ObDebug.png|300x300px]]

Die Steuerelemente der GUI:

{| class="wikitable"
|+ Steuerelemente
|-
! Icon / Symbol !! Aktion !! Tastenkürzel !! Beschreibung
|-
| [[Datei:Debug Pause.png|20px|link=]] || Pause || F6 || Hält das laufende Programm sofort an der aktuellen Stelle an.
|-
| [[Datei:Debug Weiter.png|20px|link=]] || Fortsetzen || F5 || Lässt das Programm normal weiterlaufen (bis zum nächsten Breakpoint).
|-
| [[Datei:Debug EinzelschrittStepOver.png|20px|link=]] || Einzelschritt (Step Over) || F10 || Führt die aktuelle Zeile aus. Springt bei Funktionen nicht in die Funktion hinein.
|-
| [[Datei:Debug EinzelschrittStepInto.png|20px|link=]] || Einzelschritt (Step Into) || F11 || Springt direkt in eine Funktion hinein, um sie Zeile für Zeile zu prüfen.
|-
| [[Datei:Debug Herausspringen.png|20px|link=]] || Herausspringen (Step Out) || UMSCHALT + F11 || Führt den Rest der aktuellen Funktion aus und stoppt direkt nach der Rückkehr.
|-
| [[Datei:Debug Neustart.png|20px|link=]] || Neustart || STRG + UMSCHALT + F5 || Lädt das Programm neu auf den Pi und startet den Debug-Vorgang von vorne.
|-
| [[Datei:Debug Stop.png|20px|link=]] || Stoppen || UMSCHALT +F5 || Beendet die Debug-Sitzung und schließt die Verbindung zum Pi.5
|}

==== Die Debugger-Ansichten nutzen ====
Der größte Vorteil einer professionellen GUI gegenüber der GDB-Kommandozeile ist die visuelle Aufbereitung aller Prozessor-Informationen auf der linken Seite des Bildschirms:

* Variablen-Fenster (Variables): Hier werden Ihnen lokale und globale Variablen automatisch angezeigt. Sie sehen sofort, welchen Wert sie aktuell besitzen. Sie können Werte hier während des Haltepunkts sogar per Doppelklick manipulieren, um Testfälle zu simulieren!

* Überwachungs-Fenster (Watch): Wenn Sie bestimmte Variablen oder Registeradressen permanent im Auge behalten wollen, können Sie diese hier hinzufügen.

* Aufrufliste (Call Stack): Zeigt Ihnen genau, durch welche Funktionen das Programm gelaufen ist, um an den aktuellen Punkt zu gelangen.

* Register-Fenster (Cortex-Debug): Ein Highlight für Bare-Metal-Entwickler. Hier sehen Sie die CPU-Register des ARM Cortex-A76 Cores (X0 bis X30, SP, PC, etc.) im Echtzeit-Zugriff. Ändert sich ein Registerwert nach einem Einzelschritt, wird dieser farblich hervorgehoben.

[[Datei:Debuger Ansicht.png|300x200px]]

==== Breakpoints (Haltepunkte) per Mausklick setzen ====
Das Eintippen von Speicheradressen in GDB gehört der Vergangenheit an. In VS Code bewegen Sie einfach die Maus links neben die Zeilennummern im Sourcecode (z. B. in der kernel.c in der Zeile ''LED_on();''). Ein schwach roter Punkt erscheint. Mit einem einfachen Linksklick aktivieren Sie den Breakpoint (er wird kräftig rot). Wenn Sie nun '''F5''' (Fortsetzen) drücken, läuft das Programm so lange, bis es genau diese Zeile erreicht, und friert die CPU ein. Ein weiterer Klick auf den Punkt entfernt den Haltepunkt wieder.

[[Datei:Breakpoint1.png|200x200px]]
[[Datei:Breakpoint2.png|200x200px]]

== Zusammenfassung ==
Damit haben Sie eine vollwertige, professionelle Entwicklungsumgebung mit Hardware-Debugging für den Raspberry Pi 5 eingerichtet!

Hauptseite

Satyria — Fri, 05 Jun 2026 13:07:54 GMT

Anhang

← Nächstältere Version		Version vom 5. Juni 2026, 14:07 Uhr
Zeile 101:		Zeile 101:
	**[[Bare-Metal Debugging (JTAG, RPI 4)]]		**[[Bare-Metal Debugging (JTAG, RPI 4)]]
	<!--*[[Bare-Metal Debugging]]-->		<!--*[[Bare-Metal Debugging]]-->
			**[[Professionelle GUI mit Debugging für Bare-Metal (64-Bit) auf dem Raspberry Pi 4]]
	**[[Professionelle GUI mit Debugging für Bare-Metal auf dem Raspberry Pi 5]]		**[[Professionelle GUI mit Debugging für Bare-Metal auf dem Raspberry Pi 5]]
	----		----

Bare-Metal Debugging (JTAG, RPI 4)

Satyria — Fri, 05 Jun 2026 13:06:17 GMT

Konfigurationsdatei erstellen

← Nächstältere Version		Version vom 5. Juni 2026, 14:06 Uhr
(3 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 26:		Zeile 26:
	\|-		\|-
	\| AD3 \|\| GPIO27 \|\| 13		\| AD3 \|\| GPIO27 \|\| 13
			\|-
			\| AD4 \|\| GPIO22 \|\| 15
			\|-
			\| AD7 \|\| GPIO23 \|\| 16
	\|-		\|-
	\| GND \|\| GND \|\| 6 (9,14,20,25,30,34,39)		\| GND \|\| GND \|\| 6 (9,14,20,25,30,34,39)
Zeile 47:		Zeile 51:

	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
			adapter speed 3000

	adapter driver ftdi		adapter driver ftdi

	ftdi vid_pid 0x0403 0x6014		ftdi vid_pid 0x0403 0x6014
			ftdi layout_init 0x0078 0x017b

	~~# Setze das Layout für JTAG-Signale (TDI, TDO, TMS, TCK, nTRST, nSRST)~~		ftdi_tdo_sample_edge falling
	~~# Diese Pins sind für JTAG erforderlich~~		ftdi layout_signal nTRST -ndata 0x0010 -noe 0x0040
	~~ftdi layout_init 0x0000 0x000b~~		ftdi layout_signal nSRST -ndata 0x0020 -noe 0x0040
	ftdi layout_signal nTRST -~~data 0x0020~~ -~~oe 0x0020~~
	ftdi layout_signal nSRST -~~data 0x0010 -oe 0x0010~~
	~~ftdi layout_signal TDI -data 0x0011 -oe 0x0011~~
	~~ftdi layout_signal TDO -data 0x0012 -oe 0x0012~~
	~~ftdi layout_signal TMS -data 0x0013 -oe 0x0013~~
	~~ftdi layout_signal TCK -data 0x0014~~ -~~oe 0x0014~~

	~~# Wählen Sie den JTAG-Modus aus~~
	transport select jtag		transport select jtag
	</syntaxhighlight>		</syntaxhighlight>
Zeile 88:		Zeile 88:

	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
			adapter speed 3000

	adapter driver ftdi		adapter driver ftdi

	ftdi vid_pid 0x0403 0x6014		ftdi vid_pid 0x0403 0x6014
			ftdi layout_init 0x0078 0x017b

	~~# Setze das Layout für JTAG-Signale (TDI, TDO, TMS, TCK, nTRST, nSRST)~~		ftdi_tdo_sample_edge falling
	~~# Diese Pins sind für JTAG erforderlich~~		ftdi layout_signal nTRST -ndata 0x0010 -noe 0x0040
	~~ftdi layout_init 0x0000 0x000b~~		ftdi layout_signal nSRST -ndata 0x0020 -noe 0x0040
	ftdi layout_signal nTRST -~~data 0x0020~~ -~~oe 0x0020~~
	ftdi layout_signal nSRST -~~data 0x0010 -oe 0x0010~~
	~~ftdi layout_signal TDI -data 0x0011 -oe 0x0011~~
	~~ftdi layout_signal TDO -data 0x0012 -oe 0x0012~~
	~~ftdi layout_signal TMS -data 0x0013 -oe 0x0013~~
	~~ftdi layout_signal TCK -data 0x0014~~ -~~oe 0x0014~~

	~~# Wählen Sie den JTAG-Modus aus~~
	transport select jtag		transport select jtag
	</syntaxhighlight>		</syntaxhighlight>

Professionelle GUI mit Debugging für Bare-Metal auf dem Raspberry Pi 5

Satyria — Fri, 05 Jun 2026 10:53:39 GMT

Hardware vorbereiten und SD-Karte einrichten

← Nächstältere Version		Version vom 5. Juni 2026, 11:53 Uhr
(2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 659:		Zeile 659:

	'''enable_jtag_gpio=1''' schaltet die GPIO-Pins des Raspberry Pi 5 in den JTAG-/SWD-Modus um. Dadurch wird die Kommunikation mit der Raspberry Pi Debug Probe überhaupt erst möglich.		'''enable_jtag_gpio=1''' schaltet die GPIO-Pins des Raspberry Pi 5 in den JTAG-/SWD-Modus um. Dadurch wird die Kommunikation mit der Raspberry Pi Debug Probe überhaupt erst möglich.

			<!-- Hier kannst du den kompletten Inhalt runterladen: https://www.satyria.de/arm/sources/RPI4/C/RPI4_ImageVSCode.zip -->

	Hardware verbinden:		Hardware verbinden:

Unser erstes Programm in C (PI4)

Satyria — Fri, 05 Jun 2026 10:25:36 GMT

Kompilieren und Ausführen

← Nächstältere Version		Version vom 5. Juni 2026, 11:25 Uhr
(4 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 9:		Zeile 9:

	== Erstellung des Sourcecodes ==		== Erstellung des Sourcecodes ==
	Leider kommen wir bei Bare-Metal-Programmierung in C nicht um Assembler herum. Auch wenn das Assemblerprogramm zunächst nicht viel tut, wird es später beispielsweise für die Interrupt-Programmierung benötigt.		Leider kommen wir bei Bare-Metal-Programmierung in C nicht um Assembler herum. Auch wenn das Assemblerprogramm zunächst nicht viel tut, wird es später beispielsweise für die Interrupt-Programmierung benötigt. Erstelle zunächst das Verzeichnis "src", in der wir unseren Sourcecode ablegen werden.

	=== Assembler-Code (boot.S) ===		=== Assembler-Code (boot.S) ===
Zeile 15:		Zeile 15:
	Öffnen Sie ein Textprogramm und schreiben Sie folgendes erstes Assemblerprogramm:		Öffnen Sie ein Textprogramm und schreiben Sie folgendes erstes Assemblerprogramm:

	<syntaxhighlight lang="~~GAS~~">		<syntaxhighlight lang="asm">
	//		//
	// The first program for RPI4		// The first program for RPI4
Zeile 57:		Zeile 57:
	[[Programmierumgebung erstellen (64-Bit)]]		[[Programmierumgebung erstellen (64-Bit)]]

	Erstellen Sie dann ein Makefile, ~~angepasst für den Raspberry Pi 4~~:		Erstellen Sie dann ein Makefile, welches im Root-Verzeichnis des Projektes abgelegt wird:

	<syntaxhighlight lang="makefile">		<syntaxhighlight lang="makefile">
	CSRCS := $(wildcard *.c)		CSRCS := $(wildcard src/*.c)
	CPPSRCS := $(wildcard *.cpp)		CPPSRCS := $(wildcard src/*.cpp)
	ASRCS := $(wildcard *.S)		ASRCS := $(wildcard src/*.S)
	COBJS := $(CSRCS:.c=.o)		COBJS := $(CSRCS:.c=.o)
	CPPOBJS := $(CPPSRCS:.cpp=.o)		CPPOBJS := $(CPPSRCS:.cpp=.o)
Zeile 78:		Zeile 78:

	CPPFLAGS = -fno-exceptions -fno-rtti -nostdinc++ -DAARCH=64 -mcpu=cortex-a72 -mlittle-endian -Wall -fsigned-char \		CPPFLAGS = -fno-exceptions -fno-rtti -nostdinc++ -DAARCH=64 -mcpu=cortex-a72 -mlittle-endian -Wall -fsigned-char \
	-ffreestanding -g -I ./include -O0 -mstrict-align -std=c++14 -Wno-aligned-new		-ffreestanding -g -I ./include -O0 -mstrict-align -std=c++14 -Wno-aligned-new

	all: clean new kernel8.img		all: clean new kernel8.img

	%.o: %.S		%.o: %.S
	@echo "as $@"		@echo "as $@"
	@aarch64-none-elf-gcc $(AFLAGS) -c $< -o $@		@aarch64-none-elf-gcc $(AFLAGS) -c $< -o $@

	%.o: %.c		%.o: %.c
	@echo "gcc $@"		@echo "gcc $@"
	@aarch64-none-elf-gcc $(CFLAGS) -c $< -o $@		@aarch64-none-elf-gcc $(CFLAGS) -c $< -o $@

	%.o: %.cpp		%.o: %.cpp
	@echo "g++ $@"		@echo "g++ $@"
	@aarch64-none-elf-g++ $(CPPFLAGS) -c $< -o $@		@aarch64-none-elf-g++ $(CPPFLAGS) -c $< -o $@

	kernel8.img: $(AllOBJS)		kernel8.img: $(AllOBJS)
	@echo "============================================================================="		@echo "============================================================================="
	@echo "Linking..."		@echo "Linking..."
	@aarch64-none-elf-ld -o kernel8.elf -Map kernel8.map -nostdlib \		@aarch64-none-elf-ld -o kernel8.elf -Map kernel8.map -nostdlib \
	--section-start=.init=$(LOADADDR) --no-warn-rwx-segments \		--section-start=.init=$(LOADADDR) --no-warn-rwx-segments \
	-g -T linker.ld $(AllOBJS)		-g -T linker.ld $(AllOBJS)
	aarch64-none-elf-objcopy -O binary kernel8.elf kernel8.img		aarch64-none-elf-objcopy -O binary kernel8.elf kernel8.img

	clean:		clean:
	/bin/rm -f kernel8.elf kernel8.map .o .img > /dev/null 2> /dev/null \|\| true		ifeq ($(MSYSTEM),)
			# --- Native Windows Umgebung (CMD / PowerShell) ---
			# @cls
			@if exist kernel8.elf del /q /f kernel8.elf
			@if exist kernel8.img del /q /f kernel8.img
			@if exist kernel8.map del /q /f kernel8.map
			@if exist src\.o del /q /f src\.o
			else
			# --- MSYS2 / Unix-ähnliche Umgebung ---
			/bin/rm -f kernel8.elf kernel8.map src/.o .img > /dev/null 2> /dev/null \|\| true
			endif

	new:		new:
	/bin/clear		ifeq ($(MSYSTEM),)
			@cls
			else
			/bin/clear
			endif
	</syntaxhighlight>		</syntaxhighlight>

Zeile 114:		Zeile 128:

	== Linker-Script (linker.ld) ==		== Linker-Script (linker.ld) ==
	Erstellen Sie das folgende Linker-Script, welches wir unter [[Arbeiten mit Make und Linker-Script]] beschrieben haben:		Erstellen Sie das folgende Linker-Script, welches wir unter [[Arbeiten mit Make und Linker-Script]] beschrieben haben. Dieses wird, wie das Makefile in das Root-Verzeichnis abgelegt:

	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
Zeile 159:		Zeile 173:

	== Kompilieren und Ausführen ==		== Kompilieren und Ausführen ==
			Bevor wir kompilieren, prüfe deine Verzeichnisstruktur:
			<syntaxhighlight lang="shell">
			C:.
			\| linker.ld
			\| makefile
			\|
			\---src
			boot.S
			main.c
			</syntaxhighlight>
	Nun können wir unser erstes Programm kompilieren:		Nun können wir unser erstes Programm kompilieren:

Professional GUI with Debugging for Bare-Metal on the Raspberry Pi 5

Satyria — Wed, 03 Jun 2026 16:33:55 GMT

Preparing the Hardware and Setting Up the SD Card

Änderungen zeigen

Professional GUI with Debugging for Bare-Metal on the Raspberry Pi 5

Satyria — Wed, 03 Jun 2026 15:59:42 GMT

Die Seite wurde neu angelegt: „Many developers desire a professional way to perform bare-metal development directly within a graphical user interface (GUI). In this guide, I will show you how to set up such a development environment. As our IDE (Integrated Development Environment), we will use Visual Studio Code from Microsoft, which is released under the open-source MIT license. To communicate directly with the Raspberry Pi 5 and debug programs, you will additionally need a '''Raspbe…“

Neue Seite

Many developers desire a professional way to perform bare-metal development directly within a graphical user interface (GUI). In this guide, I will show you how to set up such a development environment. As our IDE (Integrated Development Environment), we will use Visual Studio Code from Microsoft, which is released under the open-source MIT license.

To communicate directly with the Raspberry Pi 5 and debug programs, you will additionally need a '''Raspberry Pi Debug Probe'''. This is connected to a Windows PC via USB and to the Raspberry Pi 5 via the debug pins.

== Software Requirements ==
As mentioned earlier, we will use Visual Studio Code as our GUI. The software can be downloaded for free from the official website:

👉 https://code.visualstudio.com/

Additionally, we need the official toolchain from ARM to be able to compile code for the AArch64 architecture of the Raspberry Pi 5. It is available for download here:

👉 [https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads ARM GNU Toolchain Downloads]

Note: At the time of writing this tutorial, version ''arm-gnu-toolchain-15.2.rel1-mingw-w64-x86_64-aarch64-none-elf.zip'' was used. Since the toolchain is under continuous development, the version number of your download may vary slightly.

For the connection between the PC and the Debug Probe, we use OpenOCD (Open On-Chip Debugger). A pre-compiled Windows version is provided by the xPack project:

👉 [https://xpack-dev-tools.github.io/openocd-xpack/ xPack OpenOCD Website]

Direct download link for the version used: [https://github.com/xpack-dev-tools/openocd-xpack/releases/download/v0.12.0-7/xpack-openocd-0.12.0-7-win32-x64.zip xPack OpenOCD v0.12.0-7]

Finally, we also need the build tool '''GNU Make''', which we will install directly via the Windows console in the next step.

English

Satyria — Wed, 03 Jun 2026 15:58:06 GMT

Appendix

← Nächstältere Version		Version vom 3. Juni 2026, 16:58 Uhr
(2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 45:		Zeile 45:
	== Additional Material ==		== Additional Material ==
	== Appendix ==		== Appendix ==
	*[[Bare-Metal Debugging with JTAG and RPI 4]]		* Debugging
			**[[Bare-Metal Debugging with JTAG and RPI 4]]
			**[[Professional GUI with Debugging for Bare-Metal on the Raspberry Pi 5]]

	== Translations/Traducciones ==		== Translations/Traducciones ==
	*[[Hauptseite\|German]]		*[[Hauptseite\|German]]

Hauptseite

Satyria — Wed, 03 Jun 2026 15:52:15 GMT

Anhang

← Nächstältere Version		Version vom 3. Juni 2026, 16:52 Uhr
Zeile 98:		Zeile 98:
	**[[Basisadressen der Modelle]]		**[[Basisadressen der Modelle]]
	*[[LINKS]]		*[[LINKS]]
	*[[Bare-Metal Debugging (JTAG, RPI 4)]]		* Debugging
			**[[Bare-Metal Debugging (JTAG, RPI 4)]]
	<!--*[[Bare-Metal Debugging]]-->		<!--*[[Bare-Metal Debugging]]-->
			**[[Professionelle GUI mit Debugging für Bare-Metal auf dem Raspberry Pi 5]]
	----		----
	*[[Die wichtigsten Linux-Terminal-Befehle]]		*[[Die wichtigsten Linux-Terminal-Befehle]]

Professionelle GUI mit Debugging für Bare-Metal auf dem Raspberry Pi 5

Satyria — Wed, 03 Jun 2026 15:49:42 GMT

Die .vscode Konfigurationsdateien anlegen

← Nächstältere Version		Version vom 3. Juni 2026, 16:49 Uhr
(2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 180:		Zeile 180:

	* '''c_cpp_properties.json''': Diese Datei konfiguriert die Code-Vervollständigung (IntelliSense), damit VS Code die ARM-spezifischen Befehle und Header versteht.		* '''c_cpp_properties.json''': Diese Datei konfiguriert die Code-Vervollständigung (IntelliSense), damit VS Code die ARM-spezifischen Befehle und Header versteht.
	<syntaxhighlight>		<syntaxhighlight lang="json">
	{		{
	"configurations": [		"configurations": [
Zeile 199:		Zeile 199:
	</syntaxhighlight>		</syntaxhighlight>
	* '''launch.json''': Diese Datei steuert den Debugger (Cortex-Debug). Sie sorgt dafür, dass Ihr Code via OpenOCD auf den Raspberry Pi 5 geladen und der Prozessor exakt an der Startadresse gestoppt wird.		* '''launch.json''': Diese Datei steuert den Debugger (Cortex-Debug). Sie sorgt dafür, dass Ihr Code via OpenOCD auf den Raspberry Pi 5 geladen und der Prozessor exakt an der Startadresse gestoppt wird.
	<syntaxhighlight>		<syntaxhighlight lang="json">
	{		{
	"version": "0.2.0",		"version": "0.2.0",
Zeile 244:		Zeile 244:
	</syntaxhighlight>		</syntaxhighlight>
	* '''tasks.json''': Hier wird der automatisierte Build-Prozess definiert. Bevor der Debugger startet, wird über diese Task automatisch make aufgerufen.		* '''tasks.json''': Hier wird der automatisierte Build-Prozess definiert. Bevor der Debugger startet, wird über diese Task automatisch make aufgerufen.
	<syntaxhighlight>		<syntaxhighlight lang="json">
	{		{
	"version": "2.0.0",		"version": "2.0.0",
Zeile 533:		Zeile 533:
	==== linker.ld ====		==== linker.ld ====
	Dieses Skript definiert die genaue Anordnung der Code-Segmente im Arbeitsspeicher des Raspberry Pi 5.		Dieses Skript definiert die genaue Anordnung der Code-Segmente im Arbeitsspeicher des Raspberry Pi 5.
	<syntaxhighlight>		<syntaxhighlight lang="C">
	ENTRY(_start)		ENTRY(_start)

Zeile 578:		Zeile 578:
	==== Makefile ====		==== Makefile ====
	Das '''Makefile''' automatisiert den Aufruf des Compilers und Linkers. Beachten Sie, dass hier explizit die Architektur des Raspberry Pi 5 ('''-mcpu=cortex-a76''') angesprochen wird.		Das '''Makefile''' automatisiert den Aufruf des Compilers und Linkers. Beachten Sie, dass hier explizit die Architektur des Raspberry Pi 5 ('''-mcpu=cortex-a76''') angesprochen wird.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="make">
	CSRCS := $(wildcard src/*.c)		CSRCS := $(wildcard src/*.c)
	CPPSRCS := $(wildcard src/*.cpp)		CPPSRCS := $(wildcard src/*.cpp)
Zeile 728:		Zeile 728:

	* Register-Fenster (Cortex-Debug): Ein Highlight für Bare-Metal-Entwickler. Hier sehen Sie die CPU-Register des ARM Cortex-A76 Cores (X0 bis X30, SP, PC, etc.) im Echtzeit-Zugriff. Ändert sich ein Registerwert nach einem Einzelschritt, wird dieser farblich hervorgehoben.		* Register-Fenster (Cortex-Debug): Ein Highlight für Bare-Metal-Entwickler. Hier sehen Sie die CPU-Register des ARM Cortex-A76 Cores (X0 bis X30, SP, PC, etc.) im Echtzeit-Zugriff. Ändert sich ein Registerwert nach einem Einzelschritt, wird dieser farblich hervorgehoben.

			[[Datei:Debuger Ansicht.png\|300x200px]]

	==== Breakpoints (Haltepunkte) per Mausklick setzen ====		==== Breakpoints (Haltepunkte) per Mausklick setzen ====

Datei:Debuger Ansicht.png

Satyria — Wed, 03 Jun 2026 15:43:32 GMT

Satyria lud Datei:Debuger Ansicht.png hoch

Neue Seite

Debuger Ansicht

Professionelle GUI mit Debugging für Bare-Metal auf dem Raspberry Pi 5

Satyria — Wed, 03 Jun 2026 15:42:37 GMT

Breakpoints (Haltepunkte) per Mausklick setzen

← Nächstältere Version		Version vom 3. Juni 2026, 16:42 Uhr
Zeile 731:		Zeile 731:
	==== Breakpoints (Haltepunkte) per Mausklick setzen ====		==== Breakpoints (Haltepunkte) per Mausklick setzen ====
	Das Eintippen von Speicheradressen in GDB gehört der Vergangenheit an. In VS Code bewegen Sie einfach die Maus links neben die Zeilennummern im Sourcecode (z. B. in der kernel.c in der Zeile ''LED_on();''). Ein schwach roter Punkt erscheint. Mit einem einfachen Linksklick aktivieren Sie den Breakpoint (er wird kräftig rot). Wenn Sie nun '''F5''' (Fortsetzen) drücken, läuft das Programm so lange, bis es genau diese Zeile erreicht, und friert die CPU ein. Ein weiterer Klick auf den Punkt entfernt den Haltepunkt wieder.		Das Eintippen von Speicheradressen in GDB gehört der Vergangenheit an. In VS Code bewegen Sie einfach die Maus links neben die Zeilennummern im Sourcecode (z. B. in der kernel.c in der Zeile ''LED_on();''). Ein schwach roter Punkt erscheint. Mit einem einfachen Linksklick aktivieren Sie den Breakpoint (er wird kräftig rot). Wenn Sie nun '''F5''' (Fortsetzen) drücken, läuft das Programm so lange, bis es genau diese Zeile erreicht, und friert die CPU ein. Ein weiterer Klick auf den Punkt entfernt den Haltepunkt wieder.

			[[Datei:Breakpoint1.png\|200x200px]]
			[[Datei:Breakpoint2.png\|200x200px]]

	== Zusammenfassung ==		== Zusammenfassung ==
	Damit haben Sie eine vollwertige, professionelle Entwicklungsumgebung mit Hardware-Debugging für den Raspberry Pi 5 eingerichtet!		Damit haben Sie eine vollwertige, professionelle Entwicklungsumgebung mit Hardware-Debugging für den Raspberry Pi 5 eingerichtet!

Datei:Breakpoint2.png

Satyria — Wed, 03 Jun 2026 15:42:20 GMT

Satyria lud Datei:Breakpoint2.png hoch

Neue Seite

Breakpoint2

Datei:Breakpoint1.png

Satyria — Wed, 03 Jun 2026 15:42:00 GMT

Satyria lud Datei:Breakpoint1.png hoch

Neue Seite

Breakpoint1

Professionelle GUI mit Debugging für Bare-Metal auf dem Raspberry Pi 5

Satyria — Wed, 03 Jun 2026 15:40:20 GMT

Bedienung des Debuggers in VS Code

← Nächstältere Version		Version vom 3. Juni 2026, 16:40 Uhr
Zeile 702:		Zeile 702:
	! Icon / Symbol !! Aktion !! Tastenkürzel !! Beschreibung		! Icon / Symbol !! Aktion !! Tastenkürzel !! Beschreibung
	\|-		\|-
	\|		\| [[Datei:Debug Pause.png\|20px\|link=]] \|\| Pause \|\| F6 \|\| Hält das laufende Programm sofort an der aktuellen Stelle an.
	[[Datei:Debug Pause.png\|20px\|link=]]
	\|\| Pause \|\| F6 \|\| Hält das laufende Programm sofort an der aktuellen Stelle an.
	\|-		\|-
	\| ▶️ \|\| Fortsetzen \|\| F5 \|\| Lässt das Programm normal weiterlaufen (bis zum nächsten Breakpoint).		\| [[Datei:Debug Weiter.png\|20px\|link=]] \|\| Fortsetzen \|\| F5 \|\| Lässt das Programm normal weiterlaufen (bis zum nächsten Breakpoint).
	\|-		\|-
	\| ↩️ \|\| Einzelschritt (Step Over) \|\| F10 \|\| Führt die aktuelle Zeile aus. Springt bei Funktionen nicht in die Funktion hinein.		\| [[Datei:Debug EinzelschrittStepOver.png\|20px\|link=]] \|\| Einzelschritt (Step Over) \|\| F10 \|\| Führt die aktuelle Zeile aus. Springt bei Funktionen nicht in die Funktion hinein.
	\|-		\|-
	\| ⬇️ \|\| Einzelschritt (Step Into) \|\| F11 \|\| Springt direkt in eine Funktion hinein, um sie Zeile für Zeile zu prüfen.		\| [[Datei:Debug EinzelschrittStepInto.png\|20px\|link=]] \|\| Einzelschritt (Step Into) \|\| F11 \|\| Springt direkt in eine Funktion hinein, um sie Zeile für Zeile zu prüfen.
	\|-		\|-
	\| ⬆️ \|\| Herausspringen (Step Out) \|\| UMSCHALT + F11 \|\| Führt den Rest der aktuellen Funktion aus und stoppt direkt nach der Rückkehr.		\| [[Datei:Debug Herausspringen.png\|20px\|link=]] \|\| Herausspringen (Step Out) \|\| UMSCHALT + F11 \|\| Führt den Rest der aktuellen Funktion aus und stoppt direkt nach der Rückkehr.
	\|-		\|-
	\| 🔄 \|\| Neustart \|\| STRG + UMSCHALT + F5 \|\| Lädt das Programm neu auf den Pi und startet den Debug-Vorgang von vorne.		\| [[Datei:Debug Neustart.png\|20px\|link=]] \|\| Neustart \|\| STRG + UMSCHALT + F5 \|\| Lädt das Programm neu auf den Pi und startet den Debug-Vorgang von vorne.
	\|-		\|-
	\| ⏹️ \|\| Stoppen \|\| UMSCHALT +F5 \|\| Beendet die Debug-Sitzung und schließt die Verbindung zum Pi.5		\| [[Datei:Debug Stop.png\|20px\|link=]] \|\| Stoppen \|\| UMSCHALT +F5 \|\| Beendet die Debug-Sitzung und schließt die Verbindung zum Pi.5
	\|}		\|}

Datei:Debug Stop.png

Satyria — Wed, 03 Jun 2026 15:39:59 GMT

Satyria lud Datei:Debug Stop.png hoch

Neue Seite

Debug Stop