64-bitowa kompilacja jądra RT dla Raspberry Pi 4B.: 5 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:27

Ten samouczek obejmie proces budowania i instalacji 64-bitowego jądra czasu rzeczywistego na Raspberry Pi. RT Kernel ma kluczowe znaczenie dla pełnej funkcjonalności ROS2 i innych rozwiązań IOT w czasie rzeczywistym.

Kernel został zainstalowany na Raspbianie opartym na x64, który można pobrać tutaj

Notatka. Ten samouczek, choć prosty, wymaga podstawowej znajomości systemu operacyjnego Linux.

Również ze względu na ograniczenia tej platformy wszystkie linki http nie zawierają h. Aby je naprawić, po prostu dodaj „h” na początku linku

Kieszonkowe dzieci

Komputer z procesorem x64 z systemem Linux

Raspberry Pi 4B z zainstalowanym Raspbian 64

Połączenie z Internetem.

Krok 1: Zdobycie niezbędnych narzędzi

Najpierw musimy skorzystać z niezbędnych narzędzi deweloperskich.

Można je uzyskać, wykonując następujące polecenia w terminalu Linux

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

Krok 2: Kompilowanie natywnych narzędzi do kompilacji do kompilacji krzyżowej

Następnym krokiem jest przygotowanie i skompilowanie narzędzi do kompilacji krzyżowej naszego jądra.

Pierwsze narzędzie, które będziemy instalować to Binutils. Ten samouczek został przetestowany z binutils w wersji 2.35.

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 -- cel=aarch64-linux-gnu --wyłącz-nls

Po zakończeniu konfiguracji musimy skompilować program za pomocą następujących poleceń:

make -jx

sudo dokonać instalacji

gdzie -jx oznacza, ile zadań chcesz uruchomić równolegle. Zasadą jest, aby nie przekraczać liczby wątków, które ma twój system. (na przykład make -j16)

i wreszcie musimy wyeksportować ścieżkę

eksportuj PATH=$PATH:/opt/aarch64/bin/

Następnie przystępujemy do budowy i instalacji GCC

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 --without-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

Niż tak samo jak przed zrobieniem i zainstalowaniem naszego kompilatora

make all-gcc -jx

sudo make install-gcc

Jeśli wszystko poszło gładko zgodnie z poleceniem

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

powinna skutkować odpowiedzią podobną do tej.

ux-gnu-gcc -v Korzystanie z wbudowanych specyfikacji. COLLECT_GCC=/opt/aarch64/bin/aarch64-linux-gnu-gcc COLLECT_LTO_WRAPPER=/opt/aarch64/libexec/gcc/aarch64-linux-gnu/8.4.0/lto-wrapper Cel: aarch64-linux-gnu Skonfigurowany z:./configure --prefix=/opt/aarch64 --target=aarch64-linux-gnu --with-newlib --without-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 Model wątku: pojedynczy gcc w wersji 8.4.0 (GCC)

Krok 3: Łatanie jądra i konfiguracja jądra

Teraz nadszedł czas, aby pobrać nasze jądro i łatkę RT.

Ten samouczek będzie używał jądra rpi w wersji 5.4 i poprawki RT32 RT. To połączenie sprawdziło się dla mnie. Jednak wszystko powinno działać poprawnie z różnymi wersjami.

mkdir ~/rpi-jądro

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 cd kernel-out linux

następnie rozpakuj łatkę.

gzip -cd../patch-5.4.54-rt32.patch.gz | łatka -p1 --pełna

I zainicjuj konfigurację dla Rpi 4B

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

Następnie musimy wejść do menuconfig

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

Kiedy się uruchamia, musimy przejść do istniejącej konfiguracji, a następnie przejdź do

Ogólne -> Model pierwokupu i wybierz opcję Real Time.

potem zapisujemy nową konfigurację i wychodzimy z menu.

Krok 4: Budowanie jądra RT

Teraz czas na kompilację. Pamiętaj, że może to zająć dużo czasu, w zależności od możliwości Twojego komputera.

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

Tak jak poprzednio -jx oznacza liczbę zadań. Po udanej kompilacji musimy spakować nasz Kernel i wysłać go do Raspberry Pi. W tym celu wykonujemy następujące polecenia.

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..

Teraz nasze jądro powinno znajdować się w archiwum rt-kernel.tgz i być gotowe do wysłania i zainstalowania.

Krok 5: Instalacja nowego jądra

Najłatwiejszym sposobem wysłania naszego kernela do raspbperry jest użycie scp.

Po prostu wykonujemy następujące polecenie.

scp rt-kernel.tgz pi@:/tmp

Teraz musimy zalogować się do naszego pi przez ssh i rozpakować nasze jądro.

ssh pi@

Po zalogowaniu kopiujemy nasze pliki za pomocą następujących poleceń.

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/

Następnie pozostaje tylko wyedytować plik /boot/config.txt i dodać następującą linię.

kernel=kernel8.img

Po ponownym uruchomieniu pi wszystko powinno działać poprawnie.

Aby sprawdzić, czy nowe jądro zostało pomyślnie zainstalowane, możesz wykonać

uname -a

Komenda