@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/round-block.js

@@ -0,0 +1,89 @@
+module.exports = function(RED) {
+    function RoundBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            precision: config.precision
+        };
+
+        // Validate initial config
+        const validPrecisions = ["0.1", "0.5", "1.0"];
+        if (!validPrecisions.includes(node.runtime.precision)) {
+            node.runtime.precision = "1.0";
+            node.status({ fill: "red", shape: "ring", text: "invalid precision, using 1.0" });
+        } else {
+            node.status({ fill: "green", shape: "dot", text: `name: ${node.runtime.name || "round"}, precision: ${node.runtime.precision}` });
+        }
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle precision configuration
+            if (msg.hasOwnProperty("context") && msg.context === "precision") {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    if (done) done();
+                    return;
+                }
+                const newPrecision = String(msg.payload);
+                if (!validPrecisions.includes(newPrecision)) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid precision" });
+                    if (done) done();
+                    return;
+                }
+                node.runtime.precision = newPrecision;
+                node.status({ fill: "green", shape: "dot", text: `precision: ${newPrecision}` });
+                if (done) done();
+                return;
+            }
+
+            // Passthrough: Process payload if numeric, else pass unchanged
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                send(msg);
+                if (done) done();
+                return;
+            }
+
+            const input = parseFloat(msg.payload);
+            if (isNaN(input) || !isFinite(input)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                send(msg);
+                if (done) done();
+                return;
+            }
+
+            // Round based on precision
+            let result;
+            const precision = parseFloat(node.runtime.precision);
+            if (precision === 0.1) {
+                result = Math.round(input * 10) / 10;
+            } else if (precision === 0.5) {
+                result = Math.round(input / 0.5) * 0.5;
+            } else {
+                result = Math.round(input);
+            }
+
+            msg.payload = result;
+            node.status({ fill: "blue", shape: "dot", text: `in: ${input.toFixed(2)}, out: ${result.toFixed(2)}` });
+            send(msg);
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("round-block", RoundBlockNode);
+};

package/nodes/saw-tooth-wave-block.html

@@ -0,0 +1,87 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="saw-tooth-wave-block">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on the canvas"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-lowerLimit" title="Minimum output value"><i class="fa fa-arrow-down"></i> Lower Limit</label>
+        <input type="number" id="node-input-lowerLimit" placeholder="0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-upperLimit" title="Maximum output value (≥ lowerLimit)"><i class="fa fa-arrow-up"></i> Upper Limit</label>
+        <input type="number" id="node-input-upperLimit" placeholder="100" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-period" title="Wave period (positive number, e.g., 10)"><i class="fa fa-clock-o"></i> Period</label>
+        <input type="number" id="node-input-period" placeholder="10" min="0.001" step="any">
+        <select id="node-input-periodUnits">
+            <option value="milliseconds">Milliseconds</option>
+            <option value="seconds">Seconds</option>
+            <option value="minutes">Minutes</option>
+        </select>
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("saw-tooth-wave-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            lowerLimit: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            upperLimit: { value: 100, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            period: { value: 10, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) > 0 && isFinite(parseFloat(v)); } },
+            periodUnits: { value: "seconds" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-wave-square",
+        paletteLabel: "saw tooth wave",
+        label: function() {
+            return this.name || "saw tooth wave";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="saw-tooth-wave-block">
+Generates a sawtooth wave output scaled to a configurable range.
+
+### Inputs
+: context (string) : Configures settings (`"lowerLimit"`, `"upperLimit"`, `"period"`). Unmatched values trigger error.
+: payload (number) : Config value for lowerLimit, upperLimit, or period.
+: units (string, optional) : Units for period.
+: Any input triggers wave output.
+
+### Outputs
+: payload (number) : Sawtooth wave value scaled between lowerLimit and upperLimit.
+
+### Properties
+: name (string) : Display name in editor.
+: lowerLimit (number) : Minimum output value.
+: upperLimit (number) : Maximum output value (≥ lowerLimit).
+: period (number) : Wave period (positive, in periodUnits).
+: periodUnits (string) : Units for period (`"milliseconds"`, `"seconds"`, `"minutes"`).
+
+### Details
+Generates a sawtooth wave output, linearly rising from `lowerLimit` to `upperLimit` over `period`, then dropping sharply, triggered by any input. 
+
+Tracks phase (0 to 1) for continuity. Configurable via editor or `msg.context` with numeric `msg.payload` and optional `msg.units`. 
+
+Ensures `upperLimit ≥ lowerLimit` by adjusting limits. Outputs `msg.payload` with wave value; if `period ≤ 0`, outputs `lowerLimit`.
+
+### Status
+- Green (dot): Configuration update
+- Blue (dot): State changed
+- Blue (ring): State unchanged
+- Red (ring): Error
+- Yellow (ring): Warning
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/saw-tooth-wave-block.js

@@ -0,0 +1,161 @@
+module.exports = function(RED) {
+    function SawToothWaveBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            lowerLimit: parseFloat(config.lowerLimit),
+            upperLimit: parseFloat(config.upperLimit),
+            period: (parseFloat(config.period) || 10) * (config.periodUnits === "minutes" ? 60000 : config.periodUnits === "seconds" ? 1000 : 1),
+            periodUnits: config.periodUnits || "seconds",
+            lastExecution: Date.now(),
+            phase: 0
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.lowerLimit) || isNaN(node.runtime.upperLimit) || !isFinite(node.runtime.lowerLimit) || !isFinite(node.runtime.upperLimit)) {
+            node.runtime.lowerLimit = 0;
+            node.runtime.upperLimit = 100;
+            node.status({ fill: "red", shape: "ring", text: "invalid limits" });
+        } else if (node.runtime.lowerLimit > node.runtime.upperLimit) {
+            node.runtime.upperLimit = node.runtime.lowerLimit;
+            node.status({ fill: "red", shape: "ring", text: "invalid limits" });
+        }
+        if (isNaN(node.runtime.period) || node.runtime.period <= 0 || !isFinite(node.runtime.period)) {
+            node.runtime.period = 10000;
+            node.runtime.periodUnits = "milliseconds";
+            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+        }
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context updates
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                if (typeof msg.context !== "string") {
+                    node.status({ fill: "red", shape: "ring", text: "invalid context" });
+                    if (done) done();
+                    return;
+                }
+                let value = parseFloat(msg.payload);
+                if (isNaN(value) || !isFinite(value)) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                switch (msg.context) {
+                    case "lowerLimit":
+                        node.runtime.lowerLimit = value;
+                        if (node.runtime.lowerLimit > node.runtime.upperLimit) {
+                            node.runtime.upperLimit = node.runtime.lowerLimit;
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `lower: ${node.runtime.lowerLimit.toFixed(2)}, upper adjusted to ${node.runtime.upperLimit.toFixed(2)}`
+                            });
+                        } else {
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `lower: ${node.runtime.lowerLimit.toFixed(2)}`
+                            });
+                        }
+                        break;
+                    case "upperLimit":
+                        node.runtime.upperLimit = value;
+                        if (node.runtime.upperLimit < node.runtime.lowerLimit) {
+                            node.runtime.lowerLimit = node.runtime.upperLimit;
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `upper: ${node.runtime.upperLimit.toFixed(2)}, lower adjusted to ${node.runtime.lowerLimit.toFixed(2)}`
+                            });
+                        } else {
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `upper: ${node.runtime.upperLimit.toFixed(2)}`
+                            });
+                        }
+                        break;
+                    case "period":
+                        const multiplier = msg.units === "minutes" ? 60000 : msg.units === "seconds" ? 1000 : 1;
+                        value *= multiplier;
+                        if (value <= 0) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.period = value;
+                        node.runtime.periodUnits = msg.units || "milliseconds";
+                        node.status({
+                            fill: "green",
+                            shape: "dot",
+                            text: `period: ${node.runtime.period.toFixed(2)} ms`
+                        });
+                        break;
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        if (done) done("Unknown context");
+                        return;
+                }
+                if (done) done();
+                return;
+            }
+
+            // Calculate time difference
+            const now = Date.now();
+            const deltaTime = (now - node.runtime.lastExecution) / 1000; // Seconds
+            node.runtime.lastExecution = now;
+
+            // Return lowerLimit if period is invalid
+            if (node.runtime.period <= 0) {
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: `out: ${node.runtime.lowerLimit.toFixed(2)}, phase: ${node.runtime.phase.toFixed(2)}`
+                });
+                send({ payload: node.runtime.lowerLimit });
+                if (done) done();
+                return;
+            }
+
+            // Update phase
+            node.runtime.phase = (node.runtime.phase + deltaTime / (node.runtime.period / 1000)) % 1;
+
+            // Sawtooth wave calculation
+            const amplitude = node.runtime.upperLimit - node.runtime.lowerLimit;
+            const value = node.runtime.lowerLimit + amplitude * node.runtime.phase;
+
+            // Output new message
+            node.status({
+                fill: "blue",
+                shape: "dot",
+                text: `out: ${value.toFixed(2)}, phase: ${node.runtime.phase.toFixed(2)}`
+            });
+            send({ payload: value });
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("saw-tooth-wave-block", SawToothWaveBlockNode);
+};

package/nodes/scale-range-block.html

@@ -0,0 +1,90 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="scale-range-block">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on the canvas"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-inMin" title="Minimum input value (number)"><i class="fa fa-arrow-down"></i> Input Min</label>
+        <input type="number" id="node-input-inMin" placeholder="0.0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-inMax" title="Maximum input value (number, > inMin)"><i class="fa fa-arrow-up"></i> Input Max</label>
+        <input type="number" id="node-input-inMax" placeholder="100.0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-outMin" title="Minimum output value (number)"><i class="fa fa-arrow-down"></i> Output Min</label>
+        <input type="number" id="node-input-outMin" placeholder="0.0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-outMax" title="Maximum output value (number, > outMin)"><i class="fa fa-arrow-up"></i> Output Max</label>
+        <input type="number" id="node-input-outMax" placeholder="80.0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-clamp" title="Clamp output to output range (boolean)"><i class="fa fa-lock"></i> Clamp</label>
+        <input type="checkbox" id="node-input-clamp" style="width: auto; vertical-align: middle;">
+    </div>
+</script>
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("scale-range-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            inMin: { value: 0.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            inMax: { value: 100.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            outMin: { value: 0.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            outMax: { value: 80.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            clamp: { value: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-arrows-h",
+        paletteLabel: "scale range",
+        label: function() {
+            return this.name || "scale range";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="scale-range-block">
+Scales a numeric input from one range to another and passes the original message.
+
+### Inputs
+: context (string) : Configures settings (`"inMin"`, `"inMax"`, `"outMin"`, `"outMax"`, `"clamp"`). Unmatched values trigger error.
+: payload (number | boolean) : Number for input or range configuration, boolean for clamp.
+
+### Outputs
+: payload (number) : Scaled output value.
+
+### Properties
+: inMin (number) : Minimum input value.
+: inMax (number) : Maximum input value (> inMin).
+: outMin (number) : Minimum output value.
+: outMax (number) : Maximum output value (> outMin).
+: clamp (boolean) : Clamp output to output range.
+
+### Details
+Scales `msg.payload` (number) from an input range (`inMin` to `inMax`) to an output range (`outMin` to `outMax`) using linear interpolation, with optional 
+clamping to `[outMin, outMax]` if `clamp` is `true`.
+
+Outputs the input message with `msg.payload` set to the scaled value, preserving other properties. 
+
+Outputs on valid input or configuration change (recalculates with last input).
+
+### Status
+- Green (dot): Configuration update
+- Blue (dot): State changed
+- Blue (ring): State unchanged
+- Red (ring): Error
+- Yellow (ring): Warning
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/scale-range-block.js

@@ -0,0 +1,137 @@
+module.exports = function(RED) {
+    function ScaleRangeBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name || "",
+            inMin: parseFloat(config.inMin),
+            inMax: parseFloat(config.inMax),
+            outMin: parseFloat(config.outMin),
+            outMax: parseFloat(config.outMax),
+            clamp: config.clamp,
+            lastInput: parseFloat(config.inMin)
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.inMin) || isNaN(node.runtime.inMax) || !isFinite(node.runtime.inMin) || !isFinite(node.runtime.inMax) || node.runtime.inMin >= node.runtime.inMax) {
+            node.runtime.inMin = 0.0;
+            node.runtime.inMax = 100.0;
+            node.runtime.lastInput = 0.0;
+            node.status({ fill: "red", shape: "ring", text: "invalid input range" });
+        }
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context updates
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+
+                let shouldOutput = false;
+                switch (msg.context) {
+                    case "inMin":
+                    case "inMax":
+                    case "outMin":
+                    case "outMax":
+                        const value = parseFloat(msg.payload);
+                        if (isNaN(value) || !isFinite(value)) {
+                            node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime[msg.context] = value;
+                        if (node.runtime.inMax <= node.runtime.inMin) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid input range" });
+                            if (done) done();
+                            return;
+                        }
+                        if (node.runtime.outMax <= node.runtime.outMin) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid output range" });
+                            if (done) done();
+                            return;
+                        }
+                        node.status({ fill: "green", shape: "dot", text: `${msg.context}: ${value.toFixed(2)}` });
+                        shouldOutput = true;
+                        break;
+                    case "clamp":
+                        if (typeof msg.payload !== "boolean") {
+                            node.status({ fill: "red", shape: "ring", text: "invalid clamp" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.clamp = msg.payload;
+                        node.status({ fill: "green", shape: "dot", text: `clamp: ${node.runtime.clamp}` });
+                        shouldOutput = true;
+                        break;
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        if (done) done("Unknown context");
+                        return;
+                }
+
+                // Recalculate with last input after config update
+                if (shouldOutput) {
+                    const out = calculate(node.runtime.lastInput, node.runtime.inMin, node.runtime.inMax, node.runtime.outMin, node.runtime.outMax, node.runtime.clamp);
+                    msg.payload = out;
+                    node.status({ fill: "blue", shape: "dot", text: `out: ${out.toFixed(2)}, in: ${node.runtime.lastInput.toFixed(2)}` });
+                    send(msg);
+                }
+                if (done) done();
+                return;
+            }
+
+            // Validate input
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing input" });
+                if (done) done();
+                return;
+            }
+            const inputValue = parseFloat(msg.payload);
+            if (isNaN(inputValue) || !isFinite(inputValue)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                if (done) done();
+                return;
+            }
+            if (node.runtime.inMax <= node.runtime.inMin) {
+                node.status({ fill: "red", shape: "ring", text: "inMinx must be < inMax" });
+                if (done) done();
+                return;
+            }
+
+            // Scale input
+            node.runtime.lastInput = inputValue;
+            const out = calculate(inputValue, node.runtime.inMin, node.runtime.inMax, node.runtime.outMin, node.runtime.outMax, node.runtime.clamp);
+            msg.payload = out;
+            node.status({ fill: "blue", shape: "dot", text: `out: ${out.toFixed(2)}, in: ${inputValue.toFixed(2)}` });
+            send(msg);
+
+            if (done) done();
+        });
+
+        // Scaling function
+        function calculate(input, inMin, inMax, outMin, outMax, clamp) {
+            const scaleRatio = (outMax - outMin) / (inMax - inMin);
+            let output = scaleRatio * (input - inMin) + outMin;
+            return clamp ? Math.max(outMin, Math.min(outMax, output)) : output;
+        }
+
+        node.on("close", function(done) { 
+            done();
+        });
+    }
+
+    RED.nodes.registerType("scale-range-block", ScaleRangeBlockNode); 
+};

package/nodes/sine-wave-block.html

@@ -0,0 +1,88 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="sine-wave-block">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on the canvas"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-lowerLimit" title="Minimum output value"><i class="fa fa-arrow-down"></i> Lower Limit</label>
+        <input type="number" id="node-input-lowerLimit" placeholder="0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-upperLimit" title="Maximum output value (≥ lowerLimit)"><i class="fa fa-arrow-up"></i> Upper Limit</label>
+        <input type="number" id="node-input-upperLimit" placeholder="100" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-period" title="Wave period (positive number, e.g., 10)"><i class="fa fa-clock-o"></i> Period</label>
+        <input type="number" id="node-input-period" placeholder="10" min="0.001" step="any">
+        <select id="node-input-periodUnits">
+            <option value="milliseconds">Milliseconds</option>
+            <option value="seconds">Seconds</option>
+            <option value="minutes">Minutes</option>
+        </select>
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("sine-wave-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            lowerLimit: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            upperLimit: { value: 100, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            period: { value: 10, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) > 0 && isFinite(parseFloat(v)); } },
+            periodUnits: { value: "seconds" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-wave-square",
+        paletteLabel: "sine wave",
+        label: function() {
+            return this.name || "sine wave";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="sine-wave-block">
+Generates a sine wave output scaled to a configurable range.
+
+### Inputs
+: context (string) : Configures settings (`"lowerLimit"`, `"upperLimit"`, `"period"`). Unmatched values trigger error.
+: payload (number) : Config value for lowerLimit, upperLimit, or period.
+: units (string, optional) : Units for period (`"milliseconds"`, `"seconds"`, `"minutes"`).
+: Any input triggers wave output.
+
+### Outputs
+: payload (number) : Sine wave value scaled between lowerLimit and upperLimit.
+
+### Properties
+: lowerLimit (number) : Minimum output value.
+: upperLimit (number) : Maximum output value (≥ lowerLimit).
+: period (number) : Wave period (positive, in periodUnits).
+: periodUnits (string) : Units for period (`"milliseconds"`, `"seconds"`, `"minutes"`).
+
+### Details
+Generates a sine wave output, smoothly oscillating between `lowerLimit` and `upperLimit` over `period`, triggered by any input. 
+
+Tracks phase (0 to 1) for continuity. Configurable via editor or `msg.context` with numeric `msg.payload` and optional `msg.units`.
+
+Ensures `upperLimit ≥ lowerLimit` by adjusting limits. 
+
+Outputs `msg.payload` with wave value; if `period ≤ 0`, outputs `lowerLimit`.
+
+### Status
+- Green (dot): Configuration update
+- Blue (dot): State changed
+- Blue (ring): State unchanged
+- Red (ring): Error
+- Yellow (ring): Warning
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>