จะติดตั้งคอมไพเลอร์ข้าม Raspberry Pi บนเครื่องโฮสต์ Linux ของฉันได้อย่างไร

ฉันกำลังพยายามรวบรวมข้ามสำหรับ Raspberry Pi ที่ทำงานบนเครื่อง Ubuntu ของฉัน

ในระหว่างความพยายามครั้งแรกของฉันฉันใช้คอมไพเลอร์ arm-linux-gnueabi ซึ่งมีอยู่ใน repo ของ Ubuntu ฉันได้ผล ฉันสามารถสร้างการอ้างอิงทั้งหมดและใช้ cross-compiler ในโครงการ cmake ของฉัน

อย่างไรก็ตามฉันเชื่อว่าฉันควรใช้เวอร์ชัน hf ดังนั้นฉันจึงเปลี่ยนไปใช้ arm-linux-gnueabihf จากนั้นฉันก็รู้ว่าสิ่งนี้ใช้ไม่ได้กับ Raspberry Pi เนื่องจากเป็น armv6

หลังจากที่บาง Googling ผมแล้วพบtoolchain ที่สร้างไว้ล่วงหน้าจาก GitHub

ฉันดาวน์โหลด toolchain แต่ฉันไม่เข้าใจวิธี "ติดตั้ง" จริงๆ ฉันแตกไฟล์ไปยังโฮมไดเร็กทอรีของฉัน โครงสร้างไดเร็กทอรีมีลักษณะดังนี้:

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

หากฉันเปลี่ยนไดเร็กทอรีไปที่โฟลเดอร์ INNER bin ฉันสามารถรวบรวมโปรแกรมทดสอบจากเทอร์มินัลได้โดยไม่มีปัญหาใด ๆ

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

จากนั้นฉันพยายามรวบรวมโปรแกรมทดสอบในโฟลเดอร์ OUTER bin ซึ่งมีเครื่องมือรุ่นที่นำหน้า

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

อย่างไรก็ตามเมื่อฉันพยายามใช้คอมไพเลอร์ตอนนี้ (จากภายนอกไดเร็กทอรี bin ด้านใน) ไม่พบไลบรารีที่ใช้ร่วมกัน libstdc ++ ที่มาพร้อมกับ toolchain:

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

นอกจากนี้ฉันต้องการใช้คอมไพเลอร์โดยไม่ต้องไปที่ไดเร็กทอรี bin ดังนั้นฉันจึงลองเพิ่มไดเร็กทอรีถังด้านนอก (เนื่องจากฉันต้องการเวอร์ชันที่นำหน้า) และไดเร็กทอรี lib ทั้งสองใน PATH ของฉัน:

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

อย่างไรก็ตามสิ่งนี้ส่งผลให้เกิดข้อผิดพลาดเดียวกัน ฉันจะ "ติดตั้ง" toolchain ได้อย่างไรเพื่อให้สามารถใช้ toolchain จากทุกที่ได้เช่นเดียวกับที่ทำได้เมื่อใช้ cross-compiler จาก repo ของ Ubuntu

ฉันจะพยายามเขียนสิ่งนี้เป็นบทช่วยสอนเพื่อให้ง่ายต่อการปฏิบัติตาม

หมายเหตุ: บทช่วยสอนนี้ใช้ได้กับภาพราสเบียนรุ่นเก่าเท่านั้น สำหรับ Raspbian รุ่นใหม่ที่ใช้ Debian Buster ดูวิธีการต่อไปนี้ในหัวข้อนี้: https://stackoverflow.com/a/58559140/869402

Pre-ต้องการ

ก่อนที่คุณจะเริ่มคุณต้องตรวจสอบให้แน่ใจว่าได้ติดตั้งสิ่งต่อไปนี้แล้ว:

apt-get install git rsync cmake ia32-libs

มารวบรวมพายกันเถอะ!

เริ่มต้นด้วยการสร้างโฟลเดอร์ในโฮมไดเร็กทอรีของคุณชื่อraspberrypi.

เข้าไปที่โฟลเดอร์นี้และดึงโฟลเดอร์ ENTIRE tools ที่คุณกล่าวถึงข้างต้น:

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

คุณต้องการใช้ 3 ตัวต่อไปนี้gcc-linaro-arm-linux-gnueabihf-raspbianถ้าฉันอ่านไม่ผิด

เข้าไปในโฮมไดเร็กทอรีของคุณและเพิ่ม:

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

ท้ายไฟล์ชื่อ ~/.bashrc

ตอนนี้คุณสามารถออกจากระบบและกลับเข้าสู่ระบบอีกครั้ง (เช่นรีสตาร์ทเซสชันเทอร์มินัลของคุณ) หรือเรียกใช้. ~/.bashrcในเทอร์มินัลของคุณเพื่อรับส่วนPATHเพิ่มเติมในเซสชันเทอร์มินัลปัจจุบันของคุณ

ตอนนี้ตรวจสอบว่าคุณสามารถเข้าถึงคอมไพเลอร์arm-linux-gnueabihf-gcc -vได้ คุณควรได้รับสิ่งนี้:

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
 )

แต่เดี๋ยวก่อน! ฉันทำอย่างนั้นและ libs ก็ยังไม่ทำงาน!

เรายังไม่เสร็จ! จนถึงตอนนี้เราได้ทำเพียงพื้นฐานเท่านั้น

ในraspberrypiโฟลเดอร์ของคุณสร้างโฟลเดอร์ชื่อrootfs.

ตอนนี้คุณต้องคัดลอกทั้งโฟลเดอร์/libและ/usrไดเรกทอรีไปยังโฟลเดอร์ที่สร้างขึ้นใหม่นี้ ฉันมักจะนำภาพ rpi ขึ้นและคัดลอกผ่าน rsync:

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

ที่192.168.1.PIถูกแทนที่ด้วย IP ของ Raspberry Pi ของคุณ

ตอนนี้เราต้องเขียนcmakeไฟล์ config เปิด~/home/raspberrypi/pi.cmakeในโปรแกรมแก้ไขที่คุณชื่นชอบและแทรกสิ่งต่อไปนี้:

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)

ตอนนี้คุณควรจะสามารถรวบรวมของคุณโปรแกรมโดยการเพิ่มนี้ธงพิเศษ:cmake-D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake

ใช้ตัวอย่าง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

การสร้างภาพ Raspbian Debian Buster ที่ใหม่กว่าและ ARMv6

คำตอบโดย @Stenyg ใช้ได้กับภาพ Raspbian รุ่นเก่าเท่านั้น Raspbian ที่เพิ่งเปิดตัวซึ่งใช้ Debian Buster ต้องใช้ toolchain ที่อัปเดต:

ใน Debian Buster คอมไพเลอร์ gcc และ glibc ได้รับการอัปเดตเป็นเวอร์ชัน 8.3 toolchain ในgit://github.com/raspberrypi/tools.gitยังคงใช้ gcc 6 เวอร์ชันเก่า ซึ่งหมายความว่าการใช้git://github.com/raspberrypi/tools.gitจะทำให้เกิดข้อผิดพลาดในการคอมไพล์มากมาย

บทช่วยสอนนี้อ้างอิงจากคำตอบของ @Stenyg นอกเหนือจากโซลูชันอื่น ๆ ในอินเทอร์เน็ตบทช่วยสอนนี้ยังรองรับ Rasperry Pi รุ่นเก่า (A, B, B +, Zero ) ที่ใช้ CPU ARMv6 ดูเพิ่มเติม: GCC 8 Cross Compiler เอาต์พุต ARMv7 ที่เรียกใช้งานได้แทน ARMv6

ตั้งค่า toolchain

ไม่มีที่เก็บ git อย่างเป็นทางการที่มี toolchain ที่อัปเดตแล้ว (ดูhttps://github.com/raspberrypi/tools/issues/102 )

ฉันสร้างที่เก็บ github ใหม่ซึ่งรวมถึงการสร้างและห่วงโซ่เครื่องมือที่คอมไพล์ไว้ล่วงหน้าสำหรับ ARMv6 ตาม GCC8 และใหม่กว่า:

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

ดังที่ได้กล่าวไว้ใน readme ของโครงการนี่คือขั้นตอนในการรับ toolchain คุณสามารถสร้างได้ด้วยตัวเอง (ดูรายละเอียดเพิ่มเติมใน README)

1. ดาวน์โหลด toolchain:

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

2. แตกมัน หมายเหตุ: ต้องอยู่ใน toolchain /opt/cross-pi-gccเนื่องจากไม่ใช่ตำแหน่งที่เป็นอิสระ

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

3. เสร็จแล้ว! Toolchain เข้ามาแล้ว/opt/cross-pi-gcc

4. ไม่บังคับเพิ่ม toolchain ในเส้นทางของคุณโดยเพิ่ม:

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

ท้ายไฟล์ชื่อ ~/.bashrc

ตอนนี้คุณสามารถออกจากระบบและกลับเข้าสู่ระบบอีกครั้ง (เช่นรีสตาร์ทเซสชันเทอร์มินัลของคุณ) หรือเรียกใช้. ~/.bashrcในเทอร์มินัลของคุณเพื่อรับส่วนPATHเพิ่มเติมในเซสชันเทอร์มินัลปัจจุบันของคุณ

รับไลบรารีจาก Raspberry PI

ในการคอมไพล์ข้ามสำหรับ Raspberry Pi ของคุณเองซึ่งอาจมีไลบรารีที่กำหนดเองติดตั้งอยู่คุณต้องนำไลบรารีเหล่านี้เข้าสู่โฮสต์

$HOME/raspberrypiสร้างโฟลเดอร์ ในraspberrypiโฟลเดอร์ของคุณสร้างโฟลเดอร์ชื่อrootfs.

ตอนนี้คุณต้องคัดลอกทั้งโฟลเดอร์/libและ/usrไดเรกทอรีไปยังโฟลเดอร์ที่สร้างขึ้นใหม่นี้ ฉันมักจะนำภาพ rpi ขึ้นและคัดลอกผ่าน rsync:

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

ที่192.168.1.PIถูกแทนที่ด้วย IP ของ Raspberry Pi ของคุณ

ใช้ CMake เพื่อรวบรวมโครงการของคุณ

ในการบอกให้ CMake ใช้ toolchain ของคุณเองคุณต้องมีไฟล์ toolchain ที่เริ่มการตั้งค่าคอมไพเลอร์

รับไฟล์ toolchain จากที่นี่: https://github.com/Pro/raspi-toolchain/blob/master/Toolchain-rpi.cmake

ตอนนี้คุณควรจะสามารถคอมไพล์cmakeโปรแกรมของคุณได้ง่ายๆโดยการเพิ่มแฟล็กพิเศษนี้: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmakeและตั้งค่าตัวแปรสภาพแวดล้อมที่ถูกต้อง:

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

ตัวอย่าง hello world แสดงไว้ที่นี่: https://github.com/Pro/raspi-toolchain/blob/master/build_hello_world.sh

ฉันไม่สามารถรับคอมไพเลอร์ ( x64เวอร์ชัน) เพื่อใช้งานได้sysrootจนกว่าฉันSET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs)จะเพิ่มpi.cmakeไฟล์.

สำหรับโฮสต์ Windows ฉันขอแนะนำบทช่วยสอนนี้ :

• ดาวน์โหลดและติดตั้ง toolchain
• ซิงค์ sysroot กับไดเรกทอรี RPi include / lib ของคุณ
• รวบรวมรหัสของคุณ
• ลากและวางไฟล์ปฏิบัติการไปยังRPiของคุณโดยใช้SmarTTY
• เรียกใช้!

ไม่มีอะไรมากไม่มีน้อย!

ชุดเครื่องมือ GNU ที่สร้างไว้ล่วงหน้าพร้อมใช้งานสำหรับ Raspberry, Beaglebone, Cubieboard, AVR (Atmel) และอื่น ๆ

คุณอาจใช้clangด้วย มันเคยเร็วกว่า GCC และตอนนี้มันค่อนข้างเสถียร การสร้างเสียงดังจากแหล่งที่มานั้นง่ายกว่ามาก ( คุณสามารถดื่มกาแฟได้ในระหว่างกระบวนการสร้าง )

ในระยะสั้น:

1. รับ clang binaries (sudo apt-get install clang) .. หรือดาวน์โหลดและสร้าง ( อ่านคำแนะนำที่นี่ )
2. ติดตั้ง rootfs ราสเบอร์รี่ของคุณ (อาจเป็นรูทจริงที่ติดตั้งผ่าน sshfs หรือรูปภาพ)

3. รวบรวมรหัสของคุณ:

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

คุณอาจใช้ arm-linux-gnueabihf binutils แบบเดิมก็ได้ จากนั้นคุณสามารถลบแฟล็ก "-fuse-ld = lld" ต่อท้าย

ด้านล่างนี้คือไฟล์ cmake toolchain ของฉัน

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)

ฉันไม่สามารถรวบรวม QT5 ด้วย toolchains (ค่อนข้างล้าสมัย) จาก git: //github.com/raspberrypi/tools.git สคริปต์กำหนดค่ายังคงล้มเหลวด้วยข้อผิดพลาด "ไม่สามารถระบุสถาปัตยกรรม" และมีปัญหาเส้นทางขนาดใหญ่สำหรับไดเร็กทอรีรวม สิ่งที่ได้ผลสำหรับฉันคือการใช้ Linaro toolchain

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

ร่วมกับ

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

ความล้มเหลวในการแก้ไข symlink ของ sysroot ทำให้เกิดข้อผิดพลาดสัญลักษณ์ที่ไม่ได้กำหนดดังที่อธิบายไว้ที่นี่: เกิดข้อผิดพลาดในการสร้างไลบรารี Qt สำหรับ raspberry pi สิ่งนี้เกิดขึ้นกับฉันเมื่อฉันลองใช้สคริปต์ fixQualifiedLibraryPaths จาก tools.git everthing อื่นจะอธิบายในรายละเอียดในhttp://wiki.qt.io/RaspberryPi2EGLFS การกำหนดค่าของฉันคือ:

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

ด้วย / usr / local / rasp / sysroot เป็นเส้นทางของระบบ Raspberry Pi 3 Raspbian (Jessie) ในเครื่องของฉันและ / usr / local / qt5pi เป็นเส้นทางของ QT ที่คอมไพล์ข้ามซึ่งจะต้องคัดลอกไปยังอุปกรณ์ด้วย โปรดทราบว่า Jessie มาพร้อมกับ GCC 4.9.2 เมื่อคุณเลือก toolchain

คำถามเริ่มต้นได้รับการโพสต์เมื่อไม่นานมานี้และในขณะเดียวกัน Debian ได้สร้างความก้าวหน้าอย่างมากในด้านการสนับสนุนหลายตำแหน่ง

Multiarch เป็นความสำเร็จที่ยอดเยี่ยมสำหรับการรวบรวมข้าม!

โดยสรุปขั้นตอนต่อไปนี้จำเป็นในการใช้ประโยชน์จาก multiarch สำหรับการรวบรวม Raspbian Jessie cross:

• บนโฮสต์ Ubuntu ของคุณให้ติดตั้ง Debian Jessie amd64 ภายใน chroot หรือคอนเทนเนอร์ LXC
• เปิดใช้งาน armhf สถาปัตยกรรมต่างประเทศ
• ติดตั้ง cross compiler จากที่เก็บ emdebian tools
• ปรับแต่ง cross compiler (จะสร้างโค้ดสำหรับ ARMv7-A ตามค่าเริ่มต้น) โดยเขียนไฟล์ข้อมูลจำเพาะ gcc ที่กำหนดเอง
• ติดตั้งไลบรารี armhf (libstdc ++ ฯลฯ ) จากที่เก็บ Raspbian
• สร้างซอร์สโค้ดของคุณ

เนื่องจากนี่เป็นงานจำนวนมากฉันจึงทำการตั้งค่าข้างต้นโดยอัตโนมัติ คุณสามารถอ่านได้ที่นี่:

Cross Compiling สำหรับ Raspbian

มี CDP Studio IDE ซึ่งทำให้การคอมไพล์ข้ามและปรับใช้ค่อนข้างง่ายจากทั้ง windows และ linux และคุณสามารถทำเครื่องหมายที่ช่องทำเครื่องหมาย raspberry toolchain ระหว่างการติดตั้ง (ปล. มีการรองรับ GPIO และ I2C จึงไม่จำเป็นต้องใช้รหัสเพื่อเข้าถึงสิ่งเหล่านี้)

การสาธิต IDE ของการใช้ราสเบอร์รี่อยู่ที่นี่: https://youtu.be/4SVZ68sQz5U

และคุณสามารถดาวน์โหลด IDE ได้ที่นี่: https://cdpstudio.com/home-edition