Philips Hue in Shelly App

// Poll up to 2* Hue motion sensors and write presence to Virtual Booleans
// * = POLL_INTERVAL_MS must be set at minimum 2 or else the script will crash 
// Optionally control a local Shelly relay (switch) based on motion
// Hue endpoint: GET /api/<user>/sensors/<id>  -> reads: state.presence
// Fully try/catch hardened
// Relay after-run supported (keep relay ON for X seconds after motion stops)
// after_run_s = 0 disables after-run (OFF immediately)
//*

let HUE_URL = "http://192.168.2.52/"; // must end with /
let HUE_USERNAME = "MSzjJR7-HxXDMbKIdEJ7MR0JAqc5UuHmdk-oy6ts";

// How often to poll (ms). 1000ms = 1 second (2 seconds must be minimum, if it listens for 2 sensors)
let POLL_INTERVAL_MS = 1000;

// Small stagger between sensor requests inside each poll cycle (ms)
let STAGGER_MS = 200;

// =============== MOTION SENSOR CONFIG (max 2) ===============
//
// Fields:
//   use_sensor  : true/false  -> whether the script should poll this sensor
//   name        : string      -> log-only label
//   sensorId    : string      -> Hue sensor id from /api/<user>/sensors
//   boolean_id  : number      -> Virtual Boolean id in Shelly to reflect presence
//
// Note:
// - We set boolean=true when motion is detected (presence=true)
// - We set boolean=false when no motion (presence=false)
//
// ============================================================

let SENSORS = [
  { use_sensor: true, name: "Hallway motion", sensorId: "27", boolean_id: 206 },
  { use_sensor: false, name: "Kitchen motion", sensorId: "18", boolean_id: 211 },
];

// ================= RELAY CONTROL (optional) =================
//
// use_relay        : true/false  -> enable/disable relay control
// switch_id        : number      -> Shelly switch id (usually 0)
// relay_on_motion  : true/false  -> true: relay ON when motion, OFF when no motion
//                                 false: inverted (relay OFF when motion)
// relay_mode       : "ANY"       -> "ANY" means: ON if any enabled sensor has motion
// after_run_s      : number      -> keep relay ON this many seconds after motion stops
//                                 0 = disabled (OFF immediately)
//
// ============================================================

let RELAY = {
  use_relay: false,
  switch_id: 0,
  relay_on_motion: true,
  relay_mode: "ANY",

  after_run_s: 0, // 0 = disabled
};

function log(msg) {
  print("[HUE]", msg);
}

function logErr(msg) {
  print("[HUE][ERROR]", msg);
}

// Cache last written boolean value per sensor
let _lastPresence = {}; // key: boolean_id -> true/false

// Cache last known motion state per sensor (for relay aggregation)
let _sensorMotion = {}; // key: sensorId -> true/false

// Cache last relay state to avoid spamming Switch.Set
let _lastRelayOn = null;

// After-run OFF timer id (null if none scheduled)
let _afterRunTimer = null;

function setBooleanIfChanged(booleanId, value) {
  try {
    value = !!value;
    if (_lastPresence[booleanId] === value) return;

    _lastPresence[booleanId] = value;
    Shelly.call("Boolean.Set", { id: booleanId, value: value });
    log("Boolean.Set id=" + booleanId + " -> " + value);
  } catch (e) {
    logErr("Boolean.Set (" + booleanId + "): " + e);
  }
}

function computeAnyMotion() {
  try {
    // Relay rule: ANY enabled sensor with motion => true
    let any = false;

    for (let i = 0; i < SENSORS.length; i++) {
      let s = SENSORS[i];
      if (!s.use_sensor) continue;

      let v = _sensorMotion[s.sensorId];
      if (v === true) {
        any = true;
        break;
      }
    }

    return any;
  } catch (e) {
    logErr("computeAnyMotion: " + e);
    return false;
  }
}

function setRelayIfEnabled(motionAny) {
  try {
    if (!RELAY.use_relay) return;

    // Apply inversion rule
    let wantOn = RELAY.relay_on_motion ? !!motionAny : !motionAny;

    // ---------------- WANT ON ----------------
    if (wantOn) {
      // Cancel pending OFF timer
      if (_afterRunTimer !== null) {
        Timer.clear(_afterRunTimer);
        _afterRunTimer = null;
        log("After-run: OFF timer cancelled");
      }

      if (_lastRelayOn === true) return;
      _lastRelayOn = true;

      Shelly.call("Switch.Set", { id: RELAY.switch_id, on: true });
      log("Switch.Set id=" + RELAY.switch_id + " -> ON");
      return;
    }

    // ---------------- WANT OFF ----------------
    let hold = RELAY.after_run_s || 0;

    // After-run disabled → OFF immediately
    if (hold <= 0) {
      if (_lastRelayOn === false) return;
      _lastRelayOn = false;

      Shelly.call("Switch.Set", { id: RELAY.switch_id, on: false });
      log("Switch.Set id=" + RELAY.switch_id + " -> OFF");
      return;
    }

    // If already OFF, nothing to do
    if (_lastRelayOn === false) return;

    // Start OFF timer only once
    if (_afterRunTimer !== null) return;

    log("After-run: scheduling OFF in " + hold + "s");
    _afterRunTimer = Timer.set(hold * 1000, false, function () {
      try {
        _afterRunTimer = null;

        // Re-check motion before turning OFF
        let stillMotion = computeAnyMotion();
        if (stillMotion) {
          log("After-run: motion returned, keeping relay ON");
          return;
        }

        // Apply inversion rule again
        let desiredOn = RELAY.relay_on_motion ? false : true;

        if (_lastRelayOn === desiredOn) return;
        _lastRelayOn = desiredOn;

        Shelly.call("Switch.Set", { id: RELAY.switch_id, on: desiredOn });
        log("Switch.Set id=" + RELAY.switch_id + " -> " + (desiredOn ? "ON" : "OFF"));
      } catch (e) {
        logErr("after-run timer: " + e);
      }
    });

  } catch (e) {
    logErr("setRelayIfEnabled: " + e);
  }
}

function updateRelayFromSensors() {
  try {
    if (!RELAY.use_relay) return;

    // Currently only "ANY" is implemented
    let anyMotion = computeAnyMotion();
    setRelayIfEnabled(anyMotion);
  } catch (e) {
    logErr("updateRelayFromSensors: " + e);
  }
}

function request(params, cb, userdata) {
  try {
    Shelly.call(
      "HTTP.Request",
      params,
      function (res, errCode, errMsg, ud) {
        try {
          if (errCode) {
            logErr("HTTP ERROR " + errCode + ": " + errMsg);
            return;
          }
          if (ud && ud.cb) ud.cb(res, ud.userdata);
        } catch (e) {
          logErr("HTTP callback: " + e);
        }
      },
      { cb: cb, userdata: userdata }
    );
  } catch (e) {
    logErr("HTTP.Request: " + e);
  }
}

function hueSensorUrl(sensorId) {
  return HUE_URL + "api/" + HUE_USERNAME + "/sensors/" + sensorId;
}

function pollOne(sensor) {
  try {
    request(
      { method: "GET", url: hueSensorUrl(sensor.sensorId) },
      function (res, sensor) {
        try {
          let data = JSON.parse(res.body);
          let presence = !!(data.state && data.state.presence);

          log("Motion (" + sensor.name + " id=" + sensor.sensorId + ") presence=" + presence);

          // Update per-sensor boolean
          setBooleanIfChanged(sensor.boolean_id, presence);

          // Update per-sensor motion cache for relay
          _sensorMotion[sensor.sensorId] = presence;

          // Update relay based on all sensors (ANY rule)
          updateRelayFromSensors();
        } catch (e) {
          logErr("parsing sensor (" + sensor.name + "): " + e);
        }
      },
      sensor
    );
  } catch (e) {
    logErr("pollOne (" + sensor.name + "): " + e);
  }
}

function pollAll() {
  try {
    let idx = 0;

    for (let i = 0; i < SENSORS.length; i++) {
      let s = SENSORS[i];
      if (!s.use_sensor) continue;

      (function (sensor, n) {
        Timer.set(n * STAGGER_MS, false, function () {
          pollOne(sensor);
        });
      })(s, idx);

      idx++;
    }
  } catch (e) {
    logErr("pollAll: " + e);
  }
}

// ---- Start polling loop ----
try {
  log("Started. Hue motion poller. interval_ms=" + POLL_INTERVAL_MS);

  for (let i = 0; i < SENSORS.length; i++) {
    let s = SENSORS[i];
    if (s.use_sensor) {
      log("USING: " + s.name + " sensorId=" + s.sensorId + " -> boolean_id=" + s.boolean_id);
      _sensorMotion[s.sensorId] = false; // initialize
    } else {
      log("SKIPPED: " + s.name);
    }
  }

  if (RELAY.use_relay) {
    log(
      "Relay control enabled: switch_id=" +
        RELAY.switch_id +
        " relay_on_motion=" +
        RELAY.relay_on_motion +
        " mode=" +
        RELAY.relay_mode +
        " after_run_s=" +
        (RELAY.after_run_s || 0)
    );
  } else {
    log("Relay control disabled");
  }

  // immediate first poll
  pollAll();

  // repeating poll
  Timer.set(POLL_INTERVAL_MS, true, function () {
    pollAll();
  });
} catch (e) {
  logErr("startup: " + e);
}