node-red-contrib-event-calc 0.1.2 → 2.0.1

package/nodes/event-chart.js

@@ -0,0 +1,106 @@
+module.exports = function(RED) {
+    function EventChartNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.title = config.title || 'Event Chart';
+        node.maxPoints = parseInt(config.maxPoints) || 200;
+        node.timestampField = config.timestampField || 'timestamp';
+        node.valueField = config.valueField || 'payload';
+        node.seriesField = config.seriesField || 'topic';
+
+        // Store data per series
+        node.chartData = {};
+
+        node.clearChart = function() {
+            node.chartData = {};
+            node.status({ fill: "grey", shape: "ring", text: "cleared" });
+            emitData();
+        };
+
+        node.on('input', function(msg) {
+            // Handle clear command
+            if (msg.payload === '_clear' || msg.topic === '_clear') {
+                node.clearChart();
+                return;
+            }
+
+            const series = RED.util.getMessageProperty(msg, node.seriesField) || 'default';
+            let timestamp = RED.util.getMessageProperty(msg, node.timestampField);
+            let value = RED.util.getMessageProperty(msg, node.valueField);
+
+            // Handle timestamp
+            if (timestamp === undefined || timestamp === null) {
+                timestamp = Date.now();
+            } else if (typeof timestamp !== 'number') {
+                timestamp = new Date(timestamp).getTime();
+            }
+
+            // Handle value
+            if (value === undefined || value === null) {
+                return;
+            }
+
+            if (typeof value !== 'number') {
+                value = parseFloat(value);
+                if (isNaN(value)) return;
+            }
+
+            if (!node.chartData[series]) {
+                node.chartData[series] = [];
+            }
+
+            node.chartData[series].push({
+                x: timestamp,
+                y: value
+            });
+
+            // Limit points per series
+            if (node.chartData[series].length > node.maxPoints) {
+                node.chartData[series].shift();
+            }
+
+            const totalPoints = Object.values(node.chartData).reduce((sum, arr) => sum + arr.length, 0);
+            const seriesCount = Object.keys(node.chartData).length;
+            node.status({ fill: "green", shape: "dot", text: `${seriesCount} series, ${totalPoints} pts` });
+
+            emitData();
+        });
+
+        function emitData() {
+            RED.comms.publish("event-chart-data-" + node.id, {
+                id: node.id,
+                title: node.title,
+                data: node.chartData
+            });
+        }
+
+        node.on('close', function() {
+            node.chartData = {};
+            node.status({});
+        });
+    }
+
+    RED.nodes.registerType("event-chart", EventChartNode);
+
+    // Clear chart data endpoint
+    RED.httpAdmin.post("/event-chart/:id/clear", function(req, res) {
+        const node = RED.nodes.getNode(req.params.id);
+        if (node && node.clearChart) {
+            node.clearChart();
+            res.sendStatus(200);
+        } else {
+            res.status(404).send("Node not found");
+        }
+    });
+
+    // Get chart data endpoint
+    RED.httpAdmin.get("/event-chart/:id/data", function(req, res) {
+        const node = RED.nodes.getNode(req.params.id);
+        if (node) {
+            res.json({ title: node.title, data: node.chartData || {} });
+        } else {
+            res.status(404).send("Node not found");
+        }
+    });
+};

package/nodes/event-json.html

@@ -0,0 +1,58 @@
+<script type="text/javascript">
+    RED.nodes.registerType('event-json', {
+        category: 'event calc',
+        color: '#758467',
+        defaults: {
+            name: { value: "" }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-exchange",
+        label: function() {
+            return this.name || "event json";
+        },
+        paletteLabel: "event json"
+    });
+</script>
+
+<script type="text/html" data-template-name="event-json">
+    <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="Name">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="event-json">
+    <p>Bidirectional JSON envelope converter. Automatically detects direction.</p>
+
+    <h3>Behavior</h3>
+    <dl class="message-properties">
+        <dt>Unwrap (JSON to Message)</dt>
+        <dd>If payload is <code>{value, topic?, timestamp?}</code>, extracts value to <code>msg.payload</code> and copies topic/timestamp to msg.</dd>
+        <dt>Wrap (Message to JSON)</dt>
+        <dd>If payload is any other value, wraps it as <code>{timestamp, topic, value}</code>.</dd>
+    </dl>
+
+    <h3>Examples</h3>
+    <h4>Wrap (before MQTT publish)</h4>
+    <pre>
+Input:  msg.topic = "sensor/temp", msg.payload = 25.5
+Output: msg.payload = {
+    timestamp: 1704900000000,
+    topic: "sensor/temp",
+    value: 25.5
+}</pre>
+
+    <h4>Unwrap (after MQTT subscribe)</h4>
+    <pre>
+Input:  msg.payload = '{"timestamp":1704900000000,"topic":"sensor/temp","value":25.5}'
+Output: msg.topic = "sensor/temp"
+        msg.payload = 25.5
+        msg.timestamp = 1704900000000</pre>
+
+    <h3>Status</h3>
+    <ul>
+        <li><b>Green "wrapped"</b> - Created JSON envelope</li>
+        <li><b>Blue "unwrapped"</b> - Extracted from JSON envelope</li>
+    </ul>
+</script>

package/nodes/event-json.js

@@ -0,0 +1,69 @@
+/**
+ * event-json - Bidirectional JSON envelope converter
+ *
+ * Automatically detects direction:
+ * - Object with {value, topic?, timestamp?} -> extracts to msg
+ * - Any other payload -> wraps in {timestamp, topic, value}
+ */
+module.exports = function(RED) {
+    function EventJsonNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.on('input', function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+            done = done || function(err) { if (err) node.error(err, msg); };
+
+            try {
+                let data = msg.payload;
+
+                // If string, try to parse as JSON
+                if (typeof data === 'string') {
+                    try {
+                        data = JSON.parse(data);
+                    } catch (e) {
+                        // Not JSON string - wrap it
+                        msg.payload = {
+                            timestamp: Date.now(),
+                            topic: msg.topic,
+                            value: msg.payload
+                        };
+                        node.status({ fill: "green", shape: "dot", text: "wrapped" });
+                        send(msg);
+                        done();
+                        return;
+                    }
+                }
+
+                // Check if it's an envelope object (has 'value' property)
+                if (typeof data === 'object' && data !== null && 'value' in data) {
+                    // Unwrap: extract from envelope
+                    if (data.topic) {
+                        msg.topic = data.topic;
+                    }
+                    if (data.timestamp) {
+                        msg.timestamp = data.timestamp;
+                    }
+                    msg.payload = data.value;
+                    node.status({ fill: "blue", shape: "dot", text: "unwrapped" });
+                } else {
+                    // Wrap: create envelope
+                    msg.payload = {
+                        timestamp: Date.now(),
+                        topic: msg.topic,
+                        value: data
+                    };
+                    node.status({ fill: "green", shape: "dot", text: "wrapped" });
+                }
+
+                send(msg);
+                done();
+            } catch (err) {
+                node.status({ fill: "red", shape: "ring", text: "error" });
+                done(err);
+            }
+        });
+    }
+
+    RED.nodes.registerType("event-json", EventJsonNode);
+};

package/nodes/event-simulator.html

@@ -0,0 +1,156 @@
+<style>
+    .event-calc-white-text { fill: #ffffff !important; }
+    .red-ui-palette-node[data-palette-type="event-simulator"] .red-ui-palette-label { color: #ffffff !important; }
+</style>
+
+<script type="text/javascript">
+    RED.nodes.registerType('event-simulator', {
+        category: 'event calc',
+        color: '#758467',
+        defaults: {
+            name: { value: "" },
+            waveform: { value: "sinusoid" },
+            amplitude: { value: 1, validate: RED.validators.number() },
+            frequency: { value: 1, validate: RED.validators.number() },
+            offset: { value: 0, validate: RED.validators.number() },
+            interval: { value: 100, validate: RED.validators.number() },
+            startOnDeploy: { value: true },
+            noiseLevel: { value: 0, validate: RED.validators.number() },
+            topicCount: { value: 1, validate: RED.validators.number() },
+            phaseSpread: { value: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-signal",
+        label: function() {
+            return this.name || this.waveform || "simulator";
+        },
+        paletteLabel: "simulator",
+        labelStyle: function() {
+            return (this.name ? "node_label_italic" : "") + " event-calc-white-text";
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="event-simulator">
+    <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="Name (used as topic base)">
+    </div>
+    <div class="form-row">
+        <label for="node-input-topicCount"><i class="fa fa-clone"></i> Topic Count</label>
+        <input type="number" id="node-input-topicCount" min="1" max="100" value="1">
+        <div class="form-tips">Number of topics to generate (Name1, Name2, ... if count > 1)</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-waveform"><i class="fa fa-signal"></i> Waveform</label>
+        <select id="node-input-waveform">
+            <option value="sinusoid">Sinusoid</option>
+            <option value="cosine">Cosine</option>
+            <option value="sawtooth">Sawtooth</option>
+            <option value="triangle">Triangle</option>
+            <option value="rectangle">Rectangle (Square)</option>
+            <option value="pulse">Pulse</option>
+            <option value="random">Random</option>
+            <option value="randomWalk">Random Walk</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-amplitude"><i class="fa fa-arrows-v"></i> Amplitude</label>
+        <input type="number" id="node-input-amplitude" step="0.1" value="1">
+    </div>
+    <div class="form-row">
+        <label for="node-input-frequency"><i class="fa fa-tachometer"></i> Frequency (Hz)</label>
+        <input type="number" id="node-input-frequency" step="0.1" min="0.001" value="1">
+    </div>
+    <div class="form-row">
+        <label for="node-input-offset"><i class="fa fa-arrows-h"></i> Offset</label>
+        <input type="number" id="node-input-offset" step="0.1" value="0">
+    </div>
+    <div class="form-row">
+        <label for="node-input-interval"><i class="fa fa-clock-o"></i> Interval (ms)</label>
+        <input type="number" id="node-input-interval" min="10" value="100">
+    </div>
+    <div class="form-row">
+        <label for="node-input-noiseLevel"><i class="fa fa-random"></i> Noise Level</label>
+        <input type="number" id="node-input-noiseLevel" step="0.01" min="0" max="1" value="0">
+        <div class="form-tips">Noise as fraction of amplitude (0-1)</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-phaseSpread">
+            <input type="checkbox" id="node-input-phaseSpread" style="width:auto; margin-left:0;" checked>
+            Phase spread (offset each topic's phase when count > 1)
+        </label>
+    </div>
+    <div class="form-row">
+        <label for="node-input-startOnDeploy">
+            <input type="checkbox" id="node-input-startOnDeploy" style="width:auto; margin-left:0;" checked>
+            Start on deploy
+        </label>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="event-simulator">
+    <p>Generates simulated time-series data with various waveforms.</p>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">number</span></dt>
+        <dd>Generated value</dd>
+        <dt>topic <span class="property-type">string</span></dt>
+        <dd>Topic name. If count=1: uses Name. If count>1: uses Name1, Name2, etc.</dd>
+        <dt>timestamp <span class="property-type">number</span></dt>
+        <dd>Unix timestamp in ms</dd>
+    </dl>
+
+    <h3>Multiple Topics</h3>
+    <p>Set <b>Topic Count</b> > 1 to generate multiple messages per interval:</p>
+    <ul>
+        <li>Name="Sensor", Count=3 → topics: Sensor1, Sensor2, Sensor3</li>
+        <li><b>Phase Spread</b>: Each topic gets an evenly-distributed phase offset</li>
+        <li>Useful for simulating multiple related sensors</li>
+    </ul>
+
+    <h3>Waveforms</h3>
+    <ul>
+        <li><b>Sinusoid</b> - Smooth sine wave</li>
+        <li><b>Cosine</b> - Cosine wave (90° phase shift)</li>
+        <li><b>Sawtooth</b> - Linear ramp up, instant drop</li>
+        <li><b>Triangle</b> - Linear ramp up and down</li>
+        <li><b>Rectangle</b> - Square wave (±amplitude)</li>
+        <li><b>Pulse</b> - Short pulse (10% duty cycle)</li>
+        <li><b>Random</b> - Random values each sample</li>
+        <li><b>Random Walk</b> - Brownian motion with mean reversion</li>
+    </ul>
+
+    <h3>Parameters</h3>
+    <ul>
+        <li><b>Topic Count</b> - Number of topics to generate (1-100)</li>
+        <li><b>Amplitude</b> - Peak value (signal swings ±amplitude around offset)</li>
+        <li><b>Frequency</b> - Cycles per second (Hz)</li>
+        <li><b>Offset</b> - DC offset (center value)</li>
+        <li><b>Interval</b> - Sample rate in milliseconds</li>
+        <li><b>Noise Level</b> - Random noise as fraction of amplitude</li>
+        <li><b>Phase Spread</b> - Distribute phase offsets across topics</li>
+    </ul>
+
+    <h3>Control</h3>
+    <p>Send messages to control the simulator:</p>
+    <ul>
+        <li><code>msg.payload = "start"</code> - Start generating</li>
+        <li><code>msg.payload = "stop"</code> - Stop generating</li>
+        <li><code>msg.payload = "reset"</code> - Reset time and restart</li>
+    </ul>
+
+    <h3>Dynamic Parameters</h3>
+    <p>Update parameters via message properties:</p>
+    <ul>
+        <li><code>msg.amplitude</code></li>
+        <li><code>msg.frequency</code></li>
+        <li><code>msg.offset</code></li>
+        <li><code>msg.interval</code></li>
+        <li><code>msg.waveform</code></li>
+        <li><code>msg.topicCount</code></li>
+        <li><code>msg.phaseSpread</code></li>
+    </ul>
+</script>

package/nodes/event-simulator.js

@@ -0,0 +1,185 @@
+module.exports = function(RED) {
+    function EventSimulatorNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.waveform = config.waveform || "sinusoid";
+        node.amplitude = parseFloat(config.amplitude) || 1;
+        node.frequency = parseFloat(config.frequency) || 1; // Hz
+        node.offset = parseFloat(config.offset) || 0;
+        node.interval = parseInt(config.interval) || 100; // ms
+        node.startOnDeploy = config.startOnDeploy !== false;
+        node.noiseLevel = parseFloat(config.noiseLevel) || 0;
+        node.topicCount = parseInt(config.topicCount) || 1;
+        node.phaseSpread = config.phaseSpread !== false; // Add phase offset between topics
+
+        const baseName = config.name || "simulator";
+
+        let timer = null;
+        let startTime = Date.now();
+        let sampleCount = 0;
+
+        // Waveform generators
+        const waveforms = {
+            sinusoid: (t, freq, amp, offset) => {
+                return amp * Math.sin(2 * Math.PI * freq * t) + offset;
+            },
+            cosine: (t, freq, amp, offset) => {
+                return amp * Math.cos(2 * Math.PI * freq * t) + offset;
+            },
+            sawtooth: (t, freq, amp, offset) => {
+                const period = 1 / freq;
+                const phase = (t % period) / period;
+                return amp * (2 * phase - 1) + offset;
+            },
+            triangle: (t, freq, amp, offset) => {
+                const period = 1 / freq;
+                const phase = (t % period) / period;
+                return amp * (4 * Math.abs(phase - 0.5) - 1) + offset;
+            },
+            rectangle: (t, freq, amp, offset) => {
+                const period = 1 / freq;
+                const phase = (t % period) / period;
+                return amp * (phase < 0.5 ? 1 : -1) + offset;
+            },
+            pulse: (t, freq, amp, offset) => {
+                const period = 1 / freq;
+                const phase = (t % period) / period;
+                return amp * (phase < 0.1 ? 1 : 0) + offset;
+            },
+            random: (t, freq, amp, offset) => {
+                return amp * (Math.random() * 2 - 1) + offset;
+            },
+            randomWalk: (t, freq, amp, offset, topicIndex) => {
+                // Random walk with mean reversion (per-topic state)
+                if (!node._lastValues) node._lastValues = {};
+                if (node._lastValues[topicIndex] === undefined) node._lastValues[topicIndex] = offset;
+                const step = (Math.random() * 2 - 1) * amp * 0.1;
+                const reversion = (offset - node._lastValues[topicIndex]) * 0.05;
+                node._lastValues[topicIndex] = Math.max(offset - amp, Math.min(offset + amp, node._lastValues[topicIndex] + step + reversion));
+                return node._lastValues[topicIndex];
+            }
+        };
+
+        function generateSample() {
+            const now = Date.now();
+            const t = (now - startTime) / 1000; // time in seconds
+            sampleCount++;
+
+            const generator = waveforms[node.waveform] || waveforms.sinusoid;
+
+            // Generate message for each topic
+            for (let i = 0; i < node.topicCount; i++) {
+                // Calculate phase offset for this topic (spread evenly across one period)
+                const phaseOffset = node.phaseSpread ? (i / node.topicCount) / node.frequency : 0;
+                const tWithPhase = t + phaseOffset;
+
+                let value = generator(tWithPhase, node.frequency, node.amplitude, node.offset, i);
+
+                // Add noise if configured
+                if (node.noiseLevel > 0) {
+                    value += (Math.random() * 2 - 1) * node.noiseLevel * node.amplitude;
+                }
+
+                // Topic name: baseName for count=1, baseName1/baseName2/... for count>1
+                const topic = node.topicCount === 1 ? baseName : `${baseName}${i + 1}`;
+
+                const msg = {
+                    topic: topic,
+                    payload: value,
+                    timestamp: now,
+                    _simulator: {
+                        waveform: node.waveform,
+                        frequency: node.frequency,
+                        amplitude: node.amplitude,
+                        sample: sampleCount,
+                        time: tWithPhase,
+                        topicIndex: i + 1
+                    }
+                };
+
+                node.send(msg);
+            }
+
+            // Status shows count and first value
+            const firstValue = generator(t, node.frequency, node.amplitude, node.offset, 0);
+            const statusText = node.topicCount > 1
+                ? `${sampleCount}: ${node.topicCount} topics`
+                : `${sampleCount}: ${firstValue.toFixed(3)}`;
+            node.status({ fill: "green", shape: "dot", text: statusText });
+        }
+
+        function start() {
+            if (timer) return;
+            startTime = Date.now();
+            sampleCount = 0;
+            node._lastValues = {}; // Reset random walk state
+            timer = setInterval(generateSample, node.interval);
+            const statusText = node.topicCount > 1 ? `running (${node.topicCount} topics)` : "running";
+            node.status({ fill: "green", shape: "dot", text: statusText });
+        }
+
+        function stop() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            node.status({ fill: "grey", shape: "ring", text: "stopped" });
+        }
+
+        function reset() {
+            stop();
+            start();
+        }
+
+        // Start on deploy if configured
+        if (node.startOnDeploy) {
+            start();
+        } else {
+            node.status({ fill: "grey", shape: "ring", text: "stopped" });
+        }
+
+        node.on('input', function(msg, send, done) {
+            const command = (msg.payload || "").toString().toLowerCase();
+
+            switch (command) {
+                case 'start':
+                    start();
+                    break;
+                case 'stop':
+                    stop();
+                    break;
+                case 'reset':
+                    reset();
+                    break;
+                default:
+                    // Update parameters if provided
+                    if (typeof msg.amplitude === 'number') node.amplitude = msg.amplitude;
+                    if (typeof msg.frequency === 'number') node.frequency = msg.frequency;
+                    if (typeof msg.offset === 'number') node.offset = msg.offset;
+                    if (typeof msg.interval === 'number') {
+                        node.interval = msg.interval;
+                        if (timer) reset();
+                    }
+                    if (typeof msg.topicCount === 'number' && msg.topicCount >= 1) {
+                        node.topicCount = Math.floor(msg.topicCount);
+                    }
+                    if (typeof msg.phaseSpread === 'boolean') {
+                        node.phaseSpread = msg.phaseSpread;
+                    }
+                    if (msg.waveform && waveforms[msg.waveform]) {
+                        node.waveform = msg.waveform;
+                    }
+            }
+
+            if (done) done();
+        });
+
+        node.on('close', function(done) {
+            stop();
+            done();
+        });
+    }
+
+    RED.nodes.registerType("event-simulator", EventSimulatorNode);
+};