Important
Dieses Repository ist umgezogen und wird auf GitHub nicht mehr gepflegt. Die aktuelle Version und die weitere Entwicklung gibt es nur noch auf Codeberg: https://codeberg.org/Flying-Bolt/HOMI
Dein Smart-Home auf dem Handgelenk. HOMI ist eine Wear-OS-App (plus Smartphone-Begleiter), mit der du Geräte in deinem Zuhause per einfachem HTTP-Aufruf direkt von der Uhr steuerst — Türöffner, Licht, Steckdosen, Rollläden, und mehr. Und du kannst dir Live-Werte anzeigen lassen: Batterie-Ladestand, Temperaturen, aktuelle Leistung. Funktioniert mit allem, was sich über eine URL ansprechen lässt: Tasmota, Shelly, ioBroker (simple-api) und ähnliche.
Dies ist die öffentliche Download- & Anleitungs-Seite. Der Quellcode liegt in einem separaten, privaten Repository.
- Was HOMI kann
- So funktioniert's (Konzept)
- Download
- Installation
- Buttons konfigurieren
- HTTP-Grundlagen
- Reguläre Ausdrücke — die Geheimwaffe
- 🔬 JSON ausschlachten
- 🍳 Praxis-Kochbuch
- Tipps & Fehlersuche
- Hinweise & Einschränkungen
- Lizenz
- Frei konfigurierbare Buttons auf der Uhr, in Gruppen organisiert (horizontal wischen).
- Drei Button-Typen — für jeden Zweck der richtige:
- 🔘 Tap – ein Druck löst eine URL aus (Tür öffnen, Szene starten, Impuls geben).
- 🔀 Schalter – Ein/Aus mit zwei URLs und optionaler Status-Anzeige (Button leuchtet voll = Ein, gedimmt = Aus).
- 📊 Wert – zeigt einen Live-Wert aus einer URL an (z. B.
56 %,23.4 °C,420 W).
- Konfiguration am Smartphone: Buttons anlegen, Icon/Farbe/URL wählen, direkt testen — und per Knopfdruck an die Uhr senden.
- Bestätigung vor Ausführung (optional, pro Button) — schützt sicherheitskritische Aktionen (Tür, Garage, Tor) vor versehentlichen Taps.
- Eigenständig auf der Uhr – läuft auch ohne gekoppeltes Phone weiter, solange WLAN da ist.
- Lokal & privat – kein Cloud-Dienst, kein Tracking, keine Konten. HOMI spricht nur die Adressen an, die du einträgst.
HOMI ist im Kern ganz einfach: Beim Tippen eines Buttons schickt die Uhr einen HTTP-Request an eine URL deiner Wahl. Was dort passiert, bestimmt dein Smart-Home-Gerät.
[ Galaxy Watch ] [ Dein Gerät im WLAN ]
HOMI ──── HTTP GET ────► Tasmota / Shelly /
tippt Button ioBroker / …
◄─── Antwort ────── z. B. {"POWER":"ON"}
- Aktion auslösen (Tap / Schalter): HOMI ruft eine URL auf, die etwas tut (z. B. Steckdose einschalten).
- Status/Wert lesen (Schalter-Status / Wert): HOMI ruft eine URL auf, die etwas zurückgibt, und liest mit einem regulären Ausdruck den interessanten Teil aus der Antwort heraus.
Mehr ist es nicht — aber damit lässt sich erstaunlich viel bauen. 👇
Alle Releases findest du unter Releases. Es gibt zwei APKs:
| Datei | Gerät |
|---|---|
HOMI-mobile-*.apk |
Android-Smartphone (Begleiter-App zur Konfiguration) |
HOMI-wear-*.apk |
Galaxy Watch / Wear-OS-Gerät |
ℹ️ Die APKs sind mit dem Standard-Android-Debug-Key signiert, damit du sie ohne Play-Store-Schlüssel direkt installieren kannst. Für die private Nutzung im eigenen Netz ist das völlig in Ordnung.
- Auf dem Phone die Release-Seite öffnen und die
HOMI-mobile-*.apkherunterladen. - Im Browser/Datei-Manager auf die APK tippen.
- Android fragt nach „Installation aus unbekannten Quellen" – der jeweiligen App (z. B. Chrome, Files) die Erlaubnis erteilen.
- Installieren → App startet als HOMI.
Wear OS bietet keinen direkten APK-Installer auf der Uhr – die App wird per ADB „sideloaded". Einmalig etwas Aufwand, danach läuft's.
Vorbereitung auf der Uhr: Einstellungen → Watch-Info → Software-Info → Build-Nummer 7× tippen (schaltet Entwickleroptionen frei) → Entwickleroptionen → WLAN-Debugging aktivieren.
Auf dem PC (mit installierten Android Platform-Tools):
# 1. PC und Uhr im gleichen WLAN. Auf der Uhr:
# Entwickleroptionen → WLAN-Debugging → "Gerät mit Pairing-Code koppeln"
# -> zeigt IP:PORT (Pairing) und einen 6-stelligen Code.
adb pair <IP>:<PAIRING-PORT> # Code eingeben
# 2. Verbinden (der WLAN-Debugging-Hauptschirm zeigt einen ANDEREN IP:PORT):
adb connect <IP>:<DEBUG-PORT>
# 3. APK aus dem Release installieren:
adb -s <IP>:<DEBUG-PORT> install -r HOMI-wear-*.apkPairing-Port und Debug-Port sind zwei verschiedene Ports. Bei älteren Wear-Geräten (vor Wear OS 4) entfällt der Pairing-Schritt – dort genügt
adb connect <IP>:<PORT>.
Alles passiert in der Phone-App:
- Gruppe anlegen (z. B. „Türen", „Licht", „Energie") und darin Buttons hinzufügen.
- Pro Button: Icon, Farbe, Typ (Tap / Schalter / Wert) und die URL(s) wählen.
- Mit dem Testen-Button prüfen, ob alles antwortet. ✅
- Oben auf das Senden-Symbol (✈) tippen → die Konfiguration wandert auf die Uhr.
Die Gruppen-Übersicht in der Phone-App. Oben: Senden (✈), Teilen, QR-Import, Datei-Import.
Der Icon-Picker: kuratierte Symbole für Türen, Licht, Energie, Sensoren u. v. m. — durchsuchbar.
💡 In allen folgenden Beispielen ist
192.168.1.50nur ein Platzhalter — ersetze ihn durch die IP deines Geräts. Leerzeichen in URLs werden als%20geschrieben.
Der einfachste Typ: ein Druck = ein Request. Kein Status, keine Rückmeldung außer „hat geklappt / Fehler".
Du brauchst nur: eine URL.
Beispiel — Türöffner per Tasmota-Impuls:
URL: http://192.168.1.50/cm?cmnd=Power%20On
Beispiel — Szene/Skript in ioBroker starten:
URL: http://192.168.1.50:8087/set/0_userdata.0.szene_kino?value=true
🔒 Tipp für Tür/Garage/Tor: Schalte im Editor „Bestätigung vor Ausführung" ein. Dann fragt die Uhr vor dem Auslösen kurz nach — kein versehentliches Öffnen mehr.
Ein Schalter hat zwei Aktionen (Ein und Aus) und kann optional den aktuellen Zustand anzeigen: voll leuchtend = Ein, gedimmt = Aus, grau = unbekannt.
Schalter im Editor — URL EIN/AUS, optionale Status-URL + Regex. (URLs hier durch Platzhalter ersetzt.)
Du brauchst:
| Feld | Pflicht? | Wofür |
|---|---|---|
| URL EIN | ✅ | wird beim Einschalten aufgerufen |
| URL AUS | ✅ | wird beim Ausschalten aufgerufen |
| Status-URL | optional | wird periodisch abgefragt, um den Zustand zu erkennen |
| Regex EIN / Regex AUS | wenn Status-URL gesetzt | erkennen „Ein" bzw. „Aus" in der Antwort (siehe Regex-Kapitel) |
| Polling-Intervall | – | wie oft der Status geholt wird (0 / 10 / 30 / 60 s) |
So funktioniert die Status-Erkennung: HOMI ruft die Status-URL auf und prüft die Antwort — passt „Regex EIN", ist der Schalter an; passt „Regex AUS", ist er aus.
Beispiel — Tasmota-Steckdose mit Status:
URL EIN: http://192.168.1.50/cm?cmnd=Power%20On
URL AUS: http://192.168.1.50/cm?cmnd=Power%20Off
Status-URL: http://192.168.1.50/cm?cmnd=Power
Antwort: {"POWER":"ON"}
Regex EIN: "POWER":"ON"
Regex AUS: "POWER":"OFF"
Beispiel — Shelly (Gen2 / Plus):
URL EIN: http://192.168.1.51/rpc/Switch.Set?id=0&on=true
URL AUS: http://192.168.1.51/rpc/Switch.Set?id=0&on=false
Status-URL: http://192.168.1.51/rpc/Switch.GetStatus?id=0
Antwort: {"id":0,"output":true,"apower":42.5, ...}
Regex EIN: "output":true
Regex AUS: "output":false
Beispiel — ioBroker-Datenpunkt (simple-api):
URL EIN: http://192.168.1.50:8087/set/zigbee.0.abcd.state?value=true
URL AUS: http://192.168.1.50:8087/set/zigbee.0.abcd.state?value=false
Status-URL: http://192.168.1.50:8087/get/zigbee.0.abcd.state
Antwort: {"val":true, ...}
Regex EIN: "val":true
Regex AUS: "val":false
⚠️ Häufigste Stolperfalle bei ioBroker: Die Status-URL muss/get/sein, nicht/set/!/set/schreibt den Wert (und liefert HTTP 422 zurück) —/get/liest ihn. Wenn der Button grau bleibt oder erst nach mehrmaligem Drücken reagiert, ist fast immer die Status-URL oder das Regex schuld → mit „Status testen" prüfen.
Ein Wert-Button schaltet nichts — er zeigt eine Zahl aus deinem Smart-Home, z. B. 56 %, 23.4 °C, 420 W. Ein Tap aktualisiert ihn sofort, dazwischen pollt HOMI im eingestellten Intervall.
Wert im Editor — Wert-URL, Wert-Regex (Fang-Gruppe 1) und feste Einheit. (URL hier durch Platzhalter ersetzt.)
Du brauchst:
| Feld | Pflicht? | Wofür |
|---|---|---|
| Wert-URL | ✅ | liefert die Antwort mit dem Wert |
| Wert-Regex | ✅ | Fang-Gruppe 1 = der angezeigte Wert (siehe Regex-Kapitel) |
| Einheit (fester Text) | optional | feste Einheit, z. B. %, °C, W — hat Vorrang |
| Einheit (Regex) | optional | Einheit aus der Antwort lesen (Fang-Gruppe 1) |
| Polling-Intervall | – | 0 = nur beim Tap, sonst 10 / 30 / 60 s |
Beispiel — Batterie-Ladestand (ioBroker):
Wert-URL: http://192.168.1.50:8087/get/e3dc.0.EMS.BAT_SOC
Antwort: {"val":56, ...}
Wert-Regex: "val":(\d+(?:\.\d+)?) → zeigt 56
Einheit: % → Anzeige: 56 %
Beispiel — Temperatur (Tasmota-Sensor):
Wert-URL: http://192.168.1.50/cm?cmnd=Status%2010
Antwort: ... "Temperature":23.4 ...
Wert-Regex: "Temperature":([\d.]+) → zeigt 23.4
Einheit: °C → Anzeige: 23.4 °C
Beispiel — Aktuelle Leistung (Shelly):
Wert-URL: http://192.168.1.51/rpc/Switch.GetStatus?id=0
Antwort: ... "apower":420.7 ...
Wert-Regex: "apower":([\d.]+) → zeigt 420.7
Einheit: W → Anzeige: 420.7 W
Bonus — Einheit aus der Antwort lesen (statt fest eintippen):
Antwort: ... "val":56,"unit":"%" ...
Wert-Regex: "val":(\d+) → 56
Einheit-Regex: "unit":"([^"]+)" → %
Du musst kein Profi sein — aber diese vier Dinge helfen:
- GET vs. POST (Feld „Methode"): Die allermeisten Smart-Home-URLs funktionieren mit GET (Standard). POST brauchst du nur, wenn dein Gerät es verlangt (dann kannst du unter Erweitert einen Body mitschicken).
%20= Leerzeichen: URLs vertragen keine echten Leerzeichen.Power Onwird zuPower%20On.- Header (unter Erweitert, eine pro Zeile als
Key: Wert): nötig z. B. für eine Authentifizierung:Authorization: Bearer dein-token-hier - Port: ioBroker simple-api läuft typischerweise auf
:8087, Tasmota/Shelly auf dem Standard-Port (kein:nötig).
„Regex" klingt nach Zauberei, ist aber nur eine Suchschablone: Du beschreibst, wie der gesuchte Text aussieht, und HOMI findet ihn in der Antwort deines Geräts. Zwei Anwendungen:
- Schalter-Status: Das Regex muss in der Antwort irgendwo vorkommen (kein exakter Treffer nötig). Kommt „Regex EIN" vor → an; kommt „Regex AUS" vor → aus.
- Wert anzeigen: Hier zählt die Fang-Gruppe — der Teil in runden Klammern
( ). Genau dieser Teil wird als Wert angezeigt.
| Muster | Bedeutung | matcht z. B. |
|---|---|---|
\d |
eine Ziffer (0–9) | 4 |
\d+ |
eine oder mehr Ziffern | 420 |
\. |
ein echter Punkt | . |
[\d.]+ |
Ziffern und Punkt | 23.4 |
\d+(?:\.\d+)? |
Ganzzahl oder Dezimalzahl | 56 oder 56.5 |
-?\d+ |
optional negativ | -7 |
[^"]+ |
alles außer Anführungszeichen | kWh |
\s* |
beliebig viele Leerzeichen | (auch keine) |
true|false |
das eine oder das andere | true |
( … ) |
Fang-Gruppe = angezeigter Wert |
Schau dir die Antwort deines Geräts an (am besten direkt im Browser aufrufen) und „umschreibe" den interessanten Teil:
Antwort: {"val":56.5,"ack":true}
Ziel: die 56.5
Regex: "val":([\d.]+)
└─────┘ Fang-Gruppe → 56.5
Antwort: {"POWER":"ON"}
Ziel: erkennen, dass es AN ist
Regex EIN: "POWER":"ON" (muss vorkommen → an)
Regex AUS: "POWER":"OFF"
🧪 Du musst nichts raten: Der Editor hat zu jedem Typ einen Test-Button („Status testen" / „Wert holen"). Er ruft live deine URL auf und zeigt, was erkannt wurde — Regex anpassen, nochmal testen, fertig.
💡 Robustheit: Halte Regex so locker wie nötig.
"val":\s*truematcht auch"val": true(mit Leerzeichen). Für Werte ist([\d.]+)meist robuster als eine exakte Zahl.
„Und was kann ich da jetzt alles rausholen?" — Erstaunlich viel. Eine einzige Status-Antwort steckt oft voller Werte: Leistung, Spannung, Strom, Temperatur, Zählerstände, Online-Status … Mit je einem kleinen Wert-Regex machst du daraus dein eigenes Mini-Dashboard am Handgelenk. ⌚
Antwort von …/rpc/Shelly.GetStatus — der Übersicht halber gekürzt (Shelly liefert das in Wirklichkeit als eine einzige Zeile):
{"cloud":{"connected":false},"mqtt":{"connected":true},
"switch:0":{"id":0,"output":true,"apower":-592.9,"voltage":231.6,"current":2.551,"pf":1.00,"aenergy":{"total":1559924.685},"temperature":{"tC":60.5,"tF":140.9}},
"switch:1":{"id":1,"output":true,"apower":3377.3,"voltage":231.7,"current":15.771,"pf":0.93,"aenergy":{"total":803062.588},"temperature":{"tC":82.3,"tF":180.1}},
"ws":{"connected":false}}🔎 Was steckt da eigentlich alles drin? (Feld-Übersicht)
Eine einzige Shelly.GetStatus-Antwort liefert dutzende Werte — hier die wichtigsten (jeder kann ein eigener HOMI-Button werden):
Netzwerk & Cloud: cloud.connected, mqtt.connected, ws.connected (je true/false), eth.ip (IP-Adresse), wifi.status (connected / disconnected).
Eingänge: input:0.state, input:1.state (true/false).
Pro Kanal (switch:0 / switch:1):
| Feld | Bedeutung |
|---|---|
output |
Kanal an/aus (true/false) |
apower |
Momentanleistung in W (negativ = Einspeisung) |
voltage |
Spannung in V |
current |
Strom in A |
freq |
Netzfrequenz in Hz |
pf |
Leistungsfaktor (0–1) |
aenergy.total |
Zählerstand in Wh |
temperature.tC / .tF |
Kanaltemperatur °C / °F |
counts.on_time |
Einschaltdauer in s |
System (sys): mac (MAC), time / unixtime (Uhrzeit), uptime (s), ram_free / fs_free (Speicher), available_updates.stable.version (verfügbares Update), alt…name / desc (Gerätemodell, hier „Shelly Pro 2 PM").
Schau genau hin: "apower", "voltage", "tC", "output" gibt es zweimal (Kanal 0 und Kanal 1), "connected" sogar dreimal (Cloud, MQTT, WS). HOMI nimmt aber immer den ersten Treffer — ein nacktes "apower":(-?[\d.]+) liefert also stur Kanal 0.
Häng den eindeutigen Eltern-Schlüssel davor und überspringe den Rest mit .*?:
"switch:1".*?"apower":(-?[\d.]+)
│ │
│ └─ .*? = „beliebig viele Zeichen, aber so wenige wie möglich"
└─ erst zu Kanal 1 springen … (non-greedy)
.*? frisst alles zwischen Anker und Zielwert — klappt prima, weil die Antwort eine Zeile ist. So ziehst du jeden Wert exakt aus dem richtigen Kanal:
| Du willst… | Wert-Regex | Anzeige |
|---|---|---|
| Leistung Kanal 0 (negativ = Einspeisung!) | "switch:0".*?"apower":(-?[\d.]+) |
-592.9 |
| Leistung Kanal 1 | "switch:1".*?"apower":(-?[\d.]+) |
3377.3 |
| Spannung Kanal 1 | "switch:1".*?"voltage":([\d.]+) |
231.7 |
| Strom Kanal 1 | "switch:1".*?"current":([\d.]+) |
15.771 |
| Temperatur Kanal 0 | "switch:0".*?"tC":([\d.]+) |
60.5 |
| Temperatur Kanal 1 | "switch:1".*?"tC":([\d.]+) |
82.3 |
| Zählerstand Kanal 1 | "switch:1".*?"total":([\d.]+) |
803062.588 |
| Kanal 1 an? (Schalter-Status) | "switch:1".*?"output":(true|false) |
Treffer → an |
| MQTT verbunden? | "mqtt":\{"connected":(true|false) |
true |
💡 HOMI zeigt immer Fang-Gruppe 1. Für zwei Werte (z. B. beide Kanal-Temperaturen) legst du einfach zwei Buttons an — jeder mit seinem eigenen Kontext-Regex. Aus einem Dual-Channel-Messgerät wird so ein hübsches 2-Button-Duo.
🧩 Arrays gezielt umschiffen. Manche Felder sind Arrays, z. B.
"by_minute":[10067.719,10368.898,…]. Willst du den Gesamtwert, ziel einfach auf den Skalar daneben:"total":([\d.]+)greift die einzelne Zahl, das[…]-Array bleibt unangetastet.
🔧 Beide Werte in einem Regex? Für Tools, die auch Gruppe 2 auswerten (z. B. der ioBroker-Parser-Adapter), geht's in einem Abwasch:
"switch:0".*?"tC":([-0-9.]+).*?"switch:1".*?"tC":([-0-9.]+)legt Kanal-0-Temp in Gruppe 1 und Kanal-1-Temp in Gruppe 2. HOMI nutzt nur Gruppe 1 — hier bleibst du bei zwei Buttons mit je einem Kontext-Regex.
Die Fang-Gruppe darf auch Text oder true/false liefern — der Wert-Modus zeigt einfach an, was drinsteht:
{"state":"charging","online":true,"mode":"eco"}| Du willst… | Regex | Anzeige |
|---|---|---|
| Lade-Status als Text | "state":"([^"]+)" |
charging |
| Online? | "online":(true|false) |
true |
| Betriebsmodus | "mode":"([^"]+)" |
eco |
| In der Antwort steht… | …dann nimm | Holt raus |
|---|---|---|
"x":123 (Ganzzahl) |
"x":(\d+) |
123 |
"x":12.5 (Dezimal) |
"x":([\d.]+) |
12.5 |
"x":-3.5 (auch negativ) |
"x":(-?[\d.]+) |
-3.5 |
"x":true (Wahrheitswert) |
"x":(true|false) |
true |
"x":"text" (String) |
"x":"([^"]+)" |
text |
"x":[230,231,229] (1. Array-Wert) |
"x":\[([\d.]+) |
230 |
| Schlüssel kommt mehrfach vor | "kontext".*?"x":(…) |
gezielt der richtige |
evtl. Leerzeichen nach dem : |
"x":\s*(\d+) |
(egal) |
- Der erste Treffer gewinnt. Kommt ein Schlüssel mehrfach vor, gib Kontext mit (
"switch:1".*?…) — sonst bekommst du immer den ersten. - Negativ & Nachkomma gratis:
(-?[\d.]+)deckt-592.9,0,23.4ab — perfekt für Einspeise-Leistung oder Außentemperatur. - Im Zweifel „Wert holen". Ruf die URL einmal im Browser auf, schau dir die echte Antwort an und teste den Regex im Editor live — anpassen, bis die Anzeige stimmt. 30 Sekunden, fertig. ⏱️
(Mini-Detail:
.*?funktioniert, weil die Antwort eine Zeile ist. Käme das JSON jemals mit Zeilenumbrüchen, bräuchte es den „Dotall"-Modus — bei den üblichen API-Antworten nicht nötig.)
Fertige Rezepte zum Abtippen — IP anpassen, fertig.
Steckdose schalten (Tasmota) — mit Status-Anzeige
Typ: Schalter
URL EIN: http://192.168.1.50/cm?cmnd=Power%20On
URL AUS: http://192.168.1.50/cm?cmnd=Power%20Off
Status-URL: http://192.168.1.50/cm?cmnd=Power
Regex EIN: "POWER":"ON"
Regex AUS: "POWER":"OFF"
Intervall: 30 s
Licht schalten (Shelly Plus) — mit Status-Anzeige
Typ: Schalter
URL EIN: http://192.168.1.51/rpc/Switch.Set?id=0&on=true
URL AUS: http://192.168.1.51/rpc/Switch.Set?id=0&on=false
Status-URL: http://192.168.1.51/rpc/Switch.GetStatus?id=0
Regex EIN: "output":true
Regex AUS: "output":false
Intervall: 30 s
Beliebigen Datenpunkt schalten (ioBroker)
Typ: Schalter
URL EIN: http://192.168.1.50:8087/set/DEIN.DATENPUNKT?value=true
URL AUS: http://192.168.1.50:8087/set/DEIN.DATENPUNKT?value=false
Status-URL: http://192.168.1.50:8087/get/DEIN.DATENPUNKT ← /get/, nicht /set/!
Regex EIN: "val":true
Regex AUS: "val":false
Intervall: 30 s
Batterie-Ladestand anzeigen (ioBroker)
Typ: Wert
Wert-URL: http://192.168.1.50:8087/get/DEIN.BAT_SOC
Wert-Regex: "val":(\d+(?:\.\d+)?)
Einheit: %
Intervall: 60 s
Temperatur anzeigen (Tasmota / Shelly)
Typ: Wert
Wert-URL: http://192.168.1.50/cm?cmnd=Status%2010
Wert-Regex: "Temperature":([\d.]+)
Einheit: °C
Intervall: 60 s
Garagentor öffnen (Tap, mit Sicherheits-Rückfrage)
Typ: Tap
URL: http://192.168.1.50/cm?cmnd=Power%20On
Bestätigung vor Ausführung: AN ← fragt vor dem Öffnen nach
| Symptom | Ursache & Lösung |
|---|---|
| Button bleibt grau / „?" | Status-URL oder Regex passt nicht. Bei ioBroker: /get/ statt /set/. → „Status testen" im Editor. |
| HTTP 422 / 400 | Falscher Endpoint — typisch /set/ als Status-URL bei ioBroker. Auf /get/ ändern. |
| „Zeitüberschreitung" | Gerät nicht erreichbar: IP falsch, Gerät aus, oder Uhr nicht im richtigen WLAN. |
| Wert zeigt „—" | Wert-Regex matcht nicht. → „Wert holen", Antwort ansehen, Regex anpassen (oft hilft ([\d.]+)). |
| Roter „Kein WLAN" trotz WLAN | In v2.3.6 behoben — auf die aktuelle Version aktualisieren. |
| Schalter reagiert erst nach mehrmaligem Tippen | In v2.3.4 behoben — bitte aktualisieren. |
| Label abgeschnitten | Auf der Uhr werden max. 8 Zeichen angezeigt — kurze Labels wählen. |
🧰 Goldene Regel: Jede URL lässt sich vorab im Browser testen (einfach aufrufen) und im Editor mit dem Test-Button prüfen, bevor du an die Uhr sendest.
- HOMI steuert lokale Geräte im eigenen Netz (HTTP). Externe/HTTPS-URLs gehen ebenfalls, wenn das Zielgerät sie unterstützt.
- Im Energiesparmodus schaltet Wear OS das WLAN ab und blockiert Apps daran, es zu reaktivieren – HOMI kann das nicht umgehen und zeigt dann einen Hinweis.
- Keine Telemetrie, keine Cloud, keine Konten. Deine URLs und Tokens bleiben auf deinen Geräten.
Apache License 2.0 — siehe auch NOTICE.
🤖 App & Doku mitentwickelt mit Claude Code (Opus 4.8).