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

114

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?

pqvst
la source
Essayez de configurer --sysroot via CMAKE_C {XX} _FLAGS pour installer dir.
auselen
J'ai essayé différents chemins pour --sysroot, mais cela n'a pas aidé. Je ne sais pas vraiment quel chemin je devrais spécifier pour la racine système. Voir ci-dessus concernant la structure de répertoires de la chaîne d'outils. De plus, certains googlages semblent indiquer que --sysroot n'aide pas pour libstdc ++.
pqvst
J'essaierais soit / gcc-linearo-arm-linux-gnueabihf-raspbian soit / gcc-linearo-arm-linux-gnueabihf-raspbian / arm-linux-gnueabihf
auselen
allez ici launchpad.net/gcc-arm-embedded et téléchargez l'archive tar et l'extrait. Définissez votre chemin vers le répertoire bin ... c'est fait. Ou allez sur codesourcery.com (maintenant mentor graphics) pour obtenir la version allégée, décompressez / bz, définissez votre chemin vers le répertoire bin ... c'est fait.
old_timer
En relation sur RPI SE: raspberrypi.stackexchange.com/questions/64273/…
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功

Réponses:

235

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

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
Stenyg
la source
4
J'ai suivi votre tutoriel étape par étape et maintenant je suis capable de compiler sans aucune erreur. Merci! Merci supplémentaire d'avoir inclus l'exemple cmake.
pqvst
1
Cela fonctionne bien pour les projets simples, mais je ne peux pas compiler mon projet CMAKE qui dépend d'opencv. J'obtiens l'erreur suivante "/opt/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/../lib/gcc/arm-linux-gnueabihf/4.7.2/../ .. /../../arm-linux-gnueabihf/bin/ld: avertissement: libjpeg.so.8, requis par /opt/rpi-rootfs/usr/lib/libopencv_highgui.so, introuvable (essayez d'utiliser -rpath ou -rpath-link) ". Cmake semble également transmettre le drapeau "-Wl, -rpath, / opt / rpi-rootfs / usr / lib" à l'éditeur de liens
user389238
18
Le ia32-libspackage n'est pas disponible sur Ubuntu 13.10. J'ai utilisé à la libc6-i386 lib32z1 lib32stdc++6place.
Ben T
2
Excellente réponse au tutoriel! Have a bounty :)
andrewdotnich
2
Merci pour un tutoriel approfondi! Pouvez-vous expliquer pourquoi est-il nécessaire de copier les dossiers / lib / usr depuis la machine pi?
Marcello
14

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
  1. 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
  1. Vous avez terminé! La chaîne d'outils est maintenant en/opt/cross-pi-gcc

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

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

Stefan Profanter
la source
Je reçois des messages "ignorant le lien symbolique non sécurisé" pendant rsync. Est-ce que c'est bon?
Alexandr Zarubkin
Ça devrait aller. Cela est dû à l' --safe-linksargument
Stefan Profanter
Malheureusement, je ne peux pas tester cela pour un raspi 4, mais comme les exécutables de l'ancien Raspi peuvent normalement également s'exécuter sur le plus récent Raspi, cela devrait également fonctionner. Si quelqu'un pouvait le tester, je suis heureux de mettre à jour la description
Stefan Profanter
Salut @StefanProfanter, comment procéder pour rendre le chemin de la chaîne d'outils indépendant afin de le placer dans un chemin autre que /opt/cross-pi-gcc ?
nass
@nass malheureusement non. Je ne suis pas un expert sur les compilateurs croisés. Si quelqu'un a plus d'informations et d'informations à ce sujet, je serais heureux de mettre à jour mon dépôt! Vous pouvez peut-être créer une nouvelle question Stackoverflow.
Stefan Profanter
5

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.

Andreas
la source
Je pourrais exécuter l'exemple Hello World sans l'ensemble CMAKE_SYSROOT, mais en essayant le fichier pi.cmake avec un projet qui utilise une bibliothèque partagée, j'ai eu l'erreur de l'éditeur de liens libstdc ++. So.6 introuvable. Après avoir défini CMAKE_SYSROOT, tout a fonctionné parfaitement.
Michael Hilbert
4

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

SBF
la source
Le montage depuis la première ligne du corps de la question était "J'essaie d'obtenir une compilation croisée pour Raspberry Pi fonctionnant sur ma machine Ubuntu." et j'ai clarifié cela sur le titre. Cette réponse est toujours la bienvenue, mais vous voudrez peut-être aussi y répondre à: raspberrypi.stackexchange.com/questions/27163/… qui est plus spécifique.
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功
4

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)
Stepan Dyatkovskiy
la source
2

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.

manchette
la source
2

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

Matthias Lüscher
la source
1

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

Jüri T
la source