Jak zainstalować kompilator krzyżowy Raspberry Pi na moim komputerze hosta z systemem Linux?

Próbuję uzyskać kompilację krzyżową dla Raspberry Pi działającego na mojej maszynie Ubuntu.

Podczas moich pierwszych prób korzystałem z kompilatora arm-linux-gnueabi, który jest dostępny w repozytorium Ubuntu. Mam to działające. Udało mi się zbudować wszystkie moje zależności i użyć cross-kompilatora w moim projekcie cmake.

Uważam jednak, że powinienem używać wersji hf, więc przełączyłem się na arm-linux-gnueabihf. Wtedy zdałem sobie sprawę, że to nie działa z Raspberry Pi, ponieważ jest to armv6.

Po pewnym Googlingu znalazłem gotowy zestaw narzędzi z GitHub .

Ściągnąłem toolchain, ale tak naprawdę nie rozumiem, jak go „zainstalować”. Rozpakowałem pliki do mojego katalogu domowego. Struktura katalogów wygląda następująco:

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

Jeśli zmienię katalog na folder INNER bin, jestem w stanie bez problemu skompilować program testowy z terminala.

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

Następnie próbowałem skompilować program testowy w folderze OUTER bin, który zawiera prefiksowane wersje narzędzi.

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

Jednak gdy próbuję teraz użyć kompilatora (spoza wewnętrznego katalogu bin), nie mogę znaleźć biblioteki współdzielonej libstdc ++, która jest dostarczana z łańcuchem narzędzi:

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

Ponadto chcę mieć możliwość korzystania z kompilatora bez konieczności przechodzenia do katalogu bin. Próbowałem więc dodać katalog bin OUTER (ponieważ chcę wersje z prefiksami) i oba katalogi lib do mojej PATH:

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

Jednak powoduje to ten sam błąd. Jak powinienem „zainstalować” łańcuch narzędzi, aby móc używać go z dowolnego miejsca, tak jak mogę, gdy używam cross-kompilatorów z repozytorium Ubuntu?

Postaram się napisać to jako samouczek, aby było łatwe do naśladowania.

UWAGA: Ten samouczek działa tylko dla starszych obrazów raspbian. W przypadku nowszego Raspbian opartego na Debian Buster zobacz następujące instrukcje w tym wątku: https://stackoverflow.com/a/58559140/869402

Wymagania wstępne

Zanim zaczniesz, upewnij się, że zainstalowano:

apt-get install git rsync cmake ia32-libs

Skompilujmy ciasto!

Zacznij od utworzenia folderu w swoim katalogu domowym o nazwie raspberrypi.

Przejdź do tego folderu i rozwiń CAŁY folder narzędzi, o którym wspomniałeś powyżej:

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

Chciałeś użyć następujących z 3 gcc-linaro-arm-linux-gnueabihf-raspbian, jeśli nie przeczytałem źle.

Przejdź do katalogu domowego i dodaj:

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

do końca nazwanego pliku ~/.bashrc

Teraz możesz się wylogować i zalogować ponownie (tj. Zrestartować sesję terminala) lub uruchomić . ~/.bashrcw terminalu, aby odebrać PATHdodatek w bieżącej sesji terminala.

Teraz sprawdź, czy masz dostęp do kompilatora arm-linux-gnueabihf-gcc -v. Powinieneś dostać coś takiego:

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
 )

Ale hej! Zrobiłem to, a biblioteki nadal nie działają!

Jeszcze nie skończyliśmy! Jak dotąd zrobiliśmy tylko podstawy.

W swoim raspberrypifolderze utwórz folder o nazwie rootfs.

Teraz musisz skopiować cały katalog /libi /usrdo tego nowo utworzonego folderu. Zwykle podnoszę obraz rpi i kopiuję go przez rsync:

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

gdzie 192.168.1.PIjest zastąpiony adresem IP twojego Raspberry Pi.

Teraz musimy napisać cmakeplik konfiguracyjny. Otwórz ~/home/raspberrypi/pi.cmakew swoim ulubionym edytorze i wstaw:

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)

Teraz powinieneś być w stanie opracować swoje cmakeprogramy po prostu dodając ten dodatkowy flagę: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake.

Na przykładzie 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

Tworzenie dla nowszych obrazów Raspbian Debian Buster i ARMv6

Odpowiedź @Stenyg działa tylko w przypadku starszych obrazów Raspbian. Niedawno wydany Raspbian oparty na Debian Buster wymaga zaktualizowanego zestawu narzędzi:

W Debian Buster kompilator gcc i glibc zostały zaktualizowane do wersji 8.3. Łańcuch narzędzi w git://github.com/raspberrypi/tools.gitnadal jest oparty na starszej wersji gcc 6. Oznacza to, że użycie git://github.com/raspberrypi/tools.gitspowoduje wiele błędów kompilacji.

Ten samouczek jest oparty na odpowiedzi @Stenyg. Oprócz wielu innych rozwiązań w Internecie, ten poradnik obsługuje również starsze Rasperry Pi (A, B, B +, Zero ) oparte na procesorze ARMv6. Zobacz też: GCC 8 Cross Compiler wysyła plik wykonywalny ARMv7 zamiast ARMv6

Skonfiguruj łańcuch narzędzi

Nie ma oficjalnego repozytorium git zawierającego zaktualizowany łańcuch narzędzi (patrz https://github.com/raspberrypi/tools/issues/102 ).

Stworzyłem nowe repozytorium github, które zawiera budowanie i prekompilowane zestawy narzędzi dla ARMv6 w oparciu o GCC8 i nowsze:

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

Jak wspomniano w pliku Readme projektu, są to kroki, aby uzyskać zestaw narzędzi. Możesz również zbudować go samodzielnie (więcej szczegółów znajdziesz w pliku README).

1. Pobierz zestaw narzędzi:

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

2. Wyodrębnij to. Uwaga: łańcuch narzędzi musi być włączony, /opt/cross-pi-gccponieważ nie jest niezależny od lokalizacji.

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

3. Gotowe! Łańcuch narzędzi jest teraz dostępny/opt/cross-pi-gcc

4. Opcjonalnie dodaj łańcuch narzędzi do swojej ścieżki, dodając:

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

do końca nazwanego pliku ~/.bashrc

Teraz możesz się wylogować i zalogować ponownie (tj. Zrestartować sesję terminala) lub uruchomić . ~/.bashrcw terminalu, aby odebrać PATHdodatek w bieżącej sesji terminala.

Pobierz biblioteki z Raspberry PI

Aby skompilować krzyżowo dla własnego Raspberry Pi, który może mieć zainstalowane biblioteki niestandardowe, musisz pobrać te biblioteki na swój host.

Utwórz folder $HOME/raspberrypi. W swoim raspberrypifolderze utwórz folder o nazwie rootfs.

Teraz musisz skopiować cały katalog /libi /usrdo tego nowo utworzonego folderu. Zwykle podnoszę obraz rpi i kopiuję go przez rsync:

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

gdzie 192.168.1.PIjest zastąpiony adresem IP twojego Raspberry Pi.

Użyj CMake do skompilowania projektu

Aby nakazać CMake wzięcie własnego łańcucha narzędzi, musisz mieć plik toolchain, który inicjalizuje ustawienia kompilatora.

Pobierz ten plik toolchain stąd: https://github.com/Pro/raspi-toolchain/blob/master/Toolchain-rpi.cmake

Teraz powinieneś być w stanie skompilować swoje cmakeprogramy, po prostu dodając tę ​​dodatkową flagę: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmakei ustawiając poprawne zmienne środowiskowe:

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

Przykładowy świat hello pokazano tutaj: https://github.com/Pro/raspi-toolchain/blob/master/build_hello_world.sh

Nie mogłem dostać kompilator ( x64wersja) do używania sysrootaż dodałem SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs)do pi.cmake.

W przypadku hosta z systemem Windows bardzo polecam ten samouczek ::

• Pobierz i zainstaluj toolchain
• Zsynchronizuj sysroot z katalogami RPi include / lib
• Skompiluj swój kod
• Przeciągnij i upuść plik wykonywalny do RPi za pomocą SmarTTY
• Uruchom!

Nic dodać nic ująć!

Gotowe zestawy narzędzi GNU dostępne dla Raspberry, Beaglebone, Cubieboard, AVR (Atmel) i innych

Możesz również użyć clang . Kiedyś był szybszy niż GCC, a teraz jest całkiem stabilny. Dużo łatwiej jest zbudować brzęk ze źródeł ( podczas budowania można naprawdę wypić filiżankę kawy ).

W skrócie:

1. Pobierz pliki binarne Clang (sudo apt-get install clang) ... lub pobierz i zbuduj ( przeczytaj instrukcje tutaj )
2. Zamontuj swoje Raspberry Rootfs (może to być prawdziwy rootfs zamontowany przez sshfs lub obraz).

3. Skompiluj swój kod:

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

Opcjonalnie możesz użyć starszej wersji arm-linux-gnueabihf binutils. Następnie możesz usunąć flagę „-fuse-ld = lld” na końcu.

Poniżej znajduje się mój plik narzędzi 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)

Nie mogłem skompilować QT5 z żadnym z (dość przestarzałych) łańcuchów narzędzi z git: //github.com/raspberrypi/tools.git. Skrypt konfiguracyjny wciąż kończył się niepowodzeniem z błędem „nie można określić architektury” oraz z ogromnymi problemami ze ścieżkami dla katalogów dołączanych. U mnie zadziałało używanie łańcucha narzędzi 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

w połączeniu z

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

Niepowodzenie naprawy dowiązań symbolicznych sysroot prowadzi do niezdefiniowanych błędów symboli, jak opisano tutaj: Błąd podczas tworzenia bibliotek Qt dla raspberry pi To zdarzyło mi się, gdy wypróbowałem skrypt fixQualifiedLibraryPaths z tools.git. Wszystko inne jest szczegółowo opisane w http://wiki.qt.io/RaspberryPi2EGLFS . Moje ustawienia konfiguracyjne to:

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

gdzie / usr / local / rasp / sysroot to ścieżka do mojej lokalnej kopii systemu Raspberry Pi 3 Raspbian (Jessie), a / usr / local / qt5pi to ścieżka do skompilowanego krzyżowo QT, który również musi zostać skopiowany na urządzenie. Pamiętaj, że Jessie jest dostarczana z GCC 4.9.2, kiedy wybierasz swój toolchain.

Pierwsze pytanie zostało wysłane już jakiś czas temu, aw międzyczasie Debian poczynił ogromne postępy w dziedzinie obsługi multiarch.

Multiarch to świetne osiągnięcie dla kompilacji krzyżowej!

W skrócie, aby wykorzystać multiarchę do kompilacji krzyżowej Raspbian Jessie, wymagane są następujące kroki:

• Na hoście Ubuntu zainstaluj Debian Jessie amd64 w chroocie lub kontenerze LXC.
• Włącz armhf architektury obcej.
• Zainstaluj kompilator krzyżowy z repozytorium narzędzi emdebian.
• Dostosuj kompilator krzyżowy (domyślnie generowałby kod dla ARMv7-A), pisząc niestandardowy plik specyfikacji gcc.
• Zainstaluj biblioteki armhf (libstdc ++ itp.) Z repozytorium Raspbian.
• Zbuduj swój kod źródłowy.

Ponieważ jest to dużo pracy, zautomatyzowałem powyższą konfigurację. Możesz o tym przeczytać tutaj:

Kompilacja krzyżowa dla Raspbian

dostępne jest IDE CDP Studio, które sprawia, że ​​kompilacja krzyżowa i wdrażanie są dość proste zarówno w systemie Windows, jak i na Linuksie. Możesz po prostu zaznaczyć pole wyboru łańcucha narzędzi raspberry podczas instalacji. (PS. Ma obsługę GPIO i I2C, więc nie jest potrzebny kod, aby uzyskać do nich dostęp)

Demo IDE użycia maliny jest tutaj: https://youtu.be/4SVZ68sQz5U

i możesz pobrać IDE tutaj: https://cdpstudio.com/home-edition