web-dev-qa-db-fra.com

Comment installer le compilateur croisé Raspberry Pi sur mon ordinateur hôte Linux?

J'essaie de faire de la compilation croisée pour que Raspberry Pi fonctionne sur ma machine Ubuntu.

Lors de mes premières tentatives, j'utilisais le compilateur arm-linux-gnueabi, disponible dans le référentiel Ubuntu. Je travaille ça. J'ai pu construire toutes mes dépendances et utiliser le compilateur croisé dans mon projet cmake.

Cependant, je crois 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 était armv6.

Après quelques recherches sur Google, j’ai trouvé le chaîne d’outils pré-construite de GitHub .

J'ai téléchargé le toolchain, 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 OUTER bin, 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 (en dehors 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 veux pouvoir utiliser le compilateur sans avoir à naviguer dans le répertoire bin. J'ai donc essayé d'ajouter le répertoire OUTER bin (puisque je veux les versions préfixées) et les deux répertoires lib dans 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 pour pouvoir l’utiliser de partout, comme je le fais quand j’utilise les compilateurs croisés du référentiel Ubuntu?

c++linuxarmcross-compilingraspberry-pi
106
pqvst

Je vais essayer d'écrire ceci comme tutoriel pour vous afin qu'il devienne facile à suivre.

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 compiler une tarte!

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

Allez dans ce dossier et déroulez le dossier ENTIRE outils que vous avez mentionné ci-dessus:

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

Vous vouliez utiliser la suite des 3, gcc-linaro-arm-linux-gnueabihf-raspbian, si je ne lisais pas mal.

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

Maintenant, vous pouvez soit vous déconnecter et vous reconnecter (c'est-à-dire redémarrer votre session de terminal), soit exécuter . ~/.bashrc sur votre terminal pour récupérer l'addition PATH dans votre session de terminal actuelle.

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

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! Je l'ai fait et les bibliothèques ne fonctionnent toujours pas!

Nous n'avons pas encore fini! Jusqu'ici, nous avons seulement fait les bases.

Dans votre dossier raspberrypi, créez un dossier nommé rootfs.

Vous devez maintenant copier le répertoire entier /libet /usr dans ce dossier nouvellement créé. J'apporte généralement l'image rpi et la copie via rsync:

rsync -rl --delete-after --safe-links [email protected]:/{lib,usr} $HOME/raspberrypi/rootfs

où 192.168.1.PI est remplacé par l'adresse IP de votre Raspberry Pi.

Maintenant, nous devons écrire un fichier de configuration cmake. Ouvrez ~/home/raspberrypi/pi.cmake dans votre éditeur favori et insérez les éléments suivants:

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)

Vous devriez maintenant pouvoir compiler vos programmes cmake en ajoutant simplement cet indicateur supplémentaire: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake.

Utilisation d'un exemple 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 [email protected]:/home/pi/
ssh [email protected] ./CMakeHelloWorld
222
Stenyg

Je ne pouvais pas faire en sorte que le compilateur (x64 version) utilise le sysroot tant que j’ai ajouté SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs) à pi.cmake.

5
Andreas

Pour Windows Host, je recommande vivement ce tutoriel: :

  • Téléchargez et installez la chaîne d'outils
  • Synchronisez la sysroot avec vos répertoires RPi include/lib
  • Compilez votre code
  • Glissez-déposez l'exécutable sur votre RPi en utilisant SmarTTY
  • Exécuter!

Ni plus ni moins!

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

4
SBF

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

En bref:

  1. Obtenir des fichiers binaires clang (Sudo apt-get install clang) .. ou télécharger et construire ( lisez les instructions ici )
  2. Montez votre rootfs framboise (ce peut être le vrai rootfs monté 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

En option, vous pouvez utiliser les anciens binutils arm-linux-gnueabihf. Ensuite, vous pouvez supprimer le drapeau "-Fuse-ld = lld" à la fin.

Ci-dessous, 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)
3
Stepan Dyatkovskiy

La question initiale a été postée il y a quelque temps déjà 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 résumé, les étapes suivantes sont nécessaires pour exploiter le multiarch pour la compilation croisée Raspbian Jessie:

  • Sur votre hôte Ubuntu, installez Debian Jessie AMD64 dans un chroot ou un conteneur LXC.
  • Activer l'architecture étrangère armhf.
  • Installez le compilateur croisé à partir du référentiel emdebian tools.
  • 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 cela représente beaucoup de travail, j'ai automatisé la configuration ci-dessus. Vous pouvez lire à ce sujet ici:

Compilation croisée pour Raspbian

2
Matthias Lüscher

Je ne pouvais pas compiler QT5 avec les chaînes d'outils (relativement obsolètes) de git: //github.com/raspberrypi/tools.git. Le script de configuration a continué à échouer avec une erreur "Impossible de déterminer l'architecture" et des problèmes de chemin considérables pour les répertoires include. Ce qui a fonctionné pour moi a été 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 résoudre les liens symboliques de la racine système entraîne des erreurs de symbole non définies comme décrit ici: ne erreur lors de la création de bibliothèques Qt pour 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 ++ - option-dispositif CROSS_COMPILE =/usr/local/rasp/gcc-linaro-4.9-2016.02-x86_64_arm-linux-gnueabihf/bin/arm linux-gnueabihf/usr/local/rasp/sysroot -opensource -confirm-license -optimized-qmake -reduce-exports-release-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 fichier QT compilé de façon croisée, qui doit également être copié sur le périphérique. Sachez que Jessie vient avec GCC 4.9.2 lorsque vous choisissez votre chaîne d’outils.

2
cuffel

il existe un CDP Studio IDE qui facilite la compilation croisée et le déploiement depuis Windows et Linux. Vous pouvez simplement cocher la case Chaîne d'outils Framboise lors de l'installation. (PS. Il supporte GPIO et I2C, aucun code n’est nécessaire pour y accéder)

La démo IDE d'utilisation de la framboise se trouve ici: https://youtu.be/4SVZ68sQz5

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

0
Jüri T

Vous pouvez directement utiliser les dernières chaînes d'outils GCC pré-construites/précompilées en accès libre pour votre Raspberry Pi, disponibles sur my Github Project .

Aucune compilation ou installation à partir de rien n'est requise. Les fichiers binaires inter-compilateurs sont facilement disponibles et peuvent être utilisés sur n’importe quelle machine Linux (testés sur la dernière version d'Ubuntu/bionic x64) pour compiler des programmes pour votre Raspberry Pi. De plus, tous les fichiers binaires de ces compilateurs sont du matériel Raspberry Pi optimisé pour améliorer les performances globales.

Les versions de GCC actuellement prises en charge sont les suivantes:

  • GCC 6.3.0
  • GCC 7.4.0
  • GCC 8.2.0
  • GCC 8.3.0

J'espère que ça aide, merci :)

0
AbhiTronix