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


114

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?


Intente configurar --sysroot a través de CMAKE_C {XX} _FLAGS para instalar dir.
auselen

Intenté algunos caminos diferentes para --sysroot, pero eso no ayudó. No estoy realmente seguro de qué ruta debo especificar para el sysroot. Consulte más arriba sobre la estructura de directorios de la cadena de herramientas. Además, algunas búsquedas en Google parecen indicar que --sysroot no ayuda para libstdc ++.
pqvst

Probaría / gcc-linearo-arm-linux-gnueabihf-raspbian o / gcc-linearo-arm-linux-gnueabihf-raspbian / arm-linux-gnueabihf
auselen

vaya aquí launchpad.net/gcc-arm-embedded y descargue el tarball y extraiga. Establezca su ruta al directorio bin ... hecho. O vaya a codesourcery.com (ahora mentores gráficos) obtenga la versión lite, untar / bz, establezca su ruta al directorio bin ... listo.
old_timer

Respuestas:


235

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

4
Seguí su tutorial paso a paso y ahora puedo compilar sin errores. ¡Gracias! Gracias adicionales por incluir el ejemplo de cmake.
pqvst

1
Esto funciona bien para proyectos simples, pero no puedo compilar mi proyecto CMAKE que depende de opencv. Recibo el siguiente error "/opt/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/../lib/gcc/arm-linux-gnueabihf/4.7.2/../ .. /../../arm-linux-gnueabihf/bin/ld: advertencia: libjpeg.so.8, necesario para /opt/rpi-rootfs/usr/lib/libopencv_highgui.so, no encontrado (intente usar -rpath o -rpath-link) ". Cmake también parece pasar el indicador "-Wl, -rpath, / opt / rpi-rootfs / usr / lib" al vinculador
user389238

18
El ia32-libspaquete no está disponible en Ubuntu 13.10. Usé en su libc6-i386 lib32z1 lib32stdc++6lugar.
Ben T

2
¡Gran respuesta tutorial! Tenga una recompensa :)
andrewdotnich

2
¡Gracias por un tutorial completo! ¿Podría explicar por qué es necesario copiar las carpetas / lib / usr de la máquina pi?
Marcello

14

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
  1. 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
  1. ¡Estás listo! La cadena de herramientas está ahora en/opt/cross-pi-gcc

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


Recibo mensajes "ignorando el enlace simbólico inseguro" durante rsync. ¿Está bien?
Alexandr Zarubkin

Debería estar bien. Eso se debe al --safe-linksargumento
Stefan Profanter

Desafortunadamente, no puedo probar esto para un raspi 4, pero dado que los ejecutables de Raspi más antiguos normalmente también se pueden ejecutar en Raspi más nuevos, esto también debería funcionar. Si alguien pudiera probarlo, me complace actualizar la descripción
Stefan Profanter

Hola @StefanProfanter, ¿cómo haría uno para hacer que la ruta de la cadena de herramientas sea independiente para colocarla en una ruta diferente a la /opt/cross-pi-gcc ?
nass

@nass lamentablemente no. No soy un experto en compiladores cruzados. Si alguien tiene más información e información sobre esto, ¡estaría feliz de actualizar mi repositorio! Tal vez puedas crear una nueva pregunta de Stackoverflow.
Stefan Profanter

5

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.


Podría ejecutar el ejemplo de Hello World sin el conjunto CMAKE_SYSROOT, pero al probar el archivo pi.cmake con un proyecto que usa una biblioteca compartida, obtuve el error del vinculador libstdc ++. So.6 not found. Después de configurar CMAKE_SYSROOT, todo funcionó a la perfección.
Michael Hilbert

4

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


La edición desde la primera línea del cuerpo de la pregunta fue "Estoy intentando que la compilación cruzada para Raspberry Pi funcione en mi máquina Ubuntu". y lo he aclarado en el título. Esta respuesta aún es bienvenida, pero es posible que también desee responderla en: raspberrypi.stackexchange.com/questions/27163/… que es más específico.
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功

4

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)

2

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.


2

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


1

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.