Beiträge von H-OS.de

// Shelly 1PM Gen4 Script
// Scene triggern über Cloud mit Auth Header
let SCENE_ID = 1756892757365;            // deine Scene-ID
let AUTH_KEY = "HIER_DEIN_AUTH_KEY";     // aus App/Web (User Settings → Authentication Key)
let CLOUD_URL = "https://shelly-XX-eu.shelly.cloud/scene/trigger"; // deine Cloud-URL
function triggerScene() {
  Shelly.call("http.post", {
      url: CLOUD_URL,
          body: JSON.stringify({ id: SCENE_ID }),
              headers: {
                    "Content-Type": "application/json",
                          "Authorization": "Bearer " + AUTH_KEY
                              },
                                  ssl_ca: "*"
                                    }, function (res, err) {
                                        if (err) {
                                              print("Fehler HTTP: ", JSON.stringify(err));
                                                  } else {
                                                        print("Antwort Cloud: ", res.code, res.body);
                                                            }
                                                              });
                                                              }
                                                              // Switch-Änderungen überwachen
                                                              Shelly.call("Switch.Subscribe", { id: 0 });
                                                              Shelly.addStatusHandler(function (status) {
                                                                if (status.component === "switch:0" && status.delta.output === true) {
                                                                    print("Trigger Scene wegen Einschalten");
                                                                        triggerScene();
                                                                          }
                                                                          });

// --- Konfiguration ---
let mode = "hold";           // "instant", "timer", "hold"
let timerSeconds = 30;       // Timerdauer
let luxThreshold = 100;      // Lux-Schwelle
let DEBUG = true;
let LOCAL_LIGHT_ID = 0;
// Zusätzliche Lichter via HTTP
let ADDITIONAL_LIGHTS = [
  // { "ip": "192.168.1.100", "id": 0, "auth": "your_auth_key" }
  ];
  // ----------------------
  let timer = null;
  let motionStates = {};  // motion sensorId -> Boolean
  let luxStates = {};     // lux sensorId -> Number
  // --- Lichtfunktionen ---
  function turnLightOn() {
    print("💡 Licht AN");
      Shelly.call("Switch.Set", { id: LOCAL_LIGHT_ID, on: true });
        for (let l of ADDITIONAL_LIGHTS) {
            let url = "http://" + l.ip + "/rpc/Switch.Set?id=" + l.id + "&on=true";
                if (l.auth) url += "&auth_key=" + l.auth;
                    Shelly.call("HTTP.GET", { url: url });
                      }
                      }
                      function turnLightOff() {
                        print("💡 Licht AUS");
                          Shelly.call("Switch.Set", { id: LOCAL_LIGHT_ID, on: false });
                            for (let l of ADDITIONAL_LIGHTS) {
                                let url = "http://" + l.ip + "/rpc/Switch.Set?id=" + l.id + "&on=false";
                                    if (l.auth) url += "&auth_key=" + l.auth;
                                        Shelly.call("HTTP.GET", { url: url });
                                          }
                                          }
                                          // --- Hilfsfunktion ---
                                          function parseValue(val) {
                                            if (val === "true") return true;
                                              if (val === "false") return false;
                                                if (!isNaN(parseFloat(val))) return parseFloat(val);
                                                  return val;
                                                  }
                                                  // --- Lichtentscheidungs-Logik ---
                                                  function shouldLightBeOn() {
                                                    for (let motionId in motionStates) {
                                                        if (motionStates[motionId] === true) {
                                                              // Suche zugehörigen Lux-Sensor (alle Lux-Werte prüfen)
                                                                    for (let luxId in luxStates) {
                                                                            if (luxStates[luxId] < luxThreshold) return true;
                                                                                  }
                                                                                      }
                                                                                        }
                                                                                          return false;
                                                                                          }
                                                                                          // --- Event-Handler ---
                                                                                          Shelly.addEventHandler(function(event) {
                                                                                            if (event.component && event.component.indexOf("bthomesensor:") === 0) {
                                                                                                let sensorId = event.component.split(":")[1];
                                                                                                    let val = parseValue(event.info && event.info.value);
                                                                                                        if (val === true || val === false) {
                                                                                                              motionStates[sensorId] = val;
                                                                                                                    if (DEBUG) print("Motion Sensor", sensorId, "=", val);
                                                                                                                        } else if (typeof val === "number") {
                                                                                                                              luxStates[sensorId] = val;
                                                                                                                                    if (DEBUG) print("Lux Sensor", sensorId, "=", val);
                                                                                                                                        }
                                                                                                                                            // Lichtsteuerung
                                                                                                                                                let lightShouldBeOn = shouldLightBeOn();
                                                                                                                                                    if (lightShouldBeOn) {
                                                                                                                                                          turnLightOn();
                                                                                                                                                                if (timer) { Timer.clear(timer); timer = null; }
                                                                                                                                                                    } else {
                                                                                                                                                                          if (mode === "instant") {
                                                                                                                                                                                  turnLightOff();
                                                                                                                                                                                        } else if (mode === "timer") {
                                                                                                                                                                                                if (timer) Timer.clear(timer);
                                                                                                                                                                                                        timer = Timer.set(timerSeconds*1000, false, turnLightOff);
                                                                                                                                                                                                              } else if (mode === "hold") {
                                                                                                                                                                                                                      if (timer) Timer.clear(timer);
                                                                                                                                                                                                                              timer = Timer.set(timerSeconds*1000, false, function() {
                                                                                                                                                                                                                                        if (!shouldLightBeOn()) turnLightOff();
                                                                                                                                                                                                                                                  timer = null;
                                                                                                                                                                                                                                                          });
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                      });
                                                                                                                                                                                                                                                                      print("📡 Script gestartet – automatische Multi-Sensor-Logik, Mode: " + mode + ", Lux < " + luxThreshold);

/*
* Shelly Skript für die Steuerung von Lichtern auf Basis von Shelly BLU Motion Sensoren.
* Neu: Berücksichtigt den Lux-Wert zur Steuerung.
* --------------------------------------------------------------------------------
* Skript ID:     shelly-blu-motion-light-control
* Version:       1.1
* Kompatibel mit:Shelly Gen4 Geräten (z.B. Shelly Pro/Plus)
* --------------------------------------------------------------------------------
* Konfiguration:
* - Passen Sie die BLU Motion Device-IDs, die Licht-ID, die Timeout-Werte und den Lux-Schwellenwert an.
* - Optional können Sie zusätzliche Lichter über HTTP steuern.
*/
// --------- KONFIGURATION ---------
// ---------------------------------
// Liste der Shelly BLU Motion Sensoren, die das Skript überwachen soll.
// Die IDs finden Sie in den Bluetooth-Einstellungen des Shelly Geräts.
let BLU_MOTION_SENSORS = [
  "BLU_MOTION_SENSOR_ID_1", // Beispiel: "a1b2c3d4e5f6"
    "BLU_MOTION_SENSOR_ID_2", // Beispiel: "1234567890ab"
      "BLU_MOTION_SENSOR_ID_3", // Fügen Sie hier weitere IDs hinzu
      ];
      // Die ID des Lichts, das gesteuert werden soll.
      // Dies bezieht sich auf die `light` Komponente des Shelly, die Sie im Web-UI sehen.
      // Normalerweise 'light:0' oder 'switch:0' für das interne Relais.
      let LOCAL_LIGHT_ID = "switch:0";
      // Wie lange das Licht nach der letzten erkannten Bewegung eingeschaltet bleiben soll (in Sekunden).
      let TIMEOUT_SECONDS = 300; // 5 Minuten
      // Der Lux-Schwellenwert. Das Licht wird nur eingeschaltet, wenn der aktuelle Lux-Wert 
      // des Sensors UNTER diesem Wert liegt. Passen Sie diesen Wert an Ihre Umgebung an.
      let LUX_THRESHOLD = 50; // Beispiel: 50 Lux
      // Optionale Konfiguration für zusätzliche Lichter, die über HTTP gesteuert werden sollen.
      let ADDITIONAL_LIGHTS = [
        // {
          //   "ip_address": "192.168.1.100",
            //   "light_id": "switch:0",
              //   "auth": "your_auth_key"
                // },
                ];
                // ---------------------------------
                // --------- SKRIPT LOGIK ---------
                // ---------------------------------
                let motionTimeout = null;
                let lastMotionTime = 0;
                let isLightOn = false;
                // Funktion zum Einschalten des Lichts
                function turnLightOn() {
                  if (isLightOn) return;
                    
                      print("Bewegung erkannt und Lux-Wert ist niedrig. Schalte Licht ein.");
                        isLightOn = true;
                          // Schaltet das interne Shelly-Relais ein
                            Shelly.call("Switch.Set", {
                                id: LOCAL_LIGHT_ID,
                                    on: true
                                      });
                                        // Schaltet zusätzliche Lichter über HTTP ein
                                          for (let light of ADDITIONAL_LIGHTS) {
                                              let url = `http://${light.ip_address}/rpc/Switch.Set?id=${light.light_id}&on=true`;
                                                  if (light.auth) {
                                                        url += `&auth_key=${light.auth}`;
                                                            }
                                                                Shelly.call("HTTP.GET", { url: url });
                                                                  }
                                                                  }
                                                                  // Funktion zum Ausschalten des Lichts
                                                                  function turnLightOff() {
                                                                    if (!isLightOn) return;
                                                                      print("Keine Bewegung mehr. Schalte Licht aus.");
                                                                        isLightOn = false;
                                                                          
                                                                            // Schaltet das interne Shelly-Relais aus
                                                                              Shelly.call("Switch.Set", {
                                                                                  id: LOCAL_LIGHT_ID,
                                                                                      on: false
                                                                                        });
                                                                                          // Schaltet zusätzliche Lichter über HTTP aus
                                                                                            for (let light of ADDITIONAL_LIGHTS) {
                                                                                                let url = `http://${light.ip_address}/rpc/Switch.Set?id=${light.light_id}&on=false`;
                                                                                                    if (light.auth) {
                                                                                                          url += `&auth_key=${light.auth}`;
                                                                                                              }
                                                                                                                  Shelly.call("HTTP.GET", { url: url });
                                                                                                                    }
                                                                                                                    }
                                                                                                                    // Überwacht die Bluetooth-Events
                                                                                                                    Shelly.addStatusHandler(function (status) {
                                                                                                                      // Filtern nach BLE-Events und nach erfassten Sensoren
                                                                                                                        if (status.info && status.info.event === "BLE" && BLU_MOTION_SENSORS.includes(status.info.device.id)) {
                                                                                                                            // Holen des Lux-Wertes und des Bewegungserkennungs-Status
                                                                                                                                let motionDetected = status.info.device.services.some(s => s.uuid === "0000_18_01_0000" && s.data.motion);
                                                                                                                                    let luxValue = status.info.device.services.find(s => s.uuid === "0000_18_01_0000" && s.data.illuminance) ? status.info.device.services.find(s => s.uuid === "0000_18_01_0000" && s.data.illuminance).data.illuminance : null;
                                                                                                                                        // Überprüft, ob eine Bewegung erkannt wurde UND der Lux-Wert niedrig genug ist
                                                                                                                                            if (motionDetected && luxValue !== null && luxValue < LUX_THRESHOLD) {
                                                                                                                                                  print(`Bewegung von Sensor: ${status.info.device.id} erkannt. Lux: ${luxValue}`);
                                                                                                                                                        
                                                                                                                                                              // Setzt den Timeout zurück und schaltet das Licht ein
                                                                                                                                                                    lastMotionTime = Date.now();
                                                                                                                                                                          if (motionTimeout) {
                                                                                                                                                                                  Timer.clear(motionTimeout);
                                                                                                                                                                                        }
                                                                                                                                                                                              turnLightOn();
                                                                                                                                                                                                    
                                                                                                                                                                                                          // Startet den Timeout-Timer, um das Licht wieder auszuschalten
                                                                                                                                                                                                                motionTimeout = Timer.set(TIMEOUT_SECONDS * 1000, false, turnLightOff);
                                                                                                                                                                                                                    } else if (motionDetected && luxValue !== null && luxValue >= LUX_THRESHOLD) {
                                                                                                                                                                                                                          print(`Bewegung erkannt, aber Lux-Wert (${luxValue}) ist über dem Schwellenwert (${LUX_THRESHOLD}). Licht bleibt aus.`);
                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                });
                                                                                                                                                                                                                                print("Skript gestartet und wartet auf Bewegung von BLU Motion Sensoren...");