¿Cómo instalar el compilador cruzado de Raspberry Pi en mi máquina host Linux?

Estoy intentando obtener una compilación cruzada para Raspberry Pi que funcione en mi máquina Ubuntu.

Durante mis intentos iniciales, estaba usando el compilador arm-linux-gnueabi, que está disponible en el repositorio de Ubuntu. Conseguí que esto funcione. Pude construir todas mis dependencias y usar el compilador cruzado en mi proyecto cmake.

Sin embargo, creo que debería usar la versión hf, así que cambié a arm-linux-gnueabihf. Entonces me di cuenta de que esto no funciona con Raspberry Pi ya que es armv6.

Después de buscar en Google, encontré la cadena de herramientas prediseñada de GitHub .

Descargué la cadena de herramientas, pero realmente no entiendo cómo "instalarla". Extraje los archivos a mi directorio personal. La estructura del directorio se ve así:

/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 cambio de directorio a la carpeta INNER bin, puedo compilar un programa de prueba desde el terminal sin ningún problema.

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

Luego intenté compilar un programa de prueba en la carpeta bin OUTER, que contiene las versiones prefijadas de las herramientas.

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

Sin embargo, cuando intento usar el compilador ahora (desde fuera del directorio bin interno), no puedo encontrar la biblioteca compartida libstdc ++ que viene con la cadena de herramientas:

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

Además, quiero poder usar el compilador sin tener que navegar hasta el directorio bin. Así que intenté agregar el directorio bin OUTER (ya que quiero las versiones con prefijo) y ambos directorios lib a mi RUTA:

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

Sin embargo, esto da como resultado el mismo error. ¿Cómo debo "instalar" la cadena de herramientas para poder usar la cadena de herramientas desde cualquier lugar, al igual que puedo cuando uso los compiladores cruzados del repositorio de Ubuntu?

Intentaré escribir esto como un tutorial para que sea fácil de seguir.

NOTA: Este tutorial solo funciona para imágenes raspbian antiguas. Para el Raspbian más nuevo basado en Debian Buster, consulte el siguiente procedimiento en este hilo: https://stackoverflow.com/a/58559140/869402

Pre requisitos

Antes de comenzar, debe asegurarse de que esté instalado lo siguiente:

apt-get install git rsync cmake ia32-libs

¡Hagamos una compilación cruzada de un Pie!

Comience creando una carpeta en su directorio de inicio llamada raspberrypi.

Vaya a esta carpeta y despliegue la carpeta de herramientas COMPLETA que mencionó anteriormente:

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

Querías usar el siguiente de los 3 gcc-linaro-arm-linux-gnueabihf-raspbian, si no leía mal.

Vaya a su directorio de inicio y agregue:

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

al final del archivo llamado ~/.bashrc

Ahora puede cerrar la sesión y volver a iniciarla (es decir, reiniciar la sesión de su terminal), o ejecutar . ~/.bashrcen su terminal para recoger elPATH adición en su sesión de terminal actual.

Ahora, verifique que puede acceder al compilador arm-linux-gnueabihf-gcc -v. Debería obtener algo como esto:

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
 )

¡Pero hey! ¡Hice eso y las librerías todavía no funcionan!

¡Aún no hemos terminado! Hasta ahora, solo hemos hecho lo básico.

En su raspberrypicarpeta, cree una carpeta llamada rootfs.

Ahora necesita copiar todo el directorio /liby /usren esta carpeta recién creada. Por lo general, abro la imagen rpi y la copio a través de rsync:

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

donde 192.168.1.PIse reemplaza por la IP de su Raspberry Pi.

Ahora, necesitamos escribir un cmakearchivo de configuración. Abra ~/home/raspberrypi/pi.cmakeen su editor favorito e inserte lo siguiente:

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)

Ahora debería poder compilar sus cmakeprogramas simplemente agregando esta bandera adicional:-D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake .

Usando un ejemplo 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

Construyendo para nuevas imágenes Raspbian Debian Buster y ARMv6

La respuesta de @Stenyg solo funciona para imágenes de Raspbian más antiguas. El Raspbian recientemente lanzado basado en Debian Buster requiere una cadena de herramientas actualizada:

En Debian Buster, el compilador gcc y glibc se actualizaron a la versión 8.3. La cadena de herramientas de git://github.com/raspberrypi/tools.gittodavía se basa en la versión anterior de gcc 6. Esto significa que el uso git://github.com/raspberrypi/tools.gitdará lugar a muchos errores de compilación.

Este tutorial se basa en la respuesta de @Stenyg. Además de muchas otras soluciones en Internet, este tutorial también es compatible con Rasperry Pi (A, B, B +, Zero ) más antiguo basado en la CPU ARMv6. Ver también: GCC 8 Cross Compiler genera ejecutables ARMv7 en lugar de ARMv6

Configurar la cadena de herramientas

No hay un repositorio oficial de git que contenga una cadena de herramientas actualizada (consulte https://github.com/raspberrypi/tools/issues/102 ).

Creé un nuevo repositorio de github que incluye la construcción y cadenas de herramientas precompiladas para ARMv6 basadas en GCC8 y versiones posteriores:

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

Como se menciona en el archivo Léame del proyecto, estos son los pasos para obtener la cadena de herramientas. También puede crearlo usted mismo (consulte el archivo README para obtener más detalles).

1. Descarga la cadena de herramientas:

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

2. Extraelo. Nota: La cadena de herramientas debe estar instalada, /opt/cross-pi-gccya que no es independiente de la ubicación.

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

3. ¡Estás listo! La cadena de herramientas está ahora en/opt/cross-pi-gcc

4. Opcional, agregue la cadena de herramientas a su ruta, agregando:

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

al final del archivo llamado ~/.bashrc

Ahora puede cerrar la sesión y volver a iniciarla (es decir, reiniciar su sesión de terminal), o ejecutar . ~/.bashrcen su terminal para recoger laPATH adición en su sesión de terminal actual.

Obtenga las bibliotecas de Raspberry PI

Para realizar una compilación cruzada para su propia Raspberry Pi, que puede tener algunas bibliotecas personalizadas instaladas, debe obtener estas bibliotecas en su host.

Crea una carpeta $HOME/raspberrypi. En su raspberrypicarpeta, cree una carpeta llamada rootfs.

Ahora necesita copiar todo el directorio /liby /usren esta carpeta recién creada. Por lo general, abro la imagen rpi y la copio a través de rsync:

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

donde 192.168.1.PIse reemplaza por la IP de su Raspberry Pi.

Usa CMake para compilar tu proyecto

Para decirle a CMake que tome su propia cadena de herramientas, debe tener un archivo de cadena de herramientas que inicialice la configuración del compilador.

Obtenga este archivo de cadena de herramientas desde aquí: https://github.com/Pro/raspi-toolchain/blob/master/Toolchain-rpi.cmake

Ahora debería poder compilar sus cmakeprogramas simplemente agregando este indicador adicional: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmakey configurando las variables de entorno correctas:

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

Aquí se muestra un ejemplo de hola mundo: https://github.com/Pro/raspi-toolchain/blob/master/build_hello_world.sh

No pude conseguir el compilador ( x64versión) para utilizar el sysroothasta que he añadido SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs)a pi.cmake.

Para el host de Windows, quiero recomendar este tutorial :

• Descargue e instale la cadena de herramientas
• Sincronice sysroot con sus directorios RPi include / lib
• Compila tu código
• Arrastra y suelta el ejecutable a tu RPi usando SmarTTY
• ¡Ejecutarlo!

¡Nada más y nada menos!

Cadenas de herramientas GNU prediseñadas disponibles para Raspberry, Beaglebone, Cubieboard, AVR (Atmel) y más

También puedes usar clang . Solía ​​ser más rápido que GCC, y ahora es bastante estable. Es mucho más fácil generar ruido a partir de fuentes ( realmente puedes beber una taza de café durante el proceso de construcción ).

En breve:

1. Obtenga los binarios de clang (sudo apt-get install clang) ... o descargue y compile ( lea las instrucciones aquí )
2. Monte sus rootfs de frambuesa (pueden ser los rootfs reales montados a través de sshfs o una imagen).

3. Compila tu código:

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

Opcionalmente, puede usar legacy arm-linux-gnueabihf binutils. Entonces puede quitar la bandera "-fuse-ld = lld" al final.

A continuación se muestra mi archivo de cadena de herramientas 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)

No pude compilar QT5 con ninguna de las cadenas de herramientas (bastante desactualizadas) de git: //github.com/raspberrypi/tools.git. El script de configuración seguía fallando con un error de "no se pudo determinar la arquitectura" y con problemas masivos de ruta para los directorios de inclusión. Lo que funcionó para mí fue usar la cadena de herramientas 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 combinación con

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

No arreglar los enlaces simbólicos del sysroot conduce a errores de símbolo indefinidos como se describe aquí: Un error al construir bibliotecas Qt para el raspberry pi Esto me sucedió cuando probé el script fixQualifiedLibraryPaths de tools.git. Todo lo demás se describe en detalle en http://wiki.qt.io/RaspberryPi2EGLFS . Mis ajustes de configuración fueron:

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

siendo / usr / local / rasp / sysroot la ruta de mi copia del sistema local Raspberry Pi 3 Raspbian (Jessie) y / usr / local / qt5pi la ruta del QT compilado cruzado que también debe copiarse en el dispositivo. Tenga en cuenta que Jessie viene con GCC 4.9.2 cuando elige su cadena de herramientas.

La pregunta inicial se publicó hace bastante tiempo y, mientras tanto, Debian ha avanzado mucho en el área de soporte multiarca.

¡Multiarch es un gran logro para la compilación cruzada!

En pocas palabras, se requieren los siguientes pasos para aprovechar el multiarch para la compilación cruzada de Raspbian Jessie:

• En su host de Ubuntu, instale Debian Jessie amd64 dentro de un chroot o un contenedor LXC.
• Habilite la arquitectura ajena armhf.
• Instale el compilador cruzado desde el repositorio de herramientas emdebian.
• Modifique el compilador cruzado (generaría código para ARMv7-A de forma predeterminada) escribiendo un archivo de especificaciones gcc personalizado.
• Instale las bibliotecas armhf (libstdc ++, etc.) desde el repositorio de Raspbian.
• Construye tu código fuente.

Dado que esto es mucho trabajo, he automatizado la configuración anterior. Usted puede leer sobre ello aquí:

Compilación cruzada para Raspbian

hay un IDE de CDP Studio disponible que hace que la compilación cruzada y la implementación sean bastante simples tanto desde Windows como desde Linux, y puede marcar la casilla de verificación de la cadena de herramientas de frambuesa durante la instalación. (PD. Tiene soporte GPIO e I2C, por lo que no se necesita código para acceder a ellos)

La demostración IDE del uso de frambuesa está aquí: https://youtu.be/4SVZ68sQz5U

y puede descargar el IDE aquí: https://cdpstudio.com/home-edition