Shelly Script oder Home Assistant – lokal oder zentral?

was ist besser fürs Smart Home?

Smart Home kann herrlich einfach sein – oder herrlich kompliziert. Manchmal sogar beides gleichzeitig. 😄

Eine der häufigsten Fragen dabei:

Baue ich meine Logik direkt im Shelly (per Script) oder über eine Zentrale wie Home Assistant?

Ich nutze beides – und genau darum geht es hier: ein ehrlicher Praxis-Vergleich, inklusive echten Beispielen aus dem Alltag.

Zwei Philosophien: lokal vs. zentral

🧠 Shelly Script – das Gehirn sitzt im Gerät

Bei Shelly Scripts läuft die komplette Logik direkt auf dem Gerät.
Ein Taster weiß selbst, was er tun soll. Kein Server, kein Broker, kein Mittelsmann.

Eigenschaften:

läuft direkt auf dem Shelly
funktioniert auch ohne WLAN-Internet
extrem schnell (Millisekunden)
keine Abhängigkeit von Home Assistant / ioBroker
JavaScript statt Blockly

Kurz gesagt: Smart Home auf Geräteebene.

🏠 Home Assistant – das Smart-Home-Betriebssystem

Home Assistant ist das komplette Gegenmodell:

zentrale Logik
visuelle Automationen
Geräte unterschiedlichster Hersteller
komplexe Bedingungen, Zeitpläne, Sensoren, Szenen
Historie, Dashboards, Backups

Kurz gesagt: Smart Home als Betriebssystem.

Praxisbeispiel: Ein Taster schaltet zwei Relais

Setup:

Shelly i4 (4-fach Taster)
anderer Shelly mit 2 Relais
Ziel: Wenn Taster 4 gedrückt wird → beide Relais toggeln

Lösung mit Shelly Script (direkt im Gerät)

Das folgende Script läuft direkt auf dem Taster-Shelly.
Die IP-Adresse und IDs sind bewusst generisch gehalten:

let TARGET_IP = "192.168.0.100"; // Ziel-Shelly

Shelly.addEventHandler(function (event) {
  if (event.name !== "input" || !event.info) return;

  // 4. Taster
  if (event.info.id !== 3) return;

  // i4 sendet "toggle" Events
  if (event.info.event !== "toggle") return;

  // Nur bei Tastendruck (nicht beim Loslassen)
  if (event.info.state !== true) return;

  // Relais 0 toggeln
  Shelly.call("HTTP.GET", {
    url: "http://" + TARGET_IP + "/rpc/Switch.Toggle?id=0"
  });

  // Relais 1 toggeln
  Shelly.call("HTTP.GET", {
    url: "http://" + TARGET_IP + "/rpc/Switch.Toggle?id=1"
  });
});

Eigenschaften dieser Lösung:

reagiert sofort
keine Zentrale nötig
funktioniert auch wenn Home Assistant aus ist
läuft komplett lokal im LAN

Lösung mit Home Assistant (vereinfacht)

In Home Assistant sähe das so aus:

Trigger: Button pressed
Aktion: switch.toggle Relay 1
Aktion: switch.toggle Relay 2

Das ist komfortabel, visuell, leicht änderbar – aber:

Home Assistant muss laufen
WLAN + Server müssen funktionieren
leicht höhere Latenz

Praxisbeispiel: Treppenhauslicht mit Short/Long/Double-Press

Ein echter Klassiker aus dem Alltag: Treppenhauslicht. Du willst nicht jedes Mal wieder im Dunkeln stehen, aber du willst auch nicht, dass das Licht 2 Stunden durchballert, weil jemand einmal kurz dagegen geatmet hat.

Die Ziel-Logik:

Short Press → Licht 2 Minuten
Long Press → Licht 15 Minuten
Double Press → „Dauer-An“ togglen (ohne Timer)
erneutes Drücken verlängert jeweils den Timer

Setup:

Shelly Pro 1PM
Taster an Input 0
Licht an Switch 0

Lösung mit Shelly Script (Treppenhauslogik direkt im Gerät)

Hier sitzt die komplette Logik im Shelly. Kein Server, kein MQTT, keine zentrale Automation. Das Ding ist quasi dein Treppenhausrelais – nur in nerdig.

// Shelly Pro 1PM – Treppenhauslicht mit Shortpress/Longpress
// Input 0 steuert Switch 0
//
// Shortpress: Licht an für SHORT_MS (Timer wird bei erneutem Shortpress verlängert)
// Longpress:  Licht an für LONG_MS  (Timer wird bei erneutem Longpress verlängert)
// Optional Doublepress: "Dauer-An" togglen (ohne Timer)

let CFG = {
  INPUT_ID: 0,
  SWITCH_ID: 0,

  SHORT_MS: 2 * 60 * 1000,   // 2 Minuten
  LONG_MS:  15 * 60 * 1000,  // 15 Minuten

  ENABLE_DOUBLE_PRESS_ALWAYS_ON: true
};

let offTimer = null;
let alwaysOn = false;

function clearOffTimer() {
  if (offTimer !== null) {
    Timer.clear(offTimer);
    offTimer = null;
  }
}

function setSwitch(on) {
  Shelly.call("Switch.Set", { id: CFG.SWITCH_ID, on: on });
}

function startAutoOff(ms) {
  clearOffTimer();
  alwaysOn = false;

  // sicher einschalten
  setSwitch(true);

  offTimer = Timer.set(ms, false, function () {
    offTimer = null;
    // nur ausschalten, wenn nicht inzwischen "Dauer-An" aktiv wurde
    if (!alwaysOn) setSwitch(false);
  });
}

function toggleAlwaysOn() {
  clearOffTimer();
  alwaysOn = !alwaysOn;

  if (alwaysOn) {
    setSwitch(true);
  } else {
    // wenn "Dauer-An" aus, direkt in den Short-Timer zurückfallen
    startAutoOff(CFG.SHORT_MS);
  }
}

function handleButtonEvent(info) {
  // Erwartet: info.event in ["single_push","long_push","double_push", ...]
  if (!info || !info.event) return;

  if (info.event === "single_push") {
    startAutoOff(CFG.SHORT_MS);
    return;
  }

  if (info.event === "long_push") {
    startAutoOff(CFG.LONG_MS);
    return;
  }

  if (CFG.ENABLE_DOUBLE_PRESS_ALWAYS_ON &amp;&amp; info.event === "double_push") {
    toggleAlwaysOn();
    return;
  }
}

// Event-Handler registrieren
Shelly.addEventHandler(function (ev) {
  // Für Pro-Geräte kommen Button-Events typischerweise als input:* Events
  if (!ev || !ev.info) return;

  // Filter: nur unser Input
  // ev.component kann z.B. "input:0" sein
  if (ev.component === ("input:" + CFG.INPUT_ID)) {
    handleButtonEvent(ev.info);
  }
});

print("Treppenhaus-Script aktiv: Input", CFG.INPUT_ID, "-> Switch", CFG.SWITCH_ID);

Eigenschaften dieser Lösung:

reagiert sofort
kein Server nötig
Timer-Verlängerung ist automatisch drin
Dauerlicht ist optional per Double Press
läuft komplett lokal – auch wenn dein Home-Server gerade „Updates macht“

Home-Assistant-Variante (zum Vergleich)

Das gleiche Prinzip geht auch in Home Assistant – dann liegt die Logik zentral. Vorteil: du kannst später ganz entspannt Sensoren, Zeitfenster, Helligkeit (Lux), Anwesenheit oder „nachts nur gedimmt“ dranhängen.

Für „Dauer-An“ nutzen wir einen Helper:

input_boolean.treppenhaus_dauer_an

Und als Schalt-Entity fürs Licht nehmen wir in den Beispielen:

switch.treppenhauslicht

Wichtig: Die Trigger unterscheiden sich je nach Gerät/Integration. Das Muster bleibt gleich – du passt nur event_type/event_data an deinen Button an (z. B. Shelly i4, Zigbee-Button, MQTT Button, etc.).

Automation: Short Press (2 Minuten)

Der Trick ist mode: restart: erneutes Drücken startet die Automation neu → der Timer verlängert sich automatisch.

alias: Treppenhauslicht - Short Press (2 Minuten)
mode: restart
trigger:
  - platform: event
    event_type: shelly_click
    event_data:
      device: shelly_taster_treppenhaus
      click_type: single
condition:
  - condition: state
    entity_id: input_boolean.treppenhaus_dauer_an
    state: "off"
action:
  - service: switch.turn_on
    target:
      entity_id: switch.treppenhauslicht
  - delay: "00:02:00"
  - condition: state
    entity_id: input_boolean.treppenhaus_dauer_an
    state: "off"
  - service: switch.turn_off
    target:
      entity_id: switch.treppenhauslicht

Automation: Long Press (15 Minuten)

alias: Treppenhauslicht - Long Press (15 Minuten)
mode: restart
trigger:
  - platform: event
    event_type: shelly_click
    event_data:
      device: shelly_taster_treppenhaus
      click_type: long
condition:
  - condition: state
    entity_id: input_boolean.treppenhaus_dauer_an
    state: "off"
action:
  - service: switch.turn_on
    target:
      entity_id: switch.treppenhauslicht
  - delay: "00:15:00"
  - condition: state
    entity_id: input_boolean.treppenhaus_dauer_an
    state: "off"
  - service: switch.turn_off
    target:
      entity_id: switch.treppenhauslicht

Automation: Double Press („Dauer-An“ togglen)

alias: Treppenhauslicht - Double Press (Dauer-An)
mode: single
trigger:
  - platform: event
    event_type: shelly_click
    event_data:
      device: shelly_taster_treppenhaus
      click_type: double
action:
  - service: input_boolean.toggle
    target:
      entity_id: input_boolean.treppenhaus_dauer_an

  - choose:
      - conditions:
          - condition: state
            entity_id: input_boolean.treppenhaus_dauer_an
            state: "on"
        sequence:
          - service: switch.turn_on
            target:
              entity_id: switch.treppenhauslicht
    default:
      # Dauer-An wurde ausgeschaltet → zurück in den Short-Timer
      - service: switch.turn_on
        target:
          entity_id: switch.treppenhauslicht
      - delay: "00:02:00"
      - condition: state
        entity_id: input_boolean.treppenhaus_dauer_an
        state: "off"
      - service: switch.turn_off
        target:
          entity_id: switch.treppenhauslicht

Der direkte Vergleich

Geschwindigkeit

Shelly Script gewinnt. Kein Umweg, kein MQTT, kein Server.
Der Tastendruck fühlt sich sofort an.

Zuverlässigkeit

Shelly Script gewinnt ebenfalls.
Wenn dein Home-Server rebootet oder crasht, funktionieren direkte Scripts trotzdem.

Flexibilität

Home Assistant gewinnt klar:

Zeitabhängige Logik
Sensor-Kombinationen
komplexe Bedingungen
Visualisierung

Wartbarkeit

Home Assistant ist angenehmer.
Scripts sind Code. YAML/GUI ist für viele leichter.

Skalierung

Ab ca. 20–30 Geräten wird zentrale Logik übersichtlicher.
Bei 3–10 Geräten ist Shelly Script herrlich simpel.

Meine Faustregel

Ich nutze:

Shelly Script, wenn:
- Taster → Aktion
- hohe Zuverlässigkeit
- sofortige Reaktion
- einfache Logik
Home Assistant, wenn:
- mehrere Geräte beteiligt sind
- Zeit / Sensoren / Zustände eine Rolle spielen
- Visualisierung gebraucht wird

Oder anders gesagt:

Grundfunktionen dezentral, Komfort zentral.

Hardware-Empfehlungen

Die Geräte aus den Beispielen:

Shelly i4 Gen3 – für Wandtaster (bezahlter Link)
Shelly Pro 1PM – robust für Verteilung / Treppenhaus (bezahlter Link)
Shelly Plus 2PM – zwei Relais mit Messung (bezahlter Link)
Raspberry Pi 5 – als Home Assistant Host (bezahlter Link)
Mini-PC – gute Alternative zum Raspberry Pi (bezahlter Link)

Fazit

Shelly Script ist kein Ersatz für Home Assistant.
Home Assistant ist kein Ersatz für Shelly Script.

Zusammen sind sie allerdings ziemlich nah an einem kleinen, lokalen Skynet – nur ohne Weltherrschaftspläne. Hoffentlich.

Wer sein Smart Home stabil, schnell und cloudfrei betreiben will, sollte beide Werkzeuge kennen und bewusst einsetzen.

Mehr lokales Smart Home

Wenn dich das Thema „lokales Smart Home ohne Cloud“ tiefer interessiert, findest du auf dem Blog schon einige passende Praxisartikel: In Shelly Direktverknüpfung – lokale Automationen ohne Cloud zeige ich, wie Geräte komplett ohne Zentrale miteinander sprechen. Wer eher aus der ioBroker-Ecke kommt, kann sich Licht automatisch einschalten beim PC-Start oder Automatisches Licht mit Blockly anschauen. Und falls du generell zwischen Zigbee, WLAN und Z-Wave schwankst, hilft vielleicht auch der Überblick in Zigbee, Z-Wave, WLAN, was MATTERs.