inteintegrity2026-11-18

FlipCTL auf reComputer RK3576: Fernoberfläche und Apps

FlipCTL von Flipper One und Hello World auf reComputer RK3576 mit Armbian ausführen. Nativ bauen und die Browsersteuerung über SSH testen.

FlipCTLFlipper OneLinuxGitHub

Projektergebnis

Dieses Projekt führt die FlipCTL-Oberfläche von Flipper One und die offizielle Anwendung Hello World auf Seeed Studio reComputer RK3576 mit Armbian Linux aus. Kompilieren Sie die Laufzeit mit App-Unterstützung einmal, verbinden Sie sich im PC-Browser und prüfen Sie Geräteinformationen und App-Steuerung.

Das Bild zeigt die funktionierende Fernverbindung: Nach dreimaligem Drücken von Enter gilt Presses = 3 und Progress = 30%.

Hello World in FlipCTL auf reComputer RK3576 mit Presses bei 3 und Progress bei 30 %

Voraussetzungen

BestandteilVoraussetzung
GerätreComputer RK3576 / RK3576 DevKit
BetriebssystemArmbian für ARM64; die geprüfte Umgebung verwendet Debian Bookworm mit glibc 2.36
Quellcode und Build-WerkzeugeRust 1.92 oder neuer für Slint 1.17; native Werkzeuge werden in Schritt 1 installiert
NetzwerkSSH-Zugriff vom PC sowie Zugriff auf Rust-Crates und GitHub-Release-Downloads
PCSSH-Client und Webbrowser

Die Befehle verwenden seeed als beispielhaften Linux-Benutzernamen und ~/flipper-test/flipctl-slint als Quellcodeverzeichnis. Passen Sie diese Angaben an Ihre Installation an. Ersetzen Sie <BOARD_IP> durch die tatsächliche IP-Adresse des Boards, ohne die spitzen Klammern.

Ausführungsort der Befehle: SSH-Verbindungen und Tunnel werden auf Ihrem PC eingerichtet. Paketinstallation, Kompilierung, Paketierung und FlipCTL-Start erfolgen im SSH-Terminal des Boards mit Ihrem normalen Linux-Benutzer.

Schritt 1: Board und Rust-Toolchain vorbereiten

Verbinden Sie sich auf Ihrem PC mit dem Board:

powershell
ssh seeed@<BOARD_IP>

Installieren Sie im SSH-Terminal des Boards Sway für die Ausführung von Wayland-Anwendungen ohne Display, FUSE-Unterstützung und die Paketierungswerkzeuge:

bash
sudo apt update
sudo apt install -y \
  git curl ca-certificates file build-essential pkg-config \
  sway fuse3 desktop-file-utils python3 binutils

Prüfen Sie Compositor, Architektur und die C-Bibliothek des Systems:

bash
sway --version
uname -m
getconf GNU_LIBC_VERSION

Die Architektur sollte aarch64 sein. Auf dem geprüften Bookworm-System zeigt getconf den Wert glibc 2.36.

FlipCTL startet eine eigene Sway-Sitzung ohne Display für Anwendungen. Behalten Sie die vorhandene Desktop-Umgebung des Boards bei; eine Anmeldung an einem Sway-Desktop ist nicht erforderlich.

Prüfen Sie die Rust-Toolchain:

bash
rustc --version
cargo --version

Slint 1.17 benötigt Rust 1.92 oder neuer. Wenn bereits eine kompatible Rust-Version installiert ist, fahren Sie mit Schritt 2 fort; die folgenden Befehle zur Installation von rustup und zum Laden der Umgebung sind dann nicht erforderlich. Falls Rust fehlt oder zu alt ist, installieren Sie eine aktuelle Version über rustup:

bash
curl --proto '=https' --tlsv1.2 -sSf \
  https://sh.rustup.rs -o /tmp/rustup-init.sh
sh /tmp/rustup-init.sh

Folgen Sie den Anweisungen des Installationsprogramms. Laden Sie anschließend die Shell-Umgebung neu und prüfen Sie die Versionen:

bash
source "$HOME/.cargo/env"
rustc --version
cargo --version

Schritt 2: Quellcode laden und FlipCTL kompilieren

Beenden Sie vor dem erneuten Kompilieren eine laufende FlipCTL-Instanz. Läuft sie in einem Terminal, drücken Sie dort Ctrl+C. Wurde sie im Hintergrund gestartet, ermitteln und beenden Sie zuerst den betreffenden FlipCTL-Prozess.

Nutzen Sie bei einer neuen Einrichtung die folgenden Klonbefehle. Existiert ~/flipper-test/flipctl-slint bereits, verwenden Sie das Verzeichnis weiter und prüfen Sie git rev-parse HEAD, statt erneut zu klonen. Fahren Sie nur mit Revision 8aeb387dc4d13fcef9056267b2a3dd7409099834 fort.

Erstellen Sie ein eigenes Arbeitsverzeichnis:

bash
mkdir -p ~/flipper-test
cd ~/flipper-test

Klonen Sie die offizielle FlipCTL-Slint-Implementierung:

bash
git clone --recurse-submodules --branch dev \
  https://github.com/flipperdevices/flipctl-slint.git

cd flipctl-slint
git checkout --detach 8aeb387dc4d13fcef9056267b2a3dd7409099834
git submodule update --init --recursive

Der Checkout legt den Quellcode auf den Commit fest, der für die Überprüfung dieses Projekts auf dem Board verwendet wurde. Spätere Änderungen an dev verändern dadurch die Build-Bedingungen nicht. Die detached-HEAD-Meldung von Git ist hier normal.

Das Repository enthält den Cargo.toml-Workspace, den Quellcode der ausführbaren FlipCTL-Datei unter bin/flipctl und die Browser-Ressourcen unter crates/flipper-ui/assets/remote.

Führen Sie build_deploy.sh oder run_me.sh nicht auf reComputer RK3576 aus. Diese Skripte sind für Flipper-One-Hardware vorgesehen und installieren Systemdienste oder starten sie neu. Dieses Projekt kompiliert und startet die ausführbare Datei direkt, ohne den Armbian-Bootloader oder vorhandene Dienste zu verändern.

Kompilieren Sie FlipCTL und ergänzen Sie die Features um wayland:

bash
cd ~/flipper-test/flipctl-slint

export CARGO_PROFILE_RELEASE_LTO=false
export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=16

cargo build --locked --release -p flipctl \
  --features device,slint,remote,wayland
FeatureAufgabe
deviceAktiviert gerätebezogene Laufzeitfunktionen
slintAktiviert die grafische Oberfläche
remoteAktiviert Anzeige und Steuerung im Browser
waylandAktiviert die Ausführung grafischer Anwendungen und die Erkennung von AppImages

Warten Sie auf den erfolgreichen Abschluss von Cargo, bevor Sie fortfahren.

Optional: Ein Testbild rendern

Vor dem Start der Weboberfläche können Sie den UI-Renderer prüfen:

bash
./target/release/flipctl \
  --png /tmp/flipctl-test.png \
  --screen main

file /tmp/flipctl-test.png

Bei Erfolg wird eine PNG-Datei unter /tmp/flipctl-test.png erstellt.

Schritt 3: Hello World bauen und installieren

Kompilieren Sie Hello World aus demselben Quellcode. Ein vorgefertigtes AppImage kann eine neuere glibc voraussetzen, als das Board bereitstellt: Ein Paket mit der Anforderung GLIBC_2.39 beendet sich auf dem getesteten Bookworm-System mit glibc 2.36 sofort. Das Kompilieren auf dem Board vermeidet diese Inkompatibilität für diese Anwendung.

Anwendung kompilieren

Verwenden Sie weiterhin das SSH-Terminal des Boards und die Build-Einstellungen aus Schritt 2:

bash
cd ~/flipper-test/flipctl-slint
export CARGO_TARGET_DIR="$PWD/target"

cargo build --locked --release --manifest-path apps/hello/Cargo.toml

Prüfen Sie die höchste glibc-Symbolversion, die die Binärdatei benötigt:

bash
readelf --version-info target/release/hello-app \
  | grep -oE 'GLIBC_[0-9.]+' | sort -Vu | tail -n 1

Der geprüfte native Build benötigt höchstens GLIBC_2.35 und läuft mit glibc 2.36 auf dem Board. Falls Ihr Ergebnis eine neuere Version als die des Boards voraussetzt, beheben Sie die Abweichung in Toolchain oder Build-Umgebung vor der Paketierung.

AppImage-Werkzeuge vorbereiten

Laden Sie nur das ARM64-Paketierungswerkzeug und die Laufzeit aus der tools.lock des Quellcodes herunter. Der folgende Block prüft ihre SHA256-Werte und verwendet passende zwischengespeicherte Dateien erneut:

bash
(
  set -eu
  cd ~/flipper-test/flipctl-slint
  mkdir -p target/appimage/tools

  while read -r name url checksum; do
    case "$name" in
      appimagetool-aarch64|runtime-aarch64)
        tool="target/appimage/tools/$name"
        if [ ! -f "$tool" ] || ! printf '%s  %s\n' "$checksum" "$tool" | sha256sum -c --status; then
          curl -fL --retry 3 --connect-timeout 20 --max-time 180 \
            -o "$tool" "$url"
        fi
        printf '%s  %s\n' "$checksum" "$tool" | sha256sum -c -
        chmod +x "$tool"
        ;;
    esac
  done < tools/appimage/tools.lock
)

Fahren Sie erst fort, wenn die Prüfsummen beider Werkzeuge stimmen. Schlagen Downloads fehl, stellen Sie den Zugriff auf die Release-Dateien wieder her und führen Sie diesen Block erneut aus.

AppImage erstellen und installieren

Erstellen Sie das AppImage mit dem offiziellen Staging-Skript und den geprüften Werkzeugen:

bash
(
  set -eu
  cd ~/flipper-test/flipctl-slint

  python3 tools/appimage/bundle.py stage \
    apps/hello target/appimage/hello-bookworm/AppDir \
    --binary "$PWD/target/release/hello-app" \
    --version "$(git rev-parse --short HEAD)-bookworm" \
    --repo "$PWD"

  rm -f -- target/appimage/hello-bookworm-aarch64.fap.AppImage

  SOURCE_DATE_EPOCH="$(git log -1 --format=%ct)" ARCH=aarch64 \
    target/appimage/tools/appimagetool-aarch64 --appimage-extract-and-run \
    -n --comp zstd \
    --mksquashfs-opt -Xcompression-level --mksquashfs-opt 19 \
    --runtime-file "$PWD/target/appimage/tools/runtime-aarch64" \
    "$PWD/target/appimage/hello-bookworm/AppDir" \
    "$PWD/target/appimage/hello-bookworm-aarch64.fap.AppImage"

  sha256sum target/appimage/hello-bookworm-aarch64.fap.AppImage
)

Warten Sie, bis die Paketierung Success und den SHA256-Wert der Ausgabedatei anzeigt. Installieren Sie diese anschließend unter ~/Apps. Falls bereits ein Hello-World-Paket vorhanden ist, sichert der folgende Block es vor dem Ersetzen außerhalb von ~/Apps:

bash
(
  set -eu
  cd ~/flipper-test/flipctl-slint
  mkdir -p "$HOME/Apps" "$HOME/.local/share/flipctl-app-backups"

  if [ -f "$HOME/Apps/hello-aarch64.fap.AppImage" ]; then
    backup_dir="$(mktemp -d "$HOME/.local/share/flipctl-app-backups/hello-XXXXXXXX")"
    cp -p "$HOME/Apps/hello-aarch64.fap.AppImage" "$backup_dir/"
  fi

  install -m 755 target/appimage/hello-bookworm-aarch64.fap.AppImage \
    "$HOME/Apps/.hello-installing"
  mv -- "$HOME/Apps/.hello-installing" "$HOME/Apps/hello-aarch64.fap.AppImage"
  ls -lh "$HOME/Apps/hello-aarch64.fap.AppImage"
)

Die Sicherung liegt unter ~/.local/share/flipctl-app-backups/. Bewahren Sie in ~/Apps nur die gewünschte installierte Kopie auf, damit im Anwendungsstarter keine doppelten Einträge erscheinen.

Schritt 4: FlipCTL mit Pixman-Rendering starten

Prüfen Sie zuerst Port 8899 auf dem Board:

bash
ss -ltnp 'sport = :8899'

Falls bereits ein Prozess lauscht, beheben Sie zunächst den Konflikt. Beenden Sie eine ältere FlipCTL-Instanz, bevor Sie eine neue starten. Ist der lauschende Prozess ssh, prüfen Sie, ob der Weiterleitungsbefehl versehentlich auf dem Board ausgeführt wurde, und beenden Sie diesen falschen Tunnel.

Starten Sie FlipCTL mit Pixman-Softwarerendering für den App-Compositor:

bash
cd ~/flipper-test/flipctl-slint

WLR_RENDERER=pixman ./target/release/flipctl \
  --headless \
  --remote 127.0.0.1:8899 \
  --assets "$PWD/crates/flipper-ui/assets/remote"

WLR_RENDERER=pixman gilt für diesen Prozess und seinen untergeordneten Compositor. Damit wird der im getesteten RK3576-Aufbau aufgetretene GPU-Allokatorfehler vermieden, ohne die Desktop-Konfiguration des Systems zu ändern.

Prüfen Sie, ob das Startprotokoll folgende Zeile enthält:

text
remote view    http://127.0.0.1:8899/

Erscheint stattdessen not serving ... Address already in use, wurde der Browserdienst nicht gestartet. Eine apps-Liste oder die Meldung first frame committed allein bestätigt nicht, dass der Webdienst verfügbar ist.

Lassen Sie dieses Terminal während der Verwendung von FlipCTL geöffnet.

Schritt 5: Verbinden und die Fernoberfläche erkunden

Falls der vorhandene SSH-Tunnel auf dem PC noch läuft, verwenden Sie ihn weiter. Andernfalls öffnen Sie ein weiteres Terminal auf dem PC, unter Windows PowerShell, und führen Folgendes aus:

powershell
ssh -N -o ExitOnForwardFailure=yes -o ServerAliveInterval=30 -L 127.0.0.1:8899:127.0.0.1:8899 seeed@<BOARD_IP>

Führen Sie diesen Weiterleitungsbefehl auf dem PC aus, nicht innerhalb einer SSH-Sitzung auf dem Board. Nach der Authentifizierung erscheint wegen -N keine Shell-Eingabeaufforderung; lassen Sie das Fenster geöffnet. Ist Port 8899 auf dem PC bereits belegt, prüfen Sie vor einem weiteren Start, ob schon ein Tunnel besteht.

Öffnen Sie http://127.0.0.1:8899 im Browser des PCs. Warten Sie auf Status: connected und aktivieren Sie dann Show controls.

FlipCTL-Fernoberfläche auf reComputer RK3576

Geräteinformationen überprüfen

Prüfen Sie Hostname und Netzwerkinformationen in der Oberfläche. Vergleichen Sie diese Werte in einem weiteren SSH-Terminal mit der Ausgabe folgender Befehle:

bash
hostname
hostname -I
uname -r
df -h /

Stellen Sie sicher, dass Hostname und Ethernet-Adresse in der Oberfläche mit der Befehlsausgabe übereinstimmen. Wenn der Hostname des Geräts beispielsweise recomputer-rk3576-devkit lautet, sollte die Oberfläche denselben Namen anzeigen.

Sie können auch folgende Menüpunkte zur reinen Informationsanzeige aufrufen:

  • Settings → System info
  • Settings → Disk info
  • Network → Ethernet

Welche Menüs verfügbar sind, hängt von der Quellcodeversion und dem zugrunde liegenden Linux-System ab.

Warten Sie nach dem Öffnen einer Detailseite, bis die Informationen geladen sind. Vor der ersten Aktualisierung können Werte kurzzeitig als - oder 0 erscheinen.

Kehren Sie nach der Prüfung der Geräteinformationen zum FlipCTL-Startbildschirm zurück, bevor Sie den nächsten Schritt beginnen.

Schritt 6: Hello World starten und testen

  1. Klicken Sie auf dem FlipCTL-Startbildschirm auf X, den Softkey für Menu.
  2. Wählen Sie mit ↑ / ↓ den Eintrag Apps und drücken Sie Enter.
  3. Wählen Sie Hello World und drücken Sie erneut Enter.
  4. Warten Sie, bis die Anwendung vollständig geöffnet ist. Hello, Flipper One!, Presses und Progress sollten erscheinen.

Drücken Sie dreimal Enter. Presses sollte von 0 auf 3 steigen und der Fortschrittsbalken wie im Ergebnisbild am Projektanfang zu 30 % gefüllt sein.

BedienelementAktion
Enter oder AddErhöht den Zähler um eins und den Fortschrittsbalken um 10 Prozentpunkte, bis er voll ist
DrawWechselt zur Zeichenseite der Anwendung
CloseBeendet die Anwendung
BackKehrt je nach Kontext zum vorherigen FlipCTL-Bildschirm zurück oder verschiebt die Anwendung in den Hintergrund