wake-up-neo.com

Wie installiere ich den Raspberry Pi Cross-Compiler auf meinem Linux-Host-Rechner?

Ich versuche, eine Cross-Kompilierung für Raspberry Pi auf meinem Ubuntu-Rechner durchzuführen.

Bei meinen ersten Versuchen verwendete ich den Compiler arm-linux-gnueabi, der im Ubuntu-Repository verfügbar ist. Ich habe das zum Laufen gebracht. Ich konnte alle meine Abhängigkeiten aufbauen und den Cross-Compiler in meinem cmake-Projekt verwenden.

Ich glaube jedoch, ich sollte die hf-Version verwenden, also bin ich auf arm-linux-gnueabihf umgestiegen. Dann habe ich festgestellt, dass dies mit Raspberry Pi nicht funktioniert, da es armv6 ist.

Nach einigem googeln fand ich dann die vorgefertigte Toolchain von GitHub .

Ich habe die Toolchain heruntergeladen, aber ich verstehe nicht wirklich, wie ich sie "installieren" soll. Ich habe die Dateien in mein Home-Verzeichnis extrahiert. Die Verzeichnisstruktur sieht folgendermaßen aus:

/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)

Wenn ich in den Ordner INNER bin wechsle, kann ich problemlos ein Testprogramm vom Terminal aus kompilieren.

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

Ich habe dann versucht, ein Testprogramm im Ordner OUTER bin zu kompilieren, das die vorangestellten Versionen der Tools enthält.

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

Wenn ich jedoch versuche, den Compiler jetzt (von außerhalb des inneren bin-Verzeichnisses) zu verwenden, kann er die gemeinsam genutzte libstdc ++ - Bibliothek, die mit der Toolchain geliefert wird, nicht finden:

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

Außerdem möchte ich den Compiler verwenden können, ohne in das bin-Verzeichnis navigieren zu müssen. Also habe ich versucht, das OUTER bin-Verzeichnis (da ich die vorangestellten Versionen haben möchte) und beide lib-Verzeichnisse zu meinem PATH hinzuzufügen:

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

Dies führt jedoch zu demselben Fehler. Wie soll ich die Toolchain "installieren", damit ich sie von überall verwenden kann, genau wie ich es kann, wenn ich die Cross-Compiler aus dem Ubuntu-Repo verwende?

106
pqvst

Ich werde versuchen, dies als Tutorial für Sie zu schreiben, damit es leicht zu befolgen ist.

Voraussetzungen

Bevor Sie beginnen, müssen Sie sicherstellen, dass Folgendes installiert ist:

apt-get install git rsync cmake ia32-libs

Lassen Sie uns einen Kuchen zusammenstellen!

Beginnen Sie mit dem Erstellen eines Ordners in Ihrem Ausgangsverzeichnis mit dem Namen raspberrypi.

Gehen Sie in diesen Ordner und öffnen Sie den GESAMTEN Tools-Ordner, den Sie oben erwähnt haben:

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

Sie wollten die folgenden drei verwenden, gcc-linaro-arm-linux-gnueabihf-raspbian, Wenn ich nicht falsch gelesen habe.

Gehen Sie in Ihr Home-Verzeichnis und fügen Sie Folgendes hinzu:

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

zum Ende der Datei mit dem Namen ~/.bashrc

Jetzt können Sie sich entweder abmelden und wieder anmelden (d. H. Ihre Terminalsitzung neu starten) oder . ~/.bashrc In Ihrem Terminal ausführen, um den Zusatz PATH in Ihrer aktuellen Terminalsitzung abzurufen.

Stellen Sie nun sicher, dass Sie auf den Compiler zugreifen können arm-linux-gnueabihf-gcc -v. Sie sollten so etwas bekommen:

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
 )

Aber hey! Ich habe das getan und die Bibliotheken funktionieren immer noch nicht!

Wir sind noch nicht fertig! Bisher haben wir nur die Grundlagen gemacht.

Erstellen Sie in Ihrem Ordner raspberrypi einen Ordner mit dem Namen rootfs.

Jetzt müssen Sie das gesamte Verzeichnis /lib Und /usr In diesen neu erstellten Ordner kopieren. Normalerweise rufe ich das rpi-Image auf und kopiere es über rsync:

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

dabei wird 192.168.1.PI durch die IP Ihres Raspberry Pi ersetzt.

Jetzt müssen wir eine cmake Konfigurationsdatei schreiben. Öffnen Sie ~/home/raspberrypi/pi.cmake In Ihrem bevorzugten Editor und fügen Sie Folgendes ein:

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)

Jetzt sollten Sie in der Lage sein, Ihre cmake Programme zu kompilieren, indem Sie einfach dieses zusätzliche Flag hinzufügen: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake.

Anhand eines cmake hello world Beispiels:

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

Ich konnte den Compiler (x64 - Version) nicht dazu bringen, sysroot zu verwenden, bis ich SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs) zu pi.cmake Hinzugefügt habe.

5
Andreas

Für Windows Host möchte ich unbedingt empfehlen dieses Tutorial: :

  • Laden Sie die Toolchain herunter und installieren Sie sie
  • Synchronisieren Sie sysroot mit Ihren RPi include/lib-Verzeichnissen
  • Kompilieren Sie Ihren Code
  • Ziehen Sie die ausführbare Datei mit SmarTTY auf Ihr RPi und legen Sie sie dort ab
  • Starte es!

Nicht mehr, nicht weniger!

Vorgefertigte GNU) Toolchains für Raspberry, Beaglebone, Cubieboard, AVR (Atmel) und mehr

4
SBF

Sie können auch clang verwenden. Früher war es schneller als GCC und jetzt ist es ziemlich stabil. Es ist viel einfacher, Klänge aus Quellen zu erzeugen ( Sie können während des Herstellungsprozesses wirklich eine Tasse Kaffee trinken).

Zusamenfassend:

  1. Holen Sie sich clang-Binärdateien (Sudo apt-get install clang) .. oder laden Sie sie herunter und erstellen Sie sie ( Anweisungen hier lesen )
  2. Mounten Sie Ihre Himbeer-Rootfs (es können die echten Rootfs sein, die über sshfs oder ein Image gemountet wurden).
  3. Kompilieren Sie Ihren Code:

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

Optional können Sie ältere arm-linux-gnueabihf-Binutils verwenden. Anschließend können Sie das Flag "-Fuse-ld = lld" am Ende entfernen.

Unten ist meine cmake Toolchain-Datei.

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

Die anfängliche Frage wurde vor einiger Zeit veröffentlicht und in der Zwischenzeit hat Debian im Bereich der Multiarch-Unterstützung enorme Fortschritte gemacht.

Multiarch ist eine großartige Leistung für die Cross-Kompilierung!

Kurz gesagt, die folgenden Schritte sind erforderlich, um Multiarch für die Raspbian Jessie Cross-Kompilierung zu nutzen:

  • Installieren Sie Debian Jessie AMD64 auf Ihrem Ubuntu-Host in einer Chroot oder einem LXC-Container.
  • Aktivieren Sie die Fremdarchitektur armhf.
  • Installieren Sie den Cross-Compiler aus dem Emdebian Tools-Repository.
  • Optimieren Sie den Cross-Compiler (er generiert standardmäßig Code für ARMv7-A), indem Sie eine benutzerdefinierte gcc-Spezifikationsdatei schreiben.
  • Installieren Sie die armhf-Bibliotheken (libstdc ++ usw.) aus dem Raspbian-Repository.
  • Erstellen Sie Ihren Quellcode.

Da dies eine Menge Arbeit ist, habe ich das obige Setup automatisiert. Hier können Sie darüber lesen:

Cross Compiling für Raspbian

2

Ich konnte QT5 mit keiner der (ziemlich veralteten) Toolchains von git kompilieren: //github.com/raspberrypi/tools.git. Das configure-Skript schlug weiterhin mit dem Fehler "Architektur konnte nicht ermittelt werden" und mit massiven Pfadproblemen für Include-Verzeichnisse fehl. Was für mich funktioniert hat, war die Verwendung der Linaro-Toolchain

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

in Kombination mit

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

Wenn die Symlinks des Sysroot nicht repariert werden, führt dies zu undefinierten Symbolfehlern, wie hier beschrieben: Ein Fehler beim Erstellen von Qt-Bibliotheken für den Raspberry Pi Dies ist mir passiert, als ich das Skript fixQualifiedLibraryPaths aus tools.git ausprobiert habe. Alles andere wird ausführlich in http://wiki.qt.io/RaspberryPi2EGLFS beschrieben. Meine Konfigurationseinstellungen waren:

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

mit/usr/local/rasp/sysroot als Pfad für meine lokale Raspberry Pi 3 Raspbian (Jessie) -Systemkopie und/usr/local/qt5pi als Pfad für die kreuzkompilierte QT, die ebenfalls auf das Gerät kopiert werden muss. Beachten Sie, dass Jessie mit GCC 4.9.2 geliefert wird, wenn Sie Ihre Toolchain auswählen.

2
cuffel

es gibt ein CDP Studio IDE zur Verfügung, das das Cross-Kompilieren und Bereitstellen sowohl unter Windows als auch unter Linux sehr einfach macht, und Sie können während der Installation einfach das Kontrollkästchen für die Himbeer-Toolchain aktivieren. (PS. Es verfügt über GPIO und I2C Unterstützung, so dass kein Code benötigt wird, um auf diese zuzugreifen)

Die IDE Demo der Himbeernutzung ist hier zu finden: https://youtu.be/4SVZ68sQz5

und Sie können die IDE hier herunterladen: https://cdpstudio.com/home-edition

0
Jüri T

Sie können direkt die neuesten vorgefertigten/vorkompilierten Open-Sourced-GCC-Toolchains für Ihren Himbeer-Pi verwenden, die in meinem Github-Projekt verfügbar sind.

Es ist keinerlei Kompilierung oder Installation von Grund auf erforderlich. Die bereitgestellten Cross-Compiler-Binärdateien können auf jedem Linux-Computer (getestet auf Ubuntu/bionic x64) zum Kompilieren von Programmen für Ihren Raspberry Pi verwendet werden. Alle diese Compiler-Binärdateien sind Raspberry Pi-Hardware, die für eine verbesserte Gesamtleistung optimiert wurde.

Derzeit unterstützte GCC-Versionen lauten wie folgt:

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

Hoffe das hilft, danke :)

0
AbhiTronix