So installieren Sie das Raspberry Pi-cross-compiler auf meinem Linux-host-Maschine?

Ich bin versucht zu bekommen cross-compiling für den Raspberry Pi an meinem Ubuntu-Rechner.

Während meiner ersten versuche war ich mit der arm-linux-gnueabi-compiler, welcher in der Ubuntu-repo. Ich habe diese arbeiten. Ich war in der Lage, all meine Abhängigkeiten und der Verwendung des cross-Compilers in meinen cmake-Projekt.

Aber ich glaube, ich sollte mit der hf-version, also wechselte ich zu arm-linux-gnueabihf. Dann erkannte ich, dass dies nicht funktioniert mit Raspberry Pi, da es armv6.

Nach etwas Googlen habe ich dann gefunden, die vorgefertigte toolchain von GitHub.

Ich habe die toolchain, aber ich weiß nicht wirklich verstehen, wie "installiere" es. Ich extrahiert die Dateien in mein home-Verzeichnis. Die Verzeichnis-Struktur sieht wie folgt 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 das Verzeichnis ändern, um den INNEREN Ordner " bin " ich bin in der Lage zu kompilieren Sie ein test-Programm aus dem terminal ohne irgendwelche Probleme.

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

Dann habe ich versucht zu kompilieren Sie ein test-Programm in den ÄUßEREN bin-Ordner, die enthält das Präfix-Versionen der tools.

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

Jedoch, wenn ich versuche, verwenden Sie die compiler jetzt (von außen das innere bin-Verzeichnis), es ist nicht in der Lage zu finden, die libstdc++ - shared-library, die mit der toolchain:

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

Darüber hinaus möchte ich in der Lage sein zu verwenden, der compiler ohne navigieren Sie zu dem bin Verzeichnis. Also habe ich versucht, indem die ÄUßERE Verzeichnis bin (da ich möchte, dass die Präfix-Versionen) und die beiden lib-Verzeichnisse zu meinem WEG:

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

Jedoch, diese Ergebnisse in die gleichen Fehler. Wie soll ich das "installieren" der toolchain, so dass ich kann verwenden Sie die toolchain von überall her, nur wie kann ich, wenn ich den cross-Compiler aus dem Ubuntu repo?

Versuchen Sie, --sysroot über CMAKE_C{XX}_FLAGS zu installieren, dir.
Ich versuchte einige unterschiedliche Wege --sysroot, aber das hat nicht geholfen. Ich bin mir nicht wirklich sicher, welchen Weg ich sollte angeben, für die sysroot. Siehe oben bezüglich der Verzeichnis-Struktur der toolchain. Auch, etwas Googlen scheint darauf hinzudeuten, dass --sysroot nicht helfen, für libstdc++.
Ich würde versuchen entweder /gcc-linearo-arm-linux-gnueabihf-raspbian oder /gcc-linearo-arm-linux-gnueabihf-raspbian/arm-linux-gnueabihf
gehen Sie hier, launchpad.net/gcc-arm-embedded und laden den tarball herunter und entpacken es. Stellen Sie Ihren Pfad auf das bin Verzeichnis...fertig. Oder gehen Sie zu codesourcery.com (jetzt mentor graphics) Holen Sie sich die lite-version, entpacken/bz, setzen Sie Ihren Weg in das bin Verzeichnis...fertig.
Bezogen auf RPI-SE: raspberrypi.stackexchange.com/questions/64273/...

InformationsquelleAutor pqvst | 2013-10-03

arm c++cross-compiling linux raspberry-pi

222

Ich versuche zu schreiben so ein tutorial für Euch, so wird es leicht, zu Folgen.

Voraussetzungen

Bevor Sie beginnen, müssen Sie sicherstellen, dass Folgendes installiert ist:
```
apt-get install git rsync cmake ia32-libs
```
Let ' s cross kompilieren eine Torte!

Zunächst einen Ordner in Ihrem home-Verzeichnis genannt raspberrypi.

Gehen Sie in diesen Ordner, und ziehen Sie den GESAMTEN Ordner tools, die Sie bereits erwähnt:
```
git clone git://github.com/raspberrypi/tools.git
```
Sie wollte, verwenden Sie den folgenden der 3 diejenigen, gcc-linaro-arm-linux-gnueabihf-raspbian, wenn ich nicht falsch gelesen.

Gehen Sie in Ihr home-Verzeichnis und fügen Sie hinzu:
```
export PATH=$PATH:$HOME/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin
```
dem Ende der Datei mit dem Namen ~/.bashrc

Nun können Sie sich entweder Abmelden und wieder anmelden (d.h. starten Sie Ihre terminal-Sitzung), oder führen Sie . ~/.bashrc in Ihrem terminal abholen PATH hinaus in Ihrem aktuellen terminal-Sitzung.

Nun, stellen Sie sicher, dass Sie Zugriff auf den compiler arm-linux-gnueabihf-gcc -v. Sie sollten etwas wie diese:
```
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 Tat, und die libs noch funktionieren nicht!

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

In Ihrem raspberrypi Ordner, erstellen Sie einen Ordner namens rootfs.

Nun müssen Sie kopieren die gesamte /libund /usr Verzeichnis zu diesem neu erstellten Ordner. Ich in der Regel bringen die rpi-image und kopieren es über rsync:
```
rsync -rl --delete-after --safe-links pi@192.168.1.PI:/{lib,usr} $HOME/raspberrypi/rootfs
```
wo 192.168.1.PI wird ersetzt durch die IP-Adresse Ihres Raspberry Pi.

Nun, wir müssen schreiben Sie eine cmake config-Datei. Öffnen ~/home/raspberrypi/pi.cmake in Ihrem bevorzugten editor und fügen Sie die folgenden:
```
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)
```
Nun sollten Sie in der Lage sein zu kompilieren cmake Programme einfach durch das hinzufügen dieser extra-flag: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake.

Mit einem cmake hello world Beispiel:
```
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
```
- Ich folgte dem tutorial Schritt für Schritt, und jetzt bin ich in der Lage zu kompilieren ohne Fehler. Danke! Extra Dank für cmake Beispiel.
- Dies funktioniert gut für einfache Projekte, aber ich kann nicht cross-kompilieren mein CMAKE-Projekt, das hängt von opencv. Ich bekomme folgenden Fehler "/opt/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/../lib/gcc/arm-linux-gnueabihf/4.7.2/../../../../arm-linux-gnueabihf/bin/ld: Warnung: libjpeg.so.8, benötigt von " /opt/rpi-rootfs/usr/lib/libopencv_highgui.also, nicht gefunden werden (versuchen Sie mit -rpath oder -rpath-link)". Cmake scheint auch zu passieren "-Wl,-rpath,/opt/rpi-rootfs/usr/lib" - flag auf linker
- Wie würde das funktionieren mit der Installation etwas wie omxplayer oder mpich? Würde ich nur tun ./configure -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake; make; sudo make install oder ./configure; make -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake; sudo make install oder ./configure; make; sudo make -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake install
- Die ia32-libs - Paket ist nicht verfügbar auf Ubuntu 13.10. Ich verwendet libc6-i386 lib32z1 lib32stdc++6 statt.
- Ich bin wohl nicht richtig... aber ich hatte zusätzlich diese Zeile hinzufügen, um pi.cmake auf ubuntu mit cmake 2.8.11.2 : SET(CMAKE_CXX_FLAGS "-L$ENV{HOME}/raspberrypi/rootfs/usr/lib/arm-linux-gnueabihf $ENV{HOME}/raspberrypi/rootfs/lib/arm-linux-gnueabihf
- Ich habe gerade gesehen, Sie haben aktualisiert, um gcc4.8.3 aber es gibt keine solche compiler, die in den raspbian-repositories. Kann ich bedenkenlos die neue version nutzen?
- Tolles tutorial beantworten! Eine bounty 🙂
- Danke für eine ausführliche Anleitung! Würden Sie bitte erklären, warum ist es nötig zu kopieren /lib /usr Ordner von pi-Maschine?
- Hier ist auch ein guter Artikel zum einrichten von Eclipse und einrichten der toolchain: raspberrypi.org/forums/viewtopic.php?t=10739&p=119584
- Diese Verzeichnisse speichern Sie Ihre OS ' s installiert, die Bibliotheken und Header. Sie brauchen Sie für das kompilieren (damit der compiler finden kann .h include-Dateien) und auch für die Verlinkung. Sonst würden Sie nicht in der Lage sein, um cross-kompilieren eine Anwendung, die verwendet OpenCV zum Beispiel (die kann Ansis problem).
- macht Sinn, hab es! Danke!
- Hervorragende tutorial! Tat dies auf meinem Linux-Mint-installation und es funktionierte einwandfrei. Jetzt aber bin ich auf Ubuntu 15.10 (64 bit). Dies bedeutet, dass die "ia32-libs" sind eine (etwas) nicht verfügbar. Ist das ein problem? Kann ich noch bauen, raspberry pi software auf meinem computer?
- Es ist wichtig hinzuzufügen, CMAKE_SYSROOT, wie unten erklärt. Andernfalls wird der compiler suchen an der falschen Stelle (tools anstelle von rootfs) für system-Header.
- Ich habe versucht, diese auf 32-bit Debain Jessie 8.7, und ich habe E: Unable to locate package ia32-libs. Ich sah es, aber alles was ich finden konnte, war die Menschen laufen in dieses Problem, wenn Sie versuchen zum installieren von ia32-libs auf 64-bit-Debian Wheezy, das ist nicht mein problem.
- github.com/Kukkimonsuta/rpi-buildqt/blob/master/scripts/utils/...
InformationsquelleAutor Stenyg
5

Konnte ich nicht, der compiler (x64 version) zu verwenden, die sysroot bis ich Hinzugefügt SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs) zu pi.cmake.
- Ich könnte führen Sie das Hallo-Welt-Beispiel ohne CMAKE_SYSROOT gesetzt, aber wenn man versucht den pi.cmake-Datei mit einem Projekt, das eine shared library verwendet, ich habe die linker-Fehler libstdc++.so.6 nicht gefunden. Nachdem ich CMAKE_SYSROOT alles funktioniert einwandfrei.
InformationsquelleAutor Andreas
4

Für Windows-host, möchte ich empfehlen dieses tutorial::
- Herunterladen und installieren der toolchain
- Sync-sysroot mit Ihrem RPi-include/lib Verzeichnisse
- Kompilieren Sie Ihren code
- Drag-and-drop die ausführbare Datei, um Ihre RPi mit SmarTTY
- Auszuführen!
Nichts mehr, nichts weniger!

Vorkompilierte GNU-Toolchains verfügbar für Raspberry, Beaglebone, Cubieboard, AVR (Atmel) und mehr
- Die Bearbeitung, da die erste Linie des Körpers der Frage war, "ich bin versucht zu bekommen cross-compiling für den Raspberry Pi an meinem Ubuntu-Rechner." und ich habe klargestellt, dass auf den Titel. Diese Antwort ist immer noch willkommen, aber vielleicht wollen Sie auch für diese Antwort an: raspberrypi.stackexchange.com/questions/27163/..., die spezifischer ist.
InformationsquelleAutor SBF

Können Sie verwenden clang als gut. Es verwendet, um schneller als GCC, und jetzt es ist schon eine stabile Sache. Es ist viel einfacher zu bauen, clang von Quellen (kann man wirklich trinken Tasse Kaffee während des build-Prozesses).

Kurz:

Get clang-binaries (sudo apt-get install clang).. oder download und
bauen (Lesen Sie die Anweisungen hier)
Befestigen Sie Ihren raspberry rootfs (es
möglicherweise der eigentliche rootfs mounted via sshfs oder ein Bild).

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 die Verwendung von legacy-arm-linux-gnueabihf-binutils. Dann können Sie entfernen "-fuse-ld=lld" fahne am Ende.

Unten ist mein 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)

InformationsquelleAutor Stepan Dyatkovskiy

2

Konnte ich nicht kompilieren QT5 mit einer der (ziemlich veraltet) toolchains aus git://github.com/raspberrypi/tools.git. Das configure-Skript gehalten nicht mit einem "konnte nicht ermittelt Architektur" Fehler und massive Pfad Probleme für die include-Verzeichnisse. Was für mich gearbeitet wurde mit 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

Nicht zu beheben die symlinks von den sysroot führt zu einer undefined symbol Fehler wie hier beschrieben: Ein Fehler Gebäudes Qt-Bibliotheken für den raspberry pi
Dies geschah zu mir, wenn ich versuchte, die fixQualifiedLibraryPaths Skript von tools.git. Alles andere ist im detail beschrieben in http://wiki.qt.io/RaspberryPi2EGLFS . Meine Einstellungen konfiguriert wurden:

./konfigurieren -opengl es2 -Gerät linux-rpi3-g++ -Gerät-option CROSS_COMPILE=/usr/local/rasp/gcc-linaro-4.9-2016.02-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf- -sysroot /usr/local/Raspel/sysroot -opensource -confirm-license-optimiert-qmake -reduzieren-Ausfuhr -release -make libs -prefix /usr/local/qt5pi -hostprefix /usr/local/qt5pi

mit /usr/local/Raspel/sysroot der Pfad von meinem lokalen Raspberry Pi 3 Raspbian (Jessie) system kopieren und /usr/local/qt5pi der Pfad der cross-kompilierte QT, die auch auf das Gerät kopiert werden. Werden Sie sich bewusst, dass Jessie kommt mit GCC 4.9.2 Sie bei der Auswahl der toolchain.

InformationsquelleAutor cuffel
2

Ursprünglichen Frage gepostet wurde, schon vor einiger Zeit und in der Zwischenzeit Debian hat riesige Fortschritte im Bereich der multiarch-Unterstützung.

Multiarch ist eine große Errungenschaft für die cross-compilation!

In Kürze die folgenden Schritte sind erforderlich, um nutzen multiarch für Raspbian Jessie cross-Kompilation:
- Auf Ihrem Ubuntu-host-Installation von Debian Jessie amd64 innerhalb einer chroot oder ein LXC-container.
- Aktivieren Sie die ausländische Architektur armhf.
- Installieren Sie den cross-compiler von der emdebian-tools repository.
- Zwicken die cross-compiler (es generiert den code für ARMv7-A standardmäßig) durch schreiben eines benutzerdefinierten gcc specs-Datei.
- Installieren armhf Bibliotheken (libstdc++, etc.) aus dem Raspbian-repository.
- Bauen Sie Ihre source-code.
Da dies eine Menge Arbeit, die ich automatisiert haben, die oben genannten setup. Sie können darüber Lesen Sie hier:

Cross-Compilierung für Raspbian

InformationsquelleAutor Matthias Lüscher
0

es ist eine CDP-Studio-IDE zur Verfügung, das cross-kompilieren und bereitstellen-ganz einfach von windows-und linux und Sie können einfach überprüfen Sie die Himbeer-toolchain Kontrollkästchen während der installation.
(PS. es hat GPIO und I2C-Unterstützung, so dass kein code benötigt wird, der Zugriff auf diese)

Den IDE-demo von Himbeeren verwenden, ist hier oben:
https://youtu.be/4SVZ68sQz5U

und laden Sie die IDE hier: https://cdpstudio.com/home-edition

InformationsquelleAutor Jüri T

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Voraussetzungen

Let ' s cross kompilieren eine Torte!

Aber hey! Ich Tat, und die libs noch funktionieren nicht!