Touchscreen-Kiosk-Dashboard auf ZimaBoard 2 mit Docker (X.Org + Chromium)

Hallo zusammen,

Ich wollte zeigen, wie ich einen Vollbild-Touchscreen-Kiosk auf meinem ZimaBoard 2 eingerichtet habe, das über HDMI an einen 22" Touch-Monitor angeschlossen ist.

Da ZimaOS keinen Paketmanager hat (apt existiert nicht), besteht der Trick darin, alles innerhalb von Docker-Containern zu erledigen.

Meine Einrichtung

ZimaBoard 2 1664 (Intel N100, 16 GB RAM)

ZimaOS v1.5.4

22" Touch-Monitor über HDMI + USB-C→USB-A Touchscreen-Eingang

Der Ansatz

ZimaOS basiert auf Buildroot — kein apt, kein Xorg, keine Desktop-Umgebung. Stattdessen läuft ein Debian-Container mit Xorg Modesetting-Treiber + Chromium im Kiosk-Modus, mit durchgereichtem /dev/dri. Ein separater nginx:alpine-Container liefert die Dashboard-Dateien.

-15% OFF

ZimaBoard 2 – Mini-Heimserver für Ihre große Idee

Single board computer zimaboard2

$339.00 - $509.00

Buy Now

Schritt 1 — Fügen Sie Ihren Benutzer der Docker-Gruppe hinzu

Öffnen Sie das Web-Terminal unter http://your-zima-ip:7681 und führen Sie aus:

bash

sudo usermod -aG docker IHR_BENUTZERNAME

Verbinden Sie sich dann erneut per SSH, damit die Änderung wirksam wird.

Schritt 2 — Erstellen Sie die Dateien

bash

mkdir -p /DATA/AppData/kiosk/dashboard

/DATA/AppData/kiosk/Dockerfile:

text

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:

text

Abschnitt "Gerät"
Bezeichner "Intel"
Treiber "modesetting"
Option "Beschleunigungsmethode" "keine"
EndSection

Abschnitt "Bildschirm"
Bezeichner "Standard"
Gerät "Intel"
EndSection

Abschnitt "InputDevice"
Bezeichner "Touchscreen"
Treiber "libinput"
Option "Gerät" "/dev/input/event8"
EndSection

Abschnitt "ServerLayout"
Bezeichner "Standard"
Bildschirm "Standard"
Eingabegerät "Touchscreen" "CorePointer"
EndSection

/DATA/AppData/kiosk/entrypoint.sh:

text

#!/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:

text

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

Lege deine Dashboard-HTML/CSS/JS-Dateien in /DATA/AppData/kiosk/dashboard/ ab.

Schritt 3 — Bauen und Ausführen

Build (Hinweis: docker build benötigt --config /tmp auf ZimaOS):

bash

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

Dashboard-Webserver:

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

Kiosk-Anzeige:

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

Beide Container haben --restart unless-stopped, sodass sie Neustarts automatisch überleben.

Touchscreen-Klick-Fix (wichtig!)

Xorgs libinput behandelt Touch als Pointer- (Maus-) Ereignisse. Chromium wendet dann eine winzige Bewegungsschwelle für Klicks an — selbst eine 1px Fingerbewegung verhindert das Auslösen. Wenn dein Dashboard onclick-Handler verwendet, füge dieses JS hinzu, um sie durch pointerup + eine 20px-Schwelle zu ersetzen:

js

(function touchFix() {
const downs = {};
document.addEventListener('pointerdown', e => {
downs[e.pointerId] = { x: e.clientX, y: e.clientY };
}, { passive: true });
function isTap(e) {
const d = downs[e.pointerId];
return !d || (Math.abs(e.clientX - d.x) < 20 && Math.abs(e.clientY - d.y) < 20);
}
function run(fn) { try { new Function(fn)(); } catch(ex) {} }
function patchButtons(root) {
root.querySelectorAll('button[onclick]').forEach(btn => {
const 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 => {
const oc = el.getAttribute('onclick');
el.removeAttribute('onclick');
el.addEventListener('pointerup', e => { if (isTap(e) && !e.target.closest('button')) run(oc); });
});
patchButtons(document.body);
});
new MutationObserver(muts => muts.forEach(m =>
m.addedNodes.forEach(n => { if (n.nodeType === 1) patchButtons(n); })
)).observe(document.body, { childList: true, subtree: true });
})();

Füge auch folgendes zu deinem CSS hinzu, um den Mauszeiger auf einem Touchscreen auszublenden:

css

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

Fehlerbehebung

Mein immer aktives Home Assistant Setup (Antwort)

Ich habe eine energieeffiziente Home Assistant Einrichtung gebaut, die rund um die Uhr verfügbar ist, ohne dass mein Hauptrechner ständig Strom verbraucht. Die Geheimwaffe ist ein Zima, das als immer aktives Gehirn fungiert, während mein kompletter PC im Ruhezustand bleibt, bis er wirklich gebraucht wird.

Der Haupt-PC

Das ist im Hauptgerät verbaut:

CPU: AMD Ryzen 9 9950X3D

Motherboard: ASUS ROG Crosshair X870E Glacial

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

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

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

GPU (KI): Intel Arc Pro B70 32GB (wartet auf Veröffentlichung)

Netzteil: Corsair RM1200x

Gehäuse: Thermaltake Tower 900

Das Zima-Setup (Das Immer-Aktive Zentrum)

Die Zima läuft 24/7 und übernimmt alle leichten Aufgaben — Home Assistant-Dienste, Kamerafeeds und grundlegende KI-Anfragen über die Groq Free Tier Cloud.

Direkt an die Zima angeschlossene Peripheriegeräte:

Pisichen 22" Touchscreen-Monitor über HDMI → miniDP-Adapter + ein USB-C-Kabel für die Touch-Eingabe

Edifier G1000 II Lautsprecher über eine externe USB-A-zu-3,5mm-Soundkarte

DAMAO DGM20S Mikrofon über USB-A

Speicher:

Seagate IronWolf Pro 20TB — „Schwarzes Loch“ NAS-Laufwerk

Seagate IronWolf Pro 1TB — Haupt-NAS-Laufwerk

Netzwerk:

Zima per Ethernet mit dem Router verbunden

Ein zweites Ethernet-Kabel führt direkt von der Zima zum PC für schnelle lokale Übertragungen

Der clevere Teil: Wake-on-LAN

Hier ist der Clou — wenn jemand eine Frage stellt, die zu komplex für Gemini ist, schickt die Zima ein Wake-on-LAN-Paket, um den Haupt-PC aus dem Ruhezustand zu wecken. Sobald er hochgefahren ist, verbindet er sich mit einem lokalen 70B Parameter LLM, das auf der Intel Arc Pro B70 läuft. Nach Abschluss der Aufgabe geht der PC wieder in den Schlafmodus.

Das Ergebnis: ein Home Assistant, der immer reagiert, aber der große Rechner wacht nur auf, wenn wirklich schwere Arbeit ansteht. Die Stromrechnung bleibt im Rahmen, und ich habe trotzdem Zugriff auf ein wirklich leistungsfähiges lokales Modell, wenn ich es brauche.

Ein riesiges Dankeschön an Claude Code und Perplexity — ehrlich gesagt hätte ich dieses ganze Projekt ohne ihre Hilfe niemals alleine auf die Beine stellen können. Sie waren während des gesamten Prozesses von unschätzbarem Wert.

Ich hoffe, diese Informationen helfen jedem, der verrückt genug ist, ein ähnliches Projekt anzugehen — teile sie gerne, wo immer du möchtest!