Painel de Controlo de Quiosque com Ecrã Tátil no ZimaBoard 2 usando Docker (X.Org + Chromium)

Olá a todos,

Queria partilhar como consegui executar um quiosque de ecrã tátil em ecrã completo no meu ZimaBoard 2 ligado a um monitor tátil de 22" via HDMI.

Como o ZimaOS não tem gestor de pacotes (apt não existe), o truque é fazer tudo dentro de contentores Docker.

A Minha Configuração

ZimaBoard 2 1664 (Intel N100, 16 GB RAM)

ZimaOS v1.5.4

Monitor tátil de 22" via HDMI + entrada tátil USB-C→USB-A

A Abordagem

ZimaOS é baseado em Buildroot — sem apt, sem Xorg, sem ambiente de trabalho. Em vez disso, executamos um contentor Debian com o controlador Xorg modesetting + Chromium em modo quiosque, com /dev/dri passado. Um contentor nginx:alpine separado serve os ficheiros do painel.

Featured

ZimaBoard 2 - Servidor Doméstico de Placa Única de Hiperdesempenho

Single board computer zimaboard2

$279.00 - $349.00

Buy Now

Passo 1 — Adicione o seu utilizador ao grupo docker

Abra o terminal web em http://your-zima-ip:7681 e execute:

bash

sudo usermod -aG docker O_SEU_NOME_DE_UTILIZADOR

Depois volte a ligar o SSH para que a alteração tenha efeito.

Passo 2 — Criar os ficheiros

bash

mkdir -p /DATA/AppData/kiosk/dashboard

/DATA/AppData/kiosk/Dockerfile:

texto

FROM debian:bookworm-slim
RUN echo 'deb http://deb.debian.org/debian bookworm-backports main' >> /etc/apt/sources.list
RUN apt-get update && \
apt-get install -y \
xserver-xorg-core \
xserver-xorg-input-libinput \
openbox chromium \
x11-xserver-utils xinit \
fonts-noto-core && \
apt-get install -y -t bookworm-backports libgl1-mesa-dri && \
rm -rf /var/lib/apt/lists/*
COPY xorg.conf /etc/X11/xorg.conf
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]

/DATA/AppData/kiosk/xorg.conf:

texto

Secção "Dispositivo"
Identificador "Intel"
Controlador "modesetting"
Opção "MétodoAceleração" "nenhum"
EndSection

Secção "Ecrã"
Identificador "Predefinido"
Dispositivo "Intel"
EndSection

Secção "DispositivoDeEntrada"
Identificador "Ecrã tátil"
Controlador "libinput"
Opção "Dispositivo" "/dev/input/event8"
EndSection

Secção "DisposiçãoServidor"
Identificador "Predefinido"
Ecrã "Predefinido"
DispositivoDeEntrada "Ecrã tátil" "CorePointer"
EndSection

/DATA/AppData/kiosk/entrypoint.sh:

texto

#!/bin/sh
Xorg :0 vt1 -s 0 -dpms -nolisten tcp &
sleep 4
export DISPLAY=:0
xset s off && xset -dpms && xset s noblank
openbox --sm-disable &
sleep 1
exec chromium \
--kiosk --no-sandbox --disable-gpu \
--disable-dev-shm-usage \
--touch-events=enabled \
--no-first-run --disable-infobars \
"${KIOSK_URL:-http://localhost:8888}"

/DATA/AppData/kiosk/nginx.conf:

texto

server {
listen 8888;
root /usr/share/nginx/html;
index index.html;
}

Coloque os seus ficheiros HTML/CSS/JS do painel em /DATA/AppData/kiosk/dashboard/.

Passo 3 — Construir e Executar

Construir (nota: docker build precisa de --config /tmp no ZimaOS):

bash

docker --config /tmp build -t kiosk:latest /DATA/AppData/kiosk

Servidor web do painel:

bash

docker --config /tmp run -d \
--name dashboard-server \
--restart unless-stopped \
--network host \
-v /DATA/AppData/kiosk/dashboard:/usr/share/nginx/html:ro \
-v /DATA/AppData/kiosk/nginx.conf:/etc/nginx/conf.d/default.conf:ro \
nginx:alpine

Ecrã do quiosque:

bash

docker --config /tmp run -d \
--name jarvis-kiosk \
--restart unless-stopped \
--privileged \
--network host \
-e KIOSK_URL=http://localhost:8888 \
-v /DATA/AppData/kiosk/xorg.conf:/etc/X11/xorg.conf:ro \
-v /DATA/AppData/kiosk/entrypoint.sh:/entrypoint.sh:ro \
-v /run/udev:/run/udev:ro \
kiosk:latest

Ambos os contentores têm --restart unless-stopped para que sobrevivam a reinícios automaticamente.

Correção de Clique no Ecrã Tátil (importante!)

O libinput do Xorg mapeia o toque como eventos de ponteiro (mouse). O Chromium aplica então um pequeno limiar de movimento para clique — mesmo um deslocamento de 1px do dedo impede que ele dispare. Se o seu painel usa manipuladores onclick, adicione este JS para os substituir por pointerup + um limiar de 20px:

js

(função touchFix() {
constante downs = {};
document.addEventListener('pointerdown', e => {
downs[e.pointerId] = { x: e.clientX, y: e.clientY };
}, { passivo: true });
função isTap(e) {
constante d = downs[e.pointerId];
retornar !d || (Math.abs(e.clientX - d.x) < 20 && Math.abs(e.clientY - d.y) < 20);
}
função run(fn) { tente { novo Function(fn)(); } catch(ex) {} }
função patchButtons(root) {
root.querySelectorAll('button[onclick]').forEach(btn => {
constante oc = btn.getAttribute('onclick');
btn.removeAttribute('onclick');
btn.addEventListener('pointerup', e => { e.stopPropagation(); if (isTap(e)) run(oc); });
});
}
window.addEventListener('load', () => {
document.querySelectorAll('.widget[onclick]').forEach(el => {
constante oc = el.getAttribute('onclick');
el.removeAttribute('onclick');
el.addEventListener('pointerup', e => { if (isTap(e) && !e.target.closest('button')) run(oc); });
});
patchButtons(document.body);
});
novo MutationObserver(muts => muts.forEach(m =>
m.addedNodes.forEach(n => { if (n.nodeType === 1) patchButtons(n); })
)).observe(document.body, { childList: true, subtree: true });
})();

Adicione também ao seu CSS para esconder o cursor do rato num ecrã tátil:

css

{ cursor: none !important; touch-action: manipulation; }

Resolução de problemas

A Minha Configuração Sempre Ligada do Home Assistant (Resposta)

Construí uma configuração eficiente em energia de assistente doméstico disponível 24/7 sem que o meu equipamento principal consuma eletricidade constantemente. A arma secreta é um Zima que atua como o cérebro sempre ligado, enquanto o meu PC completo fica em hibernação até ser realmente necessário.

O PC Principal

Aqui está o que há dentro da máquina principal:

CPU: AMD Ryzen 9 9950X3D

Placa-mãe: ASUS ROG Crosshair X870E Glacial

RAM: Acer Predator Hermes RGB DDR5 96GB (2×48GB) 6000MHz CL28

Armazenamento: Crucial T710 4TB NVMe M.2 PCIe 5.0 Gen5

GPU (Gaming): ASUS ROG Astral GeForce RTX 5080 16GB

GPU (IA): Intel Arc Pro B70 32GB (à espera de lançamento)

Fonte de alimentação: Corsair RM1200x

Caixa: Thermaltake Tower 900

Configuração do Zima (O Hub Sempre Ligado)

O Zima funciona 24/7 e trata de tudo o que é leve — tarefas de assistente doméstico, feeds de câmaras e consultas básicas de IA usando o nível gratuito Groq via cloud.

Periféricos ligados diretamente ao Zima:

Monitor tátil Pisichen 22" via HDMI → adaptador miniDP + um cabo USB-C para entrada tátil

Colunas Edifier G1000 II através de uma placa de som externa USB-A para 3,5 mm

Microfone DAMAO DGM20S via USB-A

Armazenamento:

Seagate IronWolf Pro 20TB — disco NAS ''buraco negro''

Seagate IronWolf Pro 1TB — disco principal NAS

Rede:

Zima ligado ao router via Ethernet

Segundo cabo Ethernet liga diretamente o Zima ao PC para transferências locais rápidas

A Parte Inteligente: Wake-on-LAN

Aqui está a magia — quando alguém faz uma pergunta demasiado complexa para o Gemini responder bem, o Zima envia um pacote Wake-on-LAN para tirar o PC principal da hibernação. Assim que está ativo, liga-se a um modelo LLM local de 70 mil milhões de parâmetros a correr na Intel Arc Pro B70. Depois de a tarefa estar concluída, o PC volta a dormir.

O resultado: um assistente doméstico sempre responsivo, mas o computador principal só acorda quando há trabalho pesado a fazer. As contas de eletricidade mantêm-se controladas, e ainda tenho acesso a um modelo local realmente capaz quando preciso.

Um enorme agradecimento a Claude Code e Perplexity — honestamente, sem a ajuda deles nunca teria conseguido concretizar este projeto sozinho. Foram indispensáveis durante todo o processo.

Espero que esta informação ajude quem for louco o suficiente para embarcar num projeto semelhante — sinta-se à vontade para partilhá-la onde quiser!