Teil 2: Von der Konsole zu ersten Automationen
Im ersten Teil dieser Serie hast du die Shelly-Plattform und ihre Vorteile kennengelernt. Jetzt wird es praktisch: In diesem Artikel steigen wir direkt in die Programmierung ein.
Du lernst, wie du Shelly-Skripte erstellst, was die Skriptsprache kann und wie du erste einfache Automationen umsetzt – alles direkt im Gerät, ohne zusätzliche Software.
1. Grundlagen des Shelly Scriptings
Die Shelly-Geräte der Plus- und Gen3-Serie verfügen über eine integrierte Skriptumgebung, mit der sich lokale Automationen, Datenübertragungen und komplexe Logiken vollständig ohne Hub umsetzen lassen.
1.1 Was ist Shelly Script?
Shelly Script ist eine eigene Laufzeitumgebung, die auf ECMAScript 5.1 basiert – einer vereinfachten Form von JavaScript. Die Skripte laufen direkt auf dem Mikrocontroller des Geräts und benötigen keine zusätzliche Software oder Cloud-Verbindung.
💡 Wichtig: Shelly Script ist JavaScript-ähnlich, aber kein vollständiges JavaScript. Es gibt keinen Browser, kein DOM und keine Node.js-Module. Stattdessen bietet Shelly eigene APIs für Hardware-Zugriff.
1.2 Typische Eigenschaften der Shelly-Skripte
- JavaScript-ähnliche Syntax: Variablen, Funktionen, if-Bedingungen, Schleifen
- Zugriff auf Hardware: Relais, Eingänge, Sensoren, Schalter
- HTTP-Requests: GET und POST für Kommunikation mit Servern
- Timer: Zyklische und einmalige Zeitabläufe
- Eventhandler: Reaktionen auf Gerätereignisse in Echtzeit
- Lokale Ausführung: Keine Cloud oder externe Software erforderlich
Diese Kombination macht Shelly-Geräte zu kleinen, autonomen Automationscontrollern.
2. Erste Schritte: Skripte in den Shelly laden
Shelly macht es besonders einfach: Die gesamte Entwicklungsumgebung befindet sich bereits im Gerät. Du benötigst lediglich einen Browser oder die Shelly-App.
📚 Offizielle Ressourcen: Shelly bietet eine umfangreiche Script Library mit Beispielen unter https://www.shelly.com/blogs/scripts-library
2.1 Skripte direkt im Webinterface erstellen
Der einfachste Weg ist das Webinterface des Geräts. Hier ist der genaue Ablauf:
- Shelly im Browser öffnen
Beispiel: http://192.168.178.25
- Menüpunkt ‚Scripts‘ auswählen
Im linken Menü findest du den Punkt ‚Scripts‘ { }
- ‚Add Script‘ klicken
Öffnet den Editor für ein neues Skript
- Skript eingeben
Code direkt in den Editor schreiben
- ‚Enable on Boot‘ aktivieren
Falls das Skript beim Gerätestart automatisch laufen soll
- Speichern und Starten
Der integrierte Editor bietet:
- Live-Logs mit Ausgaben deiner print()-Befehle
- Fehlermeldungen mit Zeilenangabe
- Start/Stop-Buttons für schnelles Testen
- Status-Anzeige (läuft/gestoppt)
2.2 Skripte über die Shelly App
Auch in der Shelly-App (iOS/Android) lassen sich Skripte anlegen und verwalten:
- Gerät in der App auswählen
- Gerätemenü → ‚Scripts‘ → ‚{ }‘ Symbol
- Neues Skript erstellen oder vorhandenes bearbeiten
- Optionen: Skript starten, beim Boot ausführen, editieren
⚠️ Hinweis: Die App ist weniger komfortabel für die Entwicklung, da die Logausgaben nicht so übersichtlich dargestellt werden wie im Webinterface. Für erste Tests und kurze Skripte ist sie aber völlig ausreichend.
2.3 Skripte zentral verwalten (fortgeschritten)
Für fortgeschrittene Anwender: Shelly-Geräte können Skripte per HTTP-Request von einem Webserver nachladen. Das ist besonders hilfreich, wenn du mehrere Geräte mit identischen Skripten betreibst und diese zentral pflegen möchtest.
Diese Methode behandeln wir in einem späteren Artikel der Serie.
3. Der ideale Einstieg: Schritt für Schritt
Um effizient zu starten und Frustrationen zu vermeiden, empfiehlt sich eine schrittweise Vorgehensweise. Hier ist mein bewährter 5-Phasen-Plan:
3.1 Phase 1: Die Konsole verstehen
Beginne mit einfachen print()-Ausgaben, um direktes Feedback im Log zu erhalten:
print("Skript gestartet.");
print("Aktuelle Zeit:", Date.now());
So lässt sich prüfen, ob Timer greifen, HTTP-Requests funktionieren oder Sensorwerte korrekt gelesen werden.
3.2 Phase 2: Gerätestatus abfragen
Bevor Automationen entstehen, solltest du lernen, Informationen aus dem Gerät auszulesen. Typische Abfragen:
- Relais-Status (Ein/Aus)
- Leistungsmessung (Watt)
- Temperatur- und Feuchtigkeitswerte
- Geräteinformationen (ID, Firmware)
3.3 Phase 3: Kommunikation nach außen
HTTP-GET und POST ermöglichen die Datenübertragung an:
- PHP-Server (z.B. für Datenbank-Speicherung)
- Node-RED (für visuelle Flows)
- Datenbank-APIs (direkt oder über Middleware)
- Monitoring-Dienste (ThingSpeak, InfluxDB, etc.)
3.4 Phase 4: Events und Timer
Mit Timern und Eventhandlern wird Shelly zu einem lokalen Automationssystem:
- Timer: Erzeugen zyklische Abläufe (z.B. alle 60 Sekunden Messung)
- Eventhandler: Reagieren sofort auf Relais, Tasten oder Sensoränderungen
3.5 Phase 5: Eigene Projekte
Typische erste Projekte:
- Werte an eigenen Server senden
- Schaltszenario abhängig von Temperatur oder Leistung
- Türkontakt steuert Lichtszenarien
- Benachrichtigung bei Grenzwertüberschreitung
4. Praktische Beispielprogramme
Alle folgenden Beispiele funktionieren auf Shelly Plus- und Gen3-Geräten. Kopiere sie einfach in den Script-Editor und passe die Parameter an deine Bedürfnisse an.
4.1 Statusabfrage eines Relais
Dieses einfache Skript fragt den Zustand des ersten Relais ab und zeigt Leistung und Status im Log:
let status = Shelly.getComponentStatus("switch", 0);
print("Relay state:", status.output);
print("Power:", status.apower, "W");
💡 Erklärung: getComponentStatus() liefert Informationen über Hardware-Komponenten. Der erste Parameter ist der Komponententyp (switch), der zweite die Nummer (0 = erstes Relais).
4.2 Einfacher HTTP GET Request
Daten an einen Webserver senden – ideal für Logging oder einfache Steuerbefehle:
Shelly.call(
"HTTP.GET",
{ url: "http://example.com/receiver.php?msg=hello" },
function (res, err) {
if (err) {
print("Error:", err.code);
} else {
print("Response:", JSON.stringify(res));
}
}
);
Ersetze example.com/receiver.php durch deine eigene URL.
4.3 HTTP POST mit JSON-Daten
Ideal, wenn du strukturierte Messwerte an deine eigene Datenbank oder API senden möchtest:
let data = {
temperature: 23.5,
humidity: 58,
device: Shelly.getDeviceInfo().id
};
Shelly.call(
"HTTP.POST",
{
url: "http://example.com/api/sensor.php",
body: JSON.stringify(data),
headers: { "Content-Type": "application/json" }
},
function (res, err) {
if (err) {
print("HTTP Error:", err.code);
} else {
print("Server Antwort:", JSON.stringify(res));
}
}
);
📊 Praxistipp: Dieses Pattern nutze ich in meinem Bungalow, um alle Messwerte (Temperatur, Luftfeuchtigkeit, Leistung) an meine MySQL-Datenbank zu senden. Das PHP-Script empfängt die JSON-Daten und speichert sie in der Datenbank.
4.4 Periodischer Task (alle 30 Sekunden)
Dieser Timer wird durchgehend wiederholt ausgeführt – perfekt für zyklische Messungen:
Timer.set(30 * 1000, true, function () {
let s = Shelly.getComponentStatus("switch", 0);
print("Aktueller Zustand:", s.output);
print("Leistung:", s.apower, "W");
});
30 * 1000 = 30.000 Millisekunden = 30 Sekunden. Der zweite Parameter (true) bedeutet, dass der Timer sich wiederholt.
4.5 Reaktion auf ein Ereignis
Eventhandler ermöglichen sofortige Reaktionen auf Hardware-Events:
Shelly.addEventHandler(function (event) {
if (event.component === "switch:0") {
if (event.info.event === "toggle") {
print("Relais wurde geschaltet.");
print("Neuer Status:", event.info.output);
}
}
});
🎯 Anwendungsfall: Du kannst auf diese Weise Benachrichtigungen senden, Logging durchführen oder andere Geräte ansteuern, sobald ein Relais geschaltet wird – alles in Echtzeit, ohne Polling.
5. Best Practices und Tipps
Nach vielen Stunden Programmierung und Testing habe ich einige Best Practices zusammengestellt:
5.1 Debugging mit print()
- Nutze print() großzügig während der Entwicklung
- Gib Zeitstempel aus, um Zeitabläufe zu verstehen
- Logge Variablenwerte vor kritischen Operationen
- Kommentiere Debug-Ausgaben später aus statt sie zu löschen
5.2 Fehlerbehandlung
- Prüfe immer auf Fehler in HTTP-Callbacks
- Nutze Try-Catch für kritische Code-Abschnitte
- Logge Fehlermeldungen mit Kontext-Informationen
5.3 Speicher und Performance
- Shelly-Geräte haben begrenzte Ressourcen
- Vermeide zu viele Timer (maximal 2-3 parallel)
- Halte Skripte kurz und fokussiert
- Bei komplexen Logiken: Auslagern auf Server-Seite
5.4 Versionierung
- Speichere funktionierende Skripte lokal als Backup
- Dokumentiere Änderungen mit Kommentaren
- Teste neue Versionen auf einem Test-Gerät
6. Fazit und Ausblick
Die Skriptumgebung macht Shelly zu mehr als einem einfachen Schaltaktor: Sie verwandelt das Gerät in eine eigenständige Automationsplattform – lokal, flexibel und ohne Cloud-Zwang.
Mit wenigen Zeilen JavaScript kannst du:
- Sensorwerte auslesen und verarbeiten
- Geräte miteinander intelligent verknüpfen
- Automationen vollständig lokal ausführen
- Daten an eigene Server oder Datenbanken senden
- Komplexe Logiken realisieren, die weit über App-Funktionen hinausgehen
Was kommt als Nächstes?
In den kommenden Artikeln dieser Serie auf diytechadventures.de/projekte zeige ich dir:
- MySQL-Integration: Wie du Shelly-Daten in einer eigenen Datenbank speicherst
- Webinterface: Dashboards für Visualisierung und Steuerung
- BLU Gateway Scripting: Bluetooth-Sensoren auswerten und weiterleiten
- Erweiterte Automationen: Komplexe Szenarien aus meinem Bungalow-Projekt
- ThingSpeak-Integration: Cloud-Visualisierung für Fernzugriff
—
Folge dieser Serie auf diytechadventures.de
Hast du bereits erste Skripte erstellt?
Teile deine Erfahrungen in den Kommentaren!