Come installare il cross-compilatore Raspberry Pi sulla mia macchina host Linux?

Sto tentando di ottenere la compilazione incrociata per Raspberry Pi che funziona sulla mia macchina Ubuntu.

Durante i miei primi tentativi stavo usando il compilatore arm-linux-gnueabi, che è disponibile nel repository di Ubuntu. Ho funzionato. Sono stato in grado di creare tutte le mie dipendenze e utilizzare il cross-compilatore nel mio progetto cmake.

Tuttavia, credo che dovrei usare la versione hf, quindi sono passato a arm-linux-gnueabihf. Poi ho capito che questo non funziona con Raspberry Pi poiché è armv6.

Dopo un po 'di ricerca su Google, ho quindi trovato la toolchain precostruita da GitHub .

Ho scaricato la toolchain, ma non capisco bene come "installarla". Ho estratto i file nella mia directory home. La struttura della directory è simile a questa:

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

Se cambio directory nella cartella bin INNER, posso compilare un programma di test dal terminale senza problemi.

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

Ho quindi provato a compilare un programma di test nella cartella bin OUTER, che contiene le versioni prefissate degli strumenti.

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

Tuttavia, quando provo a utilizzare il compilatore ora (dall'esterno della directory bin interna), non è in grado di trovare la libreria condivisa libstdc ++ fornita con la toolchain:

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

Inoltre, voglio essere in grado di utilizzare il compilatore senza dover navigare nella directory bin. Quindi ho provato ad aggiungere la directory bin OUTER (poiché voglio le versioni con prefisso) ed entrambe le directory lib al mio PATH:

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

Tuttavia, ciò risulta nello stesso errore. Come devo "installare" la toolchain in modo da poter utilizzare la toolchain da qualsiasi luogo, proprio come faccio quando uso i cross-compilatori dal repository di Ubuntu?

Proverò a scriverlo come tutorial per te in modo che diventi facile da seguire.

NOTA: questo tutorial funziona solo per le immagini raspbian meno recenti. Per il più recente Raspbian basato su Debian Buster, vedere la seguente procedura in questo thread: https://stackoverflow.com/a/58559140/869402

Prerequisiti

Prima di iniziare, assicurati che sia installato quanto segue:

apt-get install git rsync cmake ia32-libs

Compiliamo una torta!

Inizia creando una cartella nella tua home directory chiamata raspberrypi.

Vai in questa cartella e apri l'INTERA cartella degli strumenti che hai menzionato sopra:

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

Volevi usare il seguente dei 3 gcc-linaro-arm-linux-gnueabihf-raspbian, se non ho letto male.

Vai nella tua home directory e aggiungi:

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

alla fine del file denominato ~/.bashrc

Ora puoi disconnetterti e riconnettersi (cioè riavviare la sessione del terminale) o eseguire . ~/.bashrcnel tuo terminale per raccogliere l' PATHaggiunta nella tua sessione del terminale corrente.

Ora verifica di poter accedere al compilatore arm-linux-gnueabihf-gcc -v. Dovresti ottenere qualcosa del genere:

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
 )

Ma hey! L'ho fatto e le librerie continuano a non funzionare!

Non abbiamo ancora finito! Finora abbiamo fatto solo le basi.

Nella tua raspberrypicartella, crea una cartella chiamata rootfs.

Ora è necessario copiare l'intera directory /libe /usrin questa cartella appena creata. Di solito porto l'immagine rpi e la copio tramite rsync:

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

dove 192.168.1.PIè sostituito dall'IP del tuo Raspberry Pi.

Ora dobbiamo scrivere un cmakefile di configurazione. Apri ~/home/raspberrypi/pi.cmakenel tuo editor preferito e inserisci quanto segue:

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)

Ora si dovrebbe essere in grado di compilare i vostri cmakeprogrammi semplicemente con l'aggiunta di questo flag in più: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake.

Utilizzando un esempio 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

Compilazione per le immagini Raspbian Debian Buster più recenti e ARMv6

La risposta di @Stenyg funziona solo per le immagini Raspbian meno recenti. Il Raspbian rilasciato di recente basato su Debian Buster richiede una toolchain aggiornata:

In Debian Buster il compilatore gcc e glibc sono stati aggiornati alla versione 8.3. La toolchain in git://github.com/raspberrypi/tools.gitè ancora basata sulla versione precedente di gcc 6. Ciò significa che l'utilizzo git://github.com/raspberrypi/tools.gitporterà a molti errori di compilazione.

Questo tutorial si basa sulla risposta di @Stenyg. Oltre a molte altre soluzioni in Internet, questo tutorial supporta anche il vecchio Rasperry Pi (A, B, B +, Zero ) basato sulla CPU ARMv6. Vedi anche: GCC 8 Cross Compiler produce l'eseguibile ARMv7 invece di ARMv6

Configura la toolchain

Non esiste un repository git ufficiale contenente una toolchain aggiornata (vedere https://github.com/raspberrypi/tools/issues/102 ).

Ho creato un nuovo repository github che include la creazione e toolchain precompilati per ARMv6 basati su GCC8 e successivi:

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

Come accennato nel file readme del progetto, questi sono i passaggi per ottenere la toolchain. Puoi anche costruirlo da solo (vedi il README per ulteriori dettagli).

1. Scarica la toolchain:

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

2. Estrailo. Nota: la toolchain deve essere inserita /opt/cross-pi-gccpoiché non è indipendente dalla posizione.

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

3. Hai fatto! La toolchain è ora disponibile/opt/cross-pi-gcc

4. Facoltativo, aggiungi la toolchain al tuo percorso, aggiungendo:

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

alla fine del file denominato ~/.bashrc

Ora puoi disconnetterti e riconnettersi (cioè riavviare la sessione del terminale) o eseguire . ~/.bashrcnel tuo terminale per raccogliere l' PATHaggiunta nella tua sessione del terminale corrente.

Ottieni le librerie da Raspberry PI

Per eseguire la compilazione incrociata per il tuo Raspberry Pi, che potrebbe avere alcune librerie personalizzate installate, devi ottenere queste librerie sul tuo host.

Crea una cartella $HOME/raspberrypi. Nella tua raspberrypicartella, crea una cartella chiamata rootfs.

Ora è necessario copiare l'intera directory /libe /usrin questa cartella appena creata. Di solito porto l'immagine rpi e la copio tramite rsync:

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

dove 192.168.1.PIè sostituito dall'IP del tuo Raspberry Pi.

Usa CMake per compilare il tuo progetto

Per dire a CMake di prendere la tua toolchain, devi disporre di un file toolchain che inizializzi le impostazioni del compilatore.

Ottieni questo file toolchain da qui: https://github.com/Pro/raspi-toolchain/blob/master/Toolchain-rpi.cmake

Ora dovresti essere in grado di compilare i tuoi cmakeprogrammi semplicemente aggiungendo questo flag extra: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmakee impostando le variabili d'ambiente corrette:

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 esempio di hello world è mostrato qui: https://github.com/Pro/raspi-toolchain/blob/master/build_hello_world.sh

Non sono riuscito a ottenere il compilatore ( x64versione) da utilizzare sysrootfino a quando non ho aggiunto SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs)a pi.cmake.

Per gli host Windows, consiglio vivamente questo tutorial :

• Scarica e installa la toolchain
• Sincronizza sysroot con le directory include / lib di RPi
• Compila il tuo codice
• Trascina e rilascia l'eseguibile sul tuo RPi usando SmarTTY
• Eseguirlo!

Niente di più, niente di meno!

Toolchain GNU precostruiti disponibili per Raspberry, Beaglebone, Cubieboard, AVR (Atmel) e altri

Puoi anche usare clang . Prima era più veloce di GCC e ora è una cosa abbastanza stabile. È molto più facile creare clang dalle fonti ( puoi davvero bere una tazza di caffè durante il processo di costruzione ).

In breve:

1. Ottieni i binari clang (sudo apt-get install clang) .. o scarica e crea ( leggi le istruzioni qui )
2. Monta il tuo rootfs di lampone (potrebbe essere il vero rootfs montato tramite sshfs o un'immagine).

3. Compila il tuo codice:

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

Opzionalmente puoi usare legacy arm-linux-gnueabihf binutils. Quindi puoi rimuovere il flag "-fuse-ld = lld" alla fine.

Di seguito è riportato il mio file toolchain 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)

Non sono riuscito a compilare QT5 con nessuna delle toolchain (abbastanza obsolete) da git: //github.com/raspberrypi/tools.git. Lo script di configurazione continuava a fallire con un errore "impossibile determinare l'architettura" e con enormi problemi di percorso per le directory include. Quello che ha funzionato per me è stato l'utilizzo della toolchain di 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

in combinazione con

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

Non riuscire a correggere i collegamenti simbolici di sysroot porta a errori di simboli indefiniti come descritto qui: Un errore nella creazione di librerie Qt per il raspberry pi Questo è successo a me quando ho provato lo script fixQualifiedLibraryPaths da tools.git. Tutto il resto è descritto in dettaglio in http://wiki.qt.io/RaspberryPi2EGLFS . Le mie impostazioni di configurazione erano:

./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-export -release -make libs -prefix / usr / local / qt5pi -hostprefix / usr / local / qt5pi

con / usr / local / rasp / sysroot è il percorso della mia copia di sistema locale Raspberry Pi 3 Raspbian (Jessie) e / usr / local / qt5pi è il percorso del QT compilato incrociato che deve essere copiato sul dispositivo. Tieni presente che Jessie viene fornito con GCC 4.9.2 quando scegli la tua toolchain.

La domanda iniziale è stata posta da tempo e nel frattempo Debian ha fatto enormi progressi nell'area del supporto multiarchiale.

Multiarch è un ottimo risultato per la compilazione incrociata!

In poche parole, sono necessari i seguenti passaggi per sfruttare il multiarch per la compilazione incrociata di Raspbian Jessie:

• Sul tuo host Ubuntu installa Debian Jessie amd64 all'interno di un chroot o di un contenitore LXC.
• Abilita l'architettura straniera armhf.
• Installa il cross compilatore dal repository degli strumenti emdebian.
• Modifica il compilatore incrociato (genererebbe codice per ARMv7-A per impostazione predefinita) scrivendo un file delle specifiche gcc personalizzato.
• Installa le librerie armhf (libstdc ++ ecc.) Dal repository Raspbian.
• Crea il tuo codice sorgente.

Poiché questo è un sacco di lavoro, ho automatizzato la configurazione di cui sopra. Puoi leggerlo qui:

Cross Compiling per Raspbian

è disponibile un IDE di CDP Studio che rende la compilazione incrociata e la distribuzione abbastanza semplice da Windows e Linux e puoi semplicemente controllare la casella di controllo della toolchain del lampone durante l'installazione. (PS. Ha supporto GPIO e I2C quindi non è necessario alcun codice per accedervi)

La demo IDE dell'uso del lampone è qui: https://youtu.be/4SVZ68sQz5U

e puoi scaricare l'IDE qui: https://cdpstudio.com/home-edition