카테고리 보관물: Programming

Raspberry Pi용 Qt5 Cross Compile

댓글 남기기

이 포스팅은 Qt5 5.15.11을 RPi5용으로 크로스 컴파일 하는 과정을 정리한 것이다. Build host는 Ubuntu 24.04이다.

Overview

2025년 12월 현재, Qt5가 RPi용 deb package 생성을 직접 지원하지는 않기 때문에 다소 복잡하고 번거롭긴 하지만, target인 Raspberry Pi OS의 image 파일을 빌드 호스트 머신에 loop device로 마운트 시켜서 크로스 컴파일을 수행하고 그 결과를 마운트된 공간에 설치하는 방식으로 이미지 파일(raspios.img)를 업데이트 시킨다. 이렇게 만들어진 이미지 파일을 RPi5용 SD card에 flash하면 Qt5가 포함된 이미지 파일을 사용할 수 있다.

Target RPi OS 이미지 준비

Raspberry Pi OS image 를 준비해서 개발 호스트에 마운트 시켜서, Qt5를 빌드하는데 필요한 패키지들을 설치한다. 이것은 cross compile중에 필요한 의존성을 해결하기 위한 과정이다.

필요한 모든 파일들을 모아둘 공간을 BASE_DIR라하고 그 아래에 Raspberry Pi OS image file을 마운트할 장소를 ROOTFS라고 정의한다. 그 외에 빌드에 필요한 환경변수들을 함께 정의해 주자.

# BASE_DIR: project에 필요한 데이터를 모아둘 파일경로
# ROOTFS: RPi image 파일을 마운트할 경로
export BASE_DIR=${PWD}
export ROOTFS=$BASE_DIR/rootfs
# QT_SRC_DIR: Qt5 소스코드를 보관
# QT_BUILD_DIR: Qt5 빌드 결과물을 보관
# QT_HOST: Qt5 호스트용 바이너리 위치
# QT_TARGET: Qt5 타겟용 바이너리 위치
export QT_BUILD_DIR=$BASE_DIR/qt5-build
export QT_SRC_DIR=$BASE_DIR
export QT_HOST=$BASE_DIR/qt5-host
export QT_TARGET=$BASE_DIR/qt5-rpi

Raspberry Pi OS의 image파일이 필요한데, 사용한 OS 이미지의 버전은 2025년 12월 현재의 최신 버전이다. 이 파일을 다운로드 받아서 raspios.img라는 이름으로 압축을 풀고, loop device로 설정해서 ROOTFS에 정의된 디렉토리 위치로 마운트 한다.

압축이 풀린 raspios.img 파일을 fdisk로 들여다 보면 두개의 파티션이 보이는데, 하나는 boot를 위한 파티션으로 p1에 있고 다른 하나는 우리가 Qt5를 빌드해서 설치할 rootfs인데, p2로 접근하면 된다. 아래의 예는 /dev/loop4로 설정된 loop device의 두번째 파티션 p2을 마운트 하는 것이다.

# Raspberry Pi OS 이미지를 다운로드
wget https://downloads.raspberrypi.com/raspios_arm64/images/raspios_arm64-2025-12-04/2025-12-04-raspios-trixie-arm64.img.xz
xzcat ./2025-12-04-raspios-trixie-arm64.img.xz > $BASE_DIR/raspios.img
# Loop device를 설정하고 ROOTFS 경로에 마운트
mkdir -p $ROOTFS
sudo losetup -Pf --show $BASE_DIR/raspios.img
/dev/loop4
# Root 파일 시스템 마운트
sudo mount /dev/loop4p2 $ROOTFS

Root 파일 시스템이 마운트 되었다면 그 안에 있는 ARM binary를 QEMU로 실행할 수 있도록 update-binfmts를 설정한다. 호스트 머신에 있는 /dev, /proc/, /sys, /dev/pts를 ROOTFS에서 사용할 수 있도록 마운트 해주고 chroot을 실행하면 마치 ARM 시스템에 접속한 것 처럼 root shell(#)을 볼 수 있고, 관리자 권한으로 파일을 접근 할 수 있는 상태가 된다.

여기에서 수행하는 명령어 들은 ROOTFS에 적용되므로 결과 적으로 Raspberry Pi OS image가 업데이트 된다.

# QEMU ARM을 실행하기 위한 준비
sudo apt install qemu-user-static binfmt-support
sudo update-binfmts --enable qemu-aarch64
sudo cp /usr/bin/qemu-aarch64-static $ROOTFS/usr/bin/
# 파일시스템 바인딩
sudo mount --bind /dev  $ROOTFS/dev
sudo mount --bind /proc $ROOTFS/proc
sudo mount --bind /sys  $ROOTFS/sys
sudo mount --bind /dev/pts $ROOTFS/dev/pts
# Launch
sudo chroot $ROOTFS /usr/bin/qemu-aarch64-static /bin/bash

Qt5를 RPi용으로 컴파일하기 위해 필요한 의존성 패키지들을 설치해 준다. 참고로, RPi OS의 베이스 이미지는 이전에 데비안 Bookworm이었다가 Trixie로 얼마전에 업데이트 되었다.

# 한국에 있는 미러 서버를 소스 리스트에 등록
# 굳이 안해도 되지만 속도를 위해서 미러로 접속한다.
cat >> /etc/apt/sources.list << 'EOF'
deb http://ftp.kaist.ac.kr/debian trixie main contrib non-free non-free-firmware
deb http://ftp.kaist.ac.kr/debian trixie-updates main contrib non-free non-free-firmware
deb http://security.debian.org/debian-security trixie-security main contrib non-free non-free-firmware
EOF
# 의존성 패키지 설치
apt update
apt install -y \
    libgles-dev \
    libegl-dev \
    libgbm-dev \
    libdrm-dev \
    libinput-dev \
    libxkbcommon-dev \
    libx11-dev \
    libxext-dev \
    libxcb1-dev \
    libx11-xcb-dev \
    libxcb-glx0-dev \
    libxcb-util-dev \
    libxcb-xkb-dev \
    libxcb-xinerama0-dev \
    libxcb-cursor-dev \
    libxcb-keysyms1-dev \
    libxcb-render-util0-dev \
    libxcb-image0-dev \
    libxi-dev \
    libfontconfig1-dev \
    libfreetype6-dev \
    libpng-dev \
    libjpeg-dev \
    zlib1g-dev \
    libudev-dev \
    libdbus-1-dev \
    pkg-config \
    libxcb-shm0-dev \
    libxcb-xfixes0-dev \
    libxcb-randr0-dev \
    libxcb-render0-dev \
    libxcb-shape0-dev \
    libxcb-sync-dev \
    libxcb-icccm4-dev \
    libxkbcommon-x11-dev \
    libxfixes-dev \
    libxrandr-dev \
    libxrender-dev \
    libwayland-dev \
    libwayland-egl-backend-dev \
    wayland-protocols \
    libegl1-mesa-dev

필요한 패키지를 설치했으면 chroot을 종료하고 host의 디렉토리들을 unmount한다.

# Clean up
exit
sudo umount $ROOTFS/dev/pts
sudo umount $ROOTFS/dev
sudo umount $ROOTFS/proc
sudo umount $ROOTFS/sys

Qt5 Cross Compilation

컴파일을 수행할 Qt5의 소스코드를 다운로드 받는다. QT_SRC_DIR 경로에 소스코드를 풀어서 저장할 것이다.

# QT_SRC_DIR: Qt5의 소스코드를 저장할 경로
https://download.qt.io/archive/qt/5.15/5.15.11/single/qt-everywhere-opensource-src-5.15.11.tar.xz
tar xvf qt-everywhere-opensource-src-5.15.11.tar.xz -C $QT_SRC_DIR

devices 경로 아래에 새로운 디바이스 명으로 linux-aarch64-gnu-g++ 디렉토리를 생성하고 qmake.conf 파일을 생성한다.

# 디렉토리를 생성하고 qmake.conf 내용을 채운다.
mkdir -p $QT_SRC_DIR/qt-everywhere-src-5.15.11/qtbase/mkspecs/devices/linux-aarch64-gnu-g++
cat << 'EOF' > $QT_SRC_DIR/qt-everywhere-src-5.15.11/qtbase/mkspecs/devices/linux-aarch64-gnu-g++/qmake.conf
MAKEFILE_GENERATOR = UNIX
CONFIG += incremental
QMAKE_INCREMENTAL_STYLE = sublib
# Inherit standard Linux desktop flags (shared libs, version scripts, etc.)
include(../../linux-g++/qmake.conf)
# Cross-compile device
CONFIG += cross_compile
#############################################
# Target / Host Architecture
#############################################
QMAKE_TARGET_ARCH = aarch64
QMAKE_TARGET      = aarch64-linux-gnu
QMAKE_TARGET_CPU  = aarch64
QMAKE_HOST_ARCH   = x86_64
#############################################
# Cross Compiler Toolchain
#############################################
QMAKE_CC          = aarch64-linux-gnu-gcc
QMAKE_CXX         = aarch64-linux-gnu-g++
QMAKE_LINK        = aarch64-linux-gnu-g++
QMAKE_LINK_SHLIB  = aarch64-linux-gnu-g++
QMAKE_AR          = aarch64-linux-gnu-ar cqs
QMAKE_OBJCOPY     = aarch64-linux-gnu-objcopy
QMAKE_STRIP       = aarch64-linux-gnu-strip
# Make configure tests use the cross-compiler too
QMAKE_CONF_COMPILER = $$QMAKE_CXX
#############################################
# Sysroot
#############################################
QMAKE_CFLAGS      += --sysroot=$$[QT_SYSROOT]
QMAKE_CXXFLAGS    += --sysroot=$$[QT_SYSROOT]
QMAKE_LFLAGS      += --sysroot=$$[QT_SYSROOT]
#############################################
# Default Include / Lib paths in sysroot
#############################################
QMAKE_INCDIR += $$[QT_SYSROOT]/usr/include
QMAKE_LIBDIR += \
    $$[QT_SYSROOT]/usr/lib/aarch64-linux-gnu \
    $$[QT_SYSROOT]/lib/aarch64-linux-gnu
#############################################
# OpenGL ES 2.0 / EGL / GBM / DRM (Mesa)
#############################################
# GLES2
QMAKE_INCDIR_OPENGL_ES2 += \
    $$[QT_SYSROOT]/usr/include \
    $$[QT_SYSROOT]/usr/include/GLES2
QMAKE_LIBDIR_OPENGL_ES2 += $$[QT_SYSROOT]/usr/lib/aarch64-linux-gnu
QMAKE_LIBS_OPENGL_ES2   += -lGLESv2
# EGL
QMAKE_INCDIR_EGL += \
    $$[QT_SYSROOT]/usr/include \
    $$[QT_SYSROOT]/usr/include/EGL \
    $$[QT_SYSROOT]/usr/include/libdrm
QMAKE_LIBDIR_EGL += $$[QT_SYSROOT]/usr/lib/aarch64-linux-gnu
QMAKE_LIBS_EGL   += -lEGL
# GBM / DRM
QMAKE_LIBS_GBM   += -lgbm
QMAKE_LIBS_DRM   += -ldrm
QT_QPA_DEFAULT_PLATFORM = eglfs
load(qt_config)
EOF

그 다음으로 qplatformdefs.h 파일을 생성해 준다.

cat << 'EOF' > $QT_SRC_DIR/qt-everywhere-src-5.15.11/qtbase/mkspecs/devices/linux-aarch64-gnu-g++/qplatformdefs.h
#include "../../linux-g++/qplatformdefs.h"
EOF

이제 크로스 컴파일을 실행한다.

# Clean build를 위한 build directory 삭제
rm -rf $QT_BUILD_DIR
mkdir -p $QT_BUILD_DIR && cd $_
# 빌드 환경설정
$QT_SRC_DIR/qt-everywhere-src-5.15.11/configure \
    -opensource -confirm-license \
    -release \
    -device linux-aarch64-gnu-g++ \
    -device-option CROSS_COMPILE=aarch64-linux-gnu- \
    -sysroot "$ROOTFS" \
    -opengl es2 \
    -eglfs \
    -xcb \
    -skip qtwebengine \
    -nomake tests -nomake examples \
    -prefix /usr/local/qt5 \
    -extprefix "$QT_TARGET" \
    -hostprefix "$QT_HOST" \
    -make-tool "make"
# 크로스 컴파일 수행 및 설치
make -j `nproc`
make -j `nproc` install

컴파일이 완료되면 파일의 hard link, 모드, 소유권 등을 그대로 유지하면서 복사해야 하는데 rsync의 archiving 기능을 이용하면 이 부분을 수월하게 수행할 수 있으므로 이를 이용해서 ROOTFS에 컴파일 결과물을 복사하고, Qt5와 관련한 환경변수들을 파일에 만들어서 넣어 준다.

설치가 잘 되었다면 ROOTFS아래의 /usr/local/qt5에 필요한 Qt5관련 라이브러리와 파일들이 설치되었을 것이다.

# rsync로 파일 모드를 유지하면서 복사
sudo -E rsync -aH --info=progress2 $QT_BUILD_DIR/../qt5-rpi/ $ROOTFS/usr/local/qt5/
# 필요한 환경별수 설정: 부팅하면 자동 실행된다.
sudo -E tee $ROOTFS/etc/profile.d/qt5.sh << 'EOF'
export LD_LIBRARY_PATH=/usr/local/qt5/lib:$LD_LIBRARY_PATH
export QT_PLUGIN_PATH=/usr/local/qt5/plugins
export QT_QPA_PLATFORM=xcb
export QML2_IMPORT_PATH=/usr/local/qt5/qml
export PATH=/usr/local/qt5/bin:$PATH
EOF
sudo chmod +x $ROOTFS/etc/profile.d/qt5.sh

Clean Up

ROOTFS를 unmount하고 loop device를 해제한다.

sudo umount $ROOTFS
# Loop device /dev/loop4를 해제.
# 처음 losetup 할 때 출력되는 loop device의 경로명을 적어준다.
# 빌드 호스트에 따라 다를 수 있음.
sudo losetup -d /dev/loop4

동작 확인

이제 생성된 raspios.img 파일을 Raspberry Pi Imager의 custom image flash 기능을 이용해서 SD card에 이미지를 flash한다.

만약, 부팅 후에 필요하다면 아래의 XCB 관련 패키지들을 설치해 준다.

sudo apt install xorg xwayland libxcb1 libx11-6 libxext6

시험용으로 간단하게 만든 c++ testapp으로 동작을 확인했다.

아마도 비슷한 글:

  1. Raspberry Pi용 Qt5 Cross Compile을 위한 Bash Script
  2. Image file의 partition 크기 늘리기
  3. Lightshail Ubuntu 배포판 업그레이드 후 ssh 접속이 안된다.
  4. Raspberry Pi 5에 간단한 Linux 시스템 올리기

gRPC를 이용한 Observer Pattern

댓글 남기기

Remote에서 제공하는 기능을 마치 local system의 function call 처럼 제공 한다는 gRPC의 개념 자체는 1990년대에도 있었던 것이기에 새로울 것은 없지만, 그 위에서 “Subject의 변경이 있을 때 subscriber에게 notify 해주는 Observer Pattern을 어떻게 구현 할 수 있을까?”하는 의문이 들었다.

이 포스팅에서는 gRPC를 이용한 observer pattern의 예제로 server에서 임의의 주식과 그 변동 가격을 client로 notify 해주고 이것을 화면에 출력하는 예제를 작성해 본다. 전체 코드는 https://github.com/litcoder/grpcobsr에서 확인 할 수 있다.

기본적인 gRPC는 client에서 필요한 정보를 server에게 요청해서 그 결과를 돌려받는다. 반면, Observer Pattern은 그 반대로 server 측에서 정보의 변경 사항이 있을 때 이것을 client 측에 알려 주어야 한다.

이를 가능하게 하는 것은 ServerWriteRector와 ClientReadReactor template인데, 이들은 client의 요청에 대해 server가 여러 개의 응답을 비동기적으로 전송하는 이른바 gRPC의 server-side streaming을 구현하는데 가장 핵심이 되는 요소들이다. 우리 예제의 경우 client는 server로 “주식 가격을 알려 주세요”라는 request를 전송하면 ClientReadReactor의 OnReadDone() 함수로 변경된 주식과 가격이 하나씩 들어오는 식이다.

Proto file

주식 정보를 제공하는 proto file은 다음과 같이 정의 한다. 클라이언트가 UpdateStockPrice()를 요청하면 서버가 StockPriceResponse를 여러 개 stream으로 전송해 주는데 그 안에는 각각의 주식의 종목(symbol)과 가격(price) 정보가 담겨져 있다.

syntax = "proto3";
import "google/protobuf/empty.proto";

message StockPriceResponse {
    string symbol = 1;
    double price = 2;
}

service StockService {
    rpc UpdateStockPrice(google.protobuf.Empty) returns (stream StockPriceResponse);
}

StockPriceWriteReactor

StockPriceWriteReactor는 서버에서 동작하는 reactor이다. 

class StockPriceWriteReactor
    : public ::grpc::ServerWriteReactor<::StockPriceResponse>
{
public:
  StockPriceWriteReactor(int evCnt);

  void OnWriteDone(bool ok) override;
  void OnDone() override;
  void OnCancel() override;

private:
  void NextWrite();

  int _mReqEventCount;
  int _mCurEventCount;
  StockPriceResponse _mResp;
  StockRepository _mStockRepo;
};
  • NextWrite(): 클라이언트로 전송할 데이터를 생성하고 stream에 쓴다.
  • OnWriteDone(): NextWrite()에서 호출하는 StartWrite()에 의해 하나의 정보가 쓰여졌을 때 호출되는 callback이다. 이전의 전송이 성공적으로 되었는지 검사하고 다음 정보를 전송한다.
  • OnDone(): Stream 전송 완료를 의미하는 Finish()를 호출하면 불리는 callback이다. 해당 인스턴스의 사용이 종료되었다는 의미이므로 메모리를 해제한다.

Server 구현

class StockServiceImpl final : public StockService::CallbackService
{
public:
  ...
  ServerWriteReactor<::StockPriceResponse> *UpdateStockPrice(
      CallbackServerContext *context,
      const google::protobuf::Empty *empty) override
  {
    return new StockPriceWriteReactor(_mEventCount);
  }
  ...
};

gRPC 비동기 호출을 위한 서버는 StockService::Server가 아닌 StockService::CallbackService를 상속받아 구현한다. StockService::Server가 write stream에 전송할 내용을 쓰고 grpc::Status를 반환 하도록 하는 것과 달리 CallbackService는 앞서 정의한 ServerWriteReactor<StockPriceResponse>* type을 반환 하도록 정의 되어있다.

StockPriceReadReactor

StockPriceReadReactor는 클라이언트에서 동작하는 reactor이다.

class StockPriceReadReactor
    : public ::grpc::ClientReadReactor<::StockPriceResponse>
{
public:
  StockPriceReadReactor(
      std::shared_ptr<StockService::Stub> stub, std::shared_ptr<Publisher> pub);
  void OnReadDone(bool ok) override;
  void OnDone(const ::grpc::Status &s) override;
  ::grpc::Status Await();

private:
  std::shared_ptr<Publisher> _mPub;
  ::grpc::ClientContext _mContext;
  ::StockPriceResponse _mResp;

  std::mutex _mMtx;
  std::condition_variable _mCondVar;
  ::grpc::Status _mStatus;
  bool _mAllDone = false;
};
  • OnReadDone(): StartRead() 호출을 통해 서버로 부터 하나의 record인 주식 정보 업데이트를 받을 때 마다 호출되는 callback이다. 이것을 이용해 Observer pattern에서 event publisher가 자신에게 등록된 subscriber들에게 event를 notify하는 코드를 구현할 수 있다.
  • OnDone(): 서버로 부터 stream 종료를 받으면 호출되는 callback이다. Await()과 공유되는 condition_variable을 이용해 process가 종료 될 수 있도록 한다.
  • Await(): 비동기 호출은 multi threading을 전체 하므로, 이 함수는 서버로 부터 받는 stream이 종료될 때까지 main thread가 종료되지 않고 유지 되도록 해준다.
  • mutext와 condition_variable: 위에서 설명한 OnDone()과 Await()이 thread control을 할 수 있도록 해주는 동기화 변수 들이다.

Client 구현

class StockClient
{
public:
  ...
  void updateStockPrice()
  {
    StockPriceReadReactor reader(_mStub, _mPub);
    Status status = reader.Await();
    if (status.ok())
    {
      spdlog::info("PriceListing succeed.");
    }
    else
    {
      spdlog::error("Failed to get prices.");
      spdlog::error("{}({})", status.error_message(), status.error_code());
    }
  }
  ...
};

클라이언트 코드는 StockPriceReadReactor의 instance를 만들고 Await()을 호출해서 서버로 부터 전송이 완료되기를 기다린다. 그럼 서버쪽으로 “주식 가격 주세요”라는 request는 누가 날리냐고? StockPriceReadReactor의 생성자에 다음과 같이 stub에 UpdateStockPrice()를 호출하는 부분이 정의되어 있다.

StockPriceReadReactor::StockPriceReadReactor(
    std::shared_ptr<StockService::Stub> stub, std::shared_ptr<Publisher> pub)
    : _mPub(pub)
{

  ::google::protobuf::Empty empty;
  stub->async()->UpdateStockPrice(&_mContext, &empty, this);
  StartRead(&_mResp);
  StartCall();
}

동작 확인

Code repo: https://github.com/litcoder/grpcobsr

References

  • gRPC Long-lived Streaming using Observer Pattern: Java로 gRPC의 Observer pattern을 구현한 내용을 설명한 글이다. 사실 본 포스팅의 시작도 원래는 이 구현을 C++로 변경해 보고자 하는 의도였으나 안타깝게도 C++에서 사용할 수 없는 의존성 때문에 많은 부분을 새롭게 작성해야 했다.
  • Asynchronous Callback API Tutorial: gPRC에 대한 비동기 호출에 대해 예제를 포함해서 매우 자세히 설명한 글이다. Observer pattern을 직접 언급하고 있지는 않으나 활용도가 높은 Unary, Server-side streaming, Client-side streaming 그리고 Bidirectional streaming을 설명한다.
  • gRPC API reference: API들에 대한 설명을 찾아 볼 수 있다. 친절하게 설명된 문서는 아니지만 그래도 없는 것 보다는 뭐…

아마도 비슷한 글:

  1. Linux에서 메모리 포인터의 유효성 검증
  2. C++ template 선언과 구현을 서로 다른 파일에 나눌 수 없다
  3. C++에서 오버라이드된 함수가 안불러져요
  4. Union을 이용한 byte 단위 접근

Union을 이용한 byte 단위 접근

댓글 남기기

Big-endian으로 주어진 byte들을 little-endian으로 변환해야 하는 문제가 생겼다. Byte들의 order를 거꾸로 만드는 것은 어렵지 않지만 그러기 위해서는 byte pointer가 가리키는 element들을 1 byte 단위로 접근해야 한다. 1 byte씩 뒤집은 다음에는 변환된 array를 원하는 크기의 타입으로 읽도록 type casting을 해주어야 한다.

Union을 이용하면 코드를 못생기게 만드는 pointer 직접 연산이나 type casting을 하지 않고 이를 구현할 수 있다. 즉 union은 선언된 element의 가장 큰 크기 만큼의 메모리가 할당 되므로 같은 크기의 두 element를 서로 다른 data type으로 선언하는 것이다.

union
{
  int32_t v;
  uint8_t b[4];
} value;

위와 같이 선언하면 value.v = 0xdeadbeef 같은 식으로 int32를 쓰거나 읽을 수 있고 value.b[0] 같이 각 메모리 index에 접근 할 수 있다.

Template으로 만들어서 여러 타입에 대응 할 수 있다.

    template <typename T> T readFromBigEndian(uint8_t *b)
    {
      union
      {
        T v;
        uint8_t b[sizeof(T)];
      } dest;

      union
      {
        T v;
        uint8_t *b;
      } src;

      src.b = b;
      for (int i = 0; i < sizeof(T); ++i)
      {
        dest.b[i] = src.b[sizeof(T) - i - 1];
      }
      return dest.v;
    }

아마도 비슷한 글:

  1. C++ template 선언과 구현을 서로 다른 파일에 나눌 수 없다
  2. Linux에서 메모리 포인터의 유효성 검증
  3. 연관 컨테이너에 find_if()를 쓴다구요?
  4. C++에서 오버라이드된 함수가 안불러져요