inteintegrity2026-11-18

FlipCTL en reComputer RK3576: interfaz remota y aplicaciones

Ejecuta la interfaz FlipCTL de Flipper One y Hello World en reComputer RK3576 con Armbian. Compila en la placa y prueba los controles del navegador por SSH.

FlipCTLFlipper OneLinuxGitHub

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

Hello World en FlipCTL sobre reComputer RK3576, con Presses en 3 y Progress al 30%

Requisitos previos

ElementoRequisito
DispositivoreComputer RK3576 / RK3576 DevKit
Sistema operativoArmbian ARM64; el entorno verificado utiliza Debian Bookworm con glibc 2.36
Código fuente y herramientasRust 1.92 o posterior para Slint 1.17; instala las herramientas nativas en el paso 1
RedAcceso SSH desde el PC y acceso a crates de Rust y descargas de versiones de GitHub
PCUn 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:

powershell
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:

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

Comprueba el compositor, la arquitectura y la biblioteca C del sistema:

bash
sway --version
uname -m
getconf GNU_LIBC_VERSION

La 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:

bash
rustc --version
cargo --version

Slint 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:

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

Sigue las indicaciones del instalador y, al terminar, vuelve a cargar el entorno de la shell y confirma las versiones:

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

Paso 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:

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

Clona la implementación oficial 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

Este 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.sh ni run_me.sh en 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:

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
FuncionalidadPropósito
deviceActiva las funciones de ejecución relacionadas con el dispositivo
slintActiva la interfaz gráfica
remoteActiva la visualización y el control desde el navegador
waylandActiva 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:

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

file /tmp/flipctl-test.png

Si 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:

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

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

Comprueba la versión más alta de los símbolos de glibc que requiere el binario:

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

La 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:

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
)

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:

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
)

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:

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 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:

bash
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:

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 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:

text
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:

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

Interfaz remota de FlipCTL en reComputer RK3576

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:

bash
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

  1. En la pantalla de inicio de FlipCTL, pulsa X, la tecla de función correspondiente a Menu.
  2. Usa ↑ / ↓ para seleccionar Apps y pulsa Enter.
  3. Selecciona Hello World y vuelve a pulsar Enter.
  4. 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.

ControlAcción
Enter o AddAumenta el contador en uno y la barra de progreso en 10 puntos porcentuales, hasta llenarla
DrawCambia a la página de dibujo de la aplicación
CloseCierra la aplicación
BackVuelve a la pantalla anterior de FlipCTL o deja la aplicación en segundo plano, según el contexto