64-Bit-RT-Kernel-Kompilierung für Raspberry Pi 4B. - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:15

Dieses Tutorial behandelt den Aufbau und die Installation des 64-Bit-Echtzeitkernels auf dem Raspberry Pi. RT Kernel ist entscheidend für die volle Funktionalität von ROS2 und anderen Real Time IOT-Lösungen.

Kernel wurde auf x64-basiertem Raspbian installiert, das hier heruntergeladen werden kann

Notiz. Dieses Tutorial erfordert, obwohl einfach, Grundkenntnisse des Linux-Betriebssystems.

Auch aufgrund von Einschränkungen dieser Plattform fehlen alle http-Links h. Um sie zu beheben, fügen Sie einfach "h" am Anfang des Links hinzu

Lieferungen

x64-basierter PC mit Linux

Raspberry Pi 4B mit bereits installiertem Raspbian 64

Verbindung zum Internet.

Schritt 1: Notwendige Werkzeuge besorgen

Zuerst müssen wir notwendige Entwicklungstools erwerben.

Sie können durch Ausführen der folgenden Befehle im Linux-Terminal abgerufen werden

sudo apt-get install build-essential libgmp-dev libmpfr-dev libmpc-dev libisl-dev libncurses5-dev bc git-core bison flexsudo apt-get install libncurses-dev libssl-dev

Schritt 2: Kompilieren von nativen Build-Tools für die Cross-Kompilierung

Der nächste Schritt besteht darin, Tools für die Cross-Kompilierung unseres Kernels vorzubereiten und zu kompilieren.

Das erste Tool, das wir installieren werden, ist Binutils. Dieses Tutorial wurde mit Binutils Version 2.35 getestet.

cd ~/Downloadswget ttps://ftp.gnu.org/gnu/binutils/binutils-2.35.tar.bz2tar xf binutils-2.35.tar.bz2cd binutils-2.35/./configure --prefix=/opt/aarch64 -- --disable-nls

Nachdem die Konfiguration abgeschlossen ist, müssen wir das Programm mit den folgenden Befehlen kompilieren

machen -jx

sudo machen installieren

wobei -jx bedeutet, wie viele Jobs Sie parallel ausführen möchten. Als Faustregel gilt, es nicht höher zu setzen als die Anzahl der Threads, die Ihr System hat. (zum Beispiel make -j16)

und schließlich müssen wir den Pfad exportieren

export PFAD=$PFAD:/opt/aarch64/bin/

Dann fahren wir mit dem Bau und der Installation von GCC fort

cd..wget ttps://ftp.gnu.org/gnu/gcc/gcc-8.4.0/gcc-8.4.0.tar.xztar xf gcc-8.4.0.tar.xzcd gcc-8.4.0/. /contrib/download_prerequisites./configure --prefix=/opt/aarch64 --target=aarch64-linux-gnu --with-newlib --with-headers / --disable-nls --disable-shared --disable-threads --disable-libssp --disable-decimal-float / --disable-libquadmath --disable-libvtv --disable-libgomp --disable-libatomic / --enable-languages=c --disable-multilib

Als das gleiche wie vorher machen und installieren wir unseren Compiler

make all-gcc -jx

sudo make install-gcc

Wenn nach Befehl alles glatt gelaufen ist

/opt/aarch64/bin/aarch64-linux-gnu-gcc -v

sollte zu einer ähnlichen Reaktion führen.

ux-gnu-gcc -v Verwendung integrierter Spezifikationen. COLLECT_GCC=/opt/aarch64/bin/aarch64-linux-gnu-gcc COLLECT_LTO_WRAPPER=/opt/aarch64/libexec/gcc/aarch64-linux-gnu/8.4.0/lto-wrapper Ziel: aarch64-linux-gnu Konfiguriert mit:./configure --prefix=/opt/aarch64 --target=aarch64-linux-gnu --with-newlib --with-headers --disable-nls --disable-shared --disable-threads --disable-libssp --disable-decimal-float --disable-libquadmath --disable-libvtv --disable-libgomp --disable-libatomic --enable-languages=c --disable-multilib Thread-Modell: Single gcc Version 8.4.0 (GCC)

Schritt 3: Kernel patchen und Kernel konfigurieren

Jetzt ist es an der Zeit, unseren Kernel- und RT-Patch zu erhalten.

Dieses Tutorial verwendet den rpi-Kernel v 5.4 und den RT-Patch RT32. Diese Kombination hat mir gut getan. Allerdings sollte mit verschiedenen Versionen alles gut funktionieren.

mkdir ~/rpi-kernel

cd ~/rpi-kernel git clone ttps://github.com/raspberrypi/linux.git -b rpi-5.4.y wget ttps://mirrors.edge.kernel.org/pub/linux/kernel/projects/rt /5.4/older/patch-5.4.54-rt32.patch.gz mkdir kernel-out cd linux

Entpacken Sie dann den Patch.

gzip -cd../patch-5.4.54-rt32.patch.gz | patch -p1 --verbose

Und initialisieren Sie die Konfiguration für Rpi 4B

make O=../kernel-out/ ARCH=arm64 CROSS_COMPILE=/opt/aarch64/bin/aarch64-linux-gnu-bcm2711_defconfig

Danach müssen wir die Menükonfiguration eingeben

make O=../kernel-out/ ARCH=arm64 CROSS_COMPILE=/opt/aarch64/bin/aarch64-linux-gnu-menuconfig

Wenn es startet, brauchen wir die vorhandene Konfiguration, dann gehen Sie zu

Allgemein -> Preemtion-Modell und wählen Sie die Option Echtzeit.

dann speichern wir die neue Konfiguration und verlassen das Menü.

Schritt 4: RT-Kernel erstellen

Jetzt ist es Zeit für die Kompilierung. Beachten Sie, dass dies je nach PC-Fähigkeiten lange dauern kann.

make -jx O=../kernel-out/ ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-

Wie zuvor bedeutet -jx die Anzahl der Jobs. Nach erfolgreicher Kompilierung müssen wir unseren Kernel packen und an Raspberry Pi senden. Dazu führen wir folgende Befehle aus.

export INSTALL_MOD_PATH=~/rpi-kernel/rt-kernelexport INSTALL_DTBS_PATH=~/rpi-kernel/rt-kernelmake O=../kernel-out/ ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-modules_install dtbs_installcp-.. out/arch/arm64/boot/Image../rt-kernel/boot/kernel8.imgcd $INSTALL_MOD_PATHtar czf../rt-kernel.tgz *cd..

Jetzt sollte sich unser Kernel im rt-kernel.tgz-Archiv befinden und bereit sein, gesendet und installiert zu werden.

Schritt 5: Neuen Kernel installieren

Der einfachste Weg, unseren Kernel an raspbperry zu senden, ist die Verwendung von scp.

Wir führen einfach folgenden Befehl aus.

scp rt-kernel.tgz pi@:/tmp

Jetzt müssen wir uns über ssh bei unserem Pi anmelden und unseren Kernel entpacken.

ssh pi@

Wenn wir eingeloggt sind, kopieren wir unsere Dateien mit den folgenden Befehlen.

cd /tmptar xzf rt-kernel.tgz cd boot sudo cp -rd * /boot/ cd../lib sudo cp -dr * /lib/ cd../overlays sudo cp -dr * /boot/overlays cd../ broadcom sudo cp -dr bcm* /boot/

Danach müssen Sie nur noch die Datei /boot/config.txt bearbeiten und die folgende Zeile hinzufügen.

kernel=kernel8.img

Nach dem Neustart von Pi sollte alles einwandfrei funktionieren.

Um zu überprüfen, ob der neue Kernel erfolgreich installiert wurde, können Sie Folgendes ausführen:

uname -a

Befehl