inteintegrity2026-11-18

FlipCTL sur reComputer RK3576 : interface distante et applications

Exécutez FlipCTL de Flipper One et Hello World sur reComputer RK3576 avec Armbian. Compilez sur la carte et testez les commandes du navigateur via SSH.

FlipCTLFlipper OneLinuxGitHub

Résultat du projet

Ce projet exécute l’interface FlipCTL de Flipper One et l’application officielle Hello World sur Seeed Studio reComputer RK3576 sous Armbian Linux. Compilez une seule fois le runtime avec la prise en charge des applications, connectez-vous depuis le navigateur du PC, puis vérifiez les informations de l’appareil et les commandes de l’application.

L’image présente une connexion distante fonctionnelle : après trois appuis sur Enter, Presses = 3 et Progress = 30%.

Hello World dans FlipCTL sur reComputer RK3576, avec Presses à 3 et Progress à 30 %

Prérequis

ÉlémentPrérequis
AppareilreComputer RK3576 / RK3576 DevKit
Système d’exploitationArmbian ARM64 ; l’environnement vérifié utilise Debian Bookworm avec glibc 2.36
Code source et outilsRust 1.92 ou ultérieur pour Slint 1.17 ; installez les outils natifs à l’étape 1
RéseauAccès SSH depuis le PC, ainsi qu’aux crates Rust et aux fichiers des versions publiées sur GitHub
PCUn client SSH et un navigateur web

Les commandes utilisent seeed comme exemple de nom d’utilisateur Linux et ~/flipper-test/flipctl-slint comme répertoire du code source. Adaptez-les à votre installation. Remplacez <BOARD_IP> par l’adresse IP réelle de la carte, sans conserver les chevrons.

Où exécuter les commandes : Les commandes de connexion SSH et du tunnel s’exécutent sur votre PC. L’installation des paquets, la compilation, la création du paquet et le démarrage de FlipCTL s’effectuent dans le terminal SSH de la carte, avec votre utilisateur Linux habituel.

Étape 1 : Préparer la carte et la chaîne d’outils Rust

Sur votre PC, connectez-vous à la carte :

powershell
ssh seeed@<BOARD_IP>

Dans le terminal SSH de la carte, installez Sway pour héberger les applications Wayland sans écran, la prise en charge de FUSE et les outils de création des paquets :

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

Vérifiez le compositeur, l’architecture et la bibliothèque C du système :

bash
sway --version
uname -m
getconf GNU_LIBC_VERSION

L’architecture doit être aarch64. Sur le système Bookworm vérifié, getconf affiche glibc 2.36.

FlipCTL démarre sa propre session Sway sans écran pour les applications. Conservez l’environnement de bureau existant de la carte ; vous n’avez pas besoin d’ouvrir une session de bureau Sway.

Vérifiez la chaîne d’outils Rust :

bash
rustc --version
cargo --version

Slint 1.17 nécessite Rust 1.92 ou une version ultérieure. Si une version compatible de Rust est déjà installée, passez à l’étape 2 ; les commandes d’installation de rustup et de chargement de l’environnement ci-dessous ne sont pas nécessaires. Si Rust est absent ou trop ancien, installez une version actuelle avec rustup :

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

Suivez les instructions de l’installateur, puis rechargez l’environnement du shell et vérifiez les versions :

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

Étape 2 : Obtenir le code et compiler FlipCTL

Arrêtez toute instance de FlipCTL avant de recompiler. Si elle s’exécute dans un terminal, appuyez sur Ctrl+C dans ce terminal. Si elle a été lancée en arrière-plan, identifiez et arrêtez d’abord le processus FlipCTL concerné.

Pour une nouvelle installation, utilisez les commandes ci-dessous. Si ~/flipper-test/flipctl-slint existe déjà, réutilisez-le et vérifiez git rev-parse HEAD au lieu de le cloner à nouveau. Ne poursuivez qu’avec la révision 8aeb387dc4d13fcef9056267b2a3dd7409099834.

Créez un répertoire de travail dédié :

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

Clonez l’implémentation officielle de FlipCTL Slint :

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

Cette commande checkout fixe le code source au commit utilisé pour la vérification de ce projet sur la carte. Les mises à jour ultérieures de dev ne changent donc pas les conditions de compilation. Le message detached HEAD de Git est normal ici.

Le dépôt contient l’espace de travail Cargo.toml, le code source de l’exécutable FlipCTL dans bin/flipctl et les ressources du navigateur dans crates/flipper-ui/assets/remote.

N’exécutez pas build_deploy.sh ni run_me.sh sur reComputer RK3576. Ces scripts sont destinés au matériel Flipper One et installent ou redémarrent des services système. Ce projet compile et lance directement l’exécutable, sans modifier le chargeur d’amorçage d’Armbian ni les services existants.

Compilez FlipCTL en ajoutant wayland aux fonctionnalités :

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
FonctionnalitéRôle
deviceActive les fonctions d’exécution liées à l’appareil
slintActive l’interface graphique
remoteActive l’affichage et les commandes dans le navigateur
waylandActive l’hébergement d’applications graphiques et la détection des AppImages

Attendez que Cargo termine correctement avant de poursuivre.

Facultatif : Générer une image de test

Avant de lancer l’interface web, vous pouvez vérifier le moteur de rendu de l’interface :

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

file /tmp/flipctl-test.png

En cas de réussite, un fichier PNG est créé à l’emplacement /tmp/flipctl-test.png.

Étape 3 : Compiler et installer Hello World

Compilez Hello World à partir de la même copie du code source. Un AppImage précompilé peut nécessiter une glibc plus récente que celle de la carte : un paquet exigeant GLIBC_2.39 se ferme immédiatement sur le système Bookworm testé avec glibc 2.36. Compiler sur la carte évite cette incompatibilité pour cette application.

Compiler l’application

Continuez à utiliser le terminal SSH de la carte et les paramètres de compilation de l’étape 2 :

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

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

Vérifiez la version la plus élevée des symboles glibc requise par le binaire :

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

La compilation native vérifiée nécessite au maximum GLIBC_2.35 et fonctionne avec la glibc 2.36 de la carte. Si votre résultat exige une version plus récente que celle disponible sur la carte, résolvez l’incompatibilité de la chaîne d’outils ou de l’environnement de compilation avant de créer le paquet.

Préparer les outils AppImage

Téléchargez uniquement l’outil de création de paquets ARM64 et le runtime indiqués dans le fichier tools.lock du code source. Le bloc suivant vérifie leurs valeurs SHA256 et réutilise les copies en cache lorsqu’elles correspondent :

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
)

Ne poursuivez qu’après la vérification réussie des deux outils. Si les téléchargements échouent, rétablissez l’accès aux fichiers des versions publiées, puis relancez ce bloc.

Créer et installer l’AppImage

Utilisez le script officiel de préparation et les outils vérifiés pour créer l’AppImage :

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
)

Attendez que la création du paquet affiche Success et le SHA256 du fichier généré. Installez-le ensuite dans ~/Apps. Si un paquet Hello World existe déjà, le bloc suivant le sauvegarde hors de ~/Apps avant de le remplacer :

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

La sauvegarde est enregistrée sous ~/.local/share/flipctl-app-backups/. Ne conservez dans ~/Apps que la copie installée que vous souhaitez utiliser, afin d’éviter les entrées en double dans le lanceur.

Étape 4 : Démarrer FlipCTL avec le rendu Pixman

Vérifiez d’abord le port 8899 sur la carte :

bash
ss -ltnp 'sport = :8899'

Si un processus est déjà à l’écoute, résolvez d’abord ce conflit. Arrêtez une ancienne instance de FlipCTL avant d’en lancer une autre. Si le processus est ssh, vérifiez si une commande de transfert a été exécutée par erreur sur la carte et fermez ce tunnel incorrect.

Démarrez FlipCTL avec le rendu logiciel Pixman pour son compositeur d’applications :

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 s’applique à ce processus et à son compositeur enfant. Ce réglage évite l’échec de l’allocateur GPU rencontré sur le RK3576 testé, sans modifier la configuration du bureau système.

Vérifiez que le journal de démarrage contient :

text
remote view    http://127.0.0.1:8899/

Si le message indique plutôt not serving ... Address already in use, le service du navigateur n’a pas démarré. La liste apps ou le message first frame committed ne suffisent pas à confirmer la disponibilité du service web.

Gardez ce terminal ouvert pendant l’utilisation de FlipCTL.

Étape 5 : Se connecter et explorer l’interface distante

Si le tunnel SSH existant du PC fonctionne encore, réutilisez-le. Sinon, ouvrez un autre terminal sur le PC, PowerShell sous Windows, et exécutez :

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

Exécutez cette commande de transfert sur le PC, et non dans une session SSH déjà connectée à la carte. Après l’authentification, aucune invite de commande n’apparaît en raison de -N ; gardez la fenêtre ouverte. Si le port 8899 du PC est déjà occupé, vérifiez la présence d’un tunnel existant avant d’en lancer un autre.

Ouvrez http://127.0.0.1:8899 dans le navigateur du PC. Attendez Status: connected, puis activez Show controls.

Interface distante FlipCTL sur reComputer RK3576

Vérifier les informations de l’appareil

Consultez le nom d’hôte et les informations réseau dans l’interface. Dans un autre terminal SSH, comparez ces valeurs avec la sortie des commandes suivantes :

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

Vérifiez que le nom d’hôte et l’adresse Ethernet de l’interface correspondent à la sortie des commandes. Par exemple, si le nom d’hôte de l’appareil est recomputer-rk3576-devkit, l’interface doit afficher ce même nom.

Vous pouvez également consulter des entrées de menu en lecture seule, telles que :

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

La disponibilité des menus dépend de la version du code source et du système Linux sous-jacent.

Après l’ouverture d’une page de détails, attendez la fin du chargement des informations. Certaines valeurs peuvent brièvement afficher - ou 0 avant la première mise à jour.

Après avoir vérifié les informations, revenez à l’écran d’accueil de FlipCTL avant l’étape suivante.

Étape 6 : Lancer et tester Hello World

  1. Sur l’écran d’accueil de FlipCTL, cliquez sur X, la touche contextuelle correspondant à Menu.
  2. Utilisez ↑ / ↓ pour sélectionner Apps, puis appuyez sur Enter.
  3. Sélectionnez Hello World et appuyez à nouveau sur Enter.
  4. Attendez la fin du démarrage de l’application. Hello, Flipper One!, Presses et Progress doivent s’afficher.

Appuyez trois fois sur Enter. Presses doit passer de 0 à 3 et la barre doit se remplir à 30 %, comme sur l’image de résultat au début du projet.

CommandeAction
Enter ou AddAugmente le compteur de un et la progression de 10 points de pourcentage, jusqu’à remplir la barre
DrawPasse à la page de dessin de l’application
CloseFerme l’application
BackRevient à l’écran FlipCTL précédent ou place l’application en arrière-plan, selon le contexte