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

package/nodes/knxUltimateRouterFilter.js

@@ -1,6 +1,36 @@
 // KNX Router Filter - filters RAW telegram objects between KNX Multi Routing nodes
 const normalizeText = (value) => String(value || '').trim()
 
+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 parseBoolean = (value, fallback) => {
+  if (value === undefined || value === null) return fallback
+  if (typeof value === 'boolean') return value
+  if (typeof value === 'number') return value !== 0
+  const s = String(value).trim().toLowerCase()
+  if (s === 'true' || s === '1' || s === 'yes' || s === 'on') return true
+  if (s === 'false' || s === '0' || s === 'no' || s === 'off') return false
+  return fallback
+}
+
+const normalizeMultiline = (value) => {
+  if (value === undefined || value === null) return ''
+  if (Array.isArray(value)) return value.map(v => String(v)).join('\n')
+  return String(value)
+}
+
+let _knxultimateCache = null
+const getKnxultimate = () => {
+  if (_knxultimateCache) return _knxultimateCache
+  _knxultimateCache = require('knxultimate')
+  return _knxultimateCache
+}
+
 const splitPatterns = (raw) => {
   const s = normalizeText(raw)
   if (!s) return []
@@ -162,6 +192,82 @@ const getPayloadObject = (msg) => {
   return msg.payload
 }
 
+const getKnxObject = (msg) => {
+  const payload = getPayloadObject(msg)
+  if (payload && payload.knx && typeof payload.knx === 'object' && !Buffer.isBuffer(payload.knx)) return payload.knx
+  if (msg && msg.knx && typeof msg.knx === 'object' && !Buffer.isBuffer(msg.knx)) return msg.knx
+  return null
+}
+
+const getCemiHexFromMsg = (msg) => {
+  const knx = getKnxObject(msg)
+  if (!knx) return ''
+  const cemi = knx.cemi
+  if (!cemi) return ''
+  if (typeof cemi === 'string') return cemi
+  if (typeof cemi === 'object' && !Buffer.isBuffer(cemi) && cemi.hex) return cemi.hex
+  return ''
+}
+
+const setCemiHexOnMsg = (msg, cemiHex) => {
+  const knx = getKnxObject(msg)
+  if (!knx) return false
+  if (knx.cemi && typeof knx.cemi === 'object' && !Buffer.isBuffer(knx.cemi) && 'hex' in knx.cemi) {
+    knx.cemi.hex = cemiHex
+    return true
+  }
+  knx.cemi = { hex: cemiHex }
+  return true
+}
+
+const isIndividualAddressString = (value) => /^\d{1,2}\.\d{1,2}\.\d{1,3}$/.test(String(value || '').trim())
+const isGroupAddressString = (value) => /^\d{1,2}\/\d{1,2}\/\d{1,3}$/.test(String(value || '').trim())
+
+const syncCemiWithKnxFields = (msg) => {
+  const knx = getKnxObject(msg)
+  if (!knx) return false
+  const cemiHex = getCemiHexFromMsg(msg)
+  const clean = normalizeHex(cemiHex)
+  if (!clean || clean.length % 2 !== 0) return false
+
+  let cemi
+  try {
+    const { KNXTunnelingRequest } = getKnxultimate()
+    cemi = KNXTunnelingRequest.parseCEMIMessage(Buffer.from(clean, 'hex'), 0)
+  } catch (e) {
+    return false
+  }
+  if (!cemi || !cemi.control) return false
+
+  let updated = false
+  try {
+    if (isIndividualAddressString(knx.source)) {
+      const { KNXAddress } = getKnxultimate()
+      cemi.srcAddress = KNXAddress.createFromString(String(knx.source).trim(), KNXAddress.TYPE_INDIVIDUAL)
+      updated = true
+    }
+  } catch (e) { /* ignore */ }
+
+  try {
+    if (isGroupAddressString(knx.destination)) {
+      const { KNXAddress } = getKnxultimate()
+      cemi.dstAddress = KNXAddress.createFromString(String(knx.destination).trim(), KNXAddress.TYPE_GROUP)
+      try { cemi.control.addressType = 1 } catch (e2) { /* ignore */ }
+      updated = true
+    }
+  } catch (e) { /* ignore */ }
+
+  if (!updated) return false
+  try {
+    const outHex = cemi.toBuffer().toString('hex')
+    setCemiHexOnMsg(msg, outHex)
+    try { knx.cemi.hopCount = knx.cemi.hopCount } catch (e) { /* ignore */ }
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
 const attachFilterMeta = (msg, meta) => {
   try {
     const payload = getPayloadObject(msg)
@@ -185,24 +291,24 @@ module.exports = function (RED) {
     const node = this
 
     node.name = config.name || 'KNX Router Filter'
-    node.allowWrite = config.allowWrite !== undefined ? (config.allowWrite === true || config.allowWrite === 'true') : true
-    node.allowResponse = config.allowResponse !== undefined ? (config.allowResponse === true || config.allowResponse === 'true') : true
-    node.allowRead = config.allowRead !== undefined ? (config.allowRead === true || config.allowRead === 'true') : true
+    node.allowWrite = parseBoolean(config.allowWrite, true)
+    node.allowResponse = parseBoolean(config.allowResponse, true)
+    node.allowRead = parseBoolean(config.allowRead, true)
 
     node.gaMode = config.gaMode || 'off' // off|allow|block
     node.gaPatterns = config.gaPatterns || ''
     node.srcMode = config.srcMode || 'off' // off|allow|block
     node.srcPatterns = config.srcPatterns || ''
 
-    node.rewriteGA = config.rewriteGA !== undefined ? (config.rewriteGA === true || config.rewriteGA === 'true') : false
+    node.rewriteGA = parseBoolean(config.rewriteGA, false)
     node.gaRewriteRules = config.gaRewriteRules || ''
-    node.rewriteSource = config.rewriteSource !== undefined ? (config.rewriteSource === true || config.rewriteSource === 'true') : false
+    node.rewriteSource = parseBoolean(config.rewriteSource, false)
     node.srcRewriteRules = config.srcRewriteRules || ''
 
-    const gaRegexes = compileAddressPatterns({ raw: node.gaPatterns, kind: 'ga' })
-    const srcRegexes = compileAddressPatterns({ raw: node.srcPatterns, kind: 'src' })
-    const gaRewrite = compileRewriteRules({ raw: node.gaRewriteRules, kind: 'ga' })
-    const srcRewrite = compileRewriteRules({ raw: node.srcRewriteRules, kind: 'src' })
+    let gaRegexes = compileAddressPatterns({ raw: node.gaPatterns, kind: 'ga' })
+    let srcRegexes = compileAddressPatterns({ raw: node.srcPatterns, kind: 'src' })
+    let gaRewrite = compileRewriteRules({ raw: node.gaRewriteRules, kind: 'ga' })
+    let srcRewrite = compileRewriteRules({ raw: node.srcRewriteRules, kind: 'src' })
 
     let passed = 0
     let dropped = 0
@@ -251,6 +357,91 @@ module.exports = function (RED) {
       applyStatus(msg, { fill: 'grey', shape: 'dot', text: `pass ${passed} / drop ${dropped}` })
     }
 
+    let configStatusTimer = null
+    const setConfigStatus = (msg, text) => {
+      try {
+        if (configStatusTimer) clearTimeout(configStatusTimer)
+        applyStatus(msg, { fill: 'blue', shape: 'ring', text: text || 'Config changed' })
+        configStatusTimer = setTimeout(() => setCountersStatus(null), 2000)
+      } catch (e) { /* ignore */ }
+    }
+
+    const rebuildCompiledRules = () => {
+      gaRegexes = compileAddressPatterns({ raw: node.gaPatterns, kind: 'ga' })
+      srcRegexes = compileAddressPatterns({ raw: node.srcPatterns, kind: 'src' })
+      gaRewrite = compileRewriteRules({ raw: node.gaRewriteRules, kind: 'ga' })
+      srcRewrite = compileRewriteRules({ raw: node.srcRewriteRules, kind: 'src' })
+    }
+
+    const applySetConfig = (msg) => {
+      const sc = msg && msg.setConfig && typeof msg.setConfig === 'object' && !Buffer.isBuffer(msg.setConfig) ? msg.setConfig : null
+      if (!sc) return false
+
+      const changedKeys = []
+      const markChanged = (key) => { if (!changedKeys.includes(key)) changedKeys.push(key) }
+
+      if (Object.prototype.hasOwnProperty.call(sc, 'name')) {
+        node.name = normalizeText(sc.name) || node.name
+        markChanged('name')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'allowWrite')) {
+        node.allowWrite = parseBoolean(sc.allowWrite, node.allowWrite)
+        markChanged('allowWrite')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'allowResponse')) {
+        node.allowResponse = parseBoolean(sc.allowResponse, node.allowResponse)
+        markChanged('allowResponse')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'allowRead')) {
+        node.allowRead = parseBoolean(sc.allowRead, node.allowRead)
+        markChanged('allowRead')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'gaMode')) {
+        const m = normalizeText(sc.gaMode).toLowerCase()
+        if (m === 'off' || m === 'allow' || m === 'block') {
+          node.gaMode = m
+          markChanged('gaMode')
+        }
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'gaPatterns')) {
+        node.gaPatterns = normalizeMultiline(sc.gaPatterns)
+        markChanged('gaPatterns')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'srcMode')) {
+        const m = normalizeText(sc.srcMode).toLowerCase()
+        if (m === 'off' || m === 'allow' || m === 'block') {
+          node.srcMode = m
+          markChanged('srcMode')
+        }
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'srcPatterns')) {
+        node.srcPatterns = normalizeMultiline(sc.srcPatterns)
+        markChanged('srcPatterns')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'rewriteGA')) {
+        node.rewriteGA = parseBoolean(sc.rewriteGA, node.rewriteGA)
+        markChanged('rewriteGA')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'gaRewriteRules')) {
+        node.gaRewriteRules = normalizeMultiline(sc.gaRewriteRules)
+        markChanged('gaRewriteRules')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'rewriteSource')) {
+        node.rewriteSource = parseBoolean(sc.rewriteSource, node.rewriteSource)
+        markChanged('rewriteSource')
+      }
+      if (Object.prototype.hasOwnProperty.call(sc, 'srcRewriteRules')) {
+        node.srcRewriteRules = normalizeMultiline(sc.srcRewriteRules)
+        markChanged('srcRewriteRules')
+      }
+
+      if (changedKeys.length > 0) {
+        rebuildCompiledRules()
+        setConfigStatus(msg, `Config changed: ${changedKeys.join(', ')}`)
+      }
+      return true
+    }
+
     const extractFields = (msg) => {
       const payload = msg && msg.payload !== undefined ? msg.payload : null
       const knx = (payload && payload.knx) ? payload.knx : (msg && msg.knx ? msg.knx : null)
@@ -279,6 +470,11 @@ module.exports = function (RED) {
 
     node.on('input', function (msg) {
       try {
+        if (msg && Object.prototype.hasOwnProperty.call(msg, 'setConfig')) {
+          applySetConfig(msg)
+          return
+        }
+
         const fields = extractFields(msg)
 
         // If message doesn't look like a KNX raw telegram, pass it through unchanged.
@@ -341,8 +537,11 @@ module.exports = function (RED) {
           }
 
           if (anyRewrite) {
+            let cemiSynced = false
+            try { cemiSynced = syncCemiWithKnxFields(msg) } catch (e) { cemiSynced = false }
             meta = Object.assign({}, meta, {
               rewritten: true,
+              cemiSynced,
               original: Object.assign({}, meta.original || {}, {
                 destination: beforeGA,
                 source: beforeSrc
@@ -360,6 +559,13 @@ module.exports = function (RED) {
       }
     })
 
+    node.on('close', function () {
+      try {
+        if (configStatusTimer) clearTimeout(configStatusTimer)
+        configStatusTimer = null
+      } catch (e) { /* ignore */ }
+    })
+
     setCountersStatus(null)
   }
 

package/nodes/locales/de/knxUltimateMultiRouting.html

@@ -4,6 +4,12 @@ Dieser Node dient dazu, **mehrere KNX-Ultimate-Gateways** (mehrere `knxUltimate-
 Er gibt für jedes Telegramm vom KNX-Bus des ausgewählten Gateways ein Objekt mit **RAW-Telegramm-Informationen** (APDU + cEMI-Hex + Adressen) aus.
 Außerdem kann er die gleichen RAW-Objekte am Eingang annehmen und an das ausgewählte Gateway weiterleiten.
 
+## Server KNX/IP Modus
+Setze **Modus** auf **Server KNX/IP**, um einen eingebetteten KNXnet/IP-Tunneling-Server (UDP) zu starten. Eingehende Client-Telegramme werden im gleichen RAW-Format ausgegeben.
+Der Node akzeptiert außerdem RAW-Telegramm-Objekte am Eingang und injiziert sie an die verbundenen Tunneling-Clients.
+
+**Wichtig (Advertise host):** KNXnet/IP-Clients senden die Daten an die IP, die der Server in der CONNECT_RESPONSE ankündigt. Wenn der Client als *connected* angezeigt wird, der Server aber keine Telegramme empfängt, setze **Advertise host** auf die LAN-IP des Servers, die vom Client erreichbar ist (insbesondere bei Docker/VM oder Multi-Homing).
+
 ## Output-Nachrichtenformat
 `msg.payload` enthält:
 - `knx.event`: `GroupValue_Write` / `GroupValue_Response` / `GroupValue_Read`
@@ -15,6 +21,16 @@ Außerdem kann er die gleichen RAW-Objekte am Eingang annehmen und an das ausgew
 - `knx.echoed`: `true`, wenn vom Gateway „echoed“
 - `knxMultiRouting.gateway`: Gateway-Metadaten (`id`, `name`, `physAddr`)
 
+## Routing counter (hop count)
+MultiRouting kann den KNX Routing Counter (Hop Count) aus `knx.cemi.hex` nutzen, um Telegramm-Loops zu verhindern.
+- **Respect routing counter (drop if 0)**: Telegramme mit Routing Counter `0` werden nicht weitergeleitet.
+- **Decrement routing counter when routing**: Der Node dekrementiert den Routing Counter beim Weiterleiten. Erreicht er `0`, wird das Telegramm verworfen.
+
+Der aktuelle Wert steht in `knx.routingCounter` (und in `knx.cemi.hopCount`, wenn `knx.cemi` ein Objekt ist).
+
+## Telegramme umschreiben
+Wenn du `knx.source` / `knx.destination` im Flow umschreibst, musst du auch `knx.cemi.hex` konsistent halten. Empfehlung: setze **KNX Router Filter** zwischen MultiRouting-Nodes; er hält `knx.cemi.hex` beim Umschreiben automatisch konsistent.
+
 ## Hinweise
 - Beim Weiterleiten an ein anderes Gateway **ändert sich die Source-PA** (es wird die phys. Adresse des sendenden Gateways). Nutze `knx.source` und/oder `knxMultiRouting.gateway`, um Loops zu filtern.
 - Die Option **„Drop messages already tagged for this gateway“** hilft, einfache Loops zu verhindern, wenn mehrere Router miteinander verbunden sind.

package/nodes/locales/de/knxUltimateMultiRouting.json

@@ -2,10 +2,24 @@
   "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",
+      "respectRoutingCounter": "Respect routing counter (drop if 0)",
+      "decrementRoutingCounter": "Decrement routing counter when routing",
+      "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"
     },
     "outputs": {
       "raw": "RAW telegrams"

package/nodes/locales/de/knxUltimateRouterFilter.html

@@ -24,6 +24,8 @@ Optionales Umschreiben von:
 - Ziel-Gruppenadresse (`knx.destination`)
 - Source-PA (`knx.source`)
 
+Beim Umschreiben aktualisiert der Node auch `knx.cemi.hex`, damit es zu den umgeschriebenen Werten von `knx.source`/`knx.destination` passt (wenn `knx.cemi.hex` vorhanden ist).
+
 Regeln werden von oben nach unten ausgewertet (first match wins).
 
 Beispiele:
@@ -33,5 +35,41 @@ Beispiele:
 ## Metadaten
 Der Node fügt `msg.payload.knxRouterFilter` hinzu:
 - verworfen: `{ dropped: true, reason: 'event'|'ga'|'source', ... }`
-- durchgelassen: `{ dropped: false, rewritten: <bool>, rewrite: { ... }, original: { ... } }`
+- durchgelassen: `{ dropped: false, rewritten: <bool>, cemiSynced: <bool>, rewrite: { ... }, original: { ... } }`
+
+## msg.setConfig
+Du kannst die Node-Konfiguration zur Laufzeit ändern, indem du ein `msg.setConfig` Objekt an den Eingang sendest.
+Unterstützte Keys: `allowWrite`, `allowResponse`, `allowRead`, `gaMode`, `gaPatterns`, `srcMode`, `srcPatterns`, `rewriteGA`, `gaRewriteRules`, `rewriteSource`, `srcRewriteRules`.
+Die Konfiguration bleibt bis zum nächsten `msg.setConfig` oder bis Redeploy/Neustart erhalten. Konfigurationsnachrichten werden nicht weitergeleitet.
+
+Bedeutung der Properties:
+- `allowWrite`: erlaubt `GroupValue_Write` Telegramme.
+- `allowResponse`: erlaubt `GroupValue_Response` Telegramme.
+- `allowRead`: erlaubt `GroupValue_Read` Telegramme.
+- `gaMode`: Filtermodus für die Ziel-GA (`off` = kein Filter, `allow` = nur Matches durchlassen, `block` = Matches verwerfen).
+- `gaPatterns`: Ziel-GA Patterns für `gaMode` (eine pro Zeile, unterstützt `*` und `re:<regex>`).
+- `srcMode`: Filtermodus für die Source-PA (`off`/`allow`/`block`).
+- `srcPatterns`: Source-Patterns für `srcMode` (eine pro Zeile, unterstützt `*` und `re:<regex>`).
+- `rewriteGA`: aktiviert Umschreiben von `knx.destination` für durchgelassene Telegramme.
+- `gaRewriteRules`: Umschreibregeln für Ziel-GA (`von => nach`, first match wins; unterstützt `*` und `re:<regex>`).
+- `rewriteSource`: aktiviert Umschreiben von `knx.source` für durchgelassene Telegramme.
+- `srcRewriteRules`: Umschreibregeln für Source-PA (`von => nach`, first match wins; unterstützt `*` und `re:<regex>`).
+
+Beispiel:
+```js
+msg.setConfig = {
+  allowWrite: true,
+  allowResponse: true,
+  allowRead: true,
+  gaMode: "allow",
+  gaPatterns: "1/1/*\n1/2/3",
+  srcMode: "off",
+  srcPatterns: "",
+  rewriteGA: true,
+  gaRewriteRules: "5/5/1 => 1/1/1",
+  rewriteSource: true,
+  srcRewriteRules: "15.*.* => 1.1.254"
+};
+return msg;
+```
 </script>

package/nodes/locales/en/knxUltimateMultiRouting.html

@@ -4,6 +4,12 @@ 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).
+
+**Important (Advertise host):** KNXnet/IP clients will send data to the IP advertised by the server in the CONNECT_RESPONSE. If the client shows *connected* but the server receives no telegrams, set **Advertise host** to the server LAN IP reachable by the client (especially when running Node-RED in Docker/VM or on a multi-homed host).
+
 ## Output message format
 `msg.payload` contains:
 - `knx.event`: `GroupValue_Write` / `GroupValue_Response` / `GroupValue_Read`
@@ -15,6 +21,16 @@ It can also accept those RAW telegram objects on its input and forward them to t
 - `knx.echoed`: `true` if echoed by the gateway
 - `knxMultiRouting.gateway`: gateway meta (`id`, `name`, `physAddr`)
 
+## Routing counter (hop count)
+MultiRouting can use the KNX routing counter (hop count) found in `knx.cemi.hex` to prevent telegram loops.
+- **Respect routing counter (drop if 0)**: telegrams with routing counter `0` are not forwarded.
+- **Decrement routing counter when routing**: the node decrements the routing counter while forwarding. If it reaches `0`, the telegram is dropped.
+
+The current value is exposed as `knx.routingCounter` (and as `knx.cemi.hopCount` when `knx.cemi` is an object).
+
+## Rewriting telegrams
+If you rewrite `knx.source` / `knx.destination` in your flow, you must also keep `knx.cemi.hex` coherent. Recommended: place **KNX Router Filter** between MultiRouting nodes: it will keep `knx.cemi.hex` in sync when rewriting.
+
 ## Notes
 - When forwarded to another gateway, the **source physical address will change** (it becomes the sender gateway address). Use `knx.source` and/or `knxMultiRouting.gateway` to filter loops.
 - The option **Drop messages already tagged for this gateway** helps prevent simple loops when you connect multiple routers together.

package/nodes/locales/en/knxUltimateMultiRouting.json

@@ -2,10 +2,24 @@
   "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",
+      "respectRoutingCounter": "Respect routing counter (drop if 0)",
+      "decrementRoutingCounter": "Decrement routing counter when routing",
+      "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"
     },
     "outputs": {
       "raw": "RAW telegrams"

package/nodes/locales/en/knxUltimateRouterFilter.html

@@ -24,6 +24,8 @@ You can optionally rewrite:
 - destination Group Address (`knx.destination`)
 - source physical address (`knx.source`)
 
+When rewriting, the node also updates `knx.cemi.hex` to match the rewritten `knx.source`/`knx.destination` (when `knx.cemi.hex` is present).
+
 Rewrite rules are evaluated top-to-bottom, first match wins.
 
 Syntax examples:
@@ -33,5 +35,41 @@ Syntax examples:
 ## Metadata
 The node adds `msg.payload.knxRouterFilter`:
 - dropped messages: `{ dropped: true, reason: 'event'|'ga'|'source', ... }`
-- passed messages: `{ dropped: false, rewritten: <bool>, rewrite: { ... }, original: { ... } }`
+- passed messages: `{ dropped: false, rewritten: <bool>, cemiSynced: <bool>, rewrite: { ... }, original: { ... } }`
+
+## msg.setConfig
+You can change the node configuration at runtime by sending a `msg.setConfig` object to the input.
+Supported keys: `allowWrite`, `allowResponse`, `allowRead`, `gaMode`, `gaPatterns`, `srcMode`, `srcPatterns`, `rewriteGA`, `gaRewriteRules`, `rewriteSource`, `srcRewriteRules`.
+The new configuration is retained until next `msg.setConfig` or until redeploy/restart. Configuration messages are not forwarded.
+
+Meaning of the properties:
+- `allowWrite`: allow `GroupValue_Write` telegrams.
+- `allowResponse`: allow `GroupValue_Response` telegrams.
+- `allowRead`: allow `GroupValue_Read` telegrams.
+- `gaMode`: destination GA filter mode (`off` = no filter, `allow` = allow only matching, `block` = drop matching).
+- `gaPatterns`: destination GA patterns used by `gaMode` (one per line, supports `*` and `re:<regex>`).
+- `srcMode`: source (physical address) filter mode (`off`/`allow`/`block`).
+- `srcPatterns`: source patterns used by `srcMode` (one per line, supports `*` and `re:<regex>`).
+- `rewriteGA`: enable rewrite of `knx.destination` on passed telegrams.
+- `gaRewriteRules`: rewrite rules for destination GA (`from => to`, first match wins; supports `*` and `re:<regex>`).
+- `rewriteSource`: enable rewrite of `knx.source` on passed telegrams.
+- `srcRewriteRules`: rewrite rules for source PA (`from => to`, first match wins; supports `*` and `re:<regex>`).
+
+Example:
+```js
+msg.setConfig = {
+  allowWrite: true,
+  allowResponse: true,
+  allowRead: true,
+  gaMode: "allow",
+  gaPatterns: "1/1/*\n1/2/3",
+  srcMode: "off",
+  srcPatterns: "",
+  rewriteGA: true,
+  gaRewriteRules: "5/5/1 => 1/1/1",
+  rewriteSource: true,
+  srcRewriteRules: "15.*.* => 1.1.254"
+};
+return msg;
+```
 </script>

package/nodes/locales/es/knxUltimateMultiRouting.html

@@ -4,6 +4,12 @@ Este nodo se utiliza para **interconectar varios gateways KNX Ultimate** (varios
 En la salida emite un objeto con información **RAW del telegrama** (APDU + cEMI en hex + direcciones) para cada telegrama recibido del bus KNX del gateway seleccionado.
 En la entrada puede recibir esos mismos objetos RAW y reenviarlos al bus KNX del gateway seleccionado.
 
+## Modo servidor KNX/IP
+Establece **Modo** en **Server KNX/IP** para iniciar un servidor KNXnet/IP tunneling (UDP) integrado. Los telegramas recibidos de los clientes se emiten en el mismo formato RAW.
+El nodo también acepta objetos RAW en la entrada y los inyecta hacia los clientes tunneling conectados.
+
+**Importante (Advertise host):** los clientes KNXnet/IP enviarán los datos a la IP anunciada por el servidor en la CONNECT_RESPONSE. Si el cliente muestra *conectado* pero el servidor no recibe telegramas, configura **Advertise host** con la IP LAN del servidor alcanzable por el cliente (especialmente si Node-RED se ejecuta en Docker/VM o en un host con múltiples interfaces).
+
 ## Formato del mensaje de salida
 `msg.payload` contiene:
 - `knx.event`: `GroupValue_Write` / `GroupValue_Response` / `GroupValue_Read`
@@ -15,6 +21,16 @@ En la entrada puede recibir esos mismos objetos RAW y reenviarlos al bus KNX del
 - `knx.echoed`: `true` si el gateway lo ha “echoed”
 - `knxMultiRouting.gateway`: metadatos del gateway (`id`, `name`, `physAddr`)
 
+## Routing counter (hop count)
+MultiRouting puede usar el routing counter (hop count) presente en `knx.cemi.hex` para evitar bucles de telegramas.
+- **Respect routing counter (drop if 0)**: los telegramas con routing counter `0` no se reenvían.
+- **Decrement routing counter when routing**: el nodo decrementa el routing counter durante el reenvío. Si llega a `0`, el telegrama se descarta.
+
+El valor actual se expone como `knx.routingCounter` (y como `knx.cemi.hopCount` cuando `knx.cemi` es un objeto).
+
+## Reescritura de telegramas
+Si en tu flow reescribes `knx.source` / `knx.destination`, también debes mantener `knx.cemi.hex` coherente. Recomendado: coloca **KNX Router Filter** entre nodos MultiRouting: sincronizará automáticamente `knx.cemi.hex` durante la reescritura.
+
 ## Notas
 - Al reenviar a otro gateway, la **dirección física de origen cambia** (pasa a ser la del gateway que envía). Usa `knx.source` y/o `knxMultiRouting.gateway` para filtrar bucles.
 - La opción **“Drop messages already tagged for this gateway”** ayuda a prevenir bucles simples cuando conectas varios routers entre sí.

package/nodes/locales/es/knxUltimateMultiRouting.json

@@ -2,10 +2,24 @@
   "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",
+      "respectRoutingCounter": "Respect routing counter (drop if 0)",
+      "decrementRoutingCounter": "Decrement routing counter when routing",
+      "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"
     },
     "outputs": {
       "raw": "RAW telegrams"

package/nodes/locales/es/knxUltimateRouterFilter.html

@@ -24,6 +24,8 @@ Puedes reescribir opcionalmente:
 - destino (Group Address) `knx.destination`
 - origen (dirección física) `knx.source`
 
+Durante la reescritura, el nodo también actualiza `knx.cemi.hex` para reflejar los valores reescritos de `knx.source`/`knx.destination` (cuando `knx.cemi.hex` está presente).
+
 Las reglas se evalúan de arriba hacia abajo (la primera coincidencia gana).
 
 Ejemplos:
@@ -33,5 +35,41 @@ Ejemplos:
 ## Metadatos
 El nodo añade `msg.payload.knxRouterFilter`:
 - descartados: `{ dropped: true, reason: 'event'|'ga'|'source', ... }`
-- pasados: `{ dropped: false, rewritten: <bool>, rewrite: { ... }, original: { ... } }`
+- pasados: `{ dropped: false, rewritten: <bool>, cemiSynced: <bool>, rewrite: { ... }, original: { ... } }`
+
+## msg.setConfig
+Puedes cambiar la configuración del nodo en tiempo de ejecución enviando un objeto `msg.setConfig` a la entrada.
+Claves soportadas: `allowWrite`, `allowResponse`, `allowRead`, `gaMode`, `gaPatterns`, `srcMode`, `srcPatterns`, `rewriteGA`, `gaRewriteRules`, `rewriteSource`, `srcRewriteRules`.
+La configuración se mantiene hasta el siguiente `msg.setConfig` o hasta redeploy/reinicio. Los mensajes de configuración no se reenvían.
+
+Significado de las propiedades:
+- `allowWrite`: permite telegramas `GroupValue_Write`.
+- `allowResponse`: permite telegramas `GroupValue_Response`.
+- `allowRead`: permite telegramas `GroupValue_Read`.
+- `gaMode`: modo de filtro para la GA de destino (`off` = sin filtro, `allow` = permitir solo coincidencias, `block` = descartar coincidencias).
+- `gaPatterns`: patrones GA de destino usados por `gaMode` (uno por línea, soporta `*` y `re:<regex>`).
+- `srcMode`: modo de filtro para el source (dirección física) (`off`/`allow`/`block`).
+- `srcPatterns`: patrones source usados por `srcMode` (uno por línea, soporta `*` y `re:<regex>`).
+- `rewriteGA`: habilita la reescritura de `knx.destination` en los telegramas que pasan.
+- `gaRewriteRules`: reglas de reescritura GA (`de => a`, primera coincidencia gana; soporta `*` y `re:<regex>`).
+- `rewriteSource`: habilita la reescritura de `knx.source` en los telegramas que pasan.
+- `srcRewriteRules`: reglas de reescritura source (`de => a`, primera coincidencia gana; soporta `*` y `re:<regex>`).
+
+Ejemplo:
+```js
+msg.setConfig = {
+  allowWrite: true,
+  allowResponse: true,
+  allowRead: true,
+  gaMode: "allow",
+  gaPatterns: "1/1/*\n1/2/3",
+  srcMode: "off",
+  srcPatterns: "",
+  rewriteGA: true,
+  gaRewriteRules: "5/5/1 => 1/1/1",
+  rewriteSource: true,
+  srcRewriteRules: "15.*.* => 1.1.254"
+};
+return msg;
+```
 </script>

package/nodes/locales/fr/knxUltimateMultiRouting.html

@@ -4,6 +4,12 @@ Ce nœud sert à **interconnecter plusieurs gateways KNX Ultimate** (plusieurs `
 Il émet en sortie un objet contenant des informations **RAW** (APDU + cEMI hex + adresses) pour chaque télégramme reçu sur le bus KNX du gateway sélectionné.
 Il peut aussi accepter ces objets RAW en entrée et les transmettre vers le bus KNX du gateway sélectionné.
 
+## Mode serveur KNX/IP
+Réglez **Mode** sur **Server KNX/IP** pour démarrer un serveur KNXnet/IP tunneling (UDP) intégré. Les télégrammes reçus des clients sont émis au même format RAW.
+Le nœud accepte aussi en entrée des objets RAW et les injecte vers les clients tunneling connectés.
+
+**Important (Advertise host) :** les clients KNXnet/IP enverront les données à l’IP annoncée par le serveur dans la CONNECT_RESPONSE. Si le client indique *connecté* mais que le serveur ne reçoit aucun télégramme, définissez **Advertise host** sur l’IP LAN du serveur accessible par le client (surtout si Node-RED tourne dans Docker/VM ou sur une machine multi-homée).
+
 ## Format du message en sortie
 `msg.payload` contient :
 - `knx.event` : `GroupValue_Write` / `GroupValue_Response` / `GroupValue_Read`
@@ -15,6 +21,16 @@ Il peut aussi accepter ces objets RAW en entrée et les transmettre vers le bus
 - `knx.echoed` : `true` si le gateway l’a « echoed »
 - `knxMultiRouting.gateway` : métadonnées du gateway (`id`, `name`, `physAddr`)
 
+## Routing counter (hop count)
+MultiRouting peut utiliser le routing counter (hop count) présent dans `knx.cemi.hex` pour éviter les boucles de télégrammes.
+- **Respect routing counter (drop if 0)** : les télégrammes avec routing counter `0` ne sont pas transmis.
+- **Decrement routing counter when routing** : le nœud décrémente le routing counter lors du transfert. S’il atteint `0`, le télégramme est supprimé.
+
+La valeur courante est exposée via `knx.routingCounter` (et via `knx.cemi.hopCount` lorsque `knx.cemi` est un objet).
+
+## Réécriture des télégrammes
+Si vous réécrivez `knx.source` / `knx.destination` dans votre flow, vous devez aussi maintenir `knx.cemi.hex` cohérent. Recommandé : placez **KNX Router Filter** entre les nœuds MultiRouting : il maintient automatiquement `knx.cemi.hex` cohérent lors d’une réécriture.
+
 ## Notes
 - Lors d’un transfert vers un autre gateway, l’**adresse physique source change** (elle devient celle du gateway émetteur). Utilisez `knx.source` et/ou `knxMultiRouting.gateway` pour filtrer les boucles.
 - L’option **« Drop messages already tagged for this gateway »** aide à prévenir des boucles simples lorsque plusieurs routeurs sont interconnectés.