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%.

Prérequis
| Élément | Prérequis |
|---|---|
| Appareil | reComputer RK3576 / RK3576 DevKit |
| Système d’exploitation | Armbian ARM64 ; l’environnement vérifié utilise Debian Bookworm avec glibc 2.36 |
| Code source et outils | Rust 1.92 ou ultérieur pour Slint 1.17 ; installez les outils natifs à l’étape 1 |
| Réseau | Accès SSH depuis le PC, ainsi qu’aux crates Rust et aux fichiers des versions publiées sur GitHub |
| PC | Un 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 :
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 :
sudo apt update
sudo apt install -y \
git curl ca-certificates file build-essential pkg-config \
sway fuse3 desktop-file-utils python3 binutilsVérifiez le compositeur, l’architecture et la bibliothèque C du système :
sway --version
uname -m
getconf GNU_LIBC_VERSIONL’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 :
rustc --version
cargo --versionSlint 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 :
curl --proto '=https' --tlsv1.2 -sSf \
https://sh.rustup.rs -o /tmp/rustup-init.sh
sh /tmp/rustup-init.shSuivez les instructions de l’installateur, puis rechargez l’environnement du shell et vérifiez les versions :
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é :
mkdir -p ~/flipper-test
cd ~/flipper-testClonez l’implémentation officielle de FlipCTL Slint :
git clone --recurse-submodules --branch dev \
https://github.com/flipperdevices/flipctl-slint.git
cd flipctl-slint
git checkout --detach 8aeb387dc4d13fcef9056267b2a3dd7409099834
git submodule update --init --recursiveCette 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.shnirun_me.shsur 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 :
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 |
|---|---|
device | Active les fonctions d’exécution liées à l’appareil |
slint | Active l’interface graphique |
remote | Active l’affichage et les commandes dans le navigateur |
wayland | Active 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 :
./target/release/flipctl \
--png /tmp/flipctl-test.png \
--screen main
file /tmp/flipctl-test.pngEn 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 :
cd ~/flipper-test/flipctl-slint
export CARGO_TARGET_DIR="$PWD/target"
cargo build --locked --release --manifest-path apps/hello/Cargo.tomlVérifiez la version la plus élevée des symboles glibc requise par le binaire :
readelf --version-info target/release/hello-app \
| grep -oE 'GLIBC_[0-9.]+' | sort -Vu | tail -n 1La 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 :
(
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 :
(
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 :
(
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 :
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 :
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 :
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 :
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.

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 :
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
- Sur l’écran d’accueil de FlipCTL, cliquez sur X, la touche contextuelle correspondant à Menu.
- Utilisez ↑ / ↓ pour sélectionner Apps, puis appuyez sur Enter.
- Sélectionnez Hello World et appuyez à nouveau sur Enter.
- 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.
| Commande | Action |
|---|---|
| Enter ou Add | Augmente le compteur de un et la progression de 10 points de pourcentage, jusqu’à remplir la barre |
| Draw | Passe à la page de dessin de l’application |
| Close | Ferme l’application |
| Back | Revient à l’écran FlipCTL précédent ou place l’application en arrière-plan, selon le contexte |