Embedded Linux: Building Systems with Buildroot and Yocto

# Clone Buildroot
git clone https://github.com/buildroot/buildroot.git
cd buildroot

# Check version
make -version

# Clean
make distclean

# Configure
make menuconfig

# Target options
# - Target architecture (ARM, x86, MIPS, etc.)
# - Architecture variant
# - Floating point strategy

# Build options
# - Enable compiler cache (ccache)
# - Enable development files
# - Strip target binaries

# Toolchain options
# - C library (glibc, musl, uClibc)
# - Enable C++ support
# - Enable tasking

# In menuconfig:
# Toolchain -> C library (musl for smaller images)
# System configuration -> Init system (BusyBox, systemd)
# Target packages -> 
#   - Graphic libraries
#   - Hardware handling
#   - Networking
#   - Audio/Video
# Filesystem images -> 
#   - tar, cpio, ext2/3/4, squashfs

# Build with all cores
make -j$(nproc)

# Build with ccache
make BR2_CCACHE=y -j$(nproc)

# Output in output/

# Use defconfig for popular boards
make pc_x86_64_efi_defconfig
make raspberrypi4_64_defconfig
make beaglebone_defconfig

# Customize
make menuconfig
make savedefconfig
cp defconfig configs/myboard_defconfig

# Install dependencies
sudo apt install build-essential git libncurses5-dev

# Get Raspberry Pi config
make raspberrypi4_64_defconfig

# Customize
make menuconfig

# Build
make -j$(nproc)

# Output images
# output/images/bcm2711-rpi-4-*.dtb
# output/images/Image
# output/images/rootfs.ext4

# Install dependencies (Ubuntu/Debian)
sudo apt install \
    git make \
    python3 python3-pip \
    gcc g++ \
    chrpath diffstat \
    file cpio \
    texinfo \
    locales \
    libncurses5-dev \
    libsdl1.2-dev \
    xterm

# Install Poky (reference distribution)
git clone -b kirkstone https://github.com/yoctoproject/poky.git
cd poky

# Source environment
source oe-init-build-env

# Configure
bitbake-layers add-layer ../meta-raspberrypi
vim conf/bblayers.conf

# Build
bitbake core-image-minimal

# Build time: hours for first build

# Common layers
# meta-openembedded - many packages
# meta-raspberrypi - Raspberry Pi support
# meta-python - Python packages
# meta-qt5 - Qt framework

# Add layer
bitbake-layers add-layer ../meta-raspberrypi

# List layers
bitbake-layers show-layers

# Create layer
bitbake-layers create-layer meta-mylayer

# Add to bblayers.conf
bitbake-layers add-layer meta-mylayer

# Add recipe
mkdir -p meta-mylayer/recipes-example/example
vim meta-mylayer/recipes-example/example/example_1.0.bb

# Build
bitbake example

# meta-mylayer/recipes-myapp/myapp/myapp.bb
SUMMARY = "My Application"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

SRC_URI = "git://github.com/example/myapp.git"
SRCREV = "${AUTOREV}"

inherit cmake

EXTRA_OECMAKE = "-DCMAKE_BUILD_TYPE=Release"

# Install cross-compiler
sudo apt install gcc-arm-linux-gnueabihf
sudo apt install aarch64-linux-gnu-gcc

# ARM 32-bit
arm-linux-gnueabihf-gcc -o app main.c

# ARM 64-bit
aarch64-linux-gnu-gcc -o app main.c

# x86_64 (native)
gcc -o app main.c

# toolchain.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)

set(CMAKE_FIND_ROOT_PATH /usr/arm-linux-gnueabihf)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

mkdir build
cd build
cmake -DCMAKE_TOOLCHAIN_FILE=../toolchain.cmake ..
make

# Install Raspberry Pi OS Lite
curl -L https://downloads.raspberrypi.org/raspios_lite_arm64_latest -o rpi-imager
# Or use Raspberry Pi Imager

# Configure headless
# Create ssh file in boot
touch /boot/ssh

# Add WiFi config
vim /boot/wpa_supplicant.conf

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=US

network={
    ssid="YourNetwork"
    psk="YourPassword"
}

# Flash eMMC (on Raspberry Pi Compute Module)
# Use rpiboot utility
sudo rpiboot
# Then use imager or dd

# For NVMe/SSD boot
# Enable in config.txt
sudo vim /boot/firmware/config.txt
dtparam=nvme

# Get PREEMPT_RT kernel
git clone https://git.kernel.org/pub/scm/linux/kernel/git/rt/linux.git
cd linux
git checkout rt/latest

# Configure
make menuconfig
# General setup -> Preemption Model -> Fully Preemptible (RT)

# Build
make -j$(nproc) zImage modules dtbs

# Kernel config for real-time
CONFIG_PREEMPT=y
CONFIG_PREEMPT_VOLUNTARY=y
CONFIG_HZ_1000=y
CONFIG_NO_HZ=y
CONFIG_HIGH_RES_TIMERS=y
CONFIG_RCU_TRACE=y

# CPU isolation
nohz_full=1-3
isolcpus=1-3

# Install Docker
curl -fsSL get.docker.com | sh

# For ARM64
curl -fsSL https://download.docker.com/linux/static/stable/aarch64/docker-24.0.7.tgz | tar xz
sudo cp docker/* /usr/bin/
sudo groupadd docker
sudo usermod -aG docker $user

# Start
sudo systemctl enable docker
sudo systemctl start docker

# Pull ARM images
docker pull arm64v8/nginx
docker pull arm32v7/nginx

# Build for ARM on x86
docker buildx build --platform linux/arm64 -t myapp:arm64 .

# Multi-platform manifest
docker buildx create --name mybuilder
docker buildx use mybuilder
docker buildx inspect --bootstrap
docker buildx build --platform linux/amd64,linux/arm64 -t myapp .

# Disable unused services
systemctl mask systemd-timesyncd

# Read-only filesystem
# /etc/fstab
/dev/root / ext4 ro,noatime 0 1
tmpfs /tmp tmpfs defaults,noatime,mode=1777 0 0

# Secure boot
# Use UEFI secure boot
# Sign kernel and initramfs

# Disable network interfaces not needed
# /etc/systemd/network/eth0.network
[Network]
Address=192.168.1.100/24

# OTA (Over-the-Air) updates
# Use Mender, SWUpdate, or RAUC

# Mender example
# Install mender client
# Configure /etc/mender/mender.conf
{
    "ServerURL": "https://mender.example.com",
    "TenantToken": "..."
}

# Trigger update
mender -install /var/lib/mender/uboot/image.artifact

# Install GDB
sudo apt install gdb-multiarch

# Debug
gdb-multiarch vmlinux
(gdb) target remote 192.168.1.100:3333

# OpenOCD configuration
# openocd.cfg
source [find interface/jlink.cfg]
transport select swd
source [find target/stm32f4x.cfg]

# Connect
openocd
# Then connect with GDB
target remote localhost:3333

# Strace
arm-linux-gnueabihf-strace -p $(pgrep app)

# Serial console
screen /dev/ttyUSB0 115200
minicom -D /dev/ttyUSB0

# Network debugging
tcpdump -i eth0 -w capture.pcap

# Install Mosquitto
sudo apt install mosquitto mosquitto-clients

# Subscribe
mosquitto_sub -t "sensor/+/data"

# Publish
mosquitto_pub -t "sensor/temperature" -m "25.5"

# Install libmodbus
git clone https://github.com/libmodbus/libmodbus.git
./autogen.sh
./configure --host=arm-linux-gnueabihf
make