node-red-contrib-freya-nodes 0.1.1 → 0.2.1

package/nodes/circadian-core/circadian-core-node.js

@@ -15,16 +15,6 @@ class AstronomicalCalculator {
         const dayAngle = 2 * Math.PI * (dayOfYear - 81) / orbitalPeriod;
         return this.degreesToRadians(axialTilt) * Math.sin(dayAngle);
     }
-    static getDayLength(latitude, solarDeclination) {
-        const latRad = this.degreesToRadians(latitude);
-        const cosHourAngle = -Math.tan(latRad) * Math.tan(solarDeclination);
-        if (cosHourAngle > 1)
-            return 0;
-        if (cosHourAngle < -1)
-            return 24;
-        const hourAngle = Math.acos(cosHourAngle);
-        return 2 * this.radiansToDegrees(hourAngle) / 15;
-    }
     static getSolarNoonOffset(longitude, timezone) {
         const tzMatch = timezone.match(/UTC([+-]?\d+(?:\.\d+)?)/i);
         const tzOffset = tzMatch ? parseFloat(tzMatch[1]) : 0;
@@ -42,7 +32,6 @@ const circadianCore = (RED) => {
             node.status({ fill: 'red', shape: 'dot', text: 'no location config' });
             node.error('Location configuration node not found');
         }
-        this.locationConfig = RED.nodes.getNode(config.locationConfig);
         this.phaseShift = parseFloat(config.phaseShift) || 0.0;
         this.diurnalSwing = parseFloat(config.diurnalSwing) || 1.0;
         this.seasonalSwing = parseFloat(config.seasonalSwing) || 1.0;
@@ -58,19 +47,12 @@ const circadianCore = (RED) => {
         };
         const getSeasonalFactor = (simulatedTime) => {
             const dayOfYear = AstronomicalCalculator.getDayOfYear(simulatedTime);
-            const solarDeclination = AstronomicalCalculator.getSolarDeclination(dayOfYear, this.locationConfig.orbitalPeriod, this.locationConfig.axialTilt);
-            const latRad = AstronomicalCalculator.degreesToRadians(this.locationConfig.latitude);
-            const seasonalAmplitude = Math.abs(Math.sin(latRad)) * Math.sin(AstronomicalCalculator.degreesToRadians(this.locationConfig.axialTilt));
             const seasonalAngle = 2 * Math.PI * (dayOfYear - 172) / this.locationConfig.orbitalPeriod;
-            const seasonalValue = Math.cos(seasonalAngle) * seasonalAmplitude;
-            return 0.5 + seasonalValue * 0.5;
+            return Math.cos(seasonalAngle);
         };
         const getDiurnalFactor = (simulatedTime) => {
-            const dayOfYear = AstronomicalCalculator.getDayOfYear(simulatedTime);
-            const solarDeclination = AstronomicalCalculator.getSolarDeclination(dayOfYear, this.locationConfig.orbitalPeriod, this.locationConfig.axialTilt);
-            const dayLength = AstronomicalCalculator.getDayLength(this.locationConfig.latitude, solarDeclination);
             const solarNoonOffset = AstronomicalCalculator.getSolarNoonOffset(this.locationConfig.longitude, this.locationConfig.timezone);
-            const hoursFromMidnight = simulatedTime.getUTCHours() + simulatedTime.getUTCMinutes() / 60;
+            const hoursFromMidnight = simulatedTime.getUTCHours() + simulatedTime.getUTCMinutes() / 60 + simulatedTime.getUTCSeconds() / 3600;
             const solarNoon = 12 + solarNoonOffset;
             let hoursFromSolarNoon = hoursFromMidnight - solarNoon;
             if (hoursFromSolarNoon > 12)
@@ -79,13 +61,7 @@ const circadianCore = (RED) => {
                 hoursFromSolarNoon += 24;
             const phaseShiftRad = AstronomicalCalculator.degreesToRadians(this.phaseShift || 0);
             const diurnalAngle = (2 * Math.PI * hoursFromSolarNoon / this.locationConfig.rotationalPeriod) + phaseShiftRad;
-            const dayFraction = dayLength / 24;
-            const maxDiurnalHours = dayLength / 2;
-            if (Math.abs(hoursFromSolarNoon) > maxDiurnalHours) {
-                return 0;
-            }
-            const diurnalValue = Math.cos(diurnalAngle);
-            return Math.max(0, diurnalValue) * dayFraction;
+            return Math.cos(diurnalAngle);
         };
         const calculateTarget = () => {
             if (state.absoluteMin === undefined || state.absoluteMax === undefined) {
@@ -94,13 +70,15 @@ const circadianCore = (RED) => {
             const simulatedTime = getSimulatedTime();
             const seasonalFactor = getSeasonalFactor(simulatedTime);
             const diurnalFactor = getDiurnalFactor(simulatedTime);
-            const seasonalContribution = seasonalFactor * (this.seasonalSwing || 1.0);
-            const diurnalContribution = diurnalFactor * (this.diurnalSwing || 1.0);
-            const totalSwing = (this.seasonalSwing || 1.0) + (this.diurnalSwing || 1.0);
-            const combinedFactor = totalSwing > 0
-                ? Math.max(0, Math.min(1, (seasonalContribution + diurnalContribution) / totalSwing))
-                : 0.5;
-            return state.absoluteMin + (state.absoluteMax - state.absoluteMin) * combinedFactor;
+            const sSwing = this.seasonalSwing || 1.0;
+            const dSwing = this.diurnalSwing || 1.0;
+            const totalSwing = sSwing + dSwing;
+            if (totalSwing === 0) {
+                return state.absoluteMin + (state.absoluteMax - state.absoluteMin) * 0.5;
+            }
+            const combined = (seasonalFactor * sSwing + diurnalFactor * dSwing) / totalSwing;
+            const factor = (combined + 1) / 2;
+            return state.absoluteMin + (state.absoluteMax - state.absoluteMin) * factor;
         };
         const emitTarget = () => {
             const target = calculateTarget();
@@ -122,7 +100,7 @@ const circadianCore = (RED) => {
             if (state.intervalId) {
                 clearInterval(state.intervalId);
             }
-            const intervalMs = (node.tickInterval || 60) * 1000;
+            const intervalMs = (this.tickInterval || 60) * 1000;
             state.intervalId = setInterval(() => {
                 if (state.absoluteMin !== undefined && state.absoluteMax !== undefined) {
                     emitTarget();
@@ -168,6 +146,7 @@ const circadianCore = (RED) => {
             }
         });
         node.status({ fill: 'yellow', shape: 'dot', text: 'awaiting setpoints' });
+        startTickInterval();
     }
     RED.nodes.registerType('circadian core', CircadianCoreNode);
 };

package/nodes/lighting-controller/lighting-controller-node.html

@@ -20,7 +20,13 @@
     category: 'Freya Vivariums',
     color: "#A2CA6F",
     defaults: {
-      name: {value:""}
+      name: {value:""},
+      gain: {value: 1.0, required: true, validate: RED.validators.number()},
+      bottomCutOff: {value: 50.0, required: true, validate: RED.validators.number()},
+      mode: {value: "analog"},
+      scheduleTime1: {value: ""},
+      scheduleTime2: {value: ""},
+      scheduleMode: {value: "allowed"}
     },
     inputs:1,
     outputs:2,
@@ -34,11 +40,107 @@
 
 <script type="text/html" data-template-name="lighting controller">
   <div class="form-row">
-    <label for="node-input-name"><i class="icon-tag"></i> Name</label>
-    <input type="text" id="node-input-name" placeholder="Name">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Lighting Controller">
+  </div>
+  <hr/>
+  
+  <div class="form-row">
+    <label for="node-input-bottomCutOff"><i class="fa fa-scissors"></i> Bottom Cut-off</label>
+    <input type="number" id="node-input-bottomCutOff" placeholder="50.0" step="1" min="0" max="100">
+    <i class="fa fa-info-circle" title="Values below this percentage are cut off to 0%. This acts as a 'single diode rectifier + schotkey'."></i>
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-gain"><i class="fa fa-line-chart"></i> Gain</label>
+    <input type="number" id="node-input-gain" placeholder="1.0" step="0.1" min="0.1">
+    <i class="fa fa-info-circle" title="Multiplier applied to input after bottom cut-off. Values above 100% are clipped to 100%."></i>
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-mode"><i class="fa fa-sliders"></i> Output Mode</label>
+    <select id="node-input-mode">
+      <option value="analog">Analog - 0.0-100.0%</option>
+      <option value="digital">Digital - ON/OFF</option>
+    </select>
+  </div>
+  
+  <hr/>
+  
+  <div class="form-row">
+    <h3><i class="fa fa-clock-o"></i> Schedule (Optional)</h3>
+    <p style="font-size: 12px; color: #666; margin: 5px 0;">
+      Restrict lighting to specific time windows
+    </p>
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-scheduleTime1">Start Time</label>
+    <input type="text" id="node-input-scheduleTime1" placeholder="HH:MM" pattern="[0-2][0-9]:[0-5][0-9]">
+    <i class="fa fa-info-circle" title="Start of allowed time window (24-hour format, e.g. 06:30)"></i>
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-scheduleTime2">End Time</label>
+    <input type="text" id="node-input-scheduleTime2" placeholder="HH:MM" pattern="[0-2][0-9]:[0-5][0-9]">
+    <i class="fa fa-info-circle" title="End of allowed time window (24-hour format, e.g. 22:00)"></i>
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-scheduleMode">Schedule Mode</label>
+    <select id="node-input-scheduleMode">
+      <option value="allowed">Allowed - Force OFF outside window</option>
+      <option value="guaranteed">Guaranteed - Force ON inside window</option>
+    </select>
   </div>
 </script>
 
 <script type="text/html" data-help-name="lighting controller">
-  <p>The lighting controller lorem ipsum ...</p>
+  <p>
+    The <strong>Lighting Controller</strong> takes a raw brightness value from the circadian core, 
+    applies a bottom cut-off, applies gain, clips to 0–100%, and optionally enforces a time-based schedule.
+  </p>
+  
+  <h3>Configuration</h3>
+  <ul>
+    <li><strong>Bottom Cut-off:</strong> Values below this percentage are cut off to 0%. This acts as a "single diode rectifier + schotkey".</li>
+    <li><strong>Gain:</strong> Multiplier applied to input after bottom cut-off. Values above 100% are clipped to 100%.</li>
+    <li><strong>Output Mode:</strong> 
+      <ul>
+        <li><strong>Analog:</strong> Outputs { lighting: &lt;float 0.0-100.0&gt; } with 1 decimal place</li>
+        <li><strong>Digital:</strong> Outputs { lighting: "on" } if value > 0, else { lighting: "off" }</li>
+      </ul>
+    </li>
+    <li><strong>Schedule (Optional):</strong> Restrict lighting to specific time windows
+      <ul>
+        <li><strong>Start/End Time:</strong> Time window in 24-hour format (HH:MM)</li>
+        <li><strong>Allowed Mode:</strong> Forces light OFF outside the time window</li>
+        <li><strong>Guaranteed Mode:</strong> Forces light ON inside the time window</li>
+      </ul>
+    </li>
+  </ul>
+  
+  <h3>Signal Chain</h3>
+  <ol>
+    <li>Apply bottom cut-off (values below cut-off become 0%)</li>
+    <li>Multiply input by gain</li>
+    <li>Clamp to 0–100% (values above 100% are clipped to 100%)</li>
+    <li>Apply schedule gate (if configured):
+      <ul>
+        <li>Allowed mode: Force 0% outside Time1–Time2 window</li>
+        <li>Guaranteed mode: Force 100% inside Time1–Time2 window</li>
+      </ul>
+    </li>
+  </ol>
+  
+  <h3>Inputs</h3>
+  <ul>
+    <li><strong>Input 1:</strong> msg.payload (number) from circadian core</li>
+  </ul>
+  
+  <h3>Outputs</h3>
+  <ul>
+    <li><strong>Output 1:</strong> Actuator command with formatted lighting value</li>
+    <li><strong>Output 2:</strong> Status message for the status aggregator</li>
+  </ul>
 </script>

package/nodes/lighting-controller/lighting-controller-node.js

@@ -1,22 +1,107 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 const lightingController = (RED) => {
     function LightingControllerNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
-        node.status({ fill: 'green', shape: 'dot', text: 'running' });
-        node.on('input', (msg, send, done) => __awaiter(this, void 0, void 0, function* () {
-            send(msg);
+        this.gain = parseFloat(config.gain) || 1.0;
+        this.bottomCutOff = parseFloat(config.bottomCutOff) || 50.0;
+        this.mode = config.mode || 'analog';
+        this.scheduleTime1 = config.scheduleTime1 || '';
+        this.scheduleTime2 = config.scheduleTime2 || '';
+        this.scheduleMode = config.scheduleMode || 'allowed';
+        const isWithinSchedule = () => {
+            if (!this.scheduleTime1 || !this.scheduleTime2) {
+                return true;
+            }
+            try {
+                const now = new Date();
+                const currentTime = now.getHours() * 60 + now.getMinutes();
+                const [hours1, minutes1] = this.scheduleTime1.split(':').map(Number);
+                const [hours2, minutes2] = this.scheduleTime2.split(':').map(Number);
+                const time1 = hours1 * 60 + minutes1;
+                const time2 = hours2 * 60 + minutes2;
+                if (time1 <= time2) {
+                    return currentTime >= time1 && currentTime <= time2;
+                }
+                else {
+                    return currentTime >= time1 || currentTime <= time2;
+                }
+            }
+            catch (error) {
+                node.warn('Error parsing schedule times: ' + error);
+                return true;
+            }
+        };
+        const formatTime = (timeStr) => {
+            if (!timeStr)
+                return '';
+            return timeStr;
+        };
+        node.on('input', (msg, send, done) => {
+            if (typeof msg.payload !== 'number') {
+                node.status({ fill: 'red', shape: 'dot', text: 'invalid input' });
+                done === null || done === void 0 ? void 0 : done(new Error('Input payload must be a number'));
+                return;
+            }
+            let value = msg.payload;
+            if (value < (this.bottomCutOff || 50.0)) {
+                value = 0;
+            }
+            else {
+                value = ((value - (this.bottomCutOff || 50.0)) / (100 - (this.bottomCutOff || 50.0))) * 100;
+            }
+            value = value * (this.gain || 1.0);
+            value = Math.max(0, Math.min(100, value));
+            let scheduleActive = false;
+            let scheduleStatus = '';
+            if (this.scheduleTime1 && this.scheduleTime2) {
+                const withinSchedule = isWithinSchedule();
+                if (this.scheduleMode === 'allowed') {
+                    if (!withinSchedule) {
+                        value = 0;
+                        scheduleActive = true;
+                        scheduleStatus = ' (outside schedule)';
+                    }
+                }
+                else if (this.scheduleMode === 'guaranteed') {
+                    if (withinSchedule) {
+                        value = 100;
+                        scheduleActive = true;
+                        scheduleStatus = ' (guaranteed)';
+                    }
+                }
+            }
+            let outputPayload;
+            let statusText;
+            const finalValue = Math.round(value * 10) / 10;
+            if (this.mode === 'digital') {
+                outputPayload = { lighting: value > 0 ? 'on' : 'off' };
+                if (value > 0) {
+                    statusText = 'ON (' + finalValue.toFixed(1) + '%)' + scheduleStatus;
+                    node.status({ fill: 'green', shape: 'dot', text: statusText });
+                }
+                else {
+                    statusText = 'OFF (0%)' + scheduleStatus;
+                    node.status({ fill: 'grey', shape: 'dot', text: statusText });
+                }
+            }
+            else {
+                outputPayload = { lighting: finalValue };
+                if (finalValue > 0) {
+                    statusText = finalValue.toFixed(1) + '%' + scheduleStatus;
+                    node.status({ fill: 'green', shape: 'dot', text: statusText });
+                }
+                else {
+                    statusText = '0%' + scheduleStatus;
+                    node.status({ fill: 'grey', shape: 'dot', text: statusText });
+                }
+            }
+            send([
+                { payload: outputPayload, topic: 'actuators' },
+                { payload: Object.assign(Object.assign({}, outputPayload), { scheduleActive, gain: this.gain, bottomCutOff: this.bottomCutOff, mode: this.mode }), topic: 'status' }
+            ]);
             done === null || done === void 0 ? void 0 : done();
-        }));
+        });
     }
     RED.nodes.registerType('lighting controller', LightingControllerNode);
 };

package/nodes/precipitation-controller/precipitation-controller-node.html

@@ -20,12 +20,16 @@
     category: 'Freya Vivariums',
     color: "#A2CA6F",
     defaults: {
-      name: {value:""}
+      name: {value:""},
+      interval: {value: 60, required: true, validate: RED.validators.number()},
+      duration: {value: 30, required: true, validate: RED.validators.number()},
+      tickInterval: {value: 60, required: true, validate: function(v) { return RED.validators.number()(v) && parseInt(v) >= 1; }}
     },
     inputs:1,
-    outputs:2,
-    outputLabels:["control", "status"],
-    icon: "font-awesome/fa-cloud",
+    outputs:1,
+    inputLabels:["parameter update"],
+    outputLabels:["actuator command"],
+    icon: "font-awesome/fa-tint",
     label: function() {
       return this.name || "Precipitation Controller";
     }
@@ -34,11 +38,80 @@
 
 <script type="text/html" data-template-name="precipitation controller">
   <div class="form-row">
-    <label for="node-input-name"><i class="icon-tag"></i> Name</label>
-    <input type="text" id="node-input-name" placeholder="Name">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Precipitation Controller">
+  </div>
+  <hr/>
+  <div class="form-row">
+    <label for="node-input-interval"><i class="fa fa-clock-o"></i> Interval (minutes)</label>
+    <input type="number" id="node-input-interval" placeholder="60" step="1" min="1">
+  </div>
+  <div class="form-row">
+    <label for="node-input-duration"><i class="fa fa-tint"></i> Duration (seconds)</label>
+    <input type="number" id="node-input-duration" placeholder="30" step="1" min="1">
+  </div>
+  <hr/>
+  <div class="form-row">
+    <label for="node-input-tickInterval"><i class="fa fa-clock-o"></i> Tick Interval (seconds)</label>
+    <input type="number" id="node-input-tickInterval" placeholder="60" step="1" min="1">
   </div>
 </script>
 
 <script type="text/html" data-help-name="precipitation controller">
-  <p>The precipitation controller lorem ipsum ...</p>
+  <p>The <b>Precipitation Controller</b> drives a pump relay on an interval/duration cycle
+  for vivarium misting or rain simulation.</p>
+
+  <h3>Input</h3>
+  <dl class="message-properties">
+    <dt>msg.topic = "interval" <span class="property-type">number</span></dt>
+    <dd><code>msg.payload</code> sets the precipitation interval in minutes, overriding the configured default</dd>
+
+    <dt>msg.topic = "duration" <span class="property-type">number</span></dt>
+    <dd><code>msg.payload</code> sets the pump duration in seconds, overriding the configured default</dd>
+
+    <dt>msg.topic = "night" <span class="property-type">boolean</span></dt>
+    <dd><code>msg.payload</code> signals nighttime (<code>true</code>) or daytime (<code>false</code>).
+    During nighttime no new precipitation events are started. If the pump is already active
+    when night begins, the current cycle finishes normally.</dd>
+  </dl>
+  <p>Messages with unrecognised topics are ignored.</p>
+
+  <h3>Output</h3>
+  <dl class="message-properties">
+    <dt>msg.payload <span class="property-type">object</span></dt>
+    <dd><code>{ pump: "on" }</code> when the pump turns on, <code>{ pump: "off" }</code> when it turns off.
+    <code>msg.topic</code> is set to <code>"actuators"</code>.
+    Two messages are sent per precipitation event.</dd>
+  </dl>
+
+  <h3>Details</h3>
+  <p>The node runs an autonomous internal tick timer. On each tick it evaluates whether
+  precipitation is due:</p>
+  <ul>
+    <li>If the pump is already running the tick is skipped (no overlapping cycles).</li>
+    <li>If nighttime is signalled, the tick is skipped.</li>
+    <li>If this is the first tick after deploy, or the configured interval has elapsed
+        since the last event, the pump is turned on for the configured duration and then
+        automatically turned off.</li>
+    <li>Otherwise the node updates its status to show the time remaining
+        until the next event.</li>
+  </ul>
+  <p>On redeploy or shutdown the node clears all timers and forces the pump off
+  to prevent it from getting stuck on.</p>
+
+  <h3>Configuration</h3>
+  <ul>
+    <li><strong>Interval:</strong> Time between precipitation events in minutes (default: 60)</li>
+    <li><strong>Duration:</strong> How long the pump runs per event in seconds (default: 30)</li>
+    <li><strong>Tick Interval:</strong> How often to evaluate whether precipitation is due in seconds (default: 60)</li>
+  </ul>
+
+  <h3>Status</h3>
+  <ul>
+    <li><strong>idle</strong> (grey/ring) — initial state before first tick</li>
+    <li><strong>pump on</strong> (blue/dot) — pump is running, shows duration</li>
+    <li><strong>next in …</strong> (green/ring) — waiting, shows time until next event</li>
+    <li><strong>last: HH:MM:SS</strong> (grey/ring) — after pump off, shows timestamp</li>
+    <li><strong>paused (night)</strong> (grey/ring) — precipitation disabled during nighttime</li>
+  </ul>
 </script>

package/nodes/precipitation-controller/precipitation-controller-node.js

@@ -1,22 +1,98 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+const formatDuration = (ms) => {
+    if (ms >= 3600000) {
+        return (ms / 3600000).toFixed(1) + 'h';
+    }
+    else if (ms >= 60000) {
+        return (ms / 60000).toFixed(1) + 'm';
+    }
+    else {
+        return (ms / 1000).toFixed(0) + 's';
+    }
 };
 const precipitationController = (RED) => {
     function PrecipitationControllerNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
-        node.status({ fill: 'green', shape: 'dot', text: 'running' });
-        node.on('input', (msg, send, done) => __awaiter(this, void 0, void 0, function* () {
-            send(msg);
+        this.interval = parseFloat(config.interval) || 60;
+        this.duration = parseFloat(config.duration) || 30;
+        this.tickInterval = parseInt(config.tickInterval) || 60;
+        const state = {
+            lastPrecipitation: null,
+            pumpActive: false,
+            intervalMs: (node.interval || 60) * 60000,
+            durationMs: (node.duration || 30) * 1000,
+            night: false
+        };
+        const evaluatePrecipitation = () => {
+            if (state.pumpActive) {
+                return;
+            }
+            if (state.night) {
+                node.status({ fill: 'grey', shape: 'ring', text: 'paused (night)' });
+                return;
+            }
+            const now = Date.now();
+            if (state.lastPrecipitation === null || (now - state.lastPrecipitation) >= state.intervalMs) {
+                state.pumpActive = true;
+                state.lastPrecipitation = now;
+                node.send({ payload: { pump: 'on' }, topic: 'actuators' });
+                node.status({ fill: 'blue', shape: 'dot', text: `pump on (${formatDuration(state.durationMs)})` });
+                state.offTimer = setTimeout(() => {
+                    state.pumpActive = false;
+                    state.offTimer = undefined;
+                    node.send({ payload: { pump: 'off' }, topic: 'actuators' });
+                    const timeStr = new Date().toLocaleTimeString('en-GB', { hour12: false });
+                    node.status({ fill: 'grey', shape: 'ring', text: `last: ${timeStr}` });
+                }, state.durationMs);
+            }
+            else {
+                const elapsed = now - state.lastPrecipitation;
+                const remaining = state.intervalMs - elapsed;
+                node.status({ fill: 'green', shape: 'ring', text: `next in ${formatDuration(remaining)}` });
+            }
+        };
+        const startTickInterval = () => {
+            if (state.tickTimerId) {
+                clearInterval(state.tickTimerId);
+            }
+            const intervalMs = (node.tickInterval || 60) * 1000;
+            state.tickTimerId = setInterval(() => {
+                evaluatePrecipitation();
+            }, intervalMs);
+        };
+        node.on('input', (msg, send, done) => {
+            if (msg.topic === 'interval' && typeof msg.payload === 'number' && isFinite(msg.payload)) {
+                state.intervalMs = msg.payload * 60000;
+                node.log(`Interval updated: ${msg.payload} minutes`);
+            }
+            else if (msg.topic === 'duration' && typeof msg.payload === 'number' && isFinite(msg.payload)) {
+                state.durationMs = msg.payload * 1000;
+                node.log(`Duration updated: ${msg.payload} seconds`);
+            }
+            else if (msg.topic === 'night' && typeof msg.payload === 'boolean') {
+                state.night = msg.payload;
+                node.log(`Night state updated: ${msg.payload}`);
+            }
             done === null || done === void 0 ? void 0 : done();
-        }));
+        });
+        node.on('close', (done) => {
+            if (state.tickTimerId) {
+                clearInterval(state.tickTimerId);
+                state.tickTimerId = undefined;
+            }
+            if (state.offTimer) {
+                clearTimeout(state.offTimer);
+                state.offTimer = undefined;
+            }
+            if (state.pumpActive) {
+                state.pumpActive = false;
+                node.send({ payload: { pump: 'off' }, topic: 'actuators' });
+            }
+            done();
+        });
+        node.status({ fill: 'grey', shape: 'ring', text: 'idle' });
+        startTickInterval();
     }
     RED.nodes.registerType('precipitation controller', PrecipitationControllerNode);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-freya-nodes",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Custom nodes for Freya Vivarium Control System",
   "author": "Sanne 'SpuQ' Santens",
   "license": "GPL-3.0",