Wie installiere ich den Raspberry Pi Cross Compiler auf meinem Linux-Hostcomputer?

Ich versuche, Cross-Compiling für Raspberry Pi auf meinem Ubuntu-Computer zum Laufen zu bringen.

Bei meinen ersten Versuchen habe ich den Arm-Linux-Gnueabi-Compiler verwendet, der im Ubuntu-Repo verfügbar ist. Ich habe das zum Laufen gebracht. Ich konnte alle meine Abhängigkeiten erstellen und den Cross-Compiler in meinem cmake-Projekt verwenden.

Ich glaube jedoch, dass ich die hf-Version verwenden sollte, also wechselte ich zu arm-linux-gnueabihf. Dann wurde mir klar, dass dies mit Raspberry Pi nicht funktioniert, da es armv6 ist.

Nach einigem Googeln fand ich dann die vorgefertigte Toolchain von GitHub .

Ich habe die Toolchain heruntergeladen, aber ich verstehe nicht wirklich, wie man sie "installiert". Ich habe die Dateien in mein Home-Verzeichnis extrahiert. Die Verzeichnisstruktur sieht folgendermaßen aus:

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

Wenn ich das Verzeichnis in den Ordner INNER bin wechsle, kann ich problemlos ein Testprogramm vom Terminal aus kompilieren.

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

Ich habe dann versucht, ein Testprogramm im Ordner OUTER bin zu kompilieren, das die vorangestellten Versionen der Tools enthält.

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

Wenn ich jedoch versuche, den Compiler jetzt (von außerhalb des inneren bin-Verzeichnisses) zu verwenden, kann er die gemeinsam genutzte Bibliothek libstdc ++, die mit der Toolchain geliefert wird, nicht finden:

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

Außerdem möchte ich den Compiler verwenden können, ohne zum bin-Verzeichnis navigieren zu müssen. Also habe ich versucht, das Verzeichnis OUTER bin (da ich die vorangestellten Versionen haben möchte) und beide lib-Verzeichnisse zu meinem PATH hinzuzufügen:

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

Dies führt jedoch zu demselben Fehler. Wie soll ich die Toolchain "installieren", damit ich die Toolchain von überall aus verwenden kann, genau wie ich es kann, wenn ich die Cross-Compiler aus dem Ubuntu-Repo verwende?

Ich werde versuchen, dies als Tutorial für Sie zu schreiben, damit es leicht zu befolgen ist.

HINWEIS: Dieses Tutorial funktioniert nur für ältere Raspbian-Bilder. Für das neuere Raspbian, das auf Debian Buster basiert, lesen Sie die folgenden Anleitungen in diesem Thread: https://stackoverflow.com/a/58559140/869402

Voraussetzungen

Bevor Sie beginnen, müssen Sie sicherstellen, dass Folgendes installiert ist:

apt-get install git rsync cmake ia32-libs

Lassen Sie uns einen Kuchen kreuzen!

Beginnen Sie mit dem Erstellen eines Ordners in Ihrem Home-Verzeichnis mit dem Namen raspberrypi.

Gehen Sie in diesen Ordner und öffnen Sie den oben erwähnten Ordner mit den GESAMTEN Werkzeugen:

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

Sie wollten die folgenden 3 verwenden gcc-linaro-arm-linux-gnueabihf-raspbian, wenn ich nicht falsch gelesen habe.

Gehen Sie in Ihr Home-Verzeichnis und fügen Sie hinzu:

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

bis zum Ende der benannten Datei ~/.bashrc

Jetzt können Sie sich entweder abmelden und wieder anmelden (dh Ihre Terminalsitzung neu starten) oder . ~/.bashrcin Ihrem Terminal ausführen , um den PATHZusatz in Ihrer aktuellen Terminalsitzung aufzunehmen.

Stellen Sie nun sicher, dass Sie auf den Compiler zugreifen können arm-linux-gnueabihf-gcc -v. Sie sollten so etwas bekommen:

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
 )

Aber hey! Ich habe das gemacht und die Bibliotheken funktionieren immer noch nicht!

Wir sind noch nicht fertig! Bisher haben wir nur die Grundlagen gemacht.

raspberrypiErstellen Sie in Ihrem Ordner einen Ordner mit dem Namen rootfs.

Nun müssen Sie das gesamte kopieren /libund /usrVerzeichnis in diesem neu erstellten Ordner. Normalerweise rufe ich das RPI-Bild auf und kopiere es über rsync:

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

wo 192.168.1.PIwird durch die IP Ihres Raspberry Pi ersetzt.

Jetzt müssen wir eine cmakeKonfigurationsdatei schreiben . Öffnen Sie ~/home/raspberrypi/pi.cmakein Ihrem bevorzugten Editor und fügen Sie Folgendes ein:

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)

Jetzt sollten Sie in der Lage sein, Ihre cmakeProgramme einfach durch Hinzufügen dieses zusätzlichen Flags zu kompilieren : -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake.

Verwenden eines Beispiels für eine cmake-Hallo-Welt :

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

Erstellen für neuere Raspbian Debian Buster-Bilder und ARMv6

Die Antwort von @Stenyg funktioniert nur für ältere Raspbian-Bilder. Das kürzlich veröffentlichte Raspbian basierend auf Debian Buster erfordert eine aktualisierte Toolchain:

In Debian Buster wurden der gcc-Compiler und glibc auf Version 8.3 aktualisiert. Die Toolchain in git://github.com/raspberrypi/tools.gitbasiert weiterhin auf der älteren gcc 6-Version. Dies bedeutet, dass die Verwendung git://github.com/raspberrypi/tools.gitzu vielen Kompilierungsfehlern führt.

Dieses Tutorial basiert auf der Antwort von @Stenyg. Neben vielen anderen Lösungen im Internet unterstützt dieses Tutorial auch ältere Rasperry Pi (A, B, B +, Zero ), die auf der ARMv6-CPU basieren. Siehe auch: GCC 8 Cross Compiler gibt die ausführbare ARMv7-Datei anstelle von ARMv6 aus

Richten Sie die Toolchain ein

Es gibt kein offizielles Git-Repository mit einer aktualisierten Toolchain (siehe https://github.com/raspberrypi/tools/issues/102 ).

Ich habe ein neues Github-Repository erstellt, das das Erstellen und Vorkompilieren von Toolchains für ARMv6 auf der Basis von GCC8 und neueren Versionen umfasst:

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

Wie in der Readme-Datei des Projekts erwähnt, sind dies die Schritte, um die Toolchain abzurufen. Sie können es auch selbst erstellen (weitere Informationen finden Sie in der README-Datei).

1. Laden Sie die Toolchain herunter:

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

2. Extrahieren Sie es. Hinweis: Die Toolchain muss vorhanden sein, /opt/cross-pi-gccda sie nicht ortsunabhängig ist.

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

3. Du bist fertig! Die Toolchain ist jetzt in/opt/cross-pi-gcc

4. Fügen Sie optional die Toolchain zu Ihrem Pfad hinzu, indem Sie Folgendes hinzufügen:

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

bis zum Ende der benannten Datei ~/.bashrc

Jetzt können Sie sich entweder abmelden und wieder anmelden (dh Ihre Terminalsitzung neu starten) oder . ~/.bashrcin Ihrem Terminal ausführen , um den PATHZusatz in Ihrer aktuellen Terminalsitzung aufzunehmen.

Holen Sie sich die Bibliotheken aus dem Raspberry PI

Um eine Cross-Kompilierung für Ihren eigenen Raspberry Pi durchzuführen, auf dem möglicherweise einige benutzerdefinierte Bibliotheken installiert sind, müssen Sie diese Bibliotheken auf Ihren Host übertragen.

Erstellen Sie einen Ordner $HOME/raspberrypi. raspberrypiErstellen Sie in Ihrem Ordner einen Ordner mit dem Namen rootfs.

Nun müssen Sie das gesamte kopieren /libund /usrVerzeichnis in diesem neu erstellten Ordner. Normalerweise rufe ich das RPI-Bild auf und kopiere es über rsync:

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

wo 192.168.1.PIwird durch die IP Ihres Raspberry Pi ersetzt.

Verwenden Sie CMake, um Ihr Projekt zu kompilieren

Um CMake anzuweisen, Ihre eigene Toolchain zu verwenden, benötigen Sie eine Toolchain-Datei, die die Compilereinstellungen initialisiert.

Diese Toolchain-Datei erhalten Sie hier: https://github.com/Pro/raspi-toolchain/blob/master/Toolchain-rpi.cmake

Jetzt sollten Sie in der Lage sein, Ihre cmakeProgramme einfach zu kompilieren, indem Sie dieses zusätzliche Flag hinzufügen: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmakeund die richtigen Umgebungsvariablen festlegen:

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

Ein Beispiel für eine Hallo-Welt finden Sie hier: https://github.com/Pro/raspi-toolchain/blob/master/build_hello_world.sh

Ich konnte nicht den Compiler (get - x64Version) die verwenden , sysrootbis ich hinzugefügt SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs)zu pi.cmake.

Für Windows - Host, möchte ich sehr empfehlen dieses Tutorial: :

• Laden Sie die Toolchain herunter und installieren Sie sie
• Synchronisieren Sie sysroot mit Ihren RPi include / lib-Verzeichnissen
• Kompilieren Sie Ihren Code
• Ziehen Sie die ausführbare Datei mit SmarTTY per Drag & Drop auf Ihr RPi
• Starte es!

Nicht mehr, nicht weniger!

Vorgefertigte GNU-Toolchains für Himbeere, Beaglebone, Cubieboard, AVR (Atmel) und mehr

Sie können auch Clang verwenden . Früher war es schneller als GCC, und jetzt ist es eine ziemlich stabile Sache. Es ist viel einfacher, Klirren aus Quellen zu bauen ( Sie können während des Bauprozesses wirklich eine Tasse Kaffee trinken ).

Zusamenfassend:

1. Holen Sie sich Clang-Binärdateien (sudo apt-get install clang) .. oder laden Sie sie herunter und erstellen Sie sie ( lesen Sie die Anweisungen hier )
2. Hängen Sie Ihre Himbeer-Rootfs ein (dies können die echten Rootfs sein, die über sshfs oder ein Image gemountet wurden).

3. Kompilieren Sie Ihren Code:

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

Optional können Sie ältere Arm-Linux-Gnueabihf-Binutils verwenden. Dann können Sie am Ende das Flag "-fuse-ld = lld" entfernen.

Unten ist meine cmake Toolchain-Datei.

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)

Ich konnte QT5 mit keiner der (ziemlich veralteten) Toolchains von git kompilieren: //github.com/raspberrypi/tools.git. Das Konfigurationsskript schlug weiterhin mit dem Fehler "Architektur konnte nicht ermittelt werden" und mit massiven Pfadproblemen für Include-Verzeichnisse fehl. Was für mich funktioniert hat, war die Verwendung der 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

in Kombination mit

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

Wenn die Symlinks der Sysroot nicht behoben werden, führt dies zu undefinierten Symbolfehlern, wie hier beschrieben: Ein Fehler beim Erstellen von Qt-Bibliotheken für den Himbeer-Pi Dies ist mir passiert, als ich das Skript fixQualifiedLibraryPaths aus tools.git ausprobiert habe. Alles andere wird ausführlich unter http://wiki.qt.io/RaspberryPi2EGLFS beschrieben . Meine Konfigurationseinstellungen waren:

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

Dabei ist / usr / local / rasp / sysroot der Pfad meiner lokalen Raspberry Pi 3 Raspbian (Jessie) -Systemkopie und / usr / local / qt5pi der Pfad der kreuzkompilierten QT, die ebenfalls auf das Gerät kopiert werden muss. Beachten Sie, dass Jessie bei der Auswahl Ihrer Toolchain mit GCC 4.9.2 geliefert wird.

Die erste Frage wurde vor einiger Zeit gestellt und in der Zwischenzeit hat Debian große Fortschritte im Bereich der Unterstützung durch Multiarchen erzielt.

Multiarch ist eine großartige Leistung für die Cross-Compilation!

Kurz gesagt, die folgenden Schritte sind erforderlich, um Multiarch für die Raspbian Jessie-Cross-Kompilierung zu nutzen:

• Installieren Sie Debian Jessie amd64 auf Ihrem Ubuntu-Host in einem Chroot- oder LXC-Container.
• Aktivieren Sie die fremde Architektur armhf.
• Installieren Sie den Cross-Compiler aus dem Emdebian-Tools-Repository.
• Optimieren Sie den Cross-Compiler (standardmäßig wird Code für ARMv7-A generiert), indem Sie eine benutzerdefinierte gcc-Spezifikationsdatei schreiben.
• Installieren Sie armhf-Bibliotheken (libstdc ++ usw.) aus dem Raspbian-Repository.
• Erstellen Sie Ihren Quellcode.

Da dies eine Menge Arbeit ist, habe ich das obige Setup automatisiert. Sie können hier darüber lesen:

Cross Compiling für Raspbian

Es gibt eine CDP Studio-IDE, die das Cross-Kompilieren und Bereitstellen unter Windows und Linux recht einfach macht. Sie können das Kontrollkästchen für die Himbeer-Toolchain während der Installation aktivieren. (PS. Es hat GPIO- und I2C-Unterstützung, daher wird kein Code benötigt, um auf diese zuzugreifen.)

Die IDE-Demo zur Verwendung von Himbeeren finden Sie hier: https://youtu.be/4SVZ68sQz5U

und Sie können die IDE hier herunterladen: https://cdpstudio.com/home-edition