Como instalar o compilador cruzado Raspberry Pi em minha máquina host Linux?

Estou tentando obter compilação cruzada para Raspberry Pi trabalhando em minha máquina Ubuntu.

Durante minhas tentativas iniciais, usei o compilador arm-linux-gnueabi, que está disponível no repositório do Ubuntu. Eu tenho isso funcionando. Consegui construir todas as minhas dependências e usar o compilador cruzado em meu projeto cmake.

No entanto, acredito que devo usar a versão hf, então mudei para arm-linux-gnueabihf. Então percebi que isso não funciona com o Raspberry Pi, pois é armv6.

Depois de pesquisar no Google, encontrei o conjunto de ferramentas pré-compilado do GitHub .

Baixei o conjunto de ferramentas, mas realmente não entendo como "instalá-lo". Extraí os arquivos para meu diretório inicial. A estrutura do diretório é semelhante a esta:

/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 eu mudar de diretório para a pasta bin INNER, poderei compilar um programa de teste do terminal sem problemas.

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

Em seguida, tentei compilar um programa de teste na pasta OUTER bin, que contém as versões prefixadas das ferramentas.

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

No entanto, quando tento usar o compilador agora (de fora do diretório bin interno), não consigo encontrar a biblioteca compartilhada libstdc ++ que vem com o conjunto de ferramentas:

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

Além disso, quero poder usar o compilador sem precisar navegar até o diretório bin. Então, tentei adicionar o diretório OUTER bin (já que quero as versões prefixadas) e os dois diretórios lib ao meu PATH:

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

No entanto, isso resulta no mesmo erro. Como devo "instalar" o conjunto de ferramentas para que possa usá-lo de qualquer lugar, assim como faço quando uso os compiladores cruzados do repositório do Ubuntu?

Vou tentar escrever isso como um tutorial para você, para que seja fácil de seguir.

NOTA: Este tutorial só funciona para imagens antigas do raspbian. Para o Raspbian mais recente baseado no Debian Buster, consulte o seguinte tutorial neste tópico: https://stackoverflow.com/a/58559140/869402

Pré requisitos

Antes de começar, você precisa se certificar de que o seguinte está instalado:

apt-get install git rsync cmake ia32-libs

Vamos compilar uma pizza!

Comece criando uma pasta chamada em seu diretório pessoal raspberrypi.

Vá para esta pasta e abra a pasta INTEIRA de ferramentas que você mencionou acima:

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

Você queria usar o seguinte dos 3 gcc-linaro-arm-linux-gnueabihf-raspbian, se eu não li errado.

Vá para o seu diretório inicial e adicione:

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

ao final do arquivo chamado ~/.bashrc

Agora você pode fazer logout e login novamente (ou seja, reiniciar sua sessão de terminal) ou executar . ~/.bashrcem seu terminal para pegar a PATHadição em sua sessão de terminal atual.

Agora, verifique se você pode acessar o compilador arm-linux-gnueabihf-gcc -v. Você deve obter algo assim:

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
 )

Mas ei! Eu fiz isso e as libs ainda não funcionam!

Ainda não terminamos! Até agora, fizemos apenas o básico.

Em sua raspberrypipasta, crie uma pasta chamada rootfs.

Agora você precisa copiar todo o diretório /libe /usrpara esta pasta recém-criada. Eu geralmente trago a imagem rpi e copio via rsync:

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

onde 192.168.1.PIé substituído pelo IP do seu Raspberry Pi.

Agora, precisamos escrever um cmakearquivo de configuração. Abra ~/home/raspberrypi/pi.cmakeem seu editor favorito e insira o seguinte:

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)

Agora você deve ser capaz de compilar seus cmakeprogramas simplesmente adicionando esta bandeira Extra: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake.

Usando um exemplo 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

Construindo para imagens mais recentes do Raspbian Debian Buster e ARMv6

A resposta de @Stenyg só funciona para imagens Raspbian mais antigas. O Raspbian lançado recentemente baseado no Debian Buster requer um conjunto de ferramentas atualizado:

No Debian Buster, o compilador gcc e glibc foram atualizados para a versão 8.3. O conjunto de ferramentas git://github.com/raspberrypi/tools.gitainda é baseado na versão anterior do gcc 6. Isso significa que o uso git://github.com/raspberrypi/tools.gitlevará a muitos erros de compilação.

Este tutorial é baseado na resposta de @Stenyg. Além de muitas outras soluções na Internet, este tutorial também oferece suporte a Rasperry Pi (A, B, B +, Zero ) mais antigo baseado na CPU ARMv6. Veja também: GCC 8 Cross Compiler gera ARMv7 executável em vez de ARMv6

Configure o conjunto de ferramentas

Não há repositório git oficial contendo um conjunto de ferramentas atualizado (consulte https://github.com/raspberrypi/tools/issues/102 ).

Eu criei um novo repositório github que inclui a construção e conjuntos de ferramentas pré-compilados para ARMv6 com base no GCC8 e mais recente:

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

Conforme mencionado no leia-me do projeto, essas são as etapas para obter o conjunto de ferramentas. Você também pode construí-lo sozinho (consulte o README para obter mais detalhes).

1. Baixe o conjunto de ferramentas:

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

2. Extraia. Observação: o conjunto de ferramentas deve estar instalado, /opt/cross-pi-gccpois não é independente do local.

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

3. Você terminou! O conjunto de ferramentas está agora em/opt/cross-pi-gcc

4. Opcional, adicione o conjunto de ferramentas ao seu caminho, adicionando:

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

ao final do arquivo chamado ~/.bashrc

Agora você pode fazer logout e login novamente (ou seja, reiniciar sua sessão de terminal) ou executar . ~/.bashrcem seu terminal para pegar a PATHadição em sua sessão de terminal atual.

Obtenha as bibliotecas do Raspberry PI

Para fazer compilação cruzada para seu próprio Raspberry Pi, que pode ter algumas bibliotecas personalizadas instaladas, você precisa obter essas bibliotecas em seu host.

Crie uma pasta $HOME/raspberrypi. Em sua raspberrypipasta, crie uma pasta chamada rootfs.

Agora você precisa copiar todo o diretório /libe /usrpara esta pasta recém-criada. Eu geralmente trago a imagem rpi e copio via rsync:

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

onde 192.168.1.PIé substituído pelo IP do seu Raspberry Pi.

Use CMake para compilar seu projeto

Para dizer ao CMake para pegar seu próprio conjunto de ferramentas, você precisa ter um arquivo de conjunto de ferramentas que inicializa as configurações do compilador.

Obtenha este arquivo de conjunto de ferramentas aqui: https://github.com/Pro/raspi-toolchain/blob/master/Toolchain-rpi.cmake

Agora você deve ser capaz de compilar seus cmakeprogramas simplesmente adicionando este sinalizador extra: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmakee definindo as variáveis ​​de ambiente corretas:

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

Um exemplo hello world é mostrado aqui: https://github.com/Pro/raspi-toolchain/blob/master/build_hello_world.sh

Não consegui fazer com que o compilador ( x64versão) usasse o sysrootaté adicionar SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs)a pi.cmake.

Para host do Windows, quero recomendar fortemente este tutorial ::

• Baixe e instale o conjunto de ferramentas
• Sincronize o sysroot com seus diretórios de inclusão / lib RPi
• Compile seu código
• Arraste e solte o executável em seu RPi usando SmarTTY
• Executá-lo!

Nada mais nada menos!

Conjuntos de ferramentas GNU pré-construídos disponíveis para Raspberry, Beaglebone, Cubieboard, AVR (Atmel) e mais

Você também pode usar o clang . Costumava ser mais rápido que o GCC e agora é bastante estável. É muito mais fácil criar clang a partir de fontes ( você pode realmente tomar uma xícara de café durante o processo de compilação ).

Em resumo:

1. Obtenha os binários do clang (sudo apt-get install clang) .. ou baixe e compile ( leia as instruções aqui )
2. Monte seus rootfs raspberry (podem ser rootfs reais montados via sshfs ou uma imagem).

3. Compile seu código:

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

Opcionalmente, você pode usar binutils arm-linux-gnueabihf legado. Então você pode remover o sinalizador "-fuse-ld = lld" no final.

Abaixo está o meu arquivo de conjunto de ferramentas 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)

Não consegui compilar o QT5 com nenhum dos conjuntos de ferramentas (razoavelmente desatualizados) de git: //github.com/raspberrypi/tools.git. O script de configuração continuava falhando com um erro "não foi possível determinar a arquitetura" e com enormes problemas de caminho para diretórios de inclusão. O que funcionou para mim foi usar o conjunto de ferramentas 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

em combinação com

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

Deixar de corrigir os links simbólicos do sysroot leva a erros de símbolo indefinidos, conforme descrito aqui: Um erro ao construir bibliotecas Qt para o raspberry pi Isso aconteceu comigo quando tentei o script fixQualifiedLibraryPaths de tools.git. Tudo o mais é descrito em detalhes em http://wiki.qt.io/RaspberryPi2EGLFS . Minhas configurações foram:

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

com / usr / local / rasp / sysroot sendo o caminho de minha cópia do sistema Raspberry Pi 3 Raspbian (Jessie) e / usr / local / qt5pi sendo o caminho do QT compilado cruzado que também deve ser copiado para o dispositivo. Esteja ciente de que Jessie vem com o GCC 4.9.2 quando você escolhe seu conjunto de ferramentas.

A questão inicial foi postada há algum tempo e, enquanto isso, o Debian fez um grande progresso na área de suporte multiarch.

Multiarch é uma grande conquista para compilação cruzada!

Em suma, as seguintes etapas são necessárias para alavancar multiarch para compilação cruzada Raspbian Jessie:

• Em seu host Ubuntu, instale o Debian Jessie amd64 dentro de um chroot ou contêiner LXC.
• Habilite o armhf de arquitetura estrangeira.
• Instale o compilador cruzado do repositório de ferramentas emdebian.
• Ajuste o compilador cruzado (ele geraria código para ARMv7-A por padrão) escrevendo um arquivo de especificações gcc personalizado.
• Instale as bibliotecas armhf (libstdc ++ etc.) do repositório Raspbian.
• Construa seu código-fonte.

Como isso dá muito trabalho, automatizei a configuração acima. Você pode ler sobre isso aqui:

Compilação cruzada para Raspbian

há um CDP Studio IDE disponível que torna a compilação cruzada e a implantação bastante simples tanto do Windows quanto do Linux e você pode apenas marcar a caixa de seleção do raspberry toolchain durante a instalação. (PS. Ele tem suporte GPIO e I2C, então nenhum código é necessário para acessá-los)

A demonstração IDE do uso de framboesa está disponível aqui: https://youtu.be/4SVZ68sQz5U

e você pode baixar o IDE aqui: https://cdpstudio.com/home-edition