node-red-contrib-knx-ultimate 4.1.18 → 4.1.19

package/CHANGELOG.md

@@ -6,7 +6,9 @@
 
 # CHANGELOG
 
-**Version 4.1.18** - January 2026<br/>
+**Version 4.1.19** - February 2026<br/>
+
+- NEW: **KNX Multi Routing**: added **Server KNX/IP** mode (standalone KNXnet/IP tunneling server) that outputs/accepts RAW telegrams on the node ports (no gateway required).<br/>
 
 - NEW: KNX AI sidebar: added another TAB in the Node-Red's toolbar buttons dedicated to AI analysis.<br>
 - NEW: added **KNX AI** node (traffic analyzer + optional LLM assistant) and **KNX AI** sidebar tab.<br/>
@@ -18,7 +20,7 @@
 - Docs: completed the help + wiki pages for **KNX AI**, **KNX Multi Routing** and **KNX Router Filter** in all supported languages, and added them to the docs homepages.<br/>
 - Docs: added the new nodes to the wiki navbar in all languages (so they appear in the left navigation menu).<br/>
 - Docs: added new wiki **Samples** pages (with diagrams) for the 3 new nodes.<br/>
-- Examples: added importable Node-RED flow JSON examples for **KNX AI**, **KNX Multi Routing** and **KNX Router Filter**.<br/>
+- Examples: added importable Node-RED flow JSON examples for **KNX AI**, **KNX Multi Routing** and **KNX Router Filter** (including KNX Multi Routing **Server KNX/IP** sample).<br/>
 
 **Version 4.1.15** - January 2026<br/>
 

package/examples/KNX Multi Routing - KNXIP Server.json

@@ -0,0 +1,133 @@
+[
+  {
+    "id": "tab_knx_mr_srv_sample",
+    "type": "tab",
+    "label": "KNX/IP Server (MultiRouting)",
+    "disabled": false,
+    "info": ""
+  },
+  {
+    "id": "cmt_knx_mr_srv_1",
+    "type": "comment",
+    "z": "tab_knx_mr_srv_sample",
+    "name": "Use knxUltimateMultiRouting as a standalone KNXnet/IP Tunneling Server (UDP).",
+    "info": "1) Deploy.\n2) Configure your KNX/IP tunneling client to connect to this Node-RED host on tunnelListenPort (default 3671).\n3) Watch the RAW telegrams in the Debug node.\n\nTo test the INPUT side: after at least one telegram is received, click the inject node \"Replay last\" to inject the last received telegram back to connected tunneling client(s).",
+    "x": 430,
+    "y": 40,
+    "wires": []
+  },
+  {
+    "id": "mr_tunnel_server",
+    "type": "knxUltimateMultiRouting",
+    "z": "tab_knx_mr_srv_sample",
+    "mode": "server",
+    "server": "",
+    "name": "KNX/IP Tunneling Server",
+    "outputtopic": "",
+    "dropIfSameGateway": true,
+    "tunnelListenHost": "0.0.0.0",
+    "tunnelListenPort": "3671",
+    "tunnelAdvertiseHost": "",
+    "tunnelAssignedIndividualAddress": "15.15.255",
+    "tunnelGatewayId": "knxip-server",
+    "tunnelMaxSessions": "1",
+    "x": 240,
+    "y": 160,
+    "wires": [
+      [
+        "fn_cache_last",
+        "dbg_tunnel_raw"
+      ]
+    ]
+  },
+  {
+    "id": "dbg_tunnel_raw",
+    "type": "debug",
+    "z": "tab_knx_mr_srv_sample",
+    "name": "RAW from tunneling client",
+    "active": true,
+    "tosidebar": true,
+    "console": false,
+    "tostatus": false,
+    "complete": "payload.knx",
+    "targetType": "msg",
+    "x": 520,
+    "y": 160,
+    "wires": []
+  },
+  {
+    "id": "fn_cache_last",
+    "type": "function",
+    "z": "tab_knx_mr_srv_sample",
+    "name": "Cache last telegram",
+    "func": "try {\n    if (msg && msg.payload && msg.payload.knx) {\n        flow.set('last_knx_raw', msg.payload.knx);\n    }\n} catch (e) {}\nreturn null;",
+    "outputs": 0,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 500,
+    "y": 220,
+    "wires": []
+  },
+  {
+    "id": "inj_replay_last",
+    "type": "inject",
+    "z": "tab_knx_mr_srv_sample",
+    "name": "Replay last",
+    "props": [
+      {
+        "p": "payload"
+      }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "",
+    "payload": "",
+    "payloadType": "date",
+    "x": 170,
+    "y": 300,
+    "wires": [
+      [
+        "fn_replay_last"
+      ]
+    ]
+  },
+  {
+    "id": "fn_replay_last",
+    "type": "function",
+    "z": "tab_knx_mr_srv_sample",
+    "name": "Build replay msg",
+    "func": "const last = flow.get('last_knx_raw');\nif (!last) {\n    node.warn('No cached telegram yet. Generate one from a tunneling client first.');\n    return null;\n}\n\n// IMPORTANT:\n// - Server mode expects msg.payload.knx.cemi.hex (or msg.payload.knx.cemi) to be present.\n// - Do NOT attach knxMultiRouting.gateway.id here, otherwise dropIfSameGateway may discard it.\nreturn {\n    topic: last.destination || '',\n    payload: {\n        knx: last\n    }\n};",
+    "outputs": 1,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 360,
+    "y": 300,
+    "wires": [
+      [
+        "mr_tunnel_server",
+        "dbg_replay"
+      ]
+    ]
+  },
+  {
+    "id": "dbg_replay",
+    "type": "debug",
+    "z": "tab_knx_mr_srv_sample",
+    "name": "Replay msg",
+    "active": true,
+    "tosidebar": true,
+    "console": false,
+    "tostatus": false,
+    "complete": "true",
+    "targetType": "full",
+    "x": 520,
+    "y": 300,
+    "wires": []
+  }
+]

package/nodes/knxUltimateAI.js

@@ -725,10 +725,14 @@ module.exports = function (RED) {
     const pushStatus = (status) => {
       if (!status) return
       const provider = node.serverKNX
-      if (provider && typeof provider.applyStatusUpdate === 'function') {
-        provider.applyStatusUpdate(node, status)
-      } else {
-        node.status(status)
+      try {
+        if (provider && typeof provider.applyStatusUpdate === 'function') {
+          provider.applyStatusUpdate(node, status)
+        } else {
+          node.status(status)
+        }
+      } catch (error) {
+        try { node.status(status) } catch (e2) { /* ignore */ }
       }
     }
 
@@ -999,14 +1003,19 @@ module.exports = function (RED) {
     }
 
     const emitSummary = () => {
-      const now = nowMs()
-      trimHistory(now)
-      const summary = buildSummary(now)
-      node._lastSummary = summary
-      node._lastSummaryAt = now
-      node.send([{ topic: node.outputtopic, payload: summary, knxAi: { type: 'summary' } }, null, null])
-      const best = summary.topGAs && summary.topGAs[0] ? `${summary.topGAs[0].ga} (${summary.topGAs[0].count})` : 'no traffic'
-      updateStatus({ fill: 'green', shape: 'dot', text: `AI ${summary.counters.overallRatePerSec}/s top ${best}` })
+      try {
+        const now = nowMs()
+        trimHistory(now)
+        const summary = buildSummary(now)
+        node._lastSummary = summary
+        node._lastSummaryAt = now
+        node.send([{ topic: node.outputtopic, payload: summary, knxAi: { type: 'summary' } }, null, null])
+        const best = summary.topGAs && summary.topGAs[0] ? `${summary.topGAs[0].ga} (${summary.topGAs[0].count})` : 'no traffic'
+        updateStatus({ fill: 'green', shape: 'dot', text: `AI ${summary.counters.overallRatePerSec}/s top ${best}` })
+      } catch (error) {
+        try { node.sysLogger?.error(`knxUltimateAI emitSummary error: ${error.message || error}`) } catch (e) { /* ignore */ }
+        updateStatus({ fill: 'red', shape: 'dot', text: `AI summary error: ${error.message || error}` })
+      }
     }
 
     const recordAnomaly = (payload) => {
@@ -1110,85 +1119,109 @@ module.exports = function (RED) {
 
     // Called by knxUltimate-config.js
     node.handleSend = (msg) => {
-      const telegram = extractTelegram(msg)
-      if (!telegram) return
-      node._history.push(telegram)
-      const now = telegram.ts
-      trimHistory(now)
-      maybeEmitGAAnomalies(telegram)
-      maybeEmitOverallAnomaly(now)
+      try {
+        const telegram = extractTelegram(msg)
+        if (!telegram) return
+        node._history.push(telegram)
+        const now = telegram.ts
+        trimHistory(now)
+        maybeEmitGAAnomalies(telegram)
+        maybeEmitOverallAnomaly(now)
+      } catch (error) {
+        try { node.sysLogger?.error(`knxUltimateAI handleSend error: ${error.message || error}`) } catch (e) { /* ignore */ }
+      }
     }
 
     const handleCommand = async (msg) => {
-      const cmd = (msg && msg.topic !== undefined) ? String(msg.topic).toLowerCase() : ''
-      if (cmd === 'reset') {
-        node._history = []
-        node._gaState = new Map()
-        updateStatus({ fill: 'grey', shape: 'dot', text: 'AI reset' })
-        node.send([{ topic: node.outputtopic, payload: { ok: true }, knxAi: { type: 'reset' } }, null, null])
-        return
-      }
+      try {
+        const cmd = (msg && msg.topic !== undefined) ? String(msg.topic).toLowerCase() : ''
+        if (cmd === 'reset') {
+          node._history = []
+          node._gaState = new Map()
+          updateStatus({ fill: 'grey', shape: 'dot', text: 'AI reset' })
+          node.send([{ topic: node.outputtopic, payload: { ok: true }, knxAi: { type: 'reset' } }, null, null])
+          return
+        }
 
-      if (cmd === 'summary' || cmd === 'stats' || cmd === 'top' || cmd === '') {
-        emitSummary()
-        return
-      }
+        if (cmd === 'summary' || cmd === 'stats' || cmd === 'top' || cmd === '') {
+          emitSummary()
+          return
+        }
 
-      if (cmd === 'ask') {
-        const question = (msg.prompt !== undefined)
-          ? String(msg.prompt)
-          : (typeof msg.payload === 'string' ? msg.payload : safeStringify(msg.payload))
-        updateStatus({ fill: 'blue', shape: 'ring', text: 'AI thinking...' })
-        try {
-          const ret = await callLLM({ question })
-          node._assistantLog.push({ at: new Date().toISOString(), question, content: ret.content, provider: ret.provider, model: ret.model })
-          while (node._assistantLog.length > 50) node._assistantLog.shift()
-          node.send([null, null, {
-            topic: node.outputtopic,
-            payload: ret.content,
-            knxAi: { type: 'llm', provider: ret.provider, model: ret.model, question },
-            summary: ret.summary
-          }])
-          updateStatus({ fill: 'green', shape: 'dot', text: 'AI answer ready' })
-        } catch (error) {
-          node._assistantLog.push({ at: new Date().toISOString(), question, error: error.message || String(error) })
-          while (node._assistantLog.length > 50) node._assistantLog.shift()
-          node.send([null, null, {
-            topic: node.outputtopic,
-            payload: { error: error.message || String(error) },
-            knxAi: { type: 'llm_error', question }
-          }])
-          updateStatus({ fill: 'red', shape: 'dot', text: `AI error: ${error.message || error}` })
+        if (cmd === 'ask') {
+          const question = (msg.prompt !== undefined)
+            ? String(msg.prompt)
+            : (typeof msg.payload === 'string' ? msg.payload : safeStringify(msg.payload))
+          updateStatus({ fill: 'blue', shape: 'ring', text: 'AI thinking...' })
+          try {
+            const ret = await callLLM({ question })
+            node._assistantLog.push({ at: new Date().toISOString(), question, content: ret.content, provider: ret.provider, model: ret.model })
+            while (node._assistantLog.length > 50) node._assistantLog.shift()
+            node.send([null, null, {
+              topic: node.outputtopic,
+              payload: ret.content,
+              knxAi: { type: 'llm', provider: ret.provider, model: ret.model, question },
+              summary: ret.summary
+            }])
+            updateStatus({ fill: 'green', shape: 'dot', text: 'AI answer ready' })
+          } catch (error) {
+            node._assistantLog.push({ at: new Date().toISOString(), question, error: error.message || String(error) })
+            while (node._assistantLog.length > 50) node._assistantLog.shift()
+            node.send([null, null, {
+              topic: node.outputtopic,
+              payload: { error: error.message || String(error) },
+              knxAi: { type: 'llm_error', question }
+            }])
+            updateStatus({ fill: 'red', shape: 'dot', text: `AI error: ${error.message || error}` })
+          }
+          return
         }
-        return
-      }
 
-      node.warn(`knxUltimateAI: unknown command '${cmd}'. Supported: reset, summary, ask`)
+        node.warn(`knxUltimateAI: unknown command '${cmd}'. Supported: reset, summary, ask`)
+      } catch (error) {
+        try { node.sysLogger?.error(`knxUltimateAI handleCommand error: ${error.message || error}`) } catch (e) { /* ignore */ }
+        try { node.error(error) } catch (e) { /* ignore */ }
+        updateStatus({ fill: 'red', shape: 'dot', text: `AI command error: ${error.message || error}` })
+      }
     }
 
     node.getSidebarState = ({ fresh = false } = {}) => {
-      const now = nowMs()
-      trimHistory(now)
-      const summary = fresh ? buildSummary(now) : (node._lastSummary || buildSummary(now))
-      if (fresh) {
-        node._lastSummary = summary
-        node._lastSummaryAt = now
-      }
-      return {
-        node: {
-          id: node.id,
-          type: node.type,
-          name: node.name || '',
-          topic: node.topic || '',
-          gatewayId: node.serverKNX ? node.serverKNX.id : '',
-          gatewayName: (node.serverKNX && node.serverKNX.name) ? node.serverKNX.name : '',
-          llmEnabled: !!node.llmEnabled,
-          llmProvider: node.llmProvider || '',
-          llmModel: node.llmModel || ''
-        },
-        summary,
-        anomalies: node._anomalies.slice(-50),
-        assistant: node._assistantLog.slice(-30)
+      try {
+        const now = nowMs()
+        trimHistory(now)
+        const summary = fresh ? buildSummary(now) : (node._lastSummary || buildSummary(now))
+        if (fresh) {
+          node._lastSummary = summary
+          node._lastSummaryAt = now
+        }
+        return {
+          node: {
+            id: node.id,
+            type: node.type,
+            name: node.name || '',
+            topic: node.topic || '',
+            gatewayId: node.serverKNX ? node.serverKNX.id : '',
+            gatewayName: (node.serverKNX && node.serverKNX.name) ? node.serverKNX.name : '',
+            llmEnabled: !!node.llmEnabled,
+            llmProvider: node.llmProvider || '',
+            llmModel: node.llmModel || ''
+          },
+          summary,
+          anomalies: node._anomalies.slice(-50),
+          assistant: node._assistantLog.slice(-30)
+        }
+      } catch (error) {
+        return {
+          node: {
+            id: node.id,
+            type: node.type,
+            name: node.name || '',
+            topic: node.topic || ''
+          },
+          summary: { error: error.message || String(error) },
+          anomalies: [],
+          assistant: []
+        }
       }
     }
 
@@ -1204,7 +1237,18 @@ module.exports = function (RED) {
     }
 
     node.on('input', function (msg) {
-      handleCommand(msg)
+      try {
+        const p = handleCommand(msg)
+        if (p && typeof p.catch === 'function') {
+          p.catch((error) => {
+            try { node.sysLogger?.error(`knxUltimateAI input error: ${error.message || error}`) } catch (e) { /* ignore */ }
+            try { node.error(error) } catch (e) { /* ignore */ }
+          })
+        }
+      } catch (error) {
+        try { node.sysLogger?.error(`knxUltimateAI input error: ${error.message || error}`) } catch (e) { /* ignore */ }
+        try { node.error(error) } catch (e) { /* ignore */ }
+      }
     })
 
     node.on('close', function (done) {
@@ -1220,13 +1264,15 @@ module.exports = function (RED) {
 
     // On each deploy, unsubscribe+resubscribe
     if (node.serverKNX) {
-      node.serverKNX.removeClient(node)
-      node.serverKNX.addClient(node)
+      try { node.serverKNX.removeClient(node) } catch (e) { /* ignore */ }
+      try { node.serverKNX.addClient(node) } catch (e) { /* ignore */ }
     }
 
     if (node.emitIntervalSec && node.emitIntervalSec > 0) {
       if (node._timerEmit) clearInterval(node._timerEmit)
-      node._timerEmit = setInterval(emitSummary, Math.max(5, node.emitIntervalSec) * 1000)
+      node._timerEmit = setInterval(() => {
+        try { emitSummary() } catch (e) { /* emitSummary already guards */ }
+      }, Math.max(5, node.emitIntervalSec) * 1000)
     }
 
     updateStatus({ fill: 'grey', shape: 'dot', text: 'AI ready' })

package/nodes/knxUltimateMultiRouting.html

@@ -5,10 +5,19 @@
         category: "KNX Ultimate",
         color: 'lightblue',
         defaults: {
-            server: { type: "knxUltimate-config", required: true },
+            mode: { value: "gateway", required: true },
+            server: { type: "knxUltimate-config", required: false },
             name: { value: "KNX Multi Routing", required: false },
             outputtopic: { value: "", required: false },
-            dropIfSameGateway: { value: true }
+            dropIfSameGateway: { value: true },
+
+            // KNX/IP tunneling server options (mode=server)
+            tunnelListenHost: { value: "0.0.0.0", required: false },
+            tunnelListenPort: { value: 3671, required: false, validate: RED.validators.number() },
+            tunnelAdvertiseHost: { value: "", required: false },
+            tunnelAssignedIndividualAddress: { value: "15.15.255", required: false },
+            tunnelMaxSessions: { value: 1, required: false, validate: RED.validators.number() },
+            tunnelGatewayId: { value: "", required: false }
         },
         inputs: 1,
         outputs: 1,
@@ -20,6 +29,19 @@
         paletteLabel: "KNX Multi Routing",
         oneditprepare: function () {
             try { RED.sidebar.show("help"); } catch (error) { }
+
+            const toggleMode = () => {
+                const mode = $("#node-input-mode").val() || "gateway";
+                if (mode === "server") {
+                    $(".knxmr-row-gateway").hide();
+                    $(".knxmr-row-tunnel").show();
+                } else {
+                    $(".knxmr-row-gateway").show();
+                    $(".knxmr-row-tunnel").hide();
+                }
+            };
+            $("#node-input-mode").on("change", toggleMode);
+            toggleMode();
         },
         oneditsave: function () {
             try { RED.sidebar.show("info"); } catch (error) { }
@@ -34,6 +56,14 @@
     <div class="form-row">
         <b><span data-i18n="knxUltimateMultiRouting.title"></span></b>
         <br/><br/>
+        <label for="node-input-mode"><i class="fa fa-sliders"></i> <span data-i18n="knxUltimateMultiRouting.properties.mode"></span></label>
+        <select id="node-input-mode">
+            <option value="gateway" data-i18n="knxUltimateMultiRouting.properties.modeGateway"></option>
+            <option value="server" data-i18n="knxUltimateMultiRouting.properties.modeServer"></option>
+        </select>
+    </div>
+
+    <div class="form-row knxmr-row-gateway">
         <label for="node-input-server"><i class="fa fa-tag"></i> <span data-i18n="knxUltimateMultiRouting.properties.server"></span></label>
         <input type="text" id="node-input-server">
     </div>
@@ -52,4 +82,34 @@
         <input type="checkbox" id="node-input-dropIfSameGateway" style="display:inline-block; width:auto; vertical-align:top;">
         <label style="width:auto" for="node-input-dropIfSameGateway">&nbsp;&nbsp;<span data-i18n="knxUltimateMultiRouting.properties.dropIfSameGateway"></span></label>
     </div>
-</script>
+
+    <div class="form-row knxmr-row-tunnel">
+        <hr/>
+        <b><span data-i18n="knxUltimateMultiRouting.properties.tunnelTitle"></span></b>
+    </div>
+
+    <div class="form-row knxmr-row-tunnel">
+        <label for="node-input-tunnelListenHost"><i class="fa fa-globe"></i> <span data-i18n="knxUltimateMultiRouting.properties.tunnelListenHost"></span></label>
+        <input type="text" id="node-input-tunnelListenHost" placeholder="0.0.0.0">
+    </div>
+    <div class="form-row knxmr-row-tunnel">
+        <label for="node-input-tunnelListenPort"><i class="fa fa-plug"></i> <span data-i18n="knxUltimateMultiRouting.properties.tunnelListenPort"></span></label>
+        <input type="text" id="node-input-tunnelListenPort" placeholder="3671">
+    </div>
+    <div class="form-row knxmr-row-tunnel">
+        <label for="node-input-tunnelAdvertiseHost"><i class="fa fa-bullhorn"></i> <span data-i18n="knxUltimateMultiRouting.properties.tunnelAdvertiseHost"></span></label>
+        <input type="text" id="node-input-tunnelAdvertiseHost" data-i18n="[placeholder]knxUltimateMultiRouting.properties.tunnelAdvertiseHostPlaceholder">
+    </div>
+    <div class="form-row knxmr-row-tunnel">
+        <label for="node-input-tunnelAssignedIndividualAddress"><i class="fa fa-id-card-o"></i> <span data-i18n="knxUltimateMultiRouting.properties.tunnelAssignedIndividualAddress"></span></label>
+        <input type="text" id="node-input-tunnelAssignedIndividualAddress" placeholder="15.15.255">
+    </div>
+    <div class="form-row knxmr-row-tunnel">
+        <label for="node-input-tunnelGatewayId"><i class="fa fa-tag"></i> <span data-i18n="knxUltimateMultiRouting.properties.tunnelGatewayId"></span></label>
+        <input type="text" id="node-input-tunnelGatewayId" data-i18n="[placeholder]knxUltimateMultiRouting.properties.tunnelGatewayIdPlaceholder">
+    </div>
+    <div class="form-row knxmr-row-tunnel">
+        <label for="node-input-tunnelMaxSessions"><i class="fa fa-users"></i> <span data-i18n="knxUltimateMultiRouting.properties.tunnelMaxSessions"></span></label>
+        <input type="text" id="node-input-tunnelMaxSessions" placeholder="1">
+    </div>
+</script>

package/nodes/knxUltimateMultiRouting.js

@@ -1,6 +1,18 @@
 // KNX Multi Routing - interconnect multiple KNX Ultimate gateways via Node-RED flows
 const loggerClass = require('./utils/sysLogger')
 
+const safeNumber = (value, fallback) => {
+  const n = Number(value)
+  return Number.isFinite(n) ? n : fallback
+}
+
+const normalizeHex = (value) => {
+  if (value === undefined || value === null) return ''
+  const s = String(value).trim()
+  if (s === '') return ''
+  return s.replace(/^0x/i, '').replace(/[^0-9a-fA-F]/g, '')
+}
+
 const bufferFromMaybe = (value) => {
   if (value === undefined || value === null) return null
   if (Buffer.isBuffer(value)) return value
@@ -21,8 +33,9 @@ module.exports = function (RED) {
     RED.nodes.createNode(this, config)
     const node = this
 
-    node.serverKNX = RED.nodes.getNode(config.server) || undefined
-    if (node.serverKNX === undefined) {
+    node.mode = config.mode || 'gateway' // 'gateway' | 'server'
+    node.serverKNX = (config.server && RED.nodes.getNode(config.server)) || undefined
+    if (node.mode !== 'server' && node.serverKNX === undefined) {
       node.status({ fill: 'red', shape: 'dot', text: '[THE GATEWAY NODE HAS BEEN DISABLED]' })
       return
     }
@@ -49,13 +62,23 @@ module.exports = function (RED) {
     // Basic loop protection: drop messages already tagged as originating from this same gateway.
     node.dropIfSameGateway = config.dropIfSameGateway !== undefined ? (config.dropIfSameGateway === true || config.dropIfSameGateway === 'true') : true
 
+    // KNX/IP tunneling server (optional)
+    node.tunnelServer = null
+    node.tunnelSessions = new Set()
+    node.tunnelGatewayId = ''
+    node.tunnelAssignedIndividualAddress = ''
+
     const pushStatus = (status) => {
       if (!status) return
       const provider = node.serverKNX
-      if (provider && typeof provider.applyStatusUpdate === 'function') {
-        provider.applyStatusUpdate(node, status)
-      } else {
-        node.status(status)
+      try {
+        if (provider && typeof provider.applyStatusUpdate === 'function') {
+          provider.applyStatusUpdate(node, status)
+        } else {
+          node.status(status)
+        }
+      } catch (error) {
+        try { node.status(status) } catch (e2) { /* ignore */ }
       }
     }
 
@@ -67,7 +90,7 @@ module.exports = function (RED) {
     // Used to call the status update from the config node.
     node.setNodeStatus = ({ fill, shape, text, payload, GA, dpt, devicename }) => {
       try {
-        if (node.serverKNX === null) { updateStatus({ fill: 'red', shape: 'dot', text: '[NO GATEWAY SELECTED]' }); return }
+        if ((node.mode !== 'server') && (node.serverKNX === null || node.serverKNX === undefined)) { updateStatus({ fill: 'red', shape: 'dot', text: '[NO GATEWAY SELECTED]' }); return }
         const dDate = new Date()
         const ts = (node.serverKNX && typeof node.serverKNX.formatStatusTimestamp === 'function')
           ? node.serverKNX.formatStatusTimestamp(dDate)
@@ -85,6 +108,13 @@ module.exports = function (RED) {
       node.sysLogger = new loggerClass({ loglevel: baseLogLevel, setPrefix: node.type + ' <' + (node.name || node.id || '') + '>' })
     } catch (error) { /* empty */ }
 
+    const localGatewayIds = () => {
+      const ids = new Set()
+      if (node.serverKNX && node.serverKNX.id) ids.add(String(node.serverKNX.id))
+      if (node.tunnelGatewayId) ids.add(String(node.tunnelGatewayId))
+      return ids
+    }
+
     // Called by knxUltimate-config.js to deliver bus telegrams (raw APDU + addresses)
     node.handleSend = (msg) => {
       try {
@@ -105,17 +135,18 @@ module.exports = function (RED) {
       const apdu = k.apdu || {}
       const apduData = bufferFromMaybe(apdu.data !== undefined ? apdu.data : (k.rawValue !== undefined ? k.rawValue : k.apduData))
       const bitlength = Number(apdu.bitlength !== undefined ? apdu.bitlength : (k.bitlength !== undefined ? k.bitlength : (apduData ? apduData.length * 8 : 0)))
+      const cemiHex = (k.cemi && (k.cemi.hex || k.cemi)) ? (k.cemi.hex || k.cemi) : ''
 
       const routing = (p && p.knxMultiRouting) ? p.knxMultiRouting : (msg && msg.knxMultiRouting ? msg.knxMultiRouting : null)
       const originGatewayId = routing && routing.gateway && routing.gateway.id ? String(routing.gateway.id) : ''
-      return { event, destination, source, apduData, bitlength, originGatewayId }
+      return { event, destination, source, apduData, bitlength, originGatewayId, cemiHex }
     }
 
-    const canForward = (parsed) => {
+    const canForwardToGateway = (parsed) => {
       if (!parsed) return false
       if (!parsed.destination || typeof parsed.destination !== 'string') return false
       if (!node.serverKNX || node.serverKNX.linkStatus !== 'connected' || !node.serverKNX.knxConnection) return false
-      if (node.dropIfSameGateway && parsed.originGatewayId && node.serverKNX && node.serverKNX.id && parsed.originGatewayId === node.serverKNX.id) return false
+      if (node.dropIfSameGateway && parsed.originGatewayId && localGatewayIds().has(String(parsed.originGatewayId))) return false
       return true
     }
 
@@ -141,20 +172,121 @@ module.exports = function (RED) {
       }
     }
 
+    const canForwardToTunnel = (parsed) => {
+      if (!parsed) return false
+      if (!node.tunnelServer) return false
+      if (!parsed.cemiHex) return false
+      if (node.dropIfSameGateway && parsed.originGatewayId && localGatewayIds().has(String(parsed.originGatewayId))) return false
+      return true
+    }
+
+    const forwardToTunnel = (parsed) => {
+      const clean = normalizeHex(parsed.cemiHex)
+      if (!clean || clean.length % 2 !== 0) return
+      let KNXTunnelingRequest
+      try { ({ KNXTunnelingRequest } = require('knxultimate')) } catch (e) { throw new Error('knxultimate KNXTunnelingRequest not available') }
+      const cemi = KNXTunnelingRequest.parseCEMIMessage(Buffer.from(clean, 'hex'), 0)
+      node.tunnelServer.injectCemi(cemi)
+    }
+
+    const updateTunnelStatus = (extraText) => {
+      if (node.mode !== 'server') return
+      const addr = node.tunnelServer && typeof node.tunnelServer.address === 'object' ? node.tunnelServer.address : null
+      const host = addr ? addr.host : (config.tunnelListenHost || '0.0.0.0')
+      const port = addr ? addr.port : safeNumber(config.tunnelListenPort, 3671)
+      const sessions = node.tunnelSessions ? node.tunnelSessions.size : 0
+      const tail = extraText ? ` ${extraText}` : ''
+      updateStatus({ fill: 'green', shape: 'dot', text: `Tunnel ${host}:${port} sessions:${sessions}${tail}` })
+    }
+
+    const startTunnelServerIfNeeded = () => {
+      if (node.mode !== 'server') return
+      let KNXIPTunnelServer
+      try { ({ KNXIPTunnelServer } = require('knxultimate')) } catch (e) {
+        updateStatus({ fill: 'red', shape: 'dot', text: 'KNX/IP Server: knxultimate missing KNXIPTunnelServer' })
+        node.error('KNX/IP Server mode requires knxultimate with KNXIPTunnelServer exported.')
+        return
+      }
+
+      node.tunnelGatewayId = (config.tunnelGatewayId && String(config.tunnelGatewayId).trim()) || String(node.id)
+      node.tunnelAssignedIndividualAddress = (config.tunnelAssignedIndividualAddress && String(config.tunnelAssignedIndividualAddress).trim()) || '15.15.255'
+
+      const listenHost = (config.tunnelListenHost && String(config.tunnelListenHost).trim()) || '0.0.0.0'
+      const listenPort = safeNumber(config.tunnelListenPort, 3671)
+      const advertiseHost = (config.tunnelAdvertiseHost && String(config.tunnelAdvertiseHost).trim()) || undefined
+      const maxSessions = Math.max(1, safeNumber(config.tunnelMaxSessions, 1))
+
+      const loglevel = (node.serverKNX && node.serverKNX.loglevel) ? node.serverKNX.loglevel : 'error'
+
+      node.tunnelServer = new KNXIPTunnelServer({
+        listenHost,
+        listenPort,
+        advertiseHost,
+        assignedIndividualAddress: node.tunnelAssignedIndividualAddress,
+        maxSessions,
+        loglevel
+      })
+
+      node.tunnelServer.on('error', (err) => {
+        updateStatus({ fill: 'red', shape: 'dot', text: `Tunnel error: ${err.message}` })
+        node.error(err)
+      })
+
+      node.tunnelServer.on('listening', () => {
+        updateTunnelStatus('')
+      })
+
+      node.tunnelServer.on('sessionUp', (s) => {
+        try { node.tunnelSessions.add(s.channelId) } catch (e) { /* ignore */ }
+        updateTunnelStatus('client connected')
+      })
+
+      node.tunnelServer.on('sessionDown', (s) => {
+        try { if (s && s.channelId) node.tunnelSessions.delete(s.channelId) } catch (e) { /* ignore */ }
+        updateTunnelStatus('client disconnected')
+      })
+
+      node.tunnelServer.on('rawTelegram', (knx, info) => {
+        try {
+          const msg = {
+            topic: node.outputtopic || knx.destination,
+            payload: {
+              knx,
+              knxMultiRouting: {
+                gateway: { id: node.tunnelGatewayId, name: node.name || '', physAddr: node.tunnelAssignedIndividualAddress || '' },
+                receivedAt: Date.now(),
+                tunnel: { channelId: info && info.channelId ? info.channelId : undefined }
+              }
+            }
+          }
+          node.send(msg)
+        } catch (error) {
+          node.sysLogger?.error(`knxUltimateMultiRouting: tunnel rawTelegram output error: ${error.message}`)
+        }
+      })
+
+      updateStatus({ fill: 'grey', shape: 'dot', text: 'Starting KNX/IP Server...' })
+      Promise.resolve()
+        .then(() => node.tunnelServer.start())
+        .then(() => updateTunnelStatus(''))
+        .catch((err) => {
+          updateStatus({ fill: 'red', shape: 'dot', text: `Tunnel start failed: ${err.message}` })
+          node.error(err)
+        })
+    }
+
     node.on('input', function (msg) {
       try {
         const parsed = parseIncoming(msg)
-        if (!canForward(parsed)) return
-        forwardToBus(parsed)
-        node.setNodeStatus({
-          fill: 'green',
-          shape: 'dot',
-          text: 'Forwarded',
-          payload: parsed.event || '',
-          GA: parsed.destination,
-          dpt: '',
-          devicename: parsed.source || ''
-        })
+        if (node.mode === 'server') {
+          if (!canForwardToTunnel(parsed)) return
+          forwardToTunnel(parsed)
+        } else {
+          if (!canForwardToGateway(parsed)) return
+          forwardToBus(parsed)
+        }
+
+        node.setNodeStatus({ fill: 'green', shape: 'dot', text: 'Forwarded', payload: parsed.event || '', GA: parsed.destination, dpt: '', devicename: parsed.source || '' })
       } catch (error) {
         node.setNodeStatus({ fill: 'red', shape: 'dot', text: `Forward error: ${error.message || error}`, payload: '', GA: '', dpt: '', devicename: '' })
         node.error(error)
@@ -162,19 +294,27 @@ module.exports = function (RED) {
     })
 
     node.on('close', function (done) {
-      if (node.serverKNX) {
-        node.serverKNX.removeClient(node)
+      const shutdown = async () => {
+        if (node.serverKNX) {
+          try { node.serverKNX.removeClient(node) } catch (e) { /* ignore */ }
+        }
+        if (node.tunnelServer) {
+          try { await node.tunnelServer.stop() } catch (e) { /* ignore */ }
+          node.tunnelServer = null
+        }
       }
-      done()
+      Promise.resolve(shutdown()).then(() => done()).catch(() => done())
     })
 
     // On each deploy, unsubscribe+resubscribe
     if (node.serverKNX) {
-      node.serverKNX.removeClient(node)
-      node.serverKNX.addClient(node)
+      try { node.serverKNX.removeClient(node) } catch (e) { /* ignore */ }
+      try { node.serverKNX.addClient(node) } catch (e) { /* ignore */ }
     }
 
-    updateStatus({ fill: 'grey', shape: 'dot', text: 'Routing ready' })
+    startTunnelServerIfNeeded()
+
+    if (node.mode !== 'server') updateStatus({ fill: 'grey', shape: 'dot', text: 'Routing ready' })
   }
 
   RED.nodes.registerType('knxUltimateMultiRouting', knxUltimateMultiRouting)

package/nodes/locales/de/knxUltimateMultiRouting.json

@@ -2,10 +2,23 @@
   "knxUltimateMultiRouting": {
     "title": "KNX Multi Routing",
     "properties": {
+      "mode": "Mode",
+      "modeGateway": "Gateway / Routing",
+      "modeServer": "Server KNX/IP",
       "server": "Gateway",
       "name": "Name",
       "outputtopic": "Output topic",
-      "dropIfSameGateway": "Drop messages already tagged for this gateway"
+      "dropIfSameGateway": "Drop messages already tagged for this gateway",
+      "tunnelTitle": "KNX/IP Server",
+      "tunnelListenHost": "Listen host",
+      "tunnelListenPort": "Listen port",
+      "tunnelAdvertiseHost": "Advertise host",
+      "tunnelAdvertiseHostPlaceholder": "(optional) Host/IP to advertise to clients",
+      "tunnelAssignedIndividualAddress": "Assigned individual address",
+      "tunnelGatewayId": "Gateway id (tag)",
+      "tunnelGatewayIdPlaceholder": "(auto) Used as knxMultiRouting.gateway.id",
+      "tunnelMaxSessions": "Max sessions",
+      "bridgeGateway": "Bridge tunnel <-> selected gateway"
     },
     "outputs": {
       "raw": "RAW telegrams"

package/nodes/locales/en/knxUltimateMultiRouting.html

@@ -4,6 +4,10 @@ This node is used to **bridge multiple KNX Ultimate gateways** (multiple `knxUlt
 It outputs **RAW telegram information** (APDU + cEMI hex + addresses) for every telegram received from the KNX bus of the selected gateway.
 It can also accept those RAW telegram objects on its input and forward them to the selected gateway.
 
+## Server KNX/IP mode
+Set **Mode** to **Server KNX/IP** to start an embedded KNXnet/IP tunneling server (UDP). Incoming client telegrams are emitted as the same RAW format used by MultiRouting.
+The node also accepts RAW telegram objects on its input and injects them to the connected tunneling client(s).
+
 ## Output message format
 `msg.payload` contains:
 - `knx.event`: `GroupValue_Write` / `GroupValue_Response` / `GroupValue_Read`

package/nodes/locales/en/knxUltimateMultiRouting.json

@@ -2,10 +2,23 @@
   "knxUltimateMultiRouting": {
     "title": "KNX Multi Routing",
     "properties": {
+      "mode": "Mode",
+      "modeGateway": "Gateway / Routing",
+      "modeServer": "Server KNX/IP",
       "server": "Gateway",
       "name": "Name",
       "outputtopic": "Output topic",
-      "dropIfSameGateway": "Drop messages already tagged for this gateway"
+      "dropIfSameGateway": "Drop messages already tagged for this gateway",
+      "tunnelTitle": "KNX/IP Server",
+      "tunnelListenHost": "Listen host",
+      "tunnelListenPort": "Listen port",
+      "tunnelAdvertiseHost": "Advertise host",
+      "tunnelAdvertiseHostPlaceholder": "(optional) Host/IP to advertise to clients",
+      "tunnelAssignedIndividualAddress": "Assigned individual address",
+      "tunnelGatewayId": "Gateway id (tag)",
+      "tunnelGatewayIdPlaceholder": "(auto) Used as knxMultiRouting.gateway.id",
+      "tunnelMaxSessions": "Max sessions",
+      "bridgeGateway": "Bridge tunnel <-> selected gateway"
     },
     "outputs": {
       "raw": "RAW telegrams"

package/nodes/locales/es/knxUltimateMultiRouting.json

@@ -2,10 +2,23 @@
   "knxUltimateMultiRouting": {
     "title": "KNX Multi Routing",
     "properties": {
+      "mode": "Mode",
+      "modeGateway": "Gateway / Routing",
+      "modeServer": "Server KNX/IP",
       "server": "Gateway",
       "name": "Name",
       "outputtopic": "Output topic",
-      "dropIfSameGateway": "Drop messages already tagged for this gateway"
+      "dropIfSameGateway": "Drop messages already tagged for this gateway",
+      "tunnelTitle": "KNX/IP Server",
+      "tunnelListenHost": "Listen host",
+      "tunnelListenPort": "Listen port",
+      "tunnelAdvertiseHost": "Advertise host",
+      "tunnelAdvertiseHostPlaceholder": "(optional) Host/IP to advertise to clients",
+      "tunnelAssignedIndividualAddress": "Assigned individual address",
+      "tunnelGatewayId": "Gateway id (tag)",
+      "tunnelGatewayIdPlaceholder": "(auto) Used as knxMultiRouting.gateway.id",
+      "tunnelMaxSessions": "Max sessions",
+      "bridgeGateway": "Bridge tunnel <-> selected gateway"
     },
     "outputs": {
       "raw": "RAW telegrams"

package/nodes/locales/fr/knxUltimateMultiRouting.json

@@ -2,10 +2,23 @@
   "knxUltimateMultiRouting": {
     "title": "KNX Multi Routing",
     "properties": {
+      "mode": "Mode",
+      "modeGateway": "Gateway / Routing",
+      "modeServer": "Server KNX/IP",
       "server": "Gateway",
       "name": "Name",
       "outputtopic": "Output topic",
-      "dropIfSameGateway": "Drop messages already tagged for this gateway"
+      "dropIfSameGateway": "Drop messages already tagged for this gateway",
+      "tunnelTitle": "KNX/IP Server",
+      "tunnelListenHost": "Listen host",
+      "tunnelListenPort": "Listen port",
+      "tunnelAdvertiseHost": "Advertise host",
+      "tunnelAdvertiseHostPlaceholder": "(optional) Host/IP to advertise to clients",
+      "tunnelAssignedIndividualAddress": "Assigned individual address",
+      "tunnelGatewayId": "Gateway id (tag)",
+      "tunnelGatewayIdPlaceholder": "(auto) Used as knxMultiRouting.gateway.id",
+      "tunnelMaxSessions": "Max sessions",
+      "bridgeGateway": "Bridge tunnel <-> selected gateway"
     },
     "outputs": {
       "raw": "RAW telegrams"

package/nodes/locales/it/knxUltimateMultiRouting.html

@@ -4,6 +4,10 @@ Questo nodo serve per **collegare tra loro più gateway KNX Ultimate** (più `kn
 In output emette un oggetto con le informazioni **RAW** del telegramma (APDU + cEMI hex + indirizzi) per ogni telegramma ricevuto dal BUS KNX del gateway selezionato.
 In input può ricevere gli stessi oggetti RAW e inoltrarli sul BUS KNX del gateway selezionato.
 
+## Modalità Server KNX/IP
+Imposta **Modalità** su **Server KNX/IP** per avviare un server KNXnet/IP tunneling (UDP). I telegrammi ricevuti dai client vengono emessi nello stesso formato RAW usato dal MultiRouting.
+Il nodo accetta anche in input gli oggetti RAW e li inietta verso i client tunneling connessi.
+
 ## Formato messaggio in output
 `msg.payload` contiene:
 - `knx.event`: `GroupValue_Write` / `GroupValue_Response` / `GroupValue_Read`

package/nodes/locales/it/knxUltimateMultiRouting.json

@@ -2,10 +2,23 @@
   "knxUltimateMultiRouting": {
     "title": "KNX Multi Routing",
     "properties": {
+      "mode": "Modalità",
+      "modeGateway": "Gateway / Routing",
+      "modeServer": "Server KNX/IP",
       "server": "Gateway",
       "name": "Nome",
       "outputtopic": "Topic output",
-      "dropIfSameGateway": "Scarta messaggi già marcati per questo gateway"
+      "dropIfSameGateway": "Scarta messaggi già marcati per questo gateway",
+      "tunnelTitle": "Server KNX/IP",
+      "tunnelListenHost": "Host in ascolto",
+      "tunnelListenPort": "Porta in ascolto",
+      "tunnelAdvertiseHost": "Host annunciato",
+      "tunnelAdvertiseHostPlaceholder": "(opzionale) Host/IP da annunciare ai client",
+      "tunnelAssignedIndividualAddress": "Indirizzo individuale assegnato",
+      "tunnelGatewayId": "Gateway id (tag)",
+      "tunnelGatewayIdPlaceholder": "(auto) Usato come knxMultiRouting.gateway.id",
+      "tunnelMaxSessions": "Sessioni max",
+      "bridgeGateway": "Bridge tunnel <-> gateway selezionato"
     },
     "outputs": {
       "raw": "Telegrammi RAW"

package/nodes/locales/zh-CN/knxUltimateMultiRouting.json

@@ -2,10 +2,23 @@
   "knxUltimateMultiRouting": {
     "title": "KNX Multi Routing",
     "properties": {
+      "mode": "Mode",
+      "modeGateway": "Gateway / Routing",
+      "modeServer": "Server KNX/IP",
       "server": "Gateway",
       "name": "Name",
       "outputtopic": "Output topic",
-      "dropIfSameGateway": "Drop messages already tagged for this gateway"
+      "dropIfSameGateway": "Drop messages already tagged for this gateway",
+      "tunnelTitle": "KNX/IP Server",
+      "tunnelListenHost": "Listen host",
+      "tunnelListenPort": "Listen port",
+      "tunnelAdvertiseHost": "Advertise host",
+      "tunnelAdvertiseHostPlaceholder": "(optional) Host/IP to advertise to clients",
+      "tunnelAssignedIndividualAddress": "Assigned individual address",
+      "tunnelGatewayId": "Gateway id (tag)",
+      "tunnelGatewayIdPlaceholder": "(auto) Used as knxMultiRouting.gateway.id",
+      "tunnelMaxSessions": "Max sessions",
+      "bridgeGateway": "Bridge tunnel <-> selected gateway"
     },
     "outputs": {
       "raw": "RAW telegrams"

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "4.1.18",
+  "version": "4.1.19",
   "description": "Control your KNX and KNX Secure intallation via Node-Red! A bunch of KNX nodes, with integrated Philips HUE control, ETS group address importer, and KNX routing between interfaces. Easy to use and highly configurable.",
   "files": [
     "nodes/",
@@ -20,7 +20,7 @@
     "crypto-js": "4.2.0",
     "dns-sync": "0.2.1",
     "js-yaml": "4.1.1",
-    "knxultimate": "5.2.6",
+    "knxultimate": "5.2.7",
     "lodash": "4.17.21",
     "mkdirp": "3.0.1",
     "node-color-log": "12.0.1",