node-red-contrib-freya-nodes 0.0.21 → 0.1.0

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

@@ -3,7 +3,11 @@
     category: 'Freya Vivariums',
     color: "#A2CA6F",
     defaults: {
-      name: {value:""}
+      name: {value:""},
+      locationConfig: {value:"", type:"location-config", required:true},
+      phaseShift: {value: 0.0, required: true, validate: RED.validators.number()},
+      tickInterval: {value: 60, required: true, validate: function(v) { return RED.validators.number()(v) && parseInt(v) >= 1; }},
+      decimals: {value: 1, required: true, validate: function(v) { return RED.validators.number()(v) && parseInt(v) >= 0 && parseInt(v) <= 4; }}
     },
     inputs:1,
     outputs:2,
@@ -23,74 +27,26 @@
     </div>
     <hr/>
     <div class="form-row">
-      <h2><i class="fa fa-map-marker"></i> Location Settings</h2>
+        <label for="node-input-locationConfig"><i class="fa fa-map-marker"></i> Location Config</label>
+        <input type="text" id="node-input-locationConfig">
+        <i class="fa fa-info-circle" title="Select a location configuration node that defines geographic and planetary parameters."></i>
     </div>
+    <hr/>
     <div class="form-row">
-        <label for="node-input-latitude">Latitude (°)</label>
-        <input type="number" id="node-input-latitude" placeholder="50.98">
-        <i class="fa fa-info-circle" title="The latitude of your simulated environment. Controls day length variation across the year. (e.g. 0° = Equator, 50° = Central Europe)"></i>
+        <label for="node-input-phaseShift"><i class="fa fa-clock-o"></i> Phase Shift (°)</label>
+        <input type="number" id="node-input-phaseShift" placeholder="0" step="1" min="-180" max="180">
+        <i class="fa fa-info-circle" title="Phase shift in degrees relative to solar cycle. 0° = peak at solar noon, 180° = peak at solar midnight, 30-45° = afternoon temperature lag."></i>
     </div>
     <div class="form-row">
-        <label for="node-input-timezone">Timezone</label>
-        <input type="text" id="node-input-timezone" placeholder="UTC+2 Copenhagen, Brussels, Kampenhout">
-        <i class="fa fa-info-circle" title="Timezone offset in hours. Aligns the simulated solar noon with your local wall clock."></i>
+        <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 class="form-tips">How often to automatically recalculate and emit target values</div>
     </div>
-    <hr/>
     <div class="form-row">
-        <a href="#" id="toggle-advanced" style="text-decoration:none; color:#C0504D;">
-            <i class="fa fa-caret-right"></i> Advanced settings
-        </a>
+        <label for="node-input-decimals"><i class="fa fa-calculator"></i> Decimal Places</label>
+        <input type="number" id="node-input-decimals" placeholder="1" step="1" min="0" max="4">
+        <div class="form-tips">Number of decimal places to round the output target value (0-4)</div>
     </div>
-    <!-- Advanced settings -->
-    <div id="advanced-settings" style="display:none;">
-        <div class="form-row">
-          <h2><i class="fa fa-globe"></i> Planetary settings</h2>
-        </div>
-        <div class="form-row">
-            <label for="node-input-axialTilt">Axial Tilt (°)</label>
-            <input type="number" id="node-input-axialTilt" placeholder="23.44">
-            <i class="fa fa-info-circle" title="Angle between the rotation axis and orbital plane. Controls seasonal variation. Earth = 23.44°"></i>
-        </div>
-        <div class="form-row">
-            <label for="node-input-orbitalPeriod">Orbital Period (days)</label>
-            <input type="number" id="node-input-orbitalPeriod" placeholder="365.25">
-            <i class="fa fa-info-circle" title="Length of a full year (orbit around the sun). Earth = 365.25 days."></i>
-        </div>
-        <div class="form-row">
-            <label for="node-input-rotationalPeriod">Rotational Period (hours)</label>
-            <input type="number" id="node-input-rotationalPeriod" placeholder="24">
-            <i class="fa fa-info-circle" title="Length of a full day-night cycle. Earth = 24 hours."></i>
-        </div>
-        <hr/>
-        <div class="form-row">
-          <h2><i class="fa fa-clock-o"></i> Time</h2>
-        </div>
-        <div class="form-row">
-            <label for="node-input-timeScale">Time Scale</label>
-            <input type="number" id="node-input-timeScale" placeholder="1.0">
-            <i class="fa fa-info-circle" title="Controls simulation speed. 1.0 = real time, 2.0 = twice as fast, 0.5 = half speed."></i>
-        </div>
-        
-    </div>
-    <!--- END Advanced settings -->
-    <script>
-    $(function() {
-        $('#toggle-advanced').on('click', function(e) {
-            e.preventDefault();
-            var adv = $('#advanced-settings');
-            var icon = $(this).find('i');
-            if (adv.is(':visible')) {
-                adv.hide();
-                icon.removeClass('fa-caret-down').addClass('fa-caret-right');
-                $(this).contents().last()[0].textContent = ' Advanced settings';
-            } else {
-                adv.show();
-                icon.removeClass('fa-caret-right').addClass('fa-caret-down');
-                $(this).contents().last()[0].textContent = ' Advanced settings';
-            }
-        });
-    });
-    </script>
 </script>
 
 
@@ -98,7 +54,33 @@
 <script type="text/html" data-help-name="circadian core">
   <p>
     The <strong>Circadian Core</strong> dynamically computes target values for key vivarium variables 
-    (temperature, humidity, light), creating natural circadian and seasonal rhythms — 
-    while always enforcing explicit absolute safety constraints.
+    (temperature, humidity, light), creating natural circadian and seasonal rhythms based on 
+    astronomical calculations and geographic location.
+  </p>
+  
+  <h3>Configuration</h3>
+  <ul>
+    <li><strong>Location Config:</strong> Reference to a shared location configuration node</li>
+    <li><strong>Phase Shift:</strong> Degrees of lead/lag relative to solar cycle (0° = solar noon peak)</li>
+  </ul>
+  
+  <h3>Input</h3>
+  <p>
+    Send numeric values with <code>msg.topic</code> set to:
+  </p>
+  <ul>
+    <li><code>"absoluteMin"</code> or <code>"min"</code> - Minimum value (winter night)</li>
+    <li><code>"absoluteMax"</code> or <code>"max"</code> - Maximum value (summer day)</li>
+  </ul>
+  
+  <h3>Outputs</h3>
+  <ul>
+    <li><strong>Output 1:</strong> Target value - calculated setpoint based on current simulated time</li>
+    <li><strong>Output 2:</strong> Status - detailed information including simulated time and time scale</li>
+  </ul>
+  
+  <p>
+    The node combines seasonal and diurnal cycles to interpolate between absolute min/max values, 
+    automatically adjusting for day length variations, latitude effects, and custom planetary parameters.
   </p>
 </script>

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

@@ -1,22 +1,163 @@
 "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());
-    });
-};
+class AstronomicalCalculator {
+    static degreesToRadians(degrees) {
+        return degrees * Math.PI / 180;
+    }
+    static radiansToDegrees(radians) {
+        return radians * 180 / Math.PI;
+    }
+    static getDayOfYear(date) {
+        const start = new Date(date.getFullYear(), 0, 0);
+        const diff = date.getTime() - start.getTime();
+        return Math.floor(diff / (1000 * 60 * 60 * 24));
+    }
+    static getSolarDeclination(dayOfYear, orbitalPeriod, axialTilt) {
+        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;
+        const longitudeOffset = longitude / 15;
+        return longitudeOffset - tzOffset;
+    }
+}
 const circadianCore = (RED) => {
     function CircadianCoreNode(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);
+        const state = {};
+        const locationConfigNode = RED.nodes.getNode(config.locationConfig);
+        if (!locationConfigNode) {
+            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 = config.phaseShift || 0.0;
+        this.tickInterval = config.tickInterval || 60;
+        this.decimals = config.decimals !== undefined ? config.decimals : 1;
+        this.locationConfig = locationConfigNode;
+        const getSimulatedTime = () => {
+            const now = Date.now();
+            const epoch = new Date('2000-01-01T00:00:00Z').getTime();
+            const realElapsed = now - epoch;
+            const simulatedElapsed = realElapsed * this.locationConfig.timeScale;
+            return new Date(epoch + simulatedElapsed);
+        };
+        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;
+        };
+        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 solarNoon = 12 + solarNoonOffset;
+            let hoursFromSolarNoon = hoursFromMidnight - solarNoon;
+            if (hoursFromSolarNoon > 12)
+                hoursFromSolarNoon -= 24;
+            if (hoursFromSolarNoon < -12)
+                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;
+        };
+        const calculateTarget = () => {
+            if (state.absoluteMin === undefined || state.absoluteMax === undefined) {
+                return null;
+            }
+            const simulatedTime = getSimulatedTime();
+            const seasonalFactor = getSeasonalFactor(simulatedTime);
+            const diurnalFactor = getDiurnalFactor(simulatedTime);
+            const combinedFactor = seasonalFactor * 0.7 + diurnalFactor * 0.3;
+            return state.absoluteMin + (state.absoluteMax - state.absoluteMin) * combinedFactor;
+        };
+        const emitTarget = () => {
+            const target = calculateTarget();
+            if (target === null) {
+                node.status({ fill: 'yellow', shape: 'dot', text: 'awaiting setpoints' });
+                return;
+            }
+            const roundedTarget = Number(target.toFixed(this.decimals));
+            const simulatedTime = getSimulatedTime();
+            node.send([
+                { payload: roundedTarget, topic: 'target' },
+                { payload: { target: roundedTarget, simulatedTime: simulatedTime.toISOString(), timeScale: this.locationConfig.timeScale }, topic: 'status' }
+            ]);
+            const statusText = `Target: ${roundedTarget.toFixed(this.decimals)} | Time: ${simulatedTime.toLocaleTimeString()}`;
+            node.status({ fill: 'green', shape: 'dot', text: statusText });
+            state.lastCalculation = Date.now();
+        };
+        const startTickInterval = () => {
+            if (state.intervalId) {
+                clearInterval(state.intervalId);
+            }
+            const intervalMs = (this.tickInterval || 60) * 1000;
+            state.intervalId = setInterval(() => {
+                if (state.absoluteMin !== undefined && state.absoluteMax !== undefined) {
+                    emitTarget();
+                }
+            }, intervalMs);
+            if (state.absoluteMin !== undefined && state.absoluteMax !== undefined) {
+                emitTarget();
+            }
+        };
+        node.on('input', (msg, send, done) => {
+            if (msg.topic === 'absoluteMin' && typeof msg.payload === 'number') {
+                state.absoluteMin = msg.payload;
+                node.log(`Absolute minimum updated: ${msg.payload}`);
+                if (state.absoluteMin !== undefined && state.absoluteMax !== undefined) {
+                    emitTarget();
+                }
+            }
+            else if (msg.topic === 'absoluteMax' && typeof msg.payload === 'number') {
+                state.absoluteMax = msg.payload;
+                node.log(`Absolute maximum updated: ${msg.payload}`);
+                if (state.absoluteMin !== undefined && state.absoluteMax !== undefined) {
+                    emitTarget();
+                }
+            }
+            else if (typeof msg.payload === 'object' && msg.payload !== null) {
+                const payload = msg.payload;
+                if (typeof payload.min === 'number' && typeof payload.max === 'number') {
+                    state.absoluteMin = payload.min;
+                    state.absoluteMax = payload.max;
+                    node.log(`Setpoints updated: min=${payload.min}, max=${payload.max}`);
+                    emitTarget();
+                }
+            }
             done === null || done === void 0 ? void 0 : done();
-        }));
+        });
+        node.on('close', () => {
+            if (state.intervalId) {
+                clearInterval(state.intervalId);
+                state.intervalId = undefined;
+            }
+        });
+        node.status({ fill: 'yellow', shape: 'dot', text: 'awaiting setpoints' });
     }
     RED.nodes.registerType('circadian core', CircadianCoreNode);
 };

package/nodes/circadian-core/location-config-node.html

@@ -0,0 +1,131 @@
+<script type="text/javascript">
+  RED.nodes.registerType('location-config', {
+    category: 'config',
+    defaults: {
+      name: { value: "" },
+      latitude: { value: 50.98, validate: RED.validators.number() },
+      longitude: { value: 4.32, validate: RED.validators.number() },
+      timezone: { value: "UTC+1" },
+      axialTilt: { value: 23.44, validate: RED.validators.number() },
+      orbitalPeriod: { value: 365.25, validate: RED.validators.number() },
+      rotationalPeriod: { value: 24, validate: RED.validators.number() },
+      timeScale: { value: 1.0, validate: RED.validators.number() }
+    },
+    label: function() {
+      return this.name || "Location Config";
+    },
+    icon: "font-awesome/fa-map-marker"
+  });
+</script>
+
+<script type="text/html" data-template-name="location-config">
+  <div class="form-row">
+    <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-config-input-name" placeholder="Location Config">
+  </div>
+  <hr/>
+  
+  <div class="form-row">
+    <h3><i class="fa fa-map-marker"></i> Geographic Location</h3>
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-latitude">Latitude (°)</label>
+    <input type="number" id="node-config-input-latitude" placeholder="50.98" step="0.01" min="-90" max="90">
+    <i class="fa fa-info-circle" title="The latitude of your location. Controls day length variation across the year. (e.g. 0° = Equator, 50° = Central Europe, -34° = Buenos Aires)"></i>
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-longitude">Longitude (°)</label>
+    <input type="number" id="node-config-input-longitude" placeholder="4.32" step="0.01" min="-180" max="180">
+    <i class="fa fa-info-circle" title="The longitude of your location. Used for precise solar calculations. (e.g. 0° = Greenwich, 4.32° = Brussels, -74° = New York)"></i>
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-timezone">Timezone</label>
+    <input type="text" id="node-config-input-timezone" placeholder="UTC+1">
+    <i class="fa fa-info-circle" title="Timezone offset from UTC. Aligns the simulated solar noon with your local wall clock. (e.g. UTC+1, UTC-5, UTC+9)"></i>
+  </div>
+  
+  <hr/>
+  <div class="form-row">
+    <a href="#" id="toggle-planetary" style="text-decoration:none; color:#C0504D;">
+      <i class="fa fa-caret-right"></i> Planetary Parameters
+    </a>
+  </div>
+  
+  <!-- Planetary settings -->
+  <div id="planetary-settings" style="display:none;">
+    <div class="form-row">
+      <h3><i class="fa fa-globe"></i> Planetary Settings</h3>
+      <p style="font-size: 12px; color: #666; margin: 5px 0;">
+        Advanced settings for simulating non-Earth environments or custom seasonal patterns.
+      </p>
+    </div>
+    <div class="form-row">
+      <label for="node-config-input-axialTilt">Axial Tilt (°)</label>
+      <input type="number" id="node-config-input-axialTilt" placeholder="23.44" step="0.01" min="0" max="90">
+      <i class="fa fa-info-circle" title="Angle between the rotation axis and orbital plane. Controls seasonal variation intensity. Earth = 23.44°, Mars = 25.19°, Jupiter = 3.13°"></i>
+    </div>
+    <div class="form-row">
+      <label for="node-config-input-orbitalPeriod">Orbital Period (days)</label>
+      <input type="number" id="node-config-input-orbitalPeriod" placeholder="365.25" step="0.01" min="1">
+      <i class="fa fa-info-circle" title="Length of a full year (orbit around the sun). Earth = 365.25 days, Mars = 687 days, Venus = 225 days"></i>
+    </div>
+    <div class="form-row">
+      <label for="node-config-input-rotationalPeriod">Rotational Period (hours)</label>
+      <input type="number" id="node-config-input-rotationalPeriod" placeholder="24" step="0.01" min="0.1">
+      <i class="fa fa-info-circle" title="Length of a full day-night cycle. Earth = 24 hours, Mars = 24.6 hours, Venus = 5832 hours"></i>
+    </div>
+    <div class="form-row">
+      <label for="node-config-input-timeScale">Time Scale</label>
+      <input type="number" id="node-config-input-timeScale" placeholder="1.0" step="0.1" min="0.1">
+      <i class="fa fa-info-circle" title="Time compression factor. 1.0 = real time, 4.0 = four day/night cycles per real day. All circadian nodes sharing this config run at the same simulated time."></i>
+    </div>
+  </div>
+  
+  <script>
+    $(function() {
+      $('#toggle-planetary').on('click', function(e) {
+        e.preventDefault();
+        var planetary = $('#planetary-settings');
+        var icon = $(this).find('i');
+        if (planetary.is(':visible')) {
+          planetary.hide();
+          icon.removeClass('fa-caret-down').addClass('fa-caret-right');
+          $(this).contents().last()[0].textContent = ' Planetary Parameters';
+        } else {
+          planetary.show();
+          icon.removeClass('fa-caret-right').addClass('fa-caret-down');
+          $(this).contents().last()[0].textContent = ' Planetary Parameters';
+        }
+      });
+    });
+  </script>
+</script>
+
+<script type="text/html" data-help-name="location-config">
+  <p>
+    The <strong>Location Configuration</strong> node stores geographic and planetary parameters 
+    that can be shared across multiple circadian rhythm nodes in your flow.
+  </p>
+  
+  <h3>Geographic Settings</h3>
+  <ul>
+    <li><strong>Latitude:</strong> Controls seasonal day length variation</li>
+    <li><strong>Longitude:</strong> Used for precise solar position calculations</li>
+    <li><strong>Timezone:</strong> Aligns simulation with local wall clock time</li>
+  </ul>
+  
+  <h3>Planetary Parameters</h3>
+  <p>
+    Advanced settings for simulating non-Earth environments or creating custom seasonal patterns:
+  </p>
+  <ul>
+    <li><strong>Axial Tilt:</strong> Controls intensity of seasonal variation</li>
+    <li><strong>Orbital Period:</strong> Length of the year cycle</li>
+    <li><strong>Rotational Period:</strong> Length of the day-night cycle</li>
+  </ul>
+  
+  <p>
+    This configuration can be referenced by multiple Circadian Core nodes, 
+    allowing consistent location settings across your entire vivarium control system.
+  </p>
+</script>

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

@@ -0,0 +1,15 @@
+"use strict";
+const locationConfig = (RED) => {
+    function LocationConfigNode(config) {
+        RED.nodes.createNode(this, config);
+        this.latitude = config.latitude || 50.98;
+        this.longitude = config.longitude || 4.32;
+        this.timezone = config.timezone || 'UTC+1';
+        this.axialTilt = config.axialTilt || 23.44;
+        this.orbitalPeriod = config.orbitalPeriod || 365.25;
+        this.rotationalPeriod = config.rotationalPeriod || 24;
+        this.timeScale = config.timeScale || 1.0;
+    }
+    RED.nodes.registerType('location-config', LocationConfigNode);
+};
+module.exports = locationConfig;

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

@@ -3,14 +3,49 @@
     category: 'Freya Vivariums',
     color: "#A2CA6F",
     defaults: {
-      name: {value:""}
+      name: {value:""},
+      deadband: {value: 2.0, required: true, validate: RED.validators.number()},
+      minimumHumidity: {value: 0.0, required: true, validate: RED.validators.number()},
+      maximumHumidity: {value: 100.0, required: true, validate: RED.validators.number()}
     },
     inputs:1,
     outputs:2,
-    outputLabels:["control", "status"],
+    outputLabels:["actuator commands", "status"],
     icon: "font-awesome/fa-tint",
     label: function() {
       return this.name || "Humidity Controller";
+    },
+    oneditprepare: function() {
+      // Validation for deadband
+      $("#node-input-deadband").on('input', function() {
+        const val = parseFloat($(this).val());
+        if (isNaN(val) || val < 0) {
+          $(this).addClass('input-error');
+        } else {
+          $(this).removeClass('input-error');
+        }
+      });
+      
+      // Validation for minimum humidity
+      $("#node-input-minimumHumidity").on('input', function() {
+        const val = parseFloat($(this).val());
+        if (isNaN(val) || val < 0 || val > 100) {
+          $(this).addClass('input-error');
+        } else {
+          $(this).removeClass('input-error');
+        }
+      });
+      
+      // Validation for maximum humidity
+      $("#node-input-maximumHumidity").on('input', function() {
+        const val = parseFloat($(this).val());
+        const min = parseFloat($("#node-input-minimumHumidity").val());
+        if (isNaN(val) || val < 0 || val > 100 || (!isNaN(min) && val <= min)) {
+          $(this).addClass('input-error');
+        } else {
+          $(this).removeClass('input-error');
+        }
+      });
     }
   });
 </script>
@@ -20,8 +55,59 @@
     <label for="node-input-name"><i class="icon-tag"></i> Name</label>
     <input type="text" id="node-input-name" placeholder="Name">
   </div>
+  
+  <div class="form-row">
+    <label for="node-input-deadband"><i class="fa fa-arrows-h"></i> Deadband (%)</label>
+    <input type="number" id="node-input-deadband" placeholder="2.0" step="0.1" min="0">
+    <div class="form-tips">Half-width around target humidity to prevent oscillation</div>
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-minimumHumidity"><i class="fa fa-thermometer-empty"></i> Minimum Humidity (%)</label>
+    <input type="number" id="node-input-minimumHumidity" placeholder="0.0" step="1" min="0" max="100">
+    <div class="form-tips">Safety floor - force humidification below this level</div>
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-maximumHumidity"><i class="fa fa-thermometer-full"></i> Maximum Humidity (%)</label>
+    <input type="number" id="node-input-maximumHumidity" placeholder="100.0" step="1" min="0" max="100">
+    <div class="form-tips">Safety ceiling - force dehumidification above this level</div>
+  </div>
 </script>
 
 <script type="text/html" data-help-name="humidity controller">
-  <p>The humidity controller lorem ipsum ...</p>
+  <p>Bang-bang humidity controller with deadband and safety overrides for vivarium environmental control.</p>
+  
+  <h3>Input</h3>
+  <dl class="message-properties">
+    <dt>Target Humidity <span class="property-type">number</span></dt>
+    <dd>Target humidity percentage from circadian core or other source</dd>
+    
+    <dt>Sensor Reading <span class="property-type">number</span></dt>
+    <dd>Current humidity reading from environment sensor with <code>msg.topic: "sensor"</code> and <code>msg.payload: number</code></dd>
+  </dl>
+  
+  <h3>Outputs</h3>
+  <dl class="message-properties">
+    <dt>Output 1: Actuator Commands <span class="property-type">object</span></dt>
+    <dd>Commands for actuators: <code>{humidifier: "on/off", dehumidifier: "on/off"}</code></dd>
+    
+    <dt>Output 2: Status <span class="property-type">object</span></dt>
+    <dd>Controller status including state, readings, safety overrides, and deadband</dd>
+  </dl>
+  
+  <h3>Control Logic</h3>
+  <ul>
+    <li><strong>Humidifying:</strong> When reading < target - deadband</li>
+    <li><strong>Dehumidifying:</strong> When reading > target + deadband</li>
+    <li><strong>Idle:</strong> When within deadband (maintains previous state)</li>
+    <li><strong>Safety Override:</strong> Force humidification below minimum or dehumidification above maximum</li>
+  </ul>
+  
+  <h3>Configuration</h3>
+  <ul>
+    <li><strong>Deadband:</strong> Half-width around target to prevent oscillation (default: 2.0%)</li>
+    <li><strong>Minimum Humidity:</strong> Safety floor for emergency humidification (default: 0%)</li>
+    <li><strong>Maximum Humidity:</strong> Safety ceiling for emergency dehumidification (default: 100%)</li>
+  </ul>
 </script>

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

@@ -1,22 +1,110 @@
 "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 humidityController = (RED) => {
     function HumidityControllerNode(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);
-            done === null || done === void 0 ? void 0 : done();
-        }));
+        this.deadband = config.deadband || 2.0;
+        this.minimumHumidity = config.minimumHumidity || 0.0;
+        this.maximumHumidity = config.maximumHumidity || 100.0;
+        const state = {
+            currentState: 'idle',
+            safetyOverride: null
+        };
+        const calculateControl = () => {
+            if (state.currentHumidity === undefined || state.targetHumidity === undefined) {
+                return { humidifier: 'off', dehumidifier: 'off', state: 'idle' };
+            }
+            const humidity = state.currentHumidity;
+            const target = state.targetHumidity;
+            const deadband = this.deadband;
+            if (humidity < (this.minimumHumidity || 0.0)) {
+                state.safetyOverride = 'min';
+                state.currentState = 'humidifying';
+                return { humidifier: 'on', dehumidifier: 'off', state: 'humidifying', override: 'minimum humidity' };
+            }
+            if (humidity > (this.maximumHumidity || 100.0)) {
+                state.safetyOverride = 'max';
+                state.currentState = 'dehumidifying';
+                return { humidifier: 'off', dehumidifier: 'on', state: 'dehumidifying', override: 'maximum humidity' };
+            }
+            state.safetyOverride = null;
+            if (humidity < target - (deadband || 2.0)) {
+                state.currentState = 'humidifying';
+                return { humidifier: 'on', dehumidifier: 'off', state: 'humidifying' };
+            }
+            else if (humidity > target + (deadband || 2.0)) {
+                state.currentState = 'dehumidifying';
+                return { humidifier: 'off', dehumidifier: 'on', state: 'dehumidifying' };
+            }
+            else {
+                const humidifier = state.currentState === 'humidifying' ? 'on' : 'off';
+                const dehumidifier = state.currentState === 'dehumidifying' ? 'on' : 'off';
+                return { humidifier, dehumidifier, state: state.currentState };
+            }
+        };
+        const updateStatus = (control) => {
+            if (state.currentHumidity === undefined || state.targetHumidity === undefined) {
+                node.status({ fill: 'yellow', shape: 'dot', text: 'awaiting inputs' });
+                return;
+            }
+            const humidity = state.currentHumidity.toFixed(1);
+            const target = state.targetHumidity.toFixed(1);
+            if (control.override) {
+                node.status({ fill: 'red', shape: 'dot', text: `SAFETY: ${control.override} (${humidity}%)` });
+            }
+            else if (control.state === 'humidifying') {
+                node.status({ fill: 'green', shape: 'dot', text: `Humidifying: ${humidity}% → ${target}%` });
+            }
+            else if (control.state === 'dehumidifying') {
+                node.status({ fill: 'blue', shape: 'dot', text: `Dehumidifying: ${humidity}% → ${target}%` });
+            }
+            else {
+                node.status({ fill: 'grey', shape: 'dot', text: `Idle: ${humidity}% (${target}%)` });
+            }
+        };
+        const processControl = () => {
+            const control = calculateControl();
+            node.send([
+                {
+                    payload: {
+                        humidifier: control.humidifier,
+                        dehumidifier: control.dehumidifier
+                    },
+                    topic: 'actuators'
+                },
+                {
+                    payload: {
+                        state: control.state,
+                        target: state.targetHumidity,
+                        reading: state.currentHumidity,
+                        safetyOverride: control.override || null,
+                        deadband: this.deadband
+                    },
+                    topic: 'status'
+                }
+            ]);
+            updateStatus(control);
+        };
+        node.on('input', (msg, send, done) => {
+            if (msg.topic === 'sensor') {
+                if (typeof msg.payload === 'number') {
+                    state.currentHumidity = msg.payload;
+                    node.log(`Current humidity updated: ${msg.payload}%`);
+                }
+            }
+            else {
+                if (typeof msg.payload === 'number') {
+                    state.targetHumidity = msg.payload;
+                    node.log(`Target humidity updated: ${msg.payload}%`);
+                }
+            }
+            if (state.targetHumidity !== undefined && state.currentHumidity !== undefined) {
+                processControl();
+            }
+            if (done)
+                done();
+        });
+        node.status({ fill: 'yellow', shape: 'dot', text: 'awaiting inputs' });
     }
     RED.nodes.registerType('humidity controller', HumidityControllerNode);
 };

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

@@ -4,13 +4,13 @@
     color: "#A2CA6F",
     defaults: {
       name: {value:""},
-      minimumTemperature: {value:"25", required:true, validate:RED.validators.number()},
-      maximumTemperature: {value:"30", required:true, validate:RED.validators.number()},
-      kp: {value:"10", required:false, validate:RED.validators.number()}
+      deadband: {value:1.0, required:true, validate:RED.validators.number()},
+      minimumTemperature: {value:10.0, required:true, validate:RED.validators.number()},
+      maximumTemperature: {value:50.0, required:true, validate:RED.validators.number()}
     },
     inputs:1,
     outputs:2,
-    outputLabels:["control","status"],
+    outputLabels:["actuator commands", "status"],
     icon: "font-awesome/fa-thermometer-half",
     label: function() {
       return this.name||"Temperature Controller";
@@ -20,41 +20,62 @@
 
 <script type="text/html" data-template-name="temperature 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="Temperature Controller">
   </div>
   <hr/>
-  <h2><i class="fa fa-thermometer-full"></i> Extremes</h2>
-  <p>The absolute maximum ratings</p>
   <div class="form-row">
-    <label for="node-input-minimumTemperature"><i class="icon-cog"></i> Minimum (°C)</label>
-    <input type="number" id="node-input-minimumTemperature" placeholder="25">
+    <h3><i class="fa fa-adjust"></i> Control Settings</h3>
   </div>
   <div class="form-row">
-    <label for="node-input-maximumTemperature"><i class="icon-cog"></i> Maximum (°C)</label>
-    <input type="number" id="node-input-maximumTemperature" placeholder="30">
+    <label for="node-input-deadband">Deadband (°C)</label>
+    <input type="number" id="node-input-deadband" placeholder="1.0" step="0.1" min="0.1">
+    <i class="fa fa-info-circle" title="Half-width of the deadband around target. With target 25°C and deadband 1.0°C, controller is idle between 24-26°C."></i>
   </div>
   <hr/>
-  <h2><i class="fa fa-sliders"></i> P-controller</h2>
   <div class="form-row">
-    <label for="node-input-kp"><i class="icon-cogs"></i> Proportional Gain (Kp)</label>
-    <input type="number" id="node-input-kp" placeholder="10">
+    <h3><i class="fa fa-shield"></i> Safety Limits</h3>
+  </div>
+  <div class="form-row">
+    <label for="node-input-minimumTemperature">Minimum Temperature (°C)</label>
+    <input type="number" id="node-input-minimumTemperature" placeholder="10.0" step="0.1">
+    <i class="fa fa-info-circle" title="Absolute safety floor. Force heating if sensor reads below this, regardless of target."></i>
+  </div>
+  <div class="form-row">
+    <label for="node-input-maximumTemperature">Maximum Temperature (°C)</label>
+    <input type="number" id="node-input-maximumTemperature" placeholder="50.0" step="0.1">
+    <i class="fa fa-info-circle" title="Absolute safety ceiling. Force cooling if sensor reads above this, regardless of target."></i>
   </div>
 </script>
 
 <script type="text/html" data-help-name="temperature controller">
-  <p>The <b>Temperature Controller</b> node implements a proportional (P) controller.</p>
-  <p><b>Inputs:</b>
-    <ul>
-      <li><code>msg.topic == 'temp'</code> (payload: number) &rarr; sensor reading</li>
-      <li><code>msg.topic == 'config'</code> (payload: { setpoint, kp }) &rarr; runtime configuration</li>
-    </ul>
-  </p>
-  <p><b>Outputs:</b>
-    <ol>
-      <li><code>control</code>: <code>msg.payload.effort</code> (-100 to +100)</li>
-      <li><code>status</code>: <code>msg.payload</code> object with <code>level</code>, <code>message</code>, and optional <code>details</code></li>
-    </ol>
-  </p>
-  <p>Configure the <i>Setpoint</i> (°C) and <i>Proportional Gain</i> (Kp) in the node's edit dialog.</p>
+  <p>The <b>Temperature Controller</b> node implements bang-bang control with deadband for temperature regulation.</p>
+  
+  <h3>Input</h3>
+  <dl class="message-properties">
+    <dt>Target Temperature <span class="property-type">number</span></dt>
+    <dd>Target temperature in degrees Celsius from circadian core or other source</dd>
+    
+    <dt>Sensor Reading <span class="property-type">number</span></dt>
+    <dd>Current temperature reading from environment sensor with <code>msg.topic: "sensor"</code> and <code>msg.payload: number</code></dd>
+  </dl>
+  
+  <h3>Outputs</h3>
+  <ul>
+    <li><strong>Output 1 (Actuators):</strong> <code>msg.payload</code> (object) - actuator commands: <code>{ heater: "on/off", cooler: "on/off" }</code></li>
+    <li><strong>Output 2 (Status):</strong> Status information for aggregation</li>
+  </ul>
+  
+  <h3>Control Logic</h3>
+  <ul>
+    <li><strong>Heating:</strong> When reading &lt; target - deadband</li>
+    <li><strong>Cooling:</strong> When reading &gt; target + deadband</li>
+    <li><strong>Idle:</strong> When reading within deadband (maintains previous state)</li>
+  </ul>
+  
+  <h3>Safety Overrides</h3>
+  <ul>
+    <li><strong>Emergency Heating:</strong> Forces heating if reading &lt; minimum temperature</li>
+    <li><strong>Emergency Cooling:</strong> Forces cooling if reading &gt; maximum temperature</li>
+  </ul>
 </script>

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

@@ -1,43 +1,110 @@
 "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 temperature_controller_1 = require("./temperature-controller");
 const temperatureController = (RED) => {
     function TemperatureControllerNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
-        const controller = new temperature_controller_1.TemperatureController();
-        controller.on('status', (status) => {
-            node.status({ fill: status.level === 'error' ? 'red' : 'green', shape: 'ring', text: status.message });
-            node.send({ topic: 'status', payload: status });
-        });
-        controller.on('controlOutput', (effort) => {
-            node.send({ topic: 'control', payload: { effort } });
-        });
-        node.status({ fill: 'green', shape: 'dot', text: 'running' });
-        node.on('input', (msg, send, done) => __awaiter(this, void 0, void 0, function* () {
-            if (msg.topic === 'temp' && typeof msg.payload === 'number') {
-                controller.updateTemperature(msg.payload);
+        this.deadband = config.deadband || 1.0;
+        this.minimumTemperature = config.minimumTemperature || 10.0;
+        this.maximumTemperature = config.maximumTemperature || 50.0;
+        const state = {
+            currentState: 'idle',
+            safetyOverride: null
+        };
+        const calculateControl = () => {
+            if (state.currentTemperature === undefined || state.targetTemperature === undefined) {
+                return { heater: 'off', cooler: 'off', state: 'idle' };
+            }
+            const temp = state.currentTemperature;
+            const target = state.targetTemperature;
+            const deadband = this.deadband;
+            if (temp < (this.minimumTemperature || 10.0)) {
+                state.safetyOverride = 'min';
+                state.currentState = 'heating';
+                return { heater: 'on', cooler: 'off', state: 'heating', override: 'minimum temperature' };
+            }
+            if (temp > (this.maximumTemperature || 50.0)) {
+                state.safetyOverride = 'max';
+                state.currentState = 'cooling';
+                return { heater: 'off', cooler: 'on', state: 'cooling', override: 'maximum temperature' };
+            }
+            state.safetyOverride = null;
+            if (temp < target - (deadband || 1.0)) {
+                state.currentState = 'heating';
+                return { heater: 'on', cooler: 'off', state: 'heating' };
+            }
+            else if (temp > target + (deadband || 1.0)) {
+                state.currentState = 'cooling';
+                return { heater: 'off', cooler: 'on', state: 'cooling' };
+            }
+            else {
+                const heater = state.currentState === 'heating' ? 'on' : 'off';
+                const cooler = state.currentState === 'cooling' ? 'on' : 'off';
+                return { heater, cooler, state: state.currentState };
+            }
+        };
+        const updateStatus = (control) => {
+            if (state.currentTemperature === undefined || state.targetTemperature === undefined) {
+                node.status({ fill: 'yellow', shape: 'dot', text: 'awaiting inputs' });
+                return;
+            }
+            const temp = state.currentTemperature.toFixed(1);
+            const target = state.targetTemperature.toFixed(1);
+            if (control.override) {
+                node.status({ fill: 'red', shape: 'dot', text: `SAFETY: ${control.override} (${temp}°C)` });
+            }
+            else if (control.state === 'heating') {
+                node.status({ fill: 'green', shape: 'dot', text: `Heating: ${temp}°C → ${target}°C` });
             }
-            else if (msg.topic === 'config' && typeof msg.payload === 'object') {
-                const { setpoint, kp } = msg.payload;
-                controller.configure(parseFloat(setpoint), parseFloat(kp));
+            else if (control.state === 'cooling') {
+                node.status({ fill: 'blue', shape: 'dot', text: `Cooling: ${temp}°C → ${target}°C` });
             }
             else {
-                node.warn('Unsupported message topic or payload');
+                node.status({ fill: 'grey', shape: 'dot', text: `Idle: ${temp}°C (${target}°C)` });
+            }
+        };
+        const processControl = () => {
+            const control = calculateControl();
+            node.send([
+                {
+                    payload: {
+                        heater: control.heater,
+                        cooler: control.cooler
+                    },
+                    topic: 'actuators'
+                },
+                {
+                    payload: {
+                        state: control.state,
+                        target: state.targetTemperature,
+                        reading: state.currentTemperature,
+                        safetyOverride: control.override || null,
+                        deadband: this.deadband
+                    },
+                    topic: 'status'
+                }
+            ]);
+            updateStatus(control);
+        };
+        node.on('input', (msg, send, done) => {
+            if (msg.topic === 'sensor') {
+                if (typeof msg.payload === 'number') {
+                    state.currentTemperature = msg.payload;
+                    node.log(`Current temperature updated: ${msg.payload}°C`);
+                }
+            }
+            else {
+                if (typeof msg.payload === 'number') {
+                    state.targetTemperature = msg.payload;
+                    node.log(`Target temperature updated: ${msg.payload}°C`);
+                }
+            }
+            if (state.targetTemperature !== undefined && state.currentTemperature !== undefined) {
+                processControl();
             }
-        }));
-        node.on('close', (done) => {
-            controller.clear();
-            done();
+            if (done)
+                done();
         });
+        node.status({ fill: 'yellow', shape: 'dot', text: 'awaiting inputs' });
     }
     RED.nodes.registerType('temperature controller', TemperatureControllerNode);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-freya-nodes",
-  "version": "0.0.21",
+  "version": "0.1.0",
   "description": "Custom nodes for Freya Vivarium Control System",
   "author": "Sanne 'SpuQ' Santens",
   "license": "MIT",
@@ -25,10 +25,12 @@
     "deploy": "bash ./scripts/deploy.sh && rm -rf build/"
   },
   "node-red": {
+    "version": ">=4.0.9",
     "nodes": {
       "environment-sensor": "nodes/environment-sensor/environment-sensor-node.js",
       "system-actuator": "nodes/system-actuators/system-actuators-node.js",
       "circadian-core": "nodes/circadian-core/circadian-core-node.js",
+      "location-config": "nodes/circadian-core/location-config-node.js",
       "humidity-controller": "nodes/humidity-controller/humidity-controller-node.js",
       "lighting-controller": "nodes/lighting-controller/lighting-controller-node.js",
       "precipitation-controller": "nodes/precipitation-controller/precipitation-controller-node.js",
@@ -36,6 +38,9 @@
       "status-aggregator": "nodes/status-aggregator/status-aggregator-node.js"
     }
   },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "files": [
     "icons",
     "nodes"