feat: Implement a rule engine for scriptable device automation, including an example timer light rule.

2026-01-16 19:49:50 -05:00
parent 9e94edab90
commit 152fce79d4
5 changed files with 374 additions and 2 deletions
--- a/rules/example_button_log.js
+++ b/rules/example_button_log.js
@@ -0,0 +1,144 @@
+/**
+ * Timer light rule
+ * 
+ * - btn_down: Light goes off
+ * - long_push: Flash to confirm, enter "count mode" - counts seconds until next btn_down, then light goes on
+ * - Normal btn_down (no long_push): Light goes off, then turns back on after the stored count elapsed
+ * 
+ * Also syncs remote switch CC8DA243B0A0 inversely (light off = switch on, light on = switch off)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const STATE_FILE = path.join(__dirname, 'timer_state.json');
+const REMOTE_SWITCH_MAC = 'CC8DA243B0A0';
+
+// Helper to set local light and sync remote switch inversely
+async function setLight(ctx, mac, on, brightness) {
+    await ctx.sendRPC(mac, 'Light.Set', { id: 0, on, brightness });
+    // Remote switch is inverse: light off = switch on, light on = switch off
+    await ctx.sendRPC(REMOTE_SWITCH_MAC, 'Switch.Set', { id: 0, on: !on });
+}
+
+// Load persisted state
+function loadPersistedState() {
+    try {
+        if (fs.existsSync(STATE_FILE)) {
+            return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+        }
+    } catch (err) {
+        console.error('Error loading state:', err);
+    }
+    return {};
+}
+
+// Save state to file
+function saveState(state) {
+    try {
+        // Only save storedDuration per MAC
+        const toSave = {};
+        for (const [mac, data] of Object.entries(state)) {
+            toSave[mac] = { storedDuration: data.storedDuration };
+        }
+        fs.writeFileSync(STATE_FILE, JSON.stringify(toSave, null, 2));
+    } catch (err) {
+        console.error('Error saving state:', err);
+    }
+}
+
+// State for devices (in memory, with persistence for storedDuration)
+const persistedState = loadPersistedState();
+const deviceState = new Map();
+
+function getState(mac) {
+    if (!deviceState.has(mac)) {
+        const persisted = persistedState[mac] || {};
+        deviceState.set(mac, {
+            countMode: false,
+            countStart: 0,
+            storedDuration: persisted.storedDuration || 5000, // Default 5 seconds
+            timer: null
+        });
+    }
+    return deviceState.get(mac);
+}
+
+export default {
+    async run(ctx) {
+        if (ctx.trigger.field !== 'button') return;
+
+        const mac = ctx.trigger.mac;
+        const state = getState(mac);
+
+        ctx.log(`Event: ${ctx.trigger.event}, countMode: ${state.countMode}, storedDuration: ${state.storedDuration}ms`);
+
+        // Handle btn_down
+        if (ctx.trigger.event === 'btn_down') {
+            // Clear any pending timer
+            if (state.timer) {
+                clearTimeout(state.timer);
+                state.timer = null;
+            }
+
+            // Turn light off (remote switch turns on)
+            await setLight(ctx, mac, false, 0);
+
+            if (state.countMode) {
+                // We're in count mode - calculate elapsed time and turn light on
+                const elapsed = Date.now() - state.countStart;
+                state.storedDuration = elapsed;
+                state.countMode = false;
+                ctx.log(`Count mode ended. Stored duration: ${elapsed}ms`);
+
+                // Persist the new duration
+                persistedState[mac] = { storedDuration: elapsed };
+                saveState(persistedState);
+
+                // Turn light on immediately (remote switch turns off)
+                await setLight(ctx, mac, true, 20);
+            } else {
+                // Normal mode - schedule light to turn on after stored duration
+                ctx.log(`Light off. Will turn on in ${state.storedDuration}ms`);
+
+                state.timer = setTimeout(async () => {
+                    ctx.log(`Timer elapsed. Turning light on.`);
+                    await setLight(ctx, mac, true, 20);
+                    state.timer = null;
+                }, state.storedDuration);
+            }
+        }
+
+        // Handle long_push - enter count mode
+        if (ctx.trigger.event === 'long_push' && !state.countMode) {
+            // Clear any pending timer
+            if (state.timer) {
+                clearTimeout(state.timer);
+                state.timer = null;
+            }
+
+            ctx.log('Entering count mode...');
+
+            // Flash to confirm (don't sync remote during flash)
+            for (let i = 0; i < 2; i++) {
+                await ctx.sendRPC(mac, 'Light.Set', { id: 0, on: true, brightness: 20 });
+                await sleep(200);
+                await ctx.sendRPC(mac, 'Light.Set', { id: 0, on: false, brightness: 0 });
+                await sleep(200);
+            }
+
+            // Ensure light stays off during count mode (remote switch on)
+            await setLight(ctx, mac, false, 0);
+
+            // Enter count mode
+            state.countMode = true;
+            state.countStart = Date.now();
+            ctx.log('Count mode active. Light stays off. Press button to set duration and turn on.');
+        }
+    }
+};