node-red-contrib-knx-ultimate 4.0.14 → 4.0.15

package/CHANGELOG.md

@@ -6,6 +6,12 @@
 
 # CHANGELOG
 
+**Version 4.0.15** - October 2025<br/>
+- NEW: Introduced the KNX Monitor sidebar plugin with live GA table, 1 s auto-refresh, highlight on fresh telegrams and row toggles for boolean values.<br/>
+- NEW: Added inline filtering, draggable column widths, persistent gateway selection and reorder controls to speed up commissioning and diagnosis.<br/>
+- Added `/knxUltimateMonitor` and `/knxUltimateMonitorToggle` admin endpoints to feed the sidebar and allow direct write/toggle actions.<br/>
+- Docs: documented the KNX Monitor panel across all supported wiki languages and refreshed screenshots/tooltips.<br/>
+
 **Version 4.0.14** - October 2025<br/>
 - NEW: Added KNX ↔ IoT Bridge node to orchestrate bidirectional KNX↔MQTT/REST/Modbus mappings with scaling, templating and ack metadata.<br/>
 

package/nodes/commonFunctions.js

@@ -61,6 +61,52 @@ module.exports = (RED) => {
     function commonFunctions() {
         var node = this;
 
+        const ensureBuffer = (rawValue) => {
+            if (!rawValue) return null;
+            if (Buffer.isBuffer(rawValue)) return rawValue;
+            if (Array.isArray(rawValue)) return Buffer.from(rawValue);
+            if (typeof rawValue === 'object' && Array.isArray(rawValue.data)) return Buffer.from(rawValue.data);
+            if (rawValue.type === 'Buffer' && Array.isArray(rawValue.data)) return Buffer.from(rawValue.data);
+            return null;
+        };
+
+        const guessDptFromRawValue = (rawBuffer) => {
+            if (!rawBuffer || !rawBuffer.length) return null;
+            if (rawBuffer.length === 1) {
+                if (rawBuffer[0] === 0 || rawBuffer[0] === 1) return '1.001';
+                return '5.001';
+            }
+            if (rawBuffer.length === 4) return '14.056';
+            if (rawBuffer.length === 2) return '9.001';
+            if (rawBuffer.length === 3) return '11.001';
+            if (rawBuffer.length === 14) return '16.001';
+
+            const dpts = Object.entries(dptlib).filter(onlyDptKeys).map(extractBaseNo).sort(sortBy('base')).reduce(toConcattedSubtypes, []);
+            for (let index = 0; index < dpts.length; index++) {
+                try {
+                    const resolved = dptlib.resolve(dpts[index].value);
+                    if (!resolved) continue;
+                    const jsValue = dptlib.fromBuffer(rawBuffer, resolved);
+                    if (typeof jsValue !== 'undefined') return dpts[index].value;
+                } catch (error) { /* empty */ }
+            }
+            return null;
+        };
+
+        const formatDisplayValue = (value) => {
+            if (value === null || value === undefined) return '';
+            if (value instanceof Date) return value.toISOString();
+            if (typeof value === 'object') {
+                try {
+                    return JSON.stringify(value);
+                } catch (error) {
+                    return String(value);
+                }
+            }
+            if (typeof value === 'boolean') return value ? 'true' : 'false';
+            return String(value);
+        };
+
         // // Gather infos about all interfaces on the lan and provides a static variable utils.aDiscoveredknxGateways
         // try {
         //     require('./utils/utils').DiscoverKNXGateways()
@@ -499,6 +545,110 @@ module.exports = (RED) => {
             }
         });
 
+        RED.httpAdmin.get('/knxUltimateMonitor', RED.auth.needsPermission("knxUltimate-config.read"), (req, res) => {
+            try {
+                const server = RED.nodes.getNode(req.query.serverId);
+                if (!server) {
+                    res.json({ items: [], error: 'NO_SERVER' });
+                    return;
+                }
+                const items = Array.isArray(server.exposedGAs) ? server.exposedGAs.map((entry) => {
+                    const rawBuffer = ensureBuffer(entry?.rawValue);
+                    const rawHex = rawBuffer ? rawBuffer.toString('hex') : '';
+                    let dpt = entry?.dpt;
+                    let guessed = false;
+                    if ((!dpt || dpt === '') && rawBuffer) {
+                        const inferred = guessDptFromRawValue(rawBuffer);
+                        if (inferred) {
+                            dpt = inferred;
+                            guessed = true;
+                        }
+                    }
+                    let value = null;
+                    if (rawBuffer && dpt) {
+                        try {
+                            const resolved = dptlib.resolve(dpt);
+                            if (resolved) value = dptlib.fromBuffer(rawBuffer, resolved);
+                        } catch (error) { /* empty */ }
+                    }
+                    return {
+                        ga: entry?.ga || '',
+                        devicename: entry?.devicename || '',
+                        dpt: dpt || '',
+                        dptGuessed: guessed,
+                        rawHex,
+                        value,
+                        valueText: formatDisplayValue(value),
+                        updatedAt: entry?.updatedAt || null,
+                    };
+                }).sort((a, b) => a.ga.localeCompare(b.ga)) : [];
+                res.json({ items });
+            } catch (error) {
+                try { RED.log.error(`KNXUltimate: knxUltimateMonitor error: ${error.message}`); } catch (e) { }
+                res.json({ items: [], error: error.message });
+            }
+        });
+
+        RED.httpAdmin.post('/knxUltimateMonitorToggle', RED.auth.needsPermission("knxUltimate-config.write"), (req, res) => {
+            try {
+                const serverId = req.body?.serverId;
+                const ga = req.body?.ga;
+                const server = serverId ? RED.nodes.getNode(serverId) : null;
+                if (!server) {
+                    res.json({ status: 'error', error: 'NO_SERVER' });
+                    return;
+                }
+                if (!ga) {
+                    res.json({ status: 'error', error: 'NO_GA' });
+                    return;
+                }
+                const entry = Array.isArray(server.exposedGAs) ? server.exposedGAs.find((item) => item.ga === ga) : undefined;
+                if (!entry) {
+                    res.json({ status: 'error', error: 'GA_NOT_FOUND' });
+                    return;
+                }
+                const rawBuffer = ensureBuffer(entry.rawValue);
+                let dpt = entry.dpt;
+                if (!rawBuffer) {
+                    res.json({ status: 'error', error: 'NO_CURRENT_VALUE' });
+                    return;
+                }
+                if (!dpt) {
+                    const inferred = guessDptFromRawValue(rawBuffer);
+                    if (inferred) dpt = inferred;
+                }
+                let currentValue = null;
+                if (dpt) {
+                    try {
+                        const resolved = dptlib.resolve(dpt);
+                        if (resolved) currentValue = dptlib.fromBuffer(rawBuffer, resolved);
+                    } catch (error) { currentValue = null; }
+                }
+                if (typeof currentValue !== 'boolean') {
+                    res.json({ status: 'error', error: 'NOT_BOOLEAN' });
+                    return;
+                }
+                const nextValue = !currentValue;
+                const sendDpt = dpt || '1.001';
+                try {
+                    server.sendKNXTelegramToKNXEngine({
+                        grpaddr: ga,
+                        payload: nextValue,
+                        dpt: sendDpt,
+                        outputtype: 'write',
+                        nodecallerid: 'knxUltimateMonitor'
+                    });
+                } catch (error) {
+                    res.json({ status: 'error', error: error.message });
+                    return;
+                }
+                res.json({ status: 'ok', value: nextValue });
+            } catch (error) {
+                try { RED.log.error(`KNXUltimate: knxUltimateMonitorToggle error: ${error.message}`); } catch (e) { }
+                res.json({ status: 'error', error: error.message });
+            }
+        });
+
         RED.httpAdmin.get("/KNXUltimateGetResourcesHUE", (req, res) => {
             try {
                 // °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°

package/nodes/knxUltimate-config.js

@@ -1154,7 +1154,7 @@ module.exports = (RED) => {
       // 04/04/2021 Supergiovane: save value to node.exposedGAs
       if (typeof _dest === "string" && _rawValue !== undefined && (_evt === "GroupValue_Write" || _evt === "GroupValue_Response")) {
         try {
-          const ret = { ga: _dest, rawValue: _rawValue, dpt: undefined, devicename: undefined };
+          const ret = { ga: _dest, rawValue: _rawValue, dpt: undefined, devicename: undefined, updatedAt: Date.now() };
           node.exposedGAs = node.exposedGAs.filter((item) => item.ga !== _dest); // Remove previous
           if (node.csv !== undefined && node.csv !== '' && node.csv.length !== 0) {
             // Add the dpt

package/nodes/knxUltimateGarage.html

@@ -3,7 +3,7 @@
 <script type="text/javascript">
   RED.nodes.registerType('knxUltimateGarage', {
     category: 'KNX Ultimate',
-    color: '#7dd484',
+    color: '#C7E9C0',
     defaults: {
       server: { type: 'knxUltimate-config', required: true },
       name: { value: '' },
@@ -306,4 +306,4 @@
   </ul>
   <h3 data-i18n="knxUltimateGarage.help.events"></h3>
   <p data-i18n="knxUltimateGarage.help.events_desc"></p>
-</script>
+</script>

package/nodes/knxUltimateIoTBridge.html

@@ -384,4 +384,4 @@ Configure bidirectional maps between KNX group addresses and IoT backends such a
 - Use `msg.bridge.id` to route acknowledgements or correlate responses.
 - Enable "Read KNX values on deploy" to bootstrap dashboards after deploys.
 
-</script>
+</script>

package/nodes/knxUltimateStaircase.html

@@ -3,7 +3,7 @@
 <script type="text/javascript">
   RED.nodes.registerType('knxUltimateStaircase', {
     category: 'KNX Ultimate',
-    color: '#7dd484',
+    color: '#C7E9C0',
     defaults: {
       server: { type: 'knxUltimate-config', required: true },
       name: { value: '' },
@@ -323,4 +323,4 @@
   </div>
 
   <br/><br/><br/><br/>
-</script>
+</script>