node-red-contrib-knx-ultimate 5.2.4 → 6.0.0

package/nodes/knxUltimateMatterDevice.js

@@ -1,308 +0,0 @@
-const dptlib = require('knxultimate').dptlib
-const matterKnxConverter = require('./utils/matterKnxConverter')
-
-module.exports = function (RED) {
-  function knxUltimateMatterDevice (config) {
-    RED.nodes.createNode(this, config)
-    const node = this
-    node.serverKNX = RED.nodes.getNode(config.server) || undefined
-    node.serverMatter = RED.nodes.getNode(config.serverMatter) || undefined
-
-    node.topic = node.name
-    node.name = config.name === undefined || config.name === '' ? 'Matter Device (BETA)' : config.name
-    node.dpt = ''
-    node.notifyreadrequest = false
-    node.notifyreadrequestalsorespondtobus = 'false'
-    node.notifyreadrequestalsorespondtobusdefaultvalueifnotinitialized = ''
-    node.notifyresponse = false
-    node.notifywrite = true
-    node.initialread = true
-    node.listenallga = true // Don't remove
-    node.outputtype = 'write'
-    node.outputRBE = 'false'
-    node.inputRBE = 'false'
-    node.currentPayload = ''
-    node.passthrough = 'no'
-    node.formatmultiplyvalue = 1
-    node.formatnegativevalue = 'leave'
-    node.formatdecimalsvalue = 2
-
-    node.matterNodeId = config.matterNodeId || ''
-    node.mappings = []
-    try {
-      node.mappings = Array.isArray(config.mappings) ? config.mappings : JSON.parse(config.mappings || '[]')
-    } catch (error) {
-      node.mappings = []
-    }
-
-    node.initializingAtStart = config.readStatusAtStartup === undefined || config.readStatusAtStartup === 'yes'
-    node.enableNodePINS = config.enableNodePINS === 'yes'
-    node.inputs = node.enableNodePINS ? 1 : 0
-    node.outputs = node.enableNodePINS ? 1 : 0
-
-    let lastInitialReadTs = 0
-
-    const pushStatus = (status) => {
-      if (!status) return
-      const provider = node.serverKNX
-      if (provider && typeof provider.applyStatusUpdate === 'function') {
-        provider.applyStatusUpdate(node, status)
-      } else {
-        node.status(status)
-      }
-    }
-
-    const formatTs = (date) => {
-      const d = date instanceof Date ? date : new Date(date)
-      const provider = node.serverKNX
-      if (provider && typeof provider.formatStatusTimestamp === 'function') return provider.formatStatusTimestamp(d)
-      return `${d.getDate()}, ${d.toLocaleTimeString()}`
-    }
-
-    node.setNodeStatus = ({ fill, shape, text, payload }) => {
-      try {
-        if (payload === undefined) payload = ''
-        const dDate = new Date()
-        payload = typeof payload === 'object' ? JSON.stringify(payload) : payload.toString()
-        node.sKNXNodeStatusText = `|KNX: ${text} ${payload} (${formatTs(dDate)})`
-        pushStatus({ fill, shape, text: (node.sMatterNodeStatusText || '') + ' ' + (node.sKNXNodeStatusText || '') })
-      } catch (error) { /* empty */ }
-    }
-
-    node.setNodeStatusMatter = ({ fill, shape, text, payload }) => {
-      try {
-        if (payload === undefined) payload = ''
-        const dDate = new Date()
-        payload = typeof payload === 'object' ? JSON.stringify(payload) : payload.toString()
-        node.sMatterNodeStatusText = `|Matter: ${text} ${payload} (${formatTs(dDate)})`
-        pushStatus({ fill, shape, text: node.sMatterNodeStatusText + ' ' + (node.sKNXNodeStatusText || '') })
-      } catch (error) { /* empty */ }
-    }
-
-    const safeSendToKNX = (telegram, context = 'write') => {
-      try {
-        if (!node.serverKNX || typeof node.serverKNX.sendKNXTelegramToKNXEngine !== 'function') {
-          pushStatus({ fill: 'red', shape: 'dot', text: `KNX server missing (${context}) (${formatTs(new Date())})` })
-          return
-        }
-        node.serverKNX.sendKNXTelegramToKNXEngine({ ...telegram, nodecallerid: node.id })
-      } catch (error) {
-        pushStatus({ fill: 'red', shape: 'dot', text: `KNX send error ${error.message}` })
-      }
-    }
-
-    const sendMappingToKNX = (mapping, payload, outputtype = 'write') => {
-      if (payload === undefined || mapping.ga === undefined || mapping.ga === '') return
-      safeSendToKNX({
-        grpaddr: mapping.ga,
-        payload,
-        dpt: mapping.dpt,
-        outputtype
-      }, outputtype)
-    }
-
-    const getMatterManager = () => {
-      if (!node.serverMatter || node.serverMatter.matterManager === null || node.serverMatter.matterManager === undefined) return undefined
-      return node.serverMatter.matterManager
-    }
-
-    // Send the cached Matter value of a status mapping to KNX
-    const sendCachedStatusToKNX = (mapping, outputtype = 'write') => {
-      try {
-        const manager = getMatterManager()
-        if (manager === undefined) return false
-        const rawValue = manager.getCachedAttribute(node.matterNodeId, mapping.endpointId, mapping.clusterId, mapping.target)
-        if (rawValue === undefined) return false
-        const payload = matterKnxConverter.matterToKnx(mapping.clusterId, mapping.target, rawValue)
-        if (payload === undefined) return false
-        sendMappingToKNX(mapping, payload, outputtype)
-        return true
-      } catch (error) {
-        node.setNodeStatusMatter({ fill: 'red', shape: 'dot', text: `Cached status error ${error.message}`, payload: '' })
-        return false
-      }
-    }
-
-    // KNX -> Matter
-    node.handleSend = (msg) => {
-      if (!msg || !msg.knx) return
-      if (node.matterNodeId === '') {
-        node.setNodeStatusMatter({ fill: 'red', shape: 'ring', text: 'Missing Matter device selection', payload: '' })
-        return
-      }
-      try {
-        if (!Array.isArray(node.mappings)) return
-        if (msg.knx.event === 'GroupValue_Read') {
-          // Respond to read requests with the cached Matter values
-          node.mappings.filter((m) => m.direction === 'status' && m.ga === msg.knx.destination).forEach((mapping) => {
-            if (sendCachedStatusToKNX(mapping, 'response')) {
-              node.setNodeStatus({ fill: 'grey', shape: 'ring', text: 'Response', payload: mapping.ga })
-            }
-          })
-          return
-        }
-        const manager = getMatterManager()
-        node.mappings.filter((m) => m.direction === 'command' && m.ga === msg.knx.destination).forEach((mapping) => {
-          const value = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(mapping.dpt))
-          const matterAction = matterKnxConverter.knxToMatter(mapping, value)
-          if (matterAction === null) return
-          if (manager === undefined || node.serverMatter.linkStatus !== 'connected') {
-            node.setNodeStatusMatter({ fill: 'red', shape: 'ring', text: 'Matter controller unavailable', payload: '' })
-            return
-          }
-          manager.writeMatterQueueAdd({
-            nodeId: node.matterNodeId,
-            endpointId: mapping.endpointId,
-            clusterId: mapping.clusterId,
-            kind: matterAction.kind,
-            name: matterAction.name,
-            args: matterAction.args
-          })
-          node.setNodeStatusMatter({
-            fill: 'green',
-            shape: 'dot',
-            text: `KNX->Matter ${mapping.clusterName || mapping.clusterId}.${matterAction.name}`,
-            payload: value
-          })
-        })
-      } catch (error) {
-        node.setNodeStatusMatter({ fill: 'red', shape: 'dot', text: `KNX->Matter error ${error.message}`, payload: '' })
-      }
-    }
-
-    // Matter -> KNX (attribute change reported by the subscription)
-    node.handleSendMatter = (_event) => {
-      try {
-        if (_event === undefined) return
-        if (_event.nodeId !== node.matterNodeId) return
-        const matchingMappings = node.mappings.filter((m) => m.direction === 'status' &&
-          Number(m.endpointId) === Number(_event.endpointId) &&
-          Number(m.clusterId) === Number(_event.clusterId) &&
-          m.targetKind === 'attribute' &&
-          m.target === _event.attributeName)
-        matchingMappings.forEach((mapping) => {
-          const payload = matterKnxConverter.matterToKnx(_event.clusterId, _event.attributeName, _event.value)
-          if (payload === undefined) return
-          sendMappingToKNX(mapping, payload, 'write')
-          node.setNodeStatusMatter({
-            fill: 'blue',
-            shape: 'dot',
-            text: `Matter->KNX ${_event.attributeName}`,
-            payload
-          })
-        })
-        if (node.enableNodePINS) {
-          node.send({
-            topic: `${_event.clusterId}.${_event.attributeName}`,
-            payload: _event.value,
-            matter: _event
-          })
-        }
-      } catch (error) {
-        node.setNodeStatusMatter({ fill: 'red', shape: 'dot', text: `Matter->KNX error ${error.message}`, payload: '' })
-      }
-    }
-
-    // Cluster events (e.g. switch presses). Forwarded to the flow only.
-    node.handleMatterClusterEvent = (_event) => {
-      try {
-        if (_event === undefined || _event.nodeId !== node.matterNodeId) return
-        if (node.enableNodePINS) {
-          node.send({
-            topic: `${_event.clusterId}.${_event.eventName}`,
-            payload: _event.events,
-            matter: _event
-          })
-        }
-      } catch (error) { /* empty */ }
-    }
-
-    // Called by matter-config when the paired node completed its initial sync (or reconnected)
-    node.handleMatterNodeInitialized = () => {
-      try {
-        if (!node.initializingAtStart) return
-        if (node.matterNodeId === '') return
-        const now = Date.now()
-        if ((now - lastInitialReadTs) < 5000) return // Avoid duplicate bursts on reconnections
-        let sentCount = 0
-        node.mappings.filter((m) => m.direction === 'status' && m.targetKind === 'attribute').forEach((mapping) => {
-          if (sendCachedStatusToKNX(mapping, 'write')) sentCount += 1
-        })
-        if (sentCount > 0) {
-          lastInitialReadTs = now
-          node.setNodeStatusMatter({ fill: 'green', shape: 'dot', text: `Initial read: ${sentCount} value(s) sent`, payload: '' })
-        }
-      } catch (error) {
-        node.setNodeStatusMatter({ fill: 'red', shape: 'dot', text: `Initial read error ${error.message}`, payload: '' })
-      }
-    }
-
-    if (node.serverKNX) {
-      try {
-        node.serverKNX.removeClient(node)
-        node.serverKNX.addClient(node)
-      } catch (error) {
-        RED.log.error(`knxUltimateMatterDevice: register KNX client error ${error.message}`)
-      }
-    }
-    if (node.serverMatter) {
-      try {
-        node.serverMatter.removeClient(node)
-        node.serverMatter.addClient(node)
-      } catch (error) {
-        RED.log.error(`knxUltimateMatterDevice: register client error ${error.message}`)
-      }
-    }
-
-    // Flow input pin: send raw Matter commands/attribute writes.
-    // msg.payload = { endpointId, clusterId, command: 'on', args: {...} } or { endpointId, clusterId, attribute: 'onOff', value: true }
-    node.on('input', (msg, send, done) => {
-      if (!node.enableNodePINS) {
-        if (done) done()
-        return
-      }
-      try {
-        const manager = getMatterManager()
-        if (manager === undefined) throw new Error('Matter controller unavailable')
-        const payload = msg.payload || {}
-        if (payload.command !== undefined) {
-          manager.writeMatterQueueAdd({
-            nodeId: node.matterNodeId,
-            endpointId: payload.endpointId,
-            clusterId: payload.clusterId,
-            kind: 'command',
-            name: payload.command,
-            args: payload.args
-          })
-        } else if (payload.attribute !== undefined) {
-          manager.writeMatterQueueAdd({
-            nodeId: node.matterNodeId,
-            endpointId: payload.endpointId,
-            clusterId: payload.clusterId,
-            kind: 'attributeWrite',
-            name: payload.attribute,
-            args: payload.value
-          })
-        } else {
-          throw new Error('msg.payload must contain "command" or "attribute"')
-        }
-        node.setNodeStatusMatter({ fill: 'green', shape: 'dot', text: 'Flow->Matter', payload })
-        if (done) done()
-      } catch (error) {
-        node.setNodeStatusMatter({ fill: 'red', shape: 'dot', text: `Flow error ${error.message}`, payload: '' })
-        if (done) done(error)
-      }
-    })
-
-    node.on('close', () => {
-      try {
-        if (node.serverKNX) node.serverKNX.removeClient(node)
-      } catch (error) { /* empty */ }
-      try {
-        if (node.serverMatter) node.serverMatter.removeClient(node)
-      } catch (error) { /* empty */ }
-    })
-  }
-
-  RED.nodes.registerType('knxUltimateMatterDevice', knxUltimateMatterDevice)
-}

package/nodes/locales/de/knxUltimateMatterDevice.html

@@ -1,56 +0,0 @@
-<script type="text/markdown" data-help-name="knxUltimateMatterDevice">
-# Matter-Gerät (BETA)
-
-> Dieser Node ist in **BETA**: Er funktioniert, aber Details können sich zwischen Releases noch ändern.
-
-## Übersicht
-
-Der Matter Device Node verbindet ein **Matter-Gerät** mit **KNX-Gruppenadressen**. Der Node arbeitet über den Konfigurations-Node *Matter Controller*, der die Geräte in seine eigene Matter-Fabric kommissioniert.
-
-- **Steuere** jedes gekoppelte Matter-Gerät vom KNX-Bus aus (Ein/Aus, Dimmen, Rollläden, Thermostate, Schlösser, ...).
-- **Verfolge** jedes Attribut des Geräts auf KNX-Gruppenadressen (Statusmeldungen, Sensoren, Leistungsmessung, Batterie...).
-- Vollständig generisch: Die Zuordnungsliste wird aus den **realen Endpoints/Clustern** des Geräts aufgebaut.
-
-## Konfiguration
-
-|Feld|Beschreibung|
-|--|--|
-| KNX GW | KNX-Gateway für die Telegramme |
-| Matter Ctrl | Der Matter-Controller-Konfigurations-Node (dort werden die Geräte gekoppelt) |
-| Gerät | Wähle das gekoppelte Matter-Gerät aus der Autovervollständigung |
-| Zuordnungen | Eine Zeile pro Zuordnung Gruppenadresse ↔ Matter-Cluster |
-| Status beim Start lesen | Wenn aktiviert, sendet der Node die aktuellen zwischengespeicherten Werte beim Deploy/Verbinden |
-| Node Input/Output PINs | Aktiviert die Node-RED-Pins für den rohen Matter-Zugriff |
-
-## Zuordnungen
-
-Die Ziel-Liste zeigt die unterstützten Funktionen mit verständlichen Namen wie *"Ein/Aus-Schalter"* oder *"Momentanleistung (W)"*, gefiltert nach dem, was das Gerät wirklich bereitstellt, mit dem aktuellen Wert in eckigen Klammern.
-
-Jede Zuordnungszeile hat eine **Richtung**:
-
-- **KNX → Matter (Befehl)**: Ein Telegramm auf der Gruppenadresse ruft einen Matter-Cluster-Befehl auf oder schreibt ein Attribut. Beispiel: GA `1/1/1` DPT 1.001 → `OnOff.on/off` (der boolesche Wert wählt automatisch Ein oder Aus).
-- **Matter → KNX (Status)**: Wenn sich das abonnierte Matter-Attribut ändert, wird sein Wert konvertiert und auf die Gruppenadresse geschrieben. `GroupValue_Read`-Anfragen werden mit dem zwischengespeicherten Wert beantwortet.
-
-Die gängigen Cluster werden automatisch in KNX-freundliche Werte konvertiert:
-
-|Cluster|Konvertierung|
-|--|--|
-| OnOff | boolesch (DPT 1.001) |
-| LevelControl | 0-254 ↔ Prozent (DPT 5.001) |
-| WindowCovering | percent100ths ↔ Prozent (DPT 5.001), Auf/Ab (DPT 1.008) |
-| ColorControl | Mired ↔ Kelvin (DPT 7.600) |
-| Thermostat | Zenti-°C ↔ °C (DPT 9.001) |
-| Temperatur/Feuchte | Zenti-Einheiten ↔ Einheiten (DPT 9.001/9.007) |
-| Beleuchtungsstärke | Log-Skala ↔ Lux (DPT 9.004) |
-| PowerSource | Halb-Prozent ↔ Batterie-Prozent (DPT 5.001) |
-| Elektrische Leistung/Energie | mW ↔ W (DPT 14.056), mWh ↔ kWh (DPT 13.013) |
-
-Andere Cluster/Attribute werden unverändert durchgereicht; der gewählte DPT übernimmt die finale KNX-Kodierung.
-
-## Node-PINs
-
-Wenn du die Node-PINs aktivierst:
-
-- **Input**: sende rohe Befehle: `msg.payload = { endpointId: 1, clusterId: 6, command: "toggle" }` oder Attribut-Schreibzugriffe: `msg.payload = { endpointId: 1, clusterId: 8, attribute: "onLevel", value: 128 }`
-- **Output**: empfängt jede Attributänderung (`msg.matter` enthält das komplette Ereignis) und jedes Cluster-Ereignis (Tastendrücke usw.).
-</script>

package/nodes/locales/de/knxUltimateMatterDevice.json

@@ -1,109 +0,0 @@
-{
-  "knxUltimateMatterDevice": {
-    "title": "Matter-Gerät (BETA)",
-    "paletteLabel": "Matter Device (BETA)",
-    "matter_controller": "Matter Ctrl",
-    "matter_device": "Gerät",
-    "device_placeholder": "Klicken, um ein gekoppeltes Matter-Gerät auszuwählen",
-    "mapping_help": "Füge pro Zuordnung eine Zeile hinzu. \"KNX → Matter\" ruft einen Cluster-Befehl auf (oder schreibt ein Attribut), wenn ein Telegramm auf der Gruppenadresse eintrifft. \"Matter → KNX\" schreibt den Attributwert bei jeder Änderung auf die Gruppenadresse (Leseanfragen werden mit dem zwischengespeicherten Wert beantwortet).",
-    "select_target": "-- Matter-Ziel auswählen --",
-    "stored_target": "Gespeichert",
-    "read_status_startup": "Status beim Start lesen",
-    "opt_yes_emit": "Ja, und KNX-Telegramme senden.",
-    "opt_no": "Nein",
-    "node_pins": "Node Input/Output PINs",
-    "node_pins_hide": "Ausblenden",
-    "node_pins_show": "Input/Output-PINs anzeigen",
-    "direction": {
-      "command": "KNX → Matter (Befehl)",
-      "status": "Matter → KNX (Status)"
-    },
-    "fields": {
-      "direction": "Richtung",
-      "target": "Matter Endpoint / Cluster / Ziel",
-      "ga": "Gruppenadresse",
-      "dpt": "DPT",
-      "ganame": "Name"
-    },
-    "no_simple_targets": "Keine unterstützten Funktionen auf diesem Gerät gefunden (oder das Gerät ist noch nicht verbunden).",
-    "endpoint": "Endpoint",
-    "friendly": {
-      "onoff_switch": "Ein/Aus-Schalter (ein-/ausschalten)",
-      "onoff_toggle": "Umschalten (Toggle)",
-      "onoff_state": "Ein/Aus-Status",
-      "level_set": "Helligkeit / Stufe setzen (%)",
-      "level_state": "Aktuelle Helligkeit / Stufe (%)",
-      "colortemp_set": "Farbtemperatur setzen (Kelvin)",
-      "colortemp_state": "Aktuelle Farbtemperatur (Kelvin)",
-      "cover_updown": "Rollladen Auf/Ab",
-      "cover_stop": "Rollladen Stopp",
-      "cover_position_set": "Rollladen auf Position fahren (%)",
-      "cover_position_state": "Aktuelle Rollladenposition (%)",
-      "cover_tilt_set": "Lamellen neigen (%)",
-      "cover_tilt_state": "Aktuelle Lamellenneigung (%)",
-      "thermo_localtemp": "Raumtemperatur (°C)",
-      "thermo_heatsp_set": "Heiz-Sollwert setzen (°C)",
-      "thermo_coolsp_set": "Kühl-Sollwert setzen (°C)",
-      "thermo_heatsp_state": "Heiz-Sollwert (°C)",
-      "thermo_coolsp_state": "Kühl-Sollwert (°C)",
-      "fan_speed_set": "Lüftergeschwindigkeit setzen (%)",
-      "fan_speed_state": "Aktuelle Lüftergeschwindigkeit (%)",
-      "lock_cmd": "Tür ver-/entriegeln",
-      "lock_state": "Schlossstatus (verriegelt)",
-      "temp_measured": "Gemessene Temperatur (°C)",
-      "humidity_measured": "Relative Luftfeuchte (%)",
-      "illuminance_measured": "Beleuchtungsstärke (Lux)",
-      "occupancy_state": "Anwesenheit erkannt",
-      "contact_state": "Kontaktstatus (geschlossen/offen)",
-      "battery_percent": "Batteriestand (%)",
-      "power_active": "Momentanleistung (W)",
-      "power_voltage": "Spannung (V)",
-      "power_current": "Strom (A)",
-      "energy_imported": "Energieverbrauch (kWh)",
-      "identify_cmd": "Gerät identifizieren (blinken)",
-      "switch_position": "Tastenposition"
-    },
-    "devtype": {
-      "onofflight": "Ein/Aus-Licht",
-      "dimmablelight": "Dimmbares Licht",
-      "colortemperaturelight": "Licht mit Farbtemperatur",
-      "extendedcolorlight": "Farblicht",
-      "onoffpluginunit": "Steckdose (Ein/Aus)",
-      "dimmablepluginunit": "Steckdose (dimmbar)",
-      "smartplug": "Smarte Steckdose",
-      "contactsensor": "Kontaktsensor",
-      "lightsensor": "Lichtsensor",
-      "occupancysensor": "Präsenzsensor",
-      "temperaturesensor": "Temperatursensor",
-      "humiditysensor": "Feuchtesensor",
-      "pressuresensor": "Drucksensor",
-      "flowsensor": "Durchflusssensor",
-      "doorlock": "Türschloss",
-      "windowcovering": "Rollladen/Jalousie",
-      "thermostat": "Thermostat",
-      "fan": "Ventilator",
-      "genericswitch": "Taster/Schalter",
-      "airqualitysensor": "Luftqualitätssensor",
-      "smokecoalarm": "Rauch-/CO-Melder",
-      "waterleakdetector": "Wasserleckmelder",
-      "roomairconditioner": "Klimagerät",
-      "airpurifier": "Luftreiniger",
-      "speaker": "Lautsprecher",
-      "pumpcontroller": "Pumpe",
-      "onofflightswitch": "Lichtschalter",
-      "dimmerswitch": "Dimmerschalter",
-      "colordimmerswitch": "Farbdimmerschalter",
-      "powersource": "Stromversorgung",
-      "electricalsensor": "Elektrischer Sensor",
-      "bridgednode": "Bridged-Gerät",
-      "aggregator": "Bridge/Aggregator",
-      "rootnode": "Root-Node"
-    }
-  },
-  "common": {
-    "ga": "GA",
-    "dpt": "DPT",
-    "name": "Name",
-    "knx_gw": "KNX GW"
-  }
-}

package/nodes/locales/en/knxUltimateMatterDevice.html

@@ -1,56 +0,0 @@
-<script type="text/markdown" data-help-name="knxUltimateMatterDevice">
-# Matter Device (BETA)
-
-> This node is in **BETA**: it works, but details may still change between releases.
-
-## Overview
-
-The Matter Device node bridges a **Matter device** to **KNX group addresses**. The node acts through the *Matter Controller* configuration node, which commissions (pairs) the devices into its own Matter fabric.
-
-- **Control** any commissioned Matter device from the KNX bus (on/off, dimming, covers, thermostats, locks, ...).
-- **Track** every attribute of the device on KNX group addresses (status feedback, sensors, power metering, battery...).
-- Fully generic: the mapping list is built from the **real endpoints/clusters** exposed by the device.
-
-## Configuration
-
-|Field|Description|
-|--|--|
-| KNX GW | KNX gateway used for telegrams |
-| Matter Ctrl | The Matter Controller configuration node (where you pair the devices) |
-| Device | Pick the commissioned Matter device from the autocomplete list |
-| Mappings | One row per group address ↔ Matter cluster mapping |
-| Read status at startup | When enabled, the node emits the current cached values on deploy/connection |
-| Node Input/Output PINs | Enable Node-RED input/output pins for raw Matter access |
-
-## Mappings
-
-The target list shows the supported functions with friendly names such as *"On/Off switch"* or *"Instantaneous power (W)"*, filtered on what the device really exposes and with the current value shown in brackets.
-
-Each mapping row has a **direction**:
-
-- **KNX → Matter (command)**: a telegram received on the group address invokes a Matter cluster command or writes an attribute. Example: GA `1/1/1` DPT 1.001 → `OnOff.on/off` (the boolean payload selects on or off automatically).
-- **Matter → KNX (status)**: whenever the subscribed Matter attribute changes, its value is converted and written to the group address. `GroupValue_Read` requests are answered with the cached value.
-
-Well-known clusters are converted automatically to KNX-friendly values:
-
-|Cluster|Conversion|
-|--|--|
-| OnOff | boolean (DPT 1.001) |
-| LevelControl | 0-254 ↔ percent (DPT 5.001) |
-| WindowCovering | percent100ths ↔ percent (DPT 5.001), up/down (DPT 1.008) |
-| ColorControl | mireds ↔ Kelvin (DPT 7.600) |
-| Thermostat | centi-°C ↔ °C (DPT 9.001) |
-| Temperature/Humidity | centi-units ↔ units (DPT 9.001/9.007) |
-| Illuminance | log scale ↔ Lux (DPT 9.004) |
-| PowerSource | half-percent ↔ percent battery (DPT 5.001) |
-| Electrical Power/Energy | mW ↔ W (DPT 14.056), mWh ↔ kWh (DPT 13.013) |
-
-Other clusters/attributes are passed through raw; the DPT you pick performs the final KNX encoding.
-
-## Node PINs
-
-If you enable the node PINs:
-
-- **Input**: send raw commands: `msg.payload = { endpointId: 1, clusterId: 6, command: "toggle" }` or attribute writes: `msg.payload = { endpointId: 1, clusterId: 8, attribute: "onLevel", value: 128 }`
-- **Output**: receives every attribute change (`msg.matter` contains the full event) and every cluster event (button presses etc.).
-</script>

package/nodes/locales/en/knxUltimateMatterDevice.json

@@ -1,109 +0,0 @@
-{
-  "knxUltimateMatterDevice": {
-    "title": "Matter Device (BETA)",
-    "paletteLabel": "Matter Device (BETA)",
-    "matter_controller": "Matter Ctrl",
-    "matter_device": "Device",
-    "device_placeholder": "Click to pick a paired Matter device",
-    "mapping_help": "Add one row per mapping. \"KNX → Matter\" invokes a cluster command (or writes an attribute) when a telegram arrives on the group address. \"Matter → KNX\" writes the attribute value to the group address whenever it changes (read requests are answered with the cached value).",
-    "select_target": "-- select the Matter target --",
-    "stored_target": "Stored",
-    "read_status_startup": "Read status at startup",
-    "opt_yes_emit": "Yes, and emit KNX telegrams.",
-    "opt_no": "No",
-    "node_pins": "Node Input/Output PINs",
-    "node_pins_hide": "Hide",
-    "node_pins_show": "Show node input/output PINs",
-    "direction": {
-      "command": "KNX → Matter (command)",
-      "status": "Matter → KNX (status)"
-    },
-    "fields": {
-      "direction": "Direction",
-      "target": "Matter endpoint / cluster / target",
-      "ga": "Group address",
-      "dpt": "DPT",
-      "ganame": "Name"
-    },
-    "no_simple_targets": "No supported functions found on this device (or the device is not connected yet).",
-    "endpoint": "Endpoint",
-    "friendly": {
-      "onoff_switch": "On/Off switch (turn on/off)",
-      "onoff_toggle": "Toggle (invert state)",
-      "onoff_state": "On/Off state",
-      "level_set": "Set brightness / level (%)",
-      "level_state": "Current brightness / level (%)",
-      "colortemp_set": "Set color temperature (Kelvin)",
-      "colortemp_state": "Current color temperature (Kelvin)",
-      "cover_updown": "Cover Up/Down",
-      "cover_stop": "Cover Stop",
-      "cover_position_set": "Move cover to position (%)",
-      "cover_position_state": "Current cover position (%)",
-      "cover_tilt_set": "Move slats to tilt (%)",
-      "cover_tilt_state": "Current slat tilt (%)",
-      "thermo_localtemp": "Room temperature (°C)",
-      "thermo_heatsp_set": "Set heating setpoint (°C)",
-      "thermo_coolsp_set": "Set cooling setpoint (°C)",
-      "thermo_heatsp_state": "Heating setpoint (°C)",
-      "thermo_coolsp_state": "Cooling setpoint (°C)",
-      "fan_speed_set": "Set fan speed (%)",
-      "fan_speed_state": "Current fan speed (%)",
-      "lock_cmd": "Lock/Unlock door",
-      "lock_state": "Lock state (locked)",
-      "temp_measured": "Measured temperature (°C)",
-      "humidity_measured": "Relative humidity (%)",
-      "illuminance_measured": "Illuminance (Lux)",
-      "occupancy_state": "Presence detected",
-      "contact_state": "Contact state (closed/open)",
-      "battery_percent": "Battery level (%)",
-      "power_active": "Instantaneous power (W)",
-      "power_voltage": "Voltage (V)",
-      "power_current": "Current (A)",
-      "energy_imported": "Energy consumed (kWh)",
-      "identify_cmd": "Identify device (blink)",
-      "switch_position": "Button position"
-    },
-    "devtype": {
-      "onofflight": "On/Off light",
-      "dimmablelight": "Dimmable light",
-      "colortemperaturelight": "Color temperature light",
-      "extendedcolorlight": "Color light",
-      "onoffpluginunit": "Plug (on/off)",
-      "dimmablepluginunit": "Plug (dimmable)",
-      "smartplug": "Smart plug",
-      "contactsensor": "Contact sensor",
-      "lightsensor": "Light sensor",
-      "occupancysensor": "Occupancy sensor",
-      "temperaturesensor": "Temperature sensor",
-      "humiditysensor": "Humidity sensor",
-      "pressuresensor": "Pressure sensor",
-      "flowsensor": "Flow sensor",
-      "doorlock": "Door lock",
-      "windowcovering": "Window covering",
-      "thermostat": "Thermostat",
-      "fan": "Fan",
-      "genericswitch": "Button/Switch",
-      "airqualitysensor": "Air quality sensor",
-      "smokecoalarm": "Smoke/CO alarm",
-      "waterleakdetector": "Water leak detector",
-      "roomairconditioner": "Air conditioner",
-      "airpurifier": "Air purifier",
-      "speaker": "Speaker",
-      "pumpcontroller": "Pump",
-      "onofflightswitch": "Light switch",
-      "dimmerswitch": "Dimmer switch",
-      "colordimmerswitch": "Color dimmer switch",
-      "powersource": "Power source",
-      "electricalsensor": "Electrical sensor",
-      "bridgednode": "Bridged device",
-      "aggregator": "Bridge/Aggregator",
-      "rootnode": "Root node"
-    }
-  },
-  "common": {
-    "ga": "GA",
-    "dpt": "DPT",
-    "name": "Name",
-    "knx_gw": "KNX GW"
-  }
-}