node-red-contrib-freya-nodes 0.0.20

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2025 Sanne 'SpuQ' Santens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+![Freya Banner](https://raw.githubusercontent.com/Freya-Vivariums/.github/refs/heads/main/brand/Freya_banner.png)
+
+<img src="https://nodered.org/about/resources/media/node-red-icon.png" align="right" width="10%"/>
+
+**[Node-RED](https://nodered.org/)** is a visual programming tool that lets you wire together hardware, APIs, and online services by connecting blocks in a flow-based editor. The **Freya Node-RED nodes** lorem ipsum...
+
+<br clear="right"/>
+
+[![Node-RED](https://img.shields.io/badge/Node--RED-Freya-%23A2CA6F?logo=nodered)](https://flows.nodered.org/node/node-red-contrib-freya)
+
+## Installation
+#### Node-RED flow editor
+Navigate to `Settings > Manage Palette`, then in the `Install` tab, search for `node-red-contrib-freya` and click the `Install` button.
+
+#### Manually using NPM
+On your device, navigate to the `nodered` folder, and run
+```
+npm install node-red-contrib-freya
+```
+
+## License & Collaboration
+**Copyright© 2025 Sanne 'SpuQ' Santens**. The Freya NodeRED nodes project is licensed under the **[MIT License](LICENSE.txt)**. The [Rules & Guidelines](https://github.com/Freya-Vivariums/.github/blob/main/brand/Freya_Trademark_Rules_and_Guidelines.md) apply to the usage of the Freya Vivariums™ brand.
+
+### Collaboration
+
+If you'd like to contribute to this project, please follow these guidelines:
+1. Fork the repository and create your branch from `main`.
+2. Make your changes and ensure they adhere to the project's coding style and conventions.
+3. Test your changes thoroughly.
+4. Ensure your commits are descriptive and well-documented.
+5. Open a pull request, describing the changes you've made and the problem or feature they address.

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

@@ -0,0 +1,104 @@
+<script type="text/javascript">
+  RED.nodes.registerType('circadian core',{
+    category: 'Freya Vivariums',
+    color: "#A2CA6F",
+    defaults: {
+      name: {value:""}
+    },
+    inputs:1,
+    outputs:2,
+    outputLabels:["control", "status"],
+    icon: "font-awesome/fa-globe",
+    label: function() {
+      return this.name || "Circadian Core";
+    }
+  });
+</script>
+
+
+<script type="text/html" data-template-name="circadian core">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Circadian Core">
+    </div>
+    <hr/>
+    <div class="form-row">
+      <h2><i class="fa fa-map-marker"></i> Location Settings</h2>
+    </div>
+    <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>
+    </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>
+    </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>
+    </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>
+
+
+
+<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.
+  </p>
+</script>

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

@@ -0,0 +1,23 @@
+"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 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);
+            done === null || done === void 0 ? void 0 : done();
+        }));
+    }
+    RED.nodes.registerType('circadian core', CircadianCoreNode);
+};
+module.exports = circadianCore;

package/nodes/environment-sensor/environment-sensor-node.html

@@ -0,0 +1,50 @@
+<script type="text/javascript">
+  RED.nodes.registerType('environment sensor',{
+    category: 'Freya Vivariums',
+    color: "#70B62D",
+    defaults: {
+      name: {value:""},
+      variable: {value:"all"},
+      sampleinterval: {value:""}
+    },
+    inputs:0,
+    outputs:2,
+    outputLabels:["control", "status"],
+    icon: "font-awesome/fa-microchip",
+    label: function() {
+      return this.name || "Environment Sensor";
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="environment sensor">
+  <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">
+  </div>
+  <hr/>
+  <div class="form-row">
+    <label for="node-input-variable">Environment Variable</label>
+    <select id="node-input-variable">
+      <option value="all" selected>All measurements</option>
+      <option value="temperature">Temperature [&deg;C]</option>
+      <option value="humidity">Relative Humidity [%]</option>
+      <option value="airquality" disabled>Relative Air Quality [%]</option>
+      <option value="pressure">Barometric Pressure [hPa]</option>
+      <option value="light">Light Intensity [Lux]</option>
+      <option value="uva" disabled>UVA (320-400 nm) [µW/cm²]</option>
+      <option value="uvb" disabled>UVB (280-320 nm) [µW/cm²]</option>
+      <option value="uvc" disabled>UVC (200-280 nm) [µW/cm²]</option>
+    </select>
+    <i class="fa fa-info-circle" title="The environment variable which we want to use"></i>
+  </div>
+  <div class="form-row">
+    <label for="node-input-sampleinterval">Sample Interval (s)</label>
+    <input type="number" id="node-input-sampleinterval" placeholder="5">
+    <i class="fa fa-info-circle" title="The sensor sample rate (seconds)"></i>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="environment sensor">
+  <p>The <strong>Freya Environment Sensor</strong> lorem ipsum ...</p>
+</script>

package/nodes/environment-sensor/environment-sensor-node.js

@@ -0,0 +1,36 @@
+"use strict";
+const environment_sensor_1 = require("./environment-sensor");
+const environmentSensor = (RED) => {
+    function EnvironmentSensorNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        const variable = config.variable;
+        const sampleinterval = parseFloat(config.sampleinterval);
+        const sensorDriver = new environment_sensor_1.SensorDriver();
+        sensorDriver.on('status', (status) => {
+            switch (status.level) {
+                case 'ok':
+                    node.status({ fill: 'green', shape: 'dot', text: status.message });
+                    break;
+                case 'warning':
+                    node.status({ fill: 'yellow', shape: 'dot', text: status.message });
+                    break;
+                default:
+                    node.status({ fill: 'red', shape: 'dot', text: status.message });
+                    break;
+            }
+        });
+        sensorDriver.on('measurement', (measurement) => {
+            if (Object.prototype.hasOwnProperty.call(measurement, variable) || variable === 'all') {
+                const msg = {
+                    _msgid: '',
+                    topic: "measurement",
+                    payload: measurement
+                };
+                this.send(msg);
+            }
+        });
+    }
+    RED.nodes.registerType('environment sensor', EnvironmentSensorNode);
+};
+module.exports = environmentSensor;

package/nodes/environment-sensor/environment-sensor.js

@@ -0,0 +1,72 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorDriver = void 0;
+const dbus = require('dbus-native');
+const events_1 = require("events");
+class SensorDriver extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.bus = dbus.systemBus();
+        this.init();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.initDriverConnection();
+                console.log('Connected to sensor driver');
+                this.emit('status', { level: "ok", message: "Connected to sensor driver" });
+            }
+            catch (err) {
+                console.error('Error connecting to sensor driver:', err);
+                this.emit('status', { level: "error", message: "No connection to driver" });
+                setTimeout(() => { this.init(); }, 5 * 1000);
+            }
+            this.iface.on('measurement', (type, value) => {
+                const parsedValue = isNaN(Number(value)) ? value : Number(value);
+                this.emit('measurement', { [type]: parsedValue });
+            });
+        });
+    }
+    initDriverConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const service = this.bus.getService('io.freya.EnvironmentSensorDriver');
+            this.iface = yield new Promise((resolve, reject) => {
+                service.getInterface('/io/freya/EnvironmentSensorDriver', 'io.freya.EnvironmentSensorDriver', (err, iface) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(iface);
+                    }
+                });
+            });
+        });
+    }
+    setSampleInterval(interval) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.iface) {
+                throw new Error('Driver not initialized. Call init() first.');
+            }
+            return new Promise((resolve, reject) => {
+                this.iface.setDigitalOutput(interval, (err, result) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(result);
+                    }
+                });
+            });
+        });
+    }
+}
+exports.SensorDriver = SensorDriver;

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

@@ -0,0 +1,27 @@
+<script type="text/javascript">
+  RED.nodes.registerType('humidity controller',{
+    category: 'Freya Vivariums',
+    color: "#A2CA6F",
+    defaults: {
+      name: {value:""}
+    },
+    inputs:1,
+    outputs:2,
+    outputLabels:["control", "status"],
+    icon: "font-awesome/fa-tint",
+    label: function() {
+      return this.name || "Humidity Controller";
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="humidity 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">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="humidity controller">
+  <p>The humidity controller lorem ipsum ...</p>
+</script>

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

@@ -0,0 +1,23 @@
+"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();
+        }));
+    }
+    RED.nodes.registerType('humidity controller', HumidityControllerNode);
+};
+module.exports = humidityController;

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

@@ -0,0 +1,27 @@
+<script type="text/javascript">
+  RED.nodes.registerType('lighting controller',{
+    category: 'Freya Vivariums',
+    color: "#A2CA6F",
+    defaults: {
+      name: {value:""}
+    },
+    inputs:1,
+    outputs:2,
+    outputLabels:["control", "status"],
+    icon: "font-awesome/fa-lightbulb-o",
+    label: function() {
+      return this.name || "Lighting Controller";
+    }
+  });
+</script>
+
+<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">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="lighting controller">
+  <p>The lighting controller lorem ipsum ...</p>
+</script>

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

@@ -0,0 +1,23 @@
+"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);
+            done === null || done === void 0 ? void 0 : done();
+        }));
+    }
+    RED.nodes.registerType('lighting controller', LightingControllerNode);
+};
+module.exports = lightingController;

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

@@ -0,0 +1,27 @@
+<script type="text/javascript">
+  RED.nodes.registerType('precipitation controller',{
+    category: 'Freya Vivariums',
+    color: "#A2CA6F",
+    defaults: {
+      name: {value:""}
+    },
+    inputs:1,
+    outputs:2,
+    outputLabels:["control", "status"],
+    icon: "font-awesome/fa-cloud",
+    label: function() {
+      return this.name || "Precipitation Controller";
+    }
+  });
+</script>
+
+<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">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="precipitation controller">
+  <p>The precipitation controller lorem ipsum ...</p>
+</script>

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

@@ -0,0 +1,23 @@
+"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 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);
+            done === null || done === void 0 ? void 0 : done();
+        }));
+    }
+    RED.nodes.registerType('precipitation controller', PrecipitationControllerNode);
+};
+module.exports = precipitationController;

package/nodes/status-aggregator/status-aggregator-node.html

@@ -0,0 +1,29 @@
+<script type="text/javascript">
+  RED.nodes.registerType('status aggregator',{
+    category: 'Freya Vivariums',
+    color: "#00A29A",
+    defaults: {
+      name: {value:""}
+    },
+    inputs:1,
+    outputs:2,
+    outputLabels:["control", "status"],
+    icon: "font-awesome/fa-stethoscope",
+    label: function() {
+      return this.name || "Status Aggregator";
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="status aggregator">
+  <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">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="status aggregator">
+  <p>
+    The <strong>Status Aggregator</strong> collects, organizes, and evaluates health and diagnostic signals from the connected components.
+  </p>
+</script>

package/nodes/status-aggregator/status-aggregator-node.js

@@ -0,0 +1,23 @@
+"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 StatusAggregator = (RED) => {
+    function StatusAggregatorNode(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();
+        }));
+    }
+    RED.nodes.registerType('status aggregator', StatusAggregatorNode);
+};
+module.exports = StatusAggregator;

package/nodes/system-actuators/system-actuators-node.html

@@ -0,0 +1,59 @@
+<script type="text/javascript">
+  RED.nodes.registerType('system actuators',{
+    category: 'Freya Vivariums',
+    color: "#70B62D",
+    defaults: {
+      name: {value:""},
+      actuator: {value:""},
+      channel: {value:""},
+      mode: {value:""}
+    },
+    inputs:1,
+    outputs:1,
+    outputLabels:["status"],
+    icon: "font-awesome/fa-microchip",
+    label: function() {
+      return this.name || "System Actuator";
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="system actuators">
+  <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">
+  </div>
+  <hr/>
+    <div class="form-row">
+    <label for="node-input-actuator"><i class="icon-tag"></i> Actuator</label>
+    <input type="text" id="node-input-actuator" placeholder="e.g. heater">
+    <i class="fa fa-info-circle" title="The name of te actuator. This node will filter messages based on this name"></i>
+  </div>
+  <div class="form-row">
+    <label for="node-input-channel"><i class="icon-cog"></i> Channel</label>
+    <select id="node-input-channel">
+      <option value="0" disabled selected>Select output...</option>
+      <option value="1">Digital Output 1</option>
+      <option value="2">Digital Output 2</option>
+      <option value="3">Digital Output 3</option>
+      <option value="4">Digital Output 4</option>
+      <option value="5">Digital Output 5</option>
+      <option value="6">Digital Output 6</option>
+      <option value="0">Disabled</option>
+    </select>
+    <i class="fa fa-info-circle" title="The physical digital output where the actuator is connected to"></i>
+  </div>
+  <div class="form-row">
+    <label for="node-input-mode"><i class="icon-exchange"></i> Mode</label>
+    <select id="node-input-mode">
+      <option value="" disabled selected>Select mode...</option>
+      <option value="digital">on/off</option>
+      <option value="pwm" disabled>PWM</option>
+    </select>
+    <i class="fa fa-info-circle" title="The output mode"></i>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="system actuators">
+  <p>The <strong>Freya System Actuators</strong> lorem ipsum ...</p>
+</script>

package/nodes/system-actuators/system-actuators-node.js

@@ -0,0 +1,66 @@
+"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 system_actuators_1 = require("./system-actuators");
+const systemActuators = (RED) => {
+    function SystemActuatorsNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        const actuator = config.actuator;
+        const channel = parseInt(config.channel);
+        const mode = config.mode;
+        const actuatorsDriver = new system_actuators_1.ActuatorsDriver();
+        actuatorsDriver.on('status', (status) => {
+            switch (status.level) {
+                case 'ok':
+                    node.status({ fill: 'green', shape: 'dot', text: status.message });
+                    break;
+                case 'warning':
+                    node.status({ fill: 'yellow', shape: 'dot', text: status.message });
+                    break;
+                default:
+                    node.status({ fill: 'red', shape: 'dot', text: status.message });
+                    break;
+            }
+        });
+        node.on('input', (msg, send, done) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (msg.payload != null && typeof msg.payload === 'object') {
+                    const rawValue = msg.payload[actuator];
+                    if (typeof rawValue !== 'undefined') {
+                        if (mode === 'digital') {
+                            const state = (rawValue === true || rawValue === "true" || rawValue === 1 || rawValue === "1" || rawValue === 'on') ? true : false;
+                            actuatorsDriver.setDigitalOutput(channel, state)
+                                .then((res) => {
+                                if (res)
+                                    node.status({ fill: 'green', shape: 'dot', text: `D${channel} turned ${state ? 'on' : 'off'}` });
+                                else
+                                    node.status({ fill: 'yellow', shape: 'dot', text: 'Invalid request' });
+                            })
+                                .catch((err) => {
+                                node.status({ fill: 'yellow', shape: 'dot', text: err });
+                            });
+                        }
+                        else if (mode === 'pwm') {
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                node.status({ fill: 'red', shape: 'dot', text: "Failed to set output" });
+                done(err);
+                return;
+            }
+            done();
+        }));
+    }
+    RED.nodes.registerType('system actuators', SystemActuatorsNode);
+};
+module.exports = systemActuators;

package/nodes/system-actuators/system-actuators.js

@@ -0,0 +1,68 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActuatorsDriver = void 0;
+const dbus = require('dbus-native');
+const events_1 = require("events");
+class ActuatorsDriver extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.bus = dbus.systemBus();
+        this.init();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.initDriverConnection();
+                console.log('Connected to actuators driver');
+                this.emit('status', { level: "ok", message: "Connected to actuators driver" });
+            }
+            catch (err) {
+                console.error('Error connecting to actuators driver:', err);
+                this.emit('status', { level: "error", message: "No connection to driver" });
+                setTimeout(() => { this.init(); }, 5 * 1000);
+            }
+        });
+    }
+    initDriverConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const service = this.bus.getService('io.freya.SystemActuatorsDriver');
+            this.iface = yield new Promise((resolve, reject) => {
+                service.getInterface('/io/freya/SystemActuatorsDriver', 'io.freya.SystemActuatorsDriver', (err, iface) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(iface);
+                    }
+                });
+            });
+        });
+    }
+    setDigitalOutput(channel, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.iface) {
+                throw new Error('Driver not initialized. Call init() first.');
+            }
+            return new Promise((resolve, reject) => {
+                this.iface.setDigitalOutput(channel, state, (err, result) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(result);
+                    }
+                });
+            });
+        });
+    }
+}
+exports.ActuatorsDriver = ActuatorsDriver;

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

@@ -0,0 +1,60 @@
+<script type="text/javascript">
+  RED.nodes.registerType('temperature controller',{  
+    category: 'Freya Vivariums',
+    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()}
+    },
+    inputs:1,
+    outputs:2,
+    outputLabels:["control","status"],
+    icon: "font-awesome/fa-thermometer-half",
+    label: function() {
+      return this.name||"Temperature Controller";
+    }
+  });
+</script>
+
+<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">
+  </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">
+  </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">
+  </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">
+  </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>
+</script>

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

@@ -0,0 +1,44 @@
+"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);
+            }
+            else if (msg.topic === 'config' && typeof msg.payload === 'object') {
+                const { setpoint, kp } = msg.payload;
+                controller.configure(parseFloat(setpoint), parseFloat(kp));
+            }
+            else {
+                node.warn('Unsupported message topic or payload');
+            }
+        }));
+        node.on('close', (done) => {
+            controller.clear();
+            done();
+        });
+    }
+    RED.nodes.registerType('temperature controller', TemperatureControllerNode);
+};
+module.exports = temperatureController;

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemperatureController = void 0;
+const EventEmitter = require('events');
+class TemperatureController extends EventEmitter {
+    constructor() {
+        super();
+        this.targetTemperature = 0;
+        this.maximumTemperature = 0;
+        this.maximumTemperature = 0;
+        this.currentTemperature = 0;
+        this.proportionalGain = 10;
+        this.controlEffort = 0;
+        this.isOpenLoop = true;
+        this.controlLoopTimer = null;
+        this.watchdogTimer = null;
+        this.watchdogTimeout = 60;
+        this._startWatchdog();
+        this.emitStatus('error', 'Open-loop mode', 'No sensor feedback — controller running without environmental feedback');
+    }
+    _startWatchdog() {
+        if (this.watchdogTimer)
+            clearTimeout(this.watchdogTimer);
+        this.setOpenLoopEnabled(false);
+        this.watchdogTimer = setTimeout(() => {
+            this.setOpenLoopEnabled(true);
+        }, this.watchdogTimeout * 1000);
+    }
+    clear() {
+        if (this.controlLoopTimer)
+            clearInterval(this.controlLoopTimer);
+        if (this.watchdogTimer)
+            clearTimeout(this.watchdogTimer);
+        this.controlEffort = 0;
+        this.emitStatus('error', 'Open-loop mode', 'Controller inactive — running without environmental feedback');
+    }
+    updateTemperature(temperature) {
+        this.currentTemperature = temperature;
+        this._startWatchdog();
+    }
+    getCurrentReading() {
+        return {
+            targetTemperature: this.targetTemperature,
+            currentTemperature: this.currentTemperature,
+            timestamp: Math.floor(Date.now() / 1000)
+        };
+    }
+    configure(minimumTemperature, maximumTemperature, proportionalGain = 10) {
+        this.proportionalGain = proportionalGain;
+        this.minimumTemperature = minimumTemperature;
+        this.maximumTemperature = maximumTemperature;
+        this.emitStatus('ok', 'Controller configured', `Setpoint=${this.targetTemperature}°C, Kp=${this.proportionalGain}`);
+    }
+    setSetpoint(targetTemperature) {
+        this.targetTemperature = targetTemperature;
+        this.emitStatus('ok', 'Setpoint Updated', `Setpoint=${this.targetTemperature}°C)`);
+    }
+    setOpenLoopEnabled(enabled) {
+        this.isOpenLoop = enabled;
+    }
+    emitStatus(level, message, details) {
+        this.emit('status', { level, message, details });
+    }
+    _executeControlLoop() {
+        if (this.isOpenLoop) {
+            this.controlEffort = 0;
+            this.emitStatus('error', 'Open-loop mode', 'No sensor feedback — controller running without environmental feedback');
+            this.emit('controlOutput', this.controlEffort);
+            return;
+        }
+        const error = this.targetTemperature - this.currentTemperature;
+        this.controlEffort = this.proportionalGain * error;
+        this.controlEffort = Math.max(-100, Math.min(100, this.controlEffort));
+        let statusMessage;
+        if (this.controlEffort > 0) {
+            statusMessage = `Heating at ${Math.round(this.controlEffort)}% effort`;
+        }
+        else if (this.controlEffort < 0) {
+            statusMessage = `Cooling at ${Math.round(-this.controlEffort)}% effort`;
+        }
+        else {
+            statusMessage = 'Idle (on target)';
+        }
+        this.emitStatus('ok', statusMessage);
+        this.emit('controlOutput', this.controlEffort);
+    }
+}
+exports.TemperatureController = TemperatureController;
+module.exports = { TemperatureController };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "node-red-contrib-freya-nodes",
+  "version": "0.0.20",
+  "description": "Custom nodes for Freya Vivarium Control System",
+  "author": "Sanne 'SpuQ' Santens",
+  "license": "MIT",
+  "homepage": "https://github.com/Freya-Vivariums",
+  "bugs": {
+    "url": "https://www.reddit.com/r/FreyaVivariums"
+  },
+  "private": false,
+  "keywords": [
+    "node-red",
+    "node-red-node",
+    "freya",
+    "vivarium",
+    "control system",
+    "paludarium",
+    "terrarium",
+    "greenhouse"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "bash ./scripts/build.sh",
+    "deploy": "bash ./scripts/deploy.sh && rm -rf build/"
+  },
+  "node-red": {
+    "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",
+      "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",
+      "temperature-controller": "nodes/temperature-controller/temperature-controller-node.js",
+      "status-aggregator": "nodes/status-aggregator/status-aggregator-node.js"
+    }
+  },
+  "files": [
+    "icons",
+    "nodes"
+  ],
+  "devDependencies": {
+    "@types/node-red": "^1.3.5",
+    "nodemon": "^3.1.4",
+    "ts-node": "^10.9.2"
+  },
+  "dependencies": {
+    "dbus-native": "^0.4.0"
+  }
+}