Shelly Script Studio: Eigene Logik direkt auf dem Gerät programmieren

Was ist das Shelly Script Studio?

Das Shelly Script Studio ist die lokale Programmierumgebung für Shelly-Geräte der Plus– und Pro-Serie. Diese Geräte besitzen eine integrierte JavaScript-Engine auf Basis von Espruino – einem schlanken JavaScript-Interpreter. Du arbeitest also mit vertrauter Syntax, ohne externe Systeme. Die gesamte Logik läuft lokal: kurze Reaktionszeiten, keine Cloud-Abhängigkeit, maximaler Datenschutz.

Unterstützte Modelle sind zum Beispiel Shelly Plus 1, Plus 2PM oder Pro 4PM – sie haben genug Rechenleistung und Speicher für lokale Skripte. Ältere Shelly-Modelle (Gen1) unterstützen kein Scripting.

Technische Rahmenbedingungen

Bevor du loslegst, solltest du die Grenzen kennen:

• Max. Skriptgröße: ca. 16 KB pro Skript
• Max. gleichzeitige Skripte: bis zu 10 (je nach Modell)
• RAM: begrenzt – vermeide große Arrays oder tiefe Rekursion
• Kein fetch(), kein DOM, kein console.log(): Statt console.log() nutzt du print(); HTTP-Requests laufen über Shelly.call()
• Begrenzte ES6-Unterstützung: Arrow Functions und let/const funktionieren, aber komplexe ES6+-Features wie Promises oder Destructuring sind nicht verfügbar

Shelly programmieren: Schritt-für-Schritt-Anleitung für dein erstes Skript

So richtest du dein erstes Skript ein – von Null bis zum laufenden Code:

1. Gerät verbinden: Versorge deinen Shelly Plus oder Pro mit Strom und verbinde ihn per WLAN mit deinem Heimnetzwerk – am einfachsten über die Shelly-App.
2. Weboberfläche öffnen: Rufe die IP-Adresse im Browser auf, z. B. http://192.168.x.x. Die IP findest du in deiner Router-Übersicht oder in der Shelly-App.
3. Skript anlegen: Navigiere zu „Skripte“ → „Neues Skript“. Gib dem Skript einen Namen (z. B. „HelloWorld“) und füge deinen JavaScript-Code in das Textfeld ein.
4. Skript starten: Klicke auf „Speichern“, dann auf „Start“. Aktiviere „Debug über Websocket“, um Ausgaben live zu sehen.
5. Autostart aktivieren: Schalte „Bei Neustart starten“ ein, damit das Skript nach jedem Neustart automatisch läuft.

Hello World: Dein erstes Shelly-Skript

Das folgende Skript gibt alle fünf Sekunden eine Meldung aus – perfekt zum Testen, ob alles funktioniert:

// Einfaches Hello-World-Skript für Shelly
// print() ersetzt console.log() in der Shelly-Umgebung

print("Shelly Script gestartet!");

// Timer.set(Intervall_ms, wiederholen, Callback)
Timer.set(5000, true, function () {
  print("Hallo aus dem Shelly-Skript! Zeit läuft...");
});

Nachdem du das Skript gespeichert und gestartet hast, siehst du im Debug-Fenster alle fünf Sekunden die Ausgabe. So weißt du sofort, dass dein Setup funktioniert.

JavaScript-Grundlagen für Shelly-Einsteiger

Du musst kein Programmierer sein, um Shelly-Skripte zu schreiben. Diese Grundbausteine reichen für die meisten Automatisierungen aus:

Variablen: Werte speichern

Mit let speicherst du Werte, die sich ändern können. Mit const definierst du feste Werte:

const SCHWELLENWERT = 70; // Fester Grenzwert in Prozent
let aktuelleFeuchte = 65; // Aktueller Messwert, kann sich ändern

Bedingungen: Wenn–Dann–Sonst

Mit if/else reagierst du auf Messwerte oder Zustände:

if (aktuelleFeuchte > SCHWELLENWERT) {
  print("Feuchte zu hoch – Lüfter einschalten");
  // Shelly.call("Switch.Set", { id: 0, on: true }, null, null);
} else {
  print("Feuchte OK – Lüfter bleibt aus");
}

Schleifen: Wiederholungen

Für Shelly-Skripte sind Schleifen selten nötig – Timer übernehmen die Wiederholung. Für einmalige Initialisierungen kannst du for nutzen:

// Beispiel: Mehrere Ausgaben initialisieren
for (let i = 0; i < 3; i++) {
  print("Initialisiere Kanal " + i);
}

Funktionen: Code wiederverwenden

Lagere wiederkehrende Logik in Funktionen aus:

function luefterSteuern(feuchte, grenzwert) {
  if (feuchte > grenzwert) {
    Shelly.call("Switch.Set", { id: 0, on: true }, null, null);
    print("Lüfter EIN (Feuchte: " + feuchte + "%)");
  } else {
    Shelly.call("Switch.Set", { id: 0, on: false }, null, null);
    print("Lüfter AUS (Feuchte: " + feuchte + "%)");
  }
}

Tipp: Kommentare (Zeilen mit //) werden nicht ausgeführt – nutze sie, um deinen Code zu erklären. Das hilft dir selbst, wenn du das Skript Wochen später wieder öffnest.

Die wichtigsten Shelly Script API-Methoden

Shelly stellt eigene Funktionen bereit, die du in jedem Skript nutzen kannst:

Beispielprojekte: Logik direkt auf dem Gerät

Hier zwei praxisnahe Projekte mit vollständigem, kommentiertem Code:

Feuchtigkeitsgesteuerte Lüftung

Ein Shelly H&T misst die Luftfeuchtigkeit im Badezimmer. Ein Shelly Plug S steuert den Ventilator. Das Skript prüft alle 30 Sekunden den Feuchtigkeitswert und schaltet den Lüfter mit Hysterese (70 % ein, 60 % aus), um ständiges Takten zu vermeiden:

// Feuchtigkeitsgesteuerte Lüftung
// Shelly Plus 1 steuert Ventilator; Feuchtigkeitswert kommt per RPC

const FEUCHTE_EIN = 70;  // Lüfter einschalten ab diesem Wert (%)
const FEUCHTE_AUS = 60;  // Lüfter ausschalten unter diesem Wert (%)
let luefterAn = false;   // Aktueller Zustand des Lüfters

// Alle 30 Sekunden Feuchtigkeitswert prüfen
Timer.set(30000, true, function () {
  // Aktuellen Schaltstatus und angeschlossene Sensorwerte abrufen
  Shelly.call("Humidity.GetStatus", { id: 0 }, function (result) {
    if (!result) {
      print("Fehler: Kein Sensorwert erhalten");
      return;
    }
    let feuchte = result.rh; // Relative Luftfeuchtigkeit in %
    print("Aktuelle Feuchte: " + feuchte + "%");

    // Hysterese: Einschalten nur wenn Grenzwert überschritten
    if (feuchte >= FEUCHTE_EIN && !luefterAn) {
      Shelly.call("Switch.Set", { id: 0, on: true }, null, null);
      luefterAn = true;
      print("Lüfter EIN");
    }
    // Ausschalten erst wenn deutlich unter Grenzwert
    if (feuchte <= FEUCHTE_AUS && luefterAn) {
      Shelly.call("Switch.Set", { id: 0, on: false }, null, null);
      luefterAn = false;
      print("Lüfter AUS");
    }
  }, null);
});

Windbasierte Markisensteuerung

Ein Shelly Plus 2PM steuert eine Markise. Über einen angeschlossenen Windsensor oder eine lokale API wird die Windgeschwindigkeit abgefragt. Überschreitet sie einen Grenzwert, fährt die Markise automatisch ein:

// Windbasierte Markisensteuerung
// Shelly Plus 2PM im Rolladen-Modus steuert die Markise

const WIND_GRENZWERT = 40; // Windgeschwindigkeit in km/h
let markiseEingefahren = false;

// Alle 60 Sekunden Windwert prüfen
Timer.set(60000, true, function () {
  // Windwert von lokalem Sensor abrufen (Beispiel: HTTP-Endpunkt)
  Shelly.call("HTTP.GET", { url: "http://192.168.1.50/wind" }, function (result) {
    if (!result || result.code !== 200) {
      print("Fehler beim Abrufen des Windwerts");
      return;
    }
    // Antwort parsen (Beispiel: JSON mit Feld "speed")
    let daten = JSON.parse(result.body);
    let wind = daten.speed;
    print("Windgeschwindigkeit: " + wind + " km/h");

    if (wind >= WIND_GRENZWERT && !markiseEingefahren) {
      // Markise einfahren (Rolladen-Befehl: Position 0 = geschlossen)
      Shelly.call("Cover.GoToPosition", { id: 0, pos: 0 }, null, null);
      markiseEingefahren = true;
      print("Markise eingefahren – zu viel Wind");
    } else if (wind < WIND_GRENZWERT && markiseEingefahren) {
      // Markise ausfahren
      Shelly.call("Cover.GoToPosition", { id: 0, pos: 100 }, null, null);
      markiseEingefahren = false;
      print("Markise ausgefahren – Wind hat nachgelassen");
    }
  }, null);
});

Vorteile und Grenzen des Shelly Script Studio

Vorteile

• Vollständige Offline-Funktion: Unabhängig von Cloud-Diensten und Internet.
• Schnelle Reaktionszeiten: Lokale Ausführung ohne Netzwerk-Latenz.
• Hohe Ausfallsicherheit: Skripte laufen weiter, selbst wenn WLAN oder Home Assistant ausfällt.
• Offene Schnittstellen: REST, MQTT und CoAP ermöglichen Integration in Home Assistant oder Node-RED.
• Flexible Logik: Komplexe Bedingungen, die über einfache Wenn-Dann-Regeln hinausgehen.

Nachteile

• Programmierkenntnisse erforderlich: Ohne JavaScript-Grundlagen wird es schwierig.
• Nur für Plus- und Pro-Geräte: Ältere Shelly-Modelle unterstützen keine Skripte.
• Isolierte Logik: Skripte laufen nur auf dem jeweiligen Gerät – keine zentrale Übersicht.
• Fehleranfälligkeit: Ein fehlerhaftes Skript kann das Gerät blockieren.
• Kein grafischer Editor: Anders als in Home Assistant gibt es keine visuelle Oberfläche.

Fehlersuche und Debugging

Websocket-Debugging aktivieren

Im Webinterface findest du im Skript-Bereich die Option „Debug über Websocket“. Aktivierst du sie, siehst du alle print()-Ausgaben in Echtzeit. So erkennst du schnell, wo dein Code hängt oder falsche Werte liefert.

Schrittweise testen

Teste deinen Code in kleinen Schritten. Setze print()-Ausgaben gezielt ein, um Zwischenwerte zu prüfen:

print("Feuchte-Wert: " + feuchte); // Wert im Debug-Fenster anzeigen

Firmware aktuell halten

Shelly verbessert die Script Engine regelmäßig. Ein Firmware-Update kann neue Funktionen bringen und Probleme mit bestehenden Skripten lösen. Wichtig: Nach einem Firmware-Update können Skripte in seltenen Fällen inkompatibel werden – teste deine Skripte nach Updates kurz durch.

Community-Ressourcen nutzen

Die Shelly Knowledge Base, das offizielle Forum und GitHub bieten viele Beispiele und Hilfestellungen. Smart-Home-Communities sind eine echte Fundgrube für fertige Skripte und Lösungen.

FAQ: Häufige Fragen und typische Fehler

Kosten und Zukunftsaussichten

Die Nutzung der Shelly Script Engine ist kostenlos – keine Lizenzgebühren, keine Abos. Die Funktion ist Teil der Firmware. Ein einfaches Modul wie der Shelly 1 kostet etwa 15–20 €, leistungsfähigere Modelle wie der Shelly Pro 4PM liegen im Bereich von 40–60 €.

Shelly entwickelt das Scripting-Ökosystem stetig weiter: Die Shelly Academy bietet Tutorials für Einsteiger, und die wachsende Community stellt fertige Skripte zur Verfügung. Mit der Gen4-Serie integriert Shelly Matter und Zigbee direkt – die Geräte unterstützen Wi-Fi 6 und machen lokale Automatisierung noch vielseitiger. Für ältere Modelle gibt es eine Matter Bridge, sodass auch bestehende Geräte in moderne Ökosysteme eingebunden werden können.