Compilation du noyau RT 64 bits pour Raspberry Pi 4B. : 5 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Ce tutoriel couvrira le processus de construction et d'installation du noyau temps réel 64 bits sur Raspberry Pi. RT Kernel est crucial pour la pleine fonctionnalité de ROS2 et d'autres solutions IOT en temps réel.

Le noyau a été installé sur Raspbian basé sur x64 qui peut être obtenu ici

Noter. Ce tutoriel bien que simple nécessite des connaissances de base du système d'exploitation Linux.

De plus, en raison des limitations de cette plate-forme, tous les liens http manquent de h. Pour les corriger, ajoutez simplement "h" au début du lien

Fournitures

PC basé sur x64 exécutant Linux

Raspberry Pi 4B avec Raspbian 64 déjà installé

Connexion à Internet.

Étape 1: Obtenir les outils nécessaires

Nous devons d'abord opter pour les outils de développement nécessaires.

Ils peuvent être obtenus en exécutant les commandes suivantes dans le terminal 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

Étape 2: Compiler les outils de construction natifs pour la compilation croisée

L'étape suivante consiste à préparer et à compiler des outils pour la compilation croisée de notre noyau.

Le premier outil que nous allons installer est Binutils. Ce tutoriel a été testé avec la version 2.35 de binutils.

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 -- cible=aarch64-linux-gnu --disable-nls

Une fois la configuration terminée, nous devons compiler le programme à l'aide des commandes suivantes

faire -jx

sudo faire installer

où -jx signifie combien de tâches vous souhaitez exécuter i parrarell. La règle de base est de ne pas le mettre plus haut que le nombre de threads de votre système. (par exemple make -j16)

et enfin nous devons exporter le chemin

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

Ensuite, nous procédons à la construction et à l'installation de 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

Que la même chose qu'avant de créer et d'installer notre compilateur

make all-gcc -jx

sudo make install-gcc

Si tout s'est bien passé après la commande

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

devrait aboutir à une réponse similaire à celle-ci.

ux-gnu-gcc -v Utilisation des spécifications intégrées. COLLECT_GCC=/opt/aarch64/bin/aarch64-linux-gnu-gcc COLLECT_LTO_WRAPPER=/opt/aarch64/libexec/gcc/aarch64-linux-gnu/8.4.0/lto-wrapper Cible: aarch64-linux-gnu Configuré avec:./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 Modèle de thread: version unique de gcc 8.4.0 (GCC)

Étape 3: Patcher le noyau et configurer le noyau

Il est maintenant temps d'obtenir notre noyau et notre patch RT.

Ce tutoriel utilisera le noyau rpi v 5.4 et le patch RT RT32. Cette combinaison a bien fonctionné pour moi. Cependant, tout devrait fonctionner correctement avec les différentes versions.

mkdir ~/rpi-noyau

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

puis déballez le patch.

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

Et initialiser la configuration pour Rpi 4B

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

Après cela, nous devons entrer dans le menuconfig

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

Lorsqu'il démarre, nous avons besoin de la configuration existante, puis accédez à

General -> Preemtion Model et sélectionnez l'option Real Time.

que nous sauvegardons la nouvelle configuration et quittons le menu.

Étape 4: Créer le noyau RT

C'est maintenant l'heure de la compilation. Notez que cela peut prendre beaucoup de temps en fonction des capacités de votre PC.

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

Comme précédemment, -jx signifie le nombre de travaux. Après une compilation réussie, nous devons emballer notre noyau et l'envoyer à Raspberry Pi. Pour ce faire, nous exécutons les commandes suivantes.

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../kernel- out/arch/arm64/boot/Image../rt-kernel/boot/kernel8.imgcd $INSTALL_MOD_PATHtar czf../rt-kernel.tgz *cd..

Maintenant, notre noyau devrait se trouver dans l'archive rt-kernel.tgz et être prêt à être envoyé et installé.

Étape 5: Installation du nouveau noyau

Le moyen le plus simple d'envoyer notre noyau à rasbbperry est d'utiliser scp.

Nous exécutons simplement la commande suivante.

scp rt-kernel.tgz pi@:/tmp

Maintenant, nous devons nous connecter à notre pi via ssh et décompresser notre noyau.

ssh pi@

Une fois connecté, nous copions nos fichiers à l'aide des commandes suivantes.

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/

Après cela, il ne reste plus qu'à éditer le fichier /boot/config.txt et à ajouter la ligne suivante.

kernel=kernel8.img

Après avoir redémarré pi, tout devrait fonctionner correctement.

Pour vérifier si le nouveau noyau a été installé avec succès, vous pouvez exécuter

uname -a

commander