Robotyka dla początkujących

Embedded Linux to potężne narzędzie w świecie robotyki i elektroniki, umożliwiające uruchomienie pełnoprawnego systemu operacyjnego na mikrokontrolerach i płytkach deweloperskich.

Zawartość wpisu: [pokaż]

W tym przewodniku krok po kroku zainstalujesz Linuksa na platformie wbudowanej, skupiając się na praktyce: kompilacji skrośnej, konfiguracji bootloadera i przygotowaniu jądra.

Do instalacji przyda się znajomość linii poleceń w Linuksie oraz podstaw kompilacji, choć znajomość języka C nie jest obowiązkowa. Skupimy się na popularnej płytce BeagleBone Black, a opisany proces jest uniwersalny dla wielu platform ARM (np. Raspberry Pi i innych SoC).

Dlaczego embedded Linux w robotyce i elektronice?

Embedded Linux oferuje elastyczność, wielozadaniowość i bogaty ekosystem bibliotek, co przyspiesza rozwój autonomicznych robotów, dronów i systemów IoT.

W odróżnieniu od RTOS-ów (np. FreeRTOS) Linux zapewnia pełny stos TCP/IP, wsparcie grafiki i zaawansowane narzędzia deweloperskie bez potrzeby pisania wszystkiego od zera.

Zalety praktyczne:

  • szybka iteracja – uruchamiasz system od zera i dopasowujesz jądro do konkretnego hardware’u;
  • niski koszt – płytki jak BeagleBone Black (ok. 100–200 zł) są tanie i stabilne;
  • społeczność – mnóstwo tutoriali i dystrybucji jak Yocto czy Buildroot.

Wyzwania to głównie footprint (pamięć) i czas rozruchu – dlatego Linux najlepiej sprawdza się w zaawansowanych projektach robotycznych.

Wymagania wstępne

Przed instalacją przygotuj poniższe elementy:

  • host PC – Ubuntu 24.04 lub nowsze do kompilacji skrośnej;
  • płytka deweloperska – np. BeagleBone Black (ARM Cortex-A8);
  • kabel USB–UART – do konsoli szeregowej (np. FT232R);
  • narzędzia – Git, make, ncurses-dev.

Aby zainstalować podstawowe pakiety narzędziowe, wykonaj:

sudo apt update
sudo apt install git build-essential bc bison flex libssl-dev u-boot-tools

Do komunikacji szeregowej możesz użyć narzędzi minicom lub picocom.

Krok 1: kompilacja skrośna (cross-compilation)

Kompilacja skrośna to budowanie kodu dla architektury ARM na maszynie x86_64. Skorzystaj z toolchainów gcc-arm-linux-gnueabihf (ARM 32-bit) lub gcc-aarch64-linux-gnu (ARM64).

Aby zainstalować toolchainy, użyj polecenia:

sudo apt install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf \
gcc-aarch64-linux-gnu g++-aarch64-linux-gnu

Alternatywnie możesz użyć Dockera z Buildx do multi-arch buildów i emulacji bez fizycznego sprzętu. Instalacja Dockera na Ubuntu przebiega tak:

sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
sudo tee /etc/apt/sources.list.d/docker.sources > /dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin

Aby przygotować buildera multiarch z QEMU, wykonaj:

docker buildx create --name multiarch-builder --use
docker buildx inspect --bootstrap
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

Test kompilacji „Hello World” dla ARM64 w Dockerze – przykładowy Dockerfile:

# Dockerfile
FROM --platform=$BUILDPLATFORM gcc:12 AS builder
ARG TARGETPLATFORM
WORKDIR /usr/src/app
COPY hello.c .
RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
apt-get update && apt-get install -y gcc-aarch64-linux-gnu && \
aarch64-linux-gnu-gcc hello.c -o hello; \
else \
gcc hello.c -o hello; \
fi

Aby zbudować i uruchomić obraz ARM64, wykonaj:

docker buildx build --platform linux/arm64 -t hello:arm64 --load .
docker run --platform linux/arm64 --rm hello:arm64

QEMU emuluje ARM na x86 w locie, co pozwala testować oprogramowanie robotyczne bez dostępu do płytki.

Krok 2: bootloader – U-Boot

Bootloader inicjuje sprzęt i ładuje jądro – w systemach embedded standardem jest U-Boot.

Aby pobrać i zbudować U-Boota dla BeagleBone Black, użyj:

git clone https://github.com/u-boot/u-boot.git
cd u-boot
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- beaglebone_black_defconfig
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-

Wgraj obrazy na kartę SD/eMMC (zastąp /dev/sdX właściwym urządzeniem):

dd if=MLO of=/dev/sdX bs=512 seek=1
dd if=u-boot.img of=/dev/sdX bs=512 seek=2

U-Boot pozwala ładować jądro przez TFTP oraz montować system plików rootfs przez NFS, co znacząco przyspiesza iterację.

Krok 3: przygotowanie jądra Linuksa

Jądro to serce systemu – dla BeagleBone użyj gałęzi Linux 6.x. Pobierz i skonfiguruj źródła:

git clone https://github.com/beagleboard/kernel.git
cd kernel
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- omap2plus_defconfig

Kluczowe decyzje konfiguracyjne: wybierz, które sterowniki wkompilować „na stałe”, a które jako moduły (np. GPIO, I2C dla robotyki) oraz włącz obsługę platformy AM335x (BeagleBone).

Aby skompilować jądro i pliki Device Tree, uruchom:

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -j$(nproc) zImage dtbs

Device Tree Blob (DTB) opisuje sprzęt i jest kluczowy dla poprawnej obsługi pinów GPIO i peryferiów w projektach robotycznych.

Krok 4: root filesystem i przestrzeń użytkownika

Rootfs to bazowy system plików – w praktyce najwygodniej zbudować go narzędziami Buildroot lub Yocto. Przykład z Buildroot:

git clone https://github.com/buildroot/buildroot
cd buildroot
make beaglebone_defconfig
make

Podczas konfiguracji zwróć uwagę na kluczowe elementy:

  • sieć (narzędzia i konfiguracja interfejsów),
  • skrypty init i proces uruchamiania,
  • biblioteki i zależności skrośnie skompilowane (np. glibc).

Programy przestrzeni użytkownika kompiluj toolchainem cross-gcc; dla minimalnych obrazów świetnie sprawdza się BusyBox.

Montaż rootfs przez NFS w U-Boot możesz zainicjować tak:

setenv serverip 192.168.1.100; bootm

Krok 5: komunikacja i debugowanie

Do uruchamiania, transferu danych i diagnostyki używaj sprawdzonych narzędzi:

  • konsola szeregowa – uruchom: minicom -D /dev/ttyUSB0 -b 115200;
  • transfer plików – wykorzystaj netcat, scp, a do zdalnego debugowania gdbserver;
  • core dumps – analizuj zrzuty pamięci w przypadku awarii aplikacji.

W zastosowaniach robotycznych wygodne jest SSH do zdalnego sterowania (np. GPIO napędzające silniki).

Praktyczne ćwiczenia dla robotyków

  1. Uruchom miganie diodą LED na GPIO (export pinu, kierunek, cykl).
  2. Skompiluj sterownik silnika krokowego jako moduł i wczytaj go narzędziem modprobe.
  3. Skonfiguruj „sieciowego robota”: jądro przez TFTP, rootfs przez NFS, sterowanie przez gniazda TCP/UDP.

Na BeagleBone po starcie systemu zweryfikuj wersję poleceniem: uname -a.

Zaawansowane tipy i pułapki

Poniższe wskazówki pomogą dopracować obraz i szybciej diagnozować problemy:

  • optymalizacja – stripowanie binariów i kompresja rootfs (np. squashfs) w celu zmniejszenia obrazu;
  • emulacja – Docker Buildx z QEMU umożliwia testy bez fizycznego hardware’u;
  • bezpieczeństwo – SELinux w embedded stosuj głównie w systemach krytycznych;
  • diagnostyka – błędny DTB skutkuje brakiem peryferiów; sprawdzaj logi dmesg.