Resultado del proyecto
Este proyecto ejecuta la interfaz FlipCTL de Flipper One y la aplicación oficial Hello World en Seeed Studio reComputer RK3576 con Armbian Linux. Compila una sola vez el entorno con soporte de aplicaciones, conéctate desde el navegador del PC y comprueba la información del dispositivo y los controles de la aplicación.
La imagen muestra la conexión remota funcionando: tras pulsar Enter tres veces, Presses = 3 y Progress = 30%.

Requisitos previos
| Elemento | Requisito |
|---|---|
| Dispositivo | reComputer RK3576 / RK3576 DevKit |
| Sistema operativo | Armbian ARM64; el entorno verificado utiliza Debian Bookworm con glibc 2.36 |
| Código fuente y herramientas | Rust 1.92 o posterior para Slint 1.17; instala las herramientas nativas en el paso 1 |
| Red | Acceso SSH desde el PC y acceso a crates de Rust y descargas de versiones de GitHub |
| PC | Un cliente SSH y un navegador web |
Los comandos utilizan seeed como nombre de usuario Linux y ~/flipper-test/flipctl-slint como directorio del código fuente. Adáptalos a tu instalación. Sustituye <BOARD_IP> por la dirección IP real de la placa, sin conservar los signos < y >.
Dónde ejecutar los comandos: Los comandos de conexión SSH y del túnel se ejecutan en el PC. La instalación de paquetes, la compilación, el empaquetado y el inicio de FlipCTL se realizan en el terminal SSH de la placa, con tu usuario Linux habitual.
Paso 1: Preparar la placa y la cadena de herramientas Rust
En el PC, conéctate a la placa:
ssh seeed@<BOARD_IP>En el terminal SSH de la placa, instala Sway para alojar aplicaciones Wayland sin pantalla, el soporte FUSE y las herramientas de empaquetado:
sudo apt update
sudo apt install -y \
git curl ca-certificates file build-essential pkg-config \
sway fuse3 desktop-file-utils python3 binutilsComprueba el compositor, la arquitectura y la biblioteca C del sistema:
sway --version
uname -m
getconf GNU_LIBC_VERSIONLa arquitectura debe ser aarch64. En el sistema Bookworm verificado, getconf muestra glibc 2.36.
FlipCTL inicia su propia sesión Sway sin pantalla para las aplicaciones. Conserva el entorno de escritorio existente de la placa; no necesitas iniciar sesión en un escritorio Sway.
Comprueba la cadena de herramientas Rust:
rustc --version
cargo --versionSlint 1.17 requiere Rust 1.92 o posterior. Si ya tienes una versión compatible de Rust, continúa con el paso 2; no necesitas ejecutar los comandos de instalación de rustup ni de carga del entorno que aparecen a continuación. Si Rust no está instalado o es demasiado antiguo, instala una versión actual mediante rustup:
curl --proto '=https' --tlsv1.2 -sSf \
https://sh.rustup.rs -o /tmp/rustup-init.sh
sh /tmp/rustup-init.shSigue las indicaciones del instalador y, al terminar, vuelve a cargar el entorno de la shell y confirma las versiones:
source "$HOME/.cargo/env"
rustc --version
cargo --versionPaso 2: Obtener el código y compilar FlipCTL
Detén cualquier instancia de FlipCTL antes de volver a compilar. Si se ejecuta en un terminal, pulsa Ctrl+C en ese terminal. Si se inició en segundo plano, identifica y detén primero ese proceso de FlipCTL.
Para una instalación nueva, usa los comandos siguientes. Si ya existe ~/flipper-test/flipctl-slint, reutilízalo y comprueba git rev-parse HEAD en lugar de clonarlo otra vez. Continúa solo con la revisión 8aeb387dc4d13fcef9056267b2a3dd7409099834.
Crea un directorio de trabajo dedicado:
mkdir -p ~/flipper-test
cd ~/flipper-testClona la implementación oficial 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 --recursiveEste checkout fija el código en el commit utilizado para verificar el tutorial en la placa, de modo que las futuras actualizaciones de dev no cambien las condiciones de compilación. El mensaje detached HEAD de Git es normal en este caso.
El repositorio contiene el espacio de trabajo Cargo.toml, el código del ejecutable FlipCTL en bin/flipctl y los recursos del navegador en crates/flipper-ui/assets/remote.
No ejecutes
build_deploy.shnirun_me.shen reComputer RK3576. Estos scripts están destinados al hardware Flipper One e instalan o reinician servicios del sistema. Este proyecto compila e inicia directamente el ejecutable, sin modificar el cargador de arranque de Armbian ni los servicios existentes.
Compila FlipCTL añadiendo wayland a las funcionalidades:
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| Funcionalidad | Propósito |
|---|---|
device | Activa las funciones de ejecución relacionadas con el dispositivo |
slint | Activa la interfaz gráfica |
remote | Activa la visualización y el control desde el navegador |
wayland | Activa el alojamiento de aplicaciones gráficas y la detección de AppImages |
Espera a que Cargo termine correctamente antes de continuar.
Opcional: Renderizar una imagen de prueba
Antes de iniciar la interfaz web, puedes comprobar el renderizador de la interfaz:
./target/release/flipctl \
--png /tmp/flipctl-test.png \
--screen main
file /tmp/flipctl-test.pngSi todo funciona, se creará un archivo PNG en /tmp/flipctl-test.png.
Paso 3: Compilar e instalar Hello World
Compila Hello World desde la misma copia del código fuente. Un AppImage precompilado puede requerir una glibc más reciente que la de la placa: un paquete que necesita GLIBC_2.39 se cierra inmediatamente en el sistema Bookworm probado con glibc 2.36. Compilar en la placa evita esa incompatibilidad para esta aplicación.
Compilar la aplicación
Sigue utilizando el terminal SSH de la placa y la configuración de compilación del paso 2:
cd ~/flipper-test/flipctl-slint
export CARGO_TARGET_DIR="$PWD/target"
cargo build --locked --release --manifest-path apps/hello/Cargo.tomlComprueba la versión más alta de los símbolos de glibc que requiere el binario:
readelf --version-info target/release/hello-app \
| grep -oE 'GLIBC_[0-9.]+' | sort -Vu | tail -n 1La compilación nativa verificada requiere como máximo GLIBC_2.35 y funciona con la glibc 2.36 de la placa. Si tu resultado requiere una versión más reciente que la disponible, resuelve la incompatibilidad de la cadena de herramientas o del entorno de compilación antes de empaquetar.
Preparar las herramientas AppImage
Descarga únicamente el empaquetador ARM64 y el entorno de ejecución especificados en tools.lock. El siguiente bloque comprueba sus valores SHA256 y reutiliza las copias en caché que coincidan:
(
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
)Continúa solo cuando ambas herramientas superen la verificación. Si las descargas fallan, restablece el acceso a los archivos de las versiones publicadas y ejecuta de nuevo este bloque.
Empaquetar e instalar el AppImage
Utiliza el script oficial de preparación y las herramientas verificadas para crear el 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
)Espera a que el empaquetado muestre Success y el SHA256 del archivo generado. Después instálalo en ~/Apps. Si ya existe un paquete de Hello World, el siguiente bloque lo copia fuera de ~/Apps antes de reemplazarlo:
(
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 copia de seguridad se guarda en ~/.local/share/flipctl-app-backups/. Conserva en ~/Apps solo la copia instalada que quieras utilizar, para evitar entradas duplicadas en el lanzador.
Paso 4: Iniciar FlipCTL con renderizado Pixman
Primero comprueba el puerto 8899 en la placa:
ss -ltnp 'sport = :8899'Si ya hay un proceso escuchando, resuelve primero el conflicto. Detén una instancia anterior de FlipCTL antes de iniciar otra. Si el proceso es ssh, comprueba si ejecutaste por error el comando de reenvío en la placa y cierra ese túnel incorrecto.
Inicia FlipCTL con renderizado por software Pixman para su compositor de aplicaciones:
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 se aplica a este proceso y a su compositor hijo. Evita el fallo de asignación de GPU encontrado en el entorno RK3576 probado, sin cambiar la configuración del escritorio del sistema.
Confirma que el registro de inicio contiene:
remote view http://127.0.0.1:8899/Si aparece not serving ... Address already in use, el servicio del navegador no ha arrancado. Una lista de apps o el mensaje first frame committed no bastan para confirmar que el servicio web esté disponible.
Mantén abierto este terminal mientras uses FlipCTL.
Paso 5: Conectarse y explorar la interfaz remota
Si el túnel SSH existente del PC sigue funcionando, reutilízalo. Si está cerrado, abre otro terminal en el PC —PowerShell en Windows— y ejecuta:
ssh -N -o ExitOnForwardFailure=yes -o ServerAliveInterval=30 -L 127.0.0.1:8899:127.0.0.1:8899 seeed@<BOARD_IP>Ejecuta este comando de reenvío en el PC, no dentro de una sesión SSH conectada a la placa. Tras la autenticación no aparece un prompt de la shell debido a -N; mantén abierta la ventana. Si el puerto 8899 del PC ya está ocupado, comprueba si hay un túnel existente antes de iniciar otro.
Abre http://127.0.0.1:8899 en el navegador del PC. Espera a que aparezca Status: connected y activa Show controls.

Verificar la información del dispositivo
Consulta el nombre de host y la información de red en la interfaz. En otro terminal SSH, compara esos valores con la salida de estos comandos:
hostname
hostname -I
uname -r
df -h /Confirma que el nombre de host y la dirección Ethernet de la interfaz coincidan con la salida de los comandos. Por ejemplo, si el nombre de host es recomputer-rk3576-devkit, la interfaz debe mostrar ese mismo nombre.
También puedes consultar opciones de menú de solo lectura, como:
- Settings → System info
- Settings → Disk info
- Network → Ethernet
La disponibilidad de los menús depende de la versión del código fuente y del sistema Linux subyacente.
Después de abrir una página de detalles, espera a que la información termine de cargarse. Antes de la primera actualización, algunos valores pueden aparecer brevemente como - o 0.
Después de comprobar la información, vuelve a la pantalla de inicio de FlipCTL antes del siguiente paso.
Paso 6: Iniciar y probar Hello World
- En la pantalla de inicio de FlipCTL, pulsa X, la tecla de función correspondiente a Menu.
- Usa ↑ / ↓ para seleccionar Apps y pulsa Enter.
- Selecciona Hello World y vuelve a pulsar Enter.
- Espera a que termine de abrirse la aplicación. Debes ver Hello, Flipper One!, Presses y Progress.
Pulsa Enter tres veces. Presses debe pasar de 0 a 3 y la barra debe llenarse hasta el 30%, como en la imagen de resultado al principio del proyecto.
| Control | Acción |
|---|---|
| Enter o Add | Aumenta el contador en uno y la barra de progreso en 10 puntos porcentuales, hasta llenarla |
| Draw | Cambia a la página de dibujo de la aplicación |
| Close | Cierra la aplicación |
| Back | Vuelve a la pantalla anterior de FlipCTL o deja la aplicación en segundo plano, según el contexto |