Comment installer le compilateur croisé Raspberry Pi sur ma machine hôte Linux?

J'essaie d'obtenir une compilation croisée pour Raspberry Pi fonctionnant sur ma machine Ubuntu.

Au cours de mes premières tentatives, j'utilisais le compilateur arm-linux-gnueabi, disponible dans le repo Ubuntu. J'ai fait fonctionner ça. J'ai pu créer toutes mes dépendances et utiliser le compilateur croisé dans mon projet cmake.

Cependant, je pense que je devrais utiliser la version hf, alors je suis passé à arm-linux-gnueabihf. Ensuite, j'ai réalisé que cela ne fonctionnait pas avec Raspberry Pi puisqu'il s'agit d'armv6.

Après quelques recherches sur Google, j'ai ensuite trouvé la chaîne d'outils prédéfinie de GitHub .

J'ai téléchargé la chaîne d'outils, mais je ne comprends pas vraiment comment «l'installer». J'ai extrait les fichiers dans mon répertoire personnel. La structure du répertoire ressemble à ceci:

/gcc-linearo-arm-linux-gnueabihf-raspbian
    /arm-linux-gnueabihf
        /bin
            (contains g++, gcc, etc)
        /lib
            (contains libstdc++ library)
    /bin
        (contains arm-linux-gnueabihf-g++, arm-linux-gnueabihf-...)
    /lib
        (gcc lib stuff)

Si je change de répertoire dans le dossier bin INNER, je peux compiler un programme de test à partir du terminal sans aucun problème.

~/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/
arm-linux-gnueabihf/bin$ g++ test.cpp -o test

J'ai ensuite essayé de compiler un programme de test dans le dossier bin OUTER, qui contient les versions préfixées des outils.

 ~/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin$ 
 arm-linux-gnueabihf-g++ test.cpp -o test

Cependant, lorsque j'essaie d'utiliser le compilateur maintenant (depuis l'extérieur du répertoire bin interne), il est impossible de trouver la bibliothèque partagée libstdc ++ fournie avec la chaîne d'outils:

arm-linux-gnueabihf-gcc: error while loading shared libraries: 
libstdc++.so.6: cannot open shared object file: No such file or directory.

De plus, je souhaite pouvoir utiliser le compilateur sans avoir à naviguer vers le répertoire bin. J'ai donc essayé d'ajouter le répertoire bin OUTER (puisque je veux les versions préfixées) et les deux répertoires lib à mon PATH:

export PATH=$PATH:~/tools/.../bin
export PATH=$PATH:~/tools/.../lib
export PATH=$PATH:~/tools/.../.../lib

Cependant, cela entraîne la même erreur. Comment dois-je «installer» la chaîne d'outils afin de pouvoir utiliser la chaîne d'outils de partout, comme je peux le faire lorsque j'utilise les compilateurs croisés du repo Ubuntu?

Je vais essayer d'écrire ceci comme un tutoriel pour que cela devienne facile à suivre.

REMARQUE: ce tutoriel ne fonctionne que pour les anciennes images raspbian. Pour le plus récent Raspbian basé sur Debian Buster, consultez le guide suivant dans ce fil: https://stackoverflow.com/a/58559140/869402

Pré-requis

Avant de commencer, vous devez vous assurer que les éléments suivants sont installés:

apt-get install git rsync cmake ia32-libs

Croisons-nous compilons une tarte!

Commencez par créer un dossier dans votre répertoire personnel appelé raspberrypi.

Accédez à ce dossier et déroulez le dossier d'outils ENTIER que vous avez mentionné ci-dessus:

git clone git://github.com/raspberrypi/tools.git

Vous vouliez utiliser les 3 suivants gcc-linaro-arm-linux-gnueabihf-raspbian, si je n'ai pas mal lu.

Allez dans votre répertoire personnel et ajoutez:

export PATH=$PATH:$HOME/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin

à la fin du fichier nommé ~/.bashrc

Vous pouvez maintenant vous déconnecter et vous reconnecter (c'est-à-dire redémarrer votre session de terminal), ou exécuter . ~/.bashrcdans votre terminal pour récupérer l' PATHajout dans votre session de terminal en cours.

Maintenant, vérifiez que vous pouvez accéder au compilateur arm-linux-gnueabihf-gcc -v. Vous devriez obtenir quelque chose comme ceci:

Using built-in specs.
COLLECT_GCC=arm-linux-gnueabihf-gcc
COLLECT_LTO_WRAPPER=/home/tudhalyas/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/../libexec/gcc/arm-linux-gnueabihf/4.7.2/lto-wrapper
Target: arm-linux-gnueabihf
Configured with: /cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-raspbian-linux/.b
 uild/src/gcc-linaro-4.7-2012.08/configure --build=i686-build_pc-linux-gnu --host=i686-build_pc-
 linux-gnu --target=arm-linux-gnueabihf --prefix=/cbuild/slaves/oort61/crosstool-ng/builds/arm-l
 inux-gnueabihf-raspbian-linux/install --with-sysroot=/cbuild/slaves/oort61/crosstool-ng/builds/
 arm-linux-gnueabihf-raspbian-linux/install/arm-linux-gnueabihf/libc --enable-languages=c,c++,fo
 rtran --disable-multilib --with-arch=armv6 --with-tune=arm1176jz-s --with-fpu=vfp --with-float=
 hard --with-pkgversion='crosstool-NG linaro-1.13.1+bzr2458 - Linaro GCC 2012.08' --with-bugurl=
 https://bugs.launchpad.net/gcc-linaro --enable-__cxa_atexit --enable-libmudflap --enable-libgom
 p --enable-libssp --with-gmp=/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-rasp
 bian-linux/.build/arm-linux-gnueabihf/build/static --with-mpfr=/cbuild/slaves/oort61/crosstool-
 ng/builds/arm-linux-gnueabihf-raspbian-linux/.build/arm-linux-gnueabihf/build/static --with-mpc
 =/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-raspbian-linux/.build/arm-linux-
 gnueabihf/build/static --with-ppl=/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf
 -raspbian-linux/.build/arm-linux-gnueabihf/build/static --with-cloog=/cbuild/slaves/oort61/cros
 stool-ng/builds/arm-linux-gnueabihf-raspbian-linux/.build/arm-linux-gnueabihf/build/static --wi
 th-libelf=/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-raspbian-linux/.build/a
 rm-linux-gnueabihf/build/static --with-host-libstdcxx='-L/cbuild/slaves/oort61/crosstool-ng/bui
 lds/arm-linux-gnueabihf-raspbian-linux/.build/arm-linux-gnueabihf/build/static/lib -lpwl' --ena
 ble-threads=posix --disable-libstdcxx-pch --enable-linker-build-id --enable-plugin --enable-gol
 d --with-local-prefix=/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-raspbian-li
 nux/install/arm-linux-gnueabihf/libc --enable-c99 --enable-long-long
Thread model: posix
gcc version 4.7.2 20120731 (prerelease) (crosstool-NG linaro-1.13.1+bzr2458 - Linaro GCC 2012.08
 )

Mais salut! J'ai fait ça et les bibliothèques ne fonctionnent toujours pas!

Nous n'avons pas encore fini! Jusqu'à présent, nous n'avons fait que les bases.

Dans votre raspberrypidossier, créez un dossier appelé rootfs.

Vous devez maintenant copier l'intégralité du répertoire /libet /usrdans ce dossier nouvellement créé. J'apporte généralement l'image rpi et la copie via rsync:

rsync -rl --delete-after --safe-links pi@192.168.1.PI:/{lib,usr} $HOME/raspberrypi/rootfs

où 192.168.1.PIest remplacé par l'IP de votre Raspberry Pi.

Maintenant, nous devons écrire un cmakefichier de configuration. Ouvrez ~/home/raspberrypi/pi.cmakedans votre éditeur préféré et insérez ce qui suit:

SET(CMAKE_SYSTEM_NAME Linux)
SET(CMAKE_SYSTEM_VERSION 1)
SET(CMAKE_C_COMPILER $ENV{HOME}/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-gcc)
SET(CMAKE_CXX_COMPILER $ENV{HOME}/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-g++)
SET(CMAKE_FIND_ROOT_PATH $ENV{HOME}/raspberrypi/rootfs)
SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

Maintenant , vous devriez être en mesure de compiler vos cmakeprogrammes en ajoutant simplement ce drapeau supplémentaire: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake.

En utilisant un exemple de cmake hello world :

git clone https://github.com/jameskbride/cmake-hello-world.git 
cd cmake-hello-world
mkdir build
cd build
cmake -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake ../
make
scp CMakeHelloWorld pi@192.168.1.PI:/home/pi/
ssh pi@192.168.1.PI ./CMakeHelloWorld

Construction pour les nouvelles images Raspbian Debian Buster et ARMv6

La réponse de @Stenyg ne fonctionne que pour les anciennes images Raspbian. Le Raspbian récemment publié basé sur Debian Buster nécessite une chaîne d'outils mise à jour:

Dans Debian Buster, le compilateur gcc et la glibc ont été mis à jour vers la version 8.3. La chaîne d'outils de git://github.com/raspberrypi/tools.gitest toujours basée sur l'ancienne version de gcc 6. Cela signifie que l'utilisation git://github.com/raspberrypi/tools.gitentraînera de nombreuses erreurs de compilation.

Ce tutoriel est basé sur la réponse @Stenyg. En plus de nombreuses autres solutions sur Internet, ce tutoriel prend également en charge les anciens Rasperry Pi (A, B, B +, Zero ) basés sur le processeur ARMv6. Voir aussi: GCC 8 Cross Compiler génère un exécutable ARMv7 au lieu d'ARMv6

Configurer la chaîne d'outils

Il n'y a pas de référentiel git officiel contenant une chaîne d'outils mise à jour (voir https://github.com/raspberrypi/tools/issues/102 ).

J'ai créé un nouveau référentiel github qui inclut la construction et les chaînes d'outils précompilées pour ARMv6 basées sur GCC8 et plus récent:

https://github.com/Pro/raspi-toolchain

Comme mentionné dans le fichier Lisez-moi du projet, voici les étapes pour obtenir la chaîne d'outils. Vous pouvez également le construire vous-même (voir le README pour plus de détails).

1. Téléchargez la chaîne d'outils:

wget https://github.com/Pro/raspi-toolchain/releases/latest/download/raspi-toolchain.tar.gz

2. Extrayez-le. Remarque: la chaîne d'outils doit être intégrée /opt/cross-pi-gcccar elle n'est pas indépendante de l'emplacement.

sudo tar xfz raspi-toolchain.tar.gz --strip-components=1 -C /opt

3. Vous avez terminé! La chaîne d'outils est maintenant en/opt/cross-pi-gcc

4. Facultatif, ajoutez la chaîne d'outils à votre chemin, en ajoutant:

export PATH=$PATH:/opt/cross-pi-gcc/bin

à la fin du fichier nommé ~/.bashrc

Vous pouvez maintenant vous déconnecter et vous reconnecter (c'est-à-dire redémarrer votre session de terminal), ou exécuter . ~/.bashrcdans votre terminal pour récupérer l' PATHajout dans votre session de terminal en cours.

Récupérez les bibliothèques du Raspberry PI

Pour effectuer une compilation croisée pour votre propre Raspberry Pi, qui peut avoir des bibliothèques personnalisées installées, vous devez obtenir ces bibliothèques sur votre hôte.

Créez un dossier $HOME/raspberrypi. Dans votre raspberrypidossier, créez un dossier appelé rootfs.

Vous devez maintenant copier l'intégralité du répertoire /libet /usrdans ce dossier nouvellement créé. J'apporte généralement l'image rpi et la copie via rsync:

rsync -vR --progress -rl --delete-after --safe-links pi@192.168.1.PI:/{lib,usr,opt/vc/lib} $HOME/raspberrypi/rootfs

où 192.168.1.PIest remplacé par l'IP de votre Raspberry Pi.

Utilisez CMake pour compiler votre projet

Pour dire à CMake de prendre votre propre chaîne d'outils, vous devez disposer d'un fichier de chaîne d'outils qui initialise les paramètres du compilateur.

Obtenez ce fichier de chaîne d'outils à partir d'ici: https://github.com/Pro/raspi-toolchain/blob/master/Toolchain-rpi.cmake

Vous devriez maintenant pouvoir compiler vos cmakeprogrammes simplement en ajoutant cet indicateur supplémentaire: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmakeet en définissant les bonnes variables d'environnement:

export RASPBIAN_ROOTFS=$HOME/raspberry/rootfs
export PATH=/opt/cross-pi-gcc/bin:$PATH
export RASPBERRY_VERSION=1
cmake -DCMAKE_TOOLCHAIN_FILE=$HOME/raspberry/Toolchain-rpi.cmake ..

Un exemple de bonjour le monde est montré ici: https://github.com/Pro/raspi-toolchain/blob/master/build_hello_world.sh

Je n'ai pas pu obtenir le compilateur ( x64version) pour utiliser le sysrootjusqu'à ce que j'aie ajouté SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs)à pi.cmake.

Pour l'hôte Windows, je recommande vivement ce tutoriel :

• Téléchargez et installez la chaîne d'outils
• Synchronisez la racine système avec vos répertoires d'inclusion / lib RPi
• Compilez votre code
• Faites glisser et déposez l'exécutable sur votre RPi à l'aide de SmarTTY
• Exécuter!

Ni plus ni moins!

Chaînes d'outils GNU prédéfinies disponibles pour Raspberry, Beaglebone, Cubieboard, AVR (Atmel) et plus

Vous pouvez également utiliser clang . Il était plus rapide que GCC, et maintenant c'est une chose assez stable. Il est beaucoup plus facile de créer un bruit à partir de sources ( vous pouvez vraiment boire une tasse de café pendant le processus de construction ).

En bref:

1. Obtenez des binaires clang (sudo apt-get install clang) .. ou téléchargez et compilez ( lisez les instructions ici )
2. Montez vos rootfs raspberry (il peut s'agir des vrais rootfs montés via sshfs, ou une image).

3. Compilez votre code:

   path/to/clang --target=arm-linux-gnueabihf --sysroot=/some/path/arm-linux-gnueabihf/sysroot my-happy-program.c -fuse-ld=lld

Vous pouvez éventuellement utiliser les anciens binutils arm-linux-gnueabihf. Ensuite, vous pouvez supprimer l'indicateur "-fuse-ld = lld" à la fin.

Voici mon fichier de chaîne d'outils cmake.

toolchain.cmake

set(CMAKE_SYSTEM_VERSION 1)
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

# Custom toolchain-specific definitions for your project
set(PLATFORM_ARM "1")
set(PLATFORM_COMPILE_DEFS "COMPILE_GLES")

# There we go!
# Below, we specify toolchain itself!

set(TARGET_TRIPLE arm-linux-gnueabihf)

# Specify your target rootfs mount point on your compiler host machine
set(TARGET_ROOTFS /Volumes/rootfs-${TARGET_TRIPLE})

# Specify clang paths
set(LLVM_DIR /Users/stepan/projects/shared/toolchains/llvm-7.0.darwin-release-x86_64/install)
set(CLANG ${LLVM_DIR}/bin/clang)
set(CLANGXX ${LLVM_DIR}/bin/clang++)

# Specify compiler (which is clang)
set(CMAKE_C_COMPILER   ${CLANG})
set(CMAKE_CXX_COMPILER ${CLANGXX})

# Specify binutils

set (CMAKE_AR      "${LLVM_DIR}/bin/llvm-ar" CACHE FILEPATH "Archiver")
set (CMAKE_LINKER  "${LLVM_DIR}/bin/llvm-ld" CACHE FILEPATH "Linker")
set (CMAKE_NM      "${LLVM_DIR}/bin/llvm-nm" CACHE FILEPATH "NM")
set (CMAKE_OBJDUMP "${LLVM_DIR}/bin/llvm-objdump" CACHE FILEPATH "Objdump")
set (CMAKE_RANLIB  "${LLVM_DIR}/bin/llvm-ranlib" CACHE FILEPATH "ranlib")

# You may use legacy binutils though.
#set(BINUTILS /usr/local/Cellar/arm-linux-gnueabihf-binutils/2.31.1)
#set (CMAKE_AR      "${BINUTILS}/bin/${TARGET_TRIPLE}-ar" CACHE FILEPATH "Archiver")
#set (CMAKE_LINKER  "${BINUTILS}/bin/${TARGET_TRIPLE}-ld" CACHE FILEPATH "Linker")
#set (CMAKE_NM      "${BINUTILS}/bin/${TARGET_TRIPLE}-nm" CACHE FILEPATH "NM")
#set (CMAKE_OBJDUMP "${BINUTILS}/bin/${TARGET_TRIPLE}-objdump" CACHE FILEPATH "Objdump")
#set (CMAKE_RANLIB  "${BINUTILS}/bin/${TARGET_TRIPLE}-ranlib" CACHE FILEPATH "ranlib")

# Specify sysroot (almost same as rootfs)
set(CMAKE_SYSROOT ${TARGET_ROOTFS})
set(CMAKE_FIND_ROOT_PATH ${TARGET_ROOTFS})

# Specify lookup methods for cmake
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

# Sometimes you also need this:
# set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

# Specify raspberry triple
set(CROSS_FLAGS "--target=${TARGET_TRIPLE}")

# Specify other raspberry related flags
set(RASP_FLAGS "-D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS")

# Gather and distribute flags specified at prev steps.
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CROSS_FLAGS} ${RASP_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CROSS_FLAGS} ${RASP_FLAGS}")

# Use clang linker. Why?
# Well, you may install custom arm-linux-gnueabihf binutils,
# but then, you also need to recompile clang, with customized triple;
# otherwise clang will try to use host 'ld' for linking,
# so... use clang linker.
set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=lld)

Je n'ai pas pu compiler QT5 avec l'une des chaînes d'outils (assez obsolètes) de git: //github.com/raspberrypi/tools.git. Le script configure a continué à échouer avec une erreur "impossible de déterminer l'architecture" et avec des problèmes de chemin massifs pour les répertoires d'inclusion. Ce qui a fonctionné pour moi, c'est d'utiliser la chaîne d'outils Linaro

http://releases.linaro.org/components/toolchain/binaries/4.9-2016.02/arm-linux-gnueabihf/runtime-linaro-gcc4.9-2016.02-arm-linux-gnueabihf.tar.xz

en combinaison avec

https://raw.githubusercontent.com/riscv/riscv-poky/master/scripts/sysroot-relativelinks.py

Ne pas corriger les liens symboliques de la racine système conduit à des erreurs de symboles non définies comme décrit ici: Une erreur de construction de bibliothèques Qt pour le raspberry pi Cela m'est arrivé lorsque j'ai essayé le script fixQualifiedLibraryPaths de tools.git. Tout le reste est décrit en détail dans http://wiki.qt.io/RaspberryPi2EGLFS . Mes paramètres de configuration étaient:

./configure -opengl es2 -device linux-rpi3-g ++ -device-option CROSS_COMPILE = / usr / local / rasp / gcc-linaro-4.9-2016.02-x86_64_arm-linux-gnueabihf / bin / arm-linux-gnueabihf- -sysroot / usr / local / rasp / sysroot -opensource -confirm-license -optimized-qmake -reduce-exports -release -make libs -prefix / usr / local / qt5pi -hostprefix / usr / local / qt5pi

avec / usr / local / rasp / sysroot étant le chemin de ma copie système Raspberry Pi 3 Raspbian (Jessie) locale et / usr / local / qt5pi étant le chemin du QT compilé croisé qui doit également être copié sur le périphérique. Sachez que Jessie est livré avec GCC 4.9.2 lorsque vous choisissez votre chaîne d'outils.

La question initiale a été postée il y a un certain temps et entre-temps Debian a fait d'énormes progrès dans le domaine du support multiarch.

Multiarch est une grande réussite pour la compilation croisée!

En un mot, les étapes suivantes sont nécessaires pour tirer parti de multiarch pour la compilation croisée Raspbian Jessie:

• Sur votre hôte Ubuntu, installez Debian Jessie amd64 dans un chroot ou un conteneur LXC.
• Activez l'architecture étrangère armhf.
• Installez le compilateur croisé à partir du référentiel d'outils emdebian.
• Ajustez le compilateur croisé (il générerait du code pour ARMv7-A par défaut) en écrivant un fichier de spécifications gcc personnalisé.
• Installez les bibliothèques armhf (libstdc ++ etc.) à partir du référentiel Raspbian.
• Construisez votre code source.

Comme c'est beaucoup de travail, j'ai automatisé la configuration ci-dessus. Vous pouvez lire à ce sujet ici:

Compilation croisée pour Raspbian

il existe un IDE CDP Studio disponible qui rend la compilation croisée et le déploiement assez simples à la fois à partir de Windows et de Linux et vous pouvez simplement cocher la case à cocher de la chaîne d'outils Raspberry pendant l'installation. (PS. Il prend en charge GPIO et I2C donc aucun code n'est nécessaire pour y accéder)

La démo IDE de l'utilisation de la framboise est ici: https://youtu.be/4SVZ68sQz5U

et vous pouvez télécharger l'IDE ici: https://cdpstudio.com/home-edition