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

package/nodes/knxUltimateMatterControllerDevice.js

@@ -0,0 +1,1701 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable camelcase */
+/* eslint-disable max-len */
+/* eslint-disable no-lonely-if */
+/* eslint-disable no-case-declarations */
+/* eslint-disable no-unused-vars */
+const cloneDeep = require('lodash/cloneDeep')
+const dptlib = require('knxultimate').dptlib
+const hueColorConverter = require('./utils/colorManipulators/hueColorConverter')
+const { createLightEngine } = require('./utils/lightEngines')
+const { hueStateToCanonical, matterEventToHuePatch } = require('./utils/lightEngines/matterHueShim')
+
+module.exports = function (RED) {
+  function knxUltimateMatterControllerDevice (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.matterNodeId = config.matterNodeId !== undefined ? String(config.matterNodeId) : ''
+    node.matterEndpointId = config.matterEndpointId !== undefined ? Number(config.matterEndpointId) : 1
+    node.matterDeviceName = config.matterDeviceName !== undefined ? String(config.matterDeviceName) : ''
+
+    // Matter engine (adapter). The manager is resolved lazily at each write, because
+    // matter-config creates its matterManager asynchronously after the deploy.
+    node.lightEngine = createLightEngine('matter', {
+      deviceId: node.matterNodeId,
+      nodeId: node.matterNodeId,
+      endpointId: node.matterEndpointId
+    })
+
+    // Facade impersonating the hue-config node. The entire light logic below was born
+    // in the Hue Light node and is kept UNCHANGED: it speaks Hue-native state objects,
+    // and this boundary translates them to the Matter engine (strategy/adapter).
+    node.serverHue = {
+      get linkStatus () { return node.serverMatter ? node.serverMatter.linkStatus : 'disconnected' },
+      hueManager: {
+        writeHueQueueAdd: (_lightID, _state, _operation) => {
+          try {
+            if (!node.lightEngine) return
+            const patch = hueStateToCanonical(_state)
+            if (!patch) return
+            node.lightEngine.manager = node.serverMatter ? node.serverMatter.matterManager : undefined
+            node.lightEngine.applyState(patch)
+          } catch (error) {
+            RED.log.error('knxUltimateMatterControllerDevice: writeHueQueueAdd shim: ' + (error && error.message))
+          }
+        },
+        deleteHueQueue: () => { }
+      },
+      addClient: (_node) => { try { if (node.serverMatter) node.serverMatter.addClient(_node) } catch (error) { /* empty */ } },
+      removeClient: (_node) => { if (node.serverMatter) { try { node.serverMatter.removeClient(_node) } catch (error) { /* empty */ } } },
+      getAllLightsBelongingToTheGroup: async () => [],
+      getHueResourceSnapshot: async () => node.currentHUEDevice,
+      getAverageColorsXYBrightnessAndTemperature: async () => undefined
+    }
+
+    // Convert for backward compatibility
+    if (config.nameLightKelvinDIM === undefined) {
+      config.nameLightKelvinDIM = config.nameLightHSV
+      config.GALightKelvinDIM = config.GALightHSV
+      config.dptLightKelvinDIM = config.dptLightHSV
+
+      config.nameLightKelvinPercentage = config.nameLightHSVPercentage
+      config.GALightKelvinPercentage = config.GALightHSVPercentage
+      config.dptLightKelvinPercentage = config.dptLightHSVPercentage
+
+      config.nameLightKelvinPercentageState = config.nameLightHSVState
+      config.GALightKelvinPercentageState = config.GALightHSVState
+      config.dptLightKelvinPercentageState = config.dptLightHSVState
+    }
+
+    node.name = config.name || node.matterDeviceName || 'Control Matter from KNX'
+    node.topic = node.name
+    node.outputtopic = node.name
+    node.dpt = ''
+    node.notifyreadrequest = true
+    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' // Apply or not RBE to the output (Messages coming from flow)
+    node.inputRBE = 'false' // Apply or not RBE to the input (Messages coming from BUS)
+    node.currentPayload = '' // Current value for the RBE input and for the .previouspayload msg
+    node.passthrough = 'no'
+    node.formatmultiplyvalue = 1
+    node.formatnegativevalue = 'leave'
+    node.formatdecimalsvalue = 2
+    node.knxUltimateAcceptedGAs = [
+      config.GALightSwitch,
+      config.GALightState,
+      config.GALightDIM,
+      config.GALightColor,
+      config.GALightColorState,
+      config.GALightHSV_H_DIM,
+      config.GALightHSV_H_State,
+      config.GALightHSV_S_DIM,
+      config.GALightHSV_S_State,
+      config.GALightKelvinDIM,
+      config.GALightKelvinPercentage,
+      config.GALightKelvinPercentageState,
+      config.GALightKelvin,
+      config.GALightKelvinState,
+      config.GALightBrightness,
+      config.GALightBrightnessState,
+      config.GALightBlink,
+      config.GALightColorCycle,
+      config.GADaylightSensor
+    ].map((ga) => String(ga || '').trim()).filter((ga) => ga !== '')
+    const isConfiguredKNXGA = (ga) => node.knxUltimateAcceptedGAs.includes(String(ga || '').trim())
+    // Synthetic "current device" in Hue shape, kept in sync from the Matter attribute
+    // reports. It lets the whole Hue-born logic below run untouched on a Matter light.
+    node.currentHUEDevice = {
+      id: node.matterNodeId,
+      type: 'light',
+      on: { on: false },
+      dimming: { brightness: 100, min_dim_level: 0 },
+      color: { xy: { x: 0.3127, y: 0.329 }, gamut: undefined, gamut_type: undefined },
+      color_temperature: { mirek: 333, mirek_valid: true, mirek_schema: { mirek_minimum: 153, mirek_maximum: 500 } }
+    }
+    node.HUEDeviceWhileDaytime = null// This retains the HUE device status while daytime, to be restored after nighttime elapsed.
+    node.HUELightsBelongingToGroupWhileDaytime = null // Array contains all light belonging to the grouped_light (if grouped_light is selected)
+    node.DayTime = true
+    node.isGrouped_light = false // No grouped lights on Matter
+    node.hueDevice = node.matterNodeId
+    node.initializingAtStart = (config.readStatusAtStartup === undefined || config.readStatusAtStartup === 'yes')
+    config.specifySwitchOnBrightness = (config.specifySwitchOnBrightness === undefined || config.specifySwitchOnBrightness === '') ? 'temperature' : config.specifySwitchOnBrightness
+    config.specifySwitchOnBrightnessNightTime = (config.specifySwitchOnBrightnessNightTime === undefined || config.specifySwitchOnBrightnessNightTime === '') ? 'no' : config.specifySwitchOnBrightnessNightTime
+    config.colorAtSwitchOnDayTime = (config.colorAtSwitchOnDayTime === '' || config.colorAtSwitchOnDayTime === undefined) ? '{ "kelvin":3000, "brightness":100 }' : config.colorAtSwitchOnDayTime
+    config.colorAtSwitchOnNightTime = (config.colorAtSwitchOnNightTime === '' || config.colorAtSwitchOnNightTime === undefined) ? '{ "kelvin":2700, "brightness":20 }' : config.colorAtSwitchOnNightTime
+    config.colorAtSwitchOnDayTime = config.colorAtSwitchOnDayTime.replace('geen', 'green')
+    config.colorAtSwitchOnNightTime = config.colorAtSwitchOnNightTime.replace('geen', 'green')
+    config.dimSpeed = (config.dimSpeed === undefined || config.dimSpeed === '') ? 5000 : Number(config.dimSpeed)
+    config.HSVDimSpeed = (config.HSVDimSpeed === undefined || config.HSVDimSpeed === '') ? 5000 : Number(config.HSVDimSpeed)
+    config.invertDimTunableWhiteDirection = config.invertDimTunableWhiteDirection !== undefined
+    config.restoreDayMode = config.restoreDayMode === undefined ? 'no' : config.restoreDayMode // no or setDayByFastSwitchLightSingle or setDayByFastSwitchLightALL
+    config.updateLocalStateFromKNXWrite = config.updateLocalStateFromKNXWrite === true || config.updateLocalStateFromKNXWrite === 'true' // Starting from v 4.1.31
+    node.timerCheckForFastLightSwitch = null
+    config.invertDayNight = config.invertDayNight === undefined ? false : config.invertDayNight
+    node.HSVObject = null // { h, s, v };// Store the current light calculated HSV
+
+    // Transform HEX in RGB and stringified json in json oblects.
+    if (config.colorAtSwitchOnDayTime.indexOf('#') !== -1) {
+      // Transform to rgb.
+      try {
+        config.colorAtSwitchOnDayTime = hueColorConverter.ColorConverter.hexRgb(config.colorAtSwitchOnDayTime.replace('#', ''))
+      } catch (error) {
+        config.colorAtSwitchOnDayTime = { kelvin: 3000, brightness: 100 }
+      }
+    } else {
+      try {
+        config.colorAtSwitchOnDayTime = JSON.parse(config.colorAtSwitchOnDayTime)
+      } catch (error) {
+        RED.log.error(`knxUltimateMatterControllerDevice:  config.colorAtSwitchOnDayTime = JSON.parse(config.colorAtSwitchOnDayTime): ${error.message} : ${error.stack || ''} `)
+        config.colorAtSwitchOnDayTime = ''
+      }
+    }
+    // Same thing, but with night color
+    if (config.colorAtSwitchOnNightTime.indexOf('#') !== -1) {
+      // Transform to rgb.
+      try {
+        config.colorAtSwitchOnNightTime = hueColorConverter.ColorConverter.hexRgb(config.colorAtSwitchOnNightTime.replace('#', ''))
+      } catch (error) {
+        config.colorAtSwitchOnNightTime = { kelvin: 2700, brightness: 20 }
+      }
+    } else {
+      try {
+        config.colorAtSwitchOnNightTime = JSON.parse(config.colorAtSwitchOnNightTime)
+      } catch (error) {
+        RED.log.error(`knxUltimateMatterControllerDevice:  config.colorAtSwitchOnDayTime = JSON.parse(config.colorAtSwitchOnNightTime): ${error.message} : ${error.stack || ''} `)
+        config.colorAtSwitchOnNightTime = ''
+      }
+    }
+
+    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.syncCurrentHUEDeviceFromKNXState = function syncCurrentHUEDeviceFromKNXState (_state) { // Starting from v 4.1.31
+      if (config.updateLocalStateFromKNXWrite !== true) return // Starting from v 4.1.31
+      if (_state === undefined || _state === null || typeof _state !== 'object') return // Starting from v 4.1.31
+      if (node.currentHUEDevice === undefined || node.currentHUEDevice === null) return // Starting from v 4.1.31
+      if (_state.on !== undefined && typeof _state.on.on === 'boolean') { // Starting from v 4.1.31
+        if (node.currentHUEDevice.on === undefined || node.currentHUEDevice.on === null) node.currentHUEDevice.on = {} // Starting from v 4.1.31
+        node.currentHUEDevice.on.on = _state.on.on // Starting from v 4.1.31
+      } // Starting from v 4.1.31
+      if (_state.dimming !== undefined && _state.dimming !== null && _state.dimming.brightness !== undefined) { // Starting from v 4.1.31
+        if (node.currentHUEDevice.dimming === undefined || node.currentHUEDevice.dimming === null) node.currentHUEDevice.dimming = {} // Starting from v 4.1.31
+        node.currentHUEDevice.dimming.brightness = _state.dimming.brightness // Starting from v 4.1.31
+      } // Starting from v 4.1.31
+      if (_state.color !== undefined && _state.color !== null && _state.color.xy !== undefined) { // Starting from v 4.1.31
+        if (node.currentHUEDevice.color === undefined || node.currentHUEDevice.color === null) node.currentHUEDevice.color = {} // Starting from v 4.1.31
+        node.currentHUEDevice.color.xy = cloneDeep(_state.color.xy) // Starting from v 4.1.31
+      } // Starting from v 4.1.31
+      if (_state.color_temperature !== undefined && _state.color_temperature !== null && _state.color_temperature.mirek !== undefined) { // Starting from v 4.1.31
+        if (node.currentHUEDevice.color_temperature === undefined || node.currentHUEDevice.color_temperature === null) node.currentHUEDevice.color_temperature = {} // Starting from v 4.1.31
+        node.currentHUEDevice.color_temperature.mirek = _state.color_temperature.mirek // Starting from v 4.1.31
+      } // Starting from v 4.1.31
+    } // Starting from v 4.1.31
+
+    // Used to call the status update from the config node.
+    node.setNodeStatus = ({
+      fill, shape, text, payload
+    }) => {
+      try {
+        if (node.currentHUEDevice?.on?.on === true) { fill = 'blue'; shape = 'dot' } else { fill = 'blue'; shape = 'ring' };
+        if (payload === undefined) payload = ''
+        const dDate = new Date()
+        payload = typeof payload === 'object' ? JSON.stringify(payload) : payload.toString()
+        node.sKNXNodeStatusText = `|KNX: ${text} ${payload} (${formatTs(dDate)})`
+        node.status({ fill, shape, text: (node.sHUENodeStatusText || '') + ' ' + (node.sKNXNodeStatusText || '') })
+      } catch (error) { }
+    }
+    // Used to call the status update from the HUE config node.
+    node.setNodeStatusHue = ({ fill, shape, text, payload }) => {
+      try {
+        if (node.currentHUEDevice?.on?.on === true) { fill = 'blue'; shape = 'dot' } else { fill = 'blue'; shape = 'ring' };
+        if (payload === undefined) payload = ''
+        const dDate = new Date()
+        payload = typeof payload === 'object' ? JSON.stringify(payload) : payload.toString()
+        node.sHUENodeStatusText = `|HUE: ${text} ${payload} (${formatTs(dDate)})`
+        node.status({ fill, shape, text: node.sHUENodeStatusText + ' ' + (node.sKNXNodeStatusText || '') })
+      } catch (error) { }
+    }
+
+    node.writeHueState = function writeHueState (_state) {
+      const defaultOperation = node.isGrouped_light === false ? 'setLight' : 'setGroupedLight'
+      const isGroupedLightOff = node.isGrouped_light === true && node.currentHUEDevice?.on?.on === false
+      const stateKeys = _state && typeof _state === 'object' ? Object.keys(_state) : []
+      const presetKeys = ['dimming', 'color', 'color_temperature', 'gradient']
+      const actionableKeys = ['dimming', ...presetKeys]
+      const hasActionablePayload = stateKeys.some((key) => actionableKeys.includes(key))
+      const mustPresetGroupedLightChildren = isGroupedLightOff &&
+        stateKeys.some((key) => presetKeys.includes(key))
+
+      if (!mustPresetGroupedLightChildren) {
+        node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, _state, defaultOperation)
+        return
+      }
+
+      (async () => {
+        try {
+          const groupLights = await node.serverHue.getAllLightsBelongingToTheGroup(node.hueDevice, false)
+          RED.log.debug(`knxUltimateMatterControllerDevice: preset grouped_light children before group on. Group=${node.hueDevice} lights=${Array.isArray(groupLights) ? groupLights.length : 0}`)
+          let hasWrittenAtLeastOneLight = false
+          for (let index = 0; index < groupLights.length; index++) {
+            const light = groupLights[index]
+            if (!light?.id) continue
+            const lightState = {}
+            let hasActionableStateForLight = false
+
+            if (_state.dimming !== undefined && light.dimming !== undefined) {
+              lightState.dimming = cloneDeep(_state.dimming)
+              hasActionableStateForLight = true
+            }
+            if (_state.color !== undefined && light.color !== undefined) {
+              lightState.color = cloneDeep(_state.color)
+              hasActionableStateForLight = true
+            }
+            if (_state.color_temperature !== undefined && light.color_temperature !== undefined) {
+              lightState.color_temperature = cloneDeep(_state.color_temperature)
+              hasActionableStateForLight = true
+            }
+            if (_state.gradient !== undefined && light.gradient !== undefined) {
+              lightState.gradient = cloneDeep(_state.gradient)
+              hasActionableStateForLight = true
+            }
+
+            if (!hasActionableStateForLight) continue
+            node.serverHue.hueManager.writeHueQueueAdd(light.id, lightState, 'setLight')
+            hasWrittenAtLeastOneLight = true
+          }
+
+          if (!hasWrittenAtLeastOneLight || !hasActionablePayload) {
+            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, _state, defaultOperation)
+            return
+          }
+
+          if (_state?.on?.on !== true) return
+
+          const groupedLightState = { on: cloneDeep(_state.on) }
+          if (_state.dynamics !== undefined) groupedLightState.dynamics = cloneDeep(_state.dynamics)
+          RED.log.debug(`knxUltimateMatterControllerDevice: turning on grouped_light after children preset. Group=${node.hueDevice}`)
+          node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, groupedLightState, defaultOperation)
+        } catch (error) {
+          RED.log.debug(`knxUltimateMatterControllerDevice: node.writeHueState fallback to grouped_light write: ${error.message}`)
+          node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, _state, defaultOperation)
+        }
+      })()
+    }
+
+    node.deleteHueStateQueue = function deleteHueStateQueue () {
+      node.serverHue.hueManager.deleteHueQueue(node.hueDevice)
+      if (node.isGrouped_light !== true) return;
+
+      (async () => {
+        try {
+          const groupLights = await node.serverHue.getAllLightsBelongingToTheGroup(node.hueDevice, false)
+          for (let index = 0; index < groupLights.length; index++) {
+            const light = groupLights[index]
+            if (!light?.id) continue
+            node.serverHue.hueManager.deleteHueQueue(light.id)
+          }
+        } catch (error) {
+          RED.log.debug(`knxUltimateMatterControllerDevice: node.deleteHueStateQueue: ${error.message}`)
+        }
+      })()
+    }
+
+    function getRandomIntInclusive (min, max) {
+      min = Math.ceil(min)
+      max = Math.floor(max)
+      return Math.floor(Math.random() * (max - min + 1) + min) // The maximum is inclusive and the minimum is inclusive
+    }
+
+    // This function is called by the hue-config.js
+    node.handleSend = (msg) => {
+      if (!msg || !msg.knx || !isConfiguredKNXGA(msg.knx.destination)) return
+      if (node.currentHUEDevice === undefined && node.serverHue.linkStatus === 'connected') {
+        node.setNodeStatusHue({
+          fill: 'yellow',
+          shape: 'ring',
+          text: 'Initializing. Please wait.',
+          payload: ''
+        })
+        return
+      }
+      if (msg.knx.event !== 'GroupValue_Read' && node.currentHUEDevice !== undefined) {
+        let state = {}
+        try {
+          switch (msg.knx.destination) {
+            case config.GALightSwitch:
+              msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightSwitch))
+
+              // 15/05/2024 Supergiovane: check the Override to Day option
+              // config.restoreDayMode can be: no or setDayByFastSwitchLightSingle or setDayByFastSwitchLightALL
+              // ----------------------------------------------------------
+              if (config.restoreDayMode === 'setDayByFastSwitchLightSingle' || config.restoreDayMode === 'setDayByFastSwitchLightALL') {
+                if (node.DayTime === false) {
+                  if (msg.payload === true) {
+                    if (node.timerCheckForFastLightSwitch === null) {
+                      node.timerCheckForFastLightSwitch = setTimeout(() => {
+                        node.DayTime = false
+                        RED.log.debug('knxUltimateMatterControllerDevice: node.timerCheckForFastLightSwitch: set daytime to false after node.timerCheckForFastLightSwitch elapsed')
+                        node.timerCheckForFastLightSwitch = null
+                      }, 10000) // 10 seconds
+                    } else {
+                      if (config.restoreDayMode === 'setDayByFastSwitchLightALL') {
+                        // Turn off the Day/Night group address
+                        if (config.GADaylightSensor !== undefined && config.GADaylightSensor !== '') {
+                          if (node.timerCheckForFastLightSwitch !== null) { clearTimeout(node.timerCheckForFastLightSwitch); node.timerCheckForFastLightSwitch = null }
+                          RED.log.debug(`knxUltimateMatterControllerDevice: node.timerCheckForFastLightSwitch: set daytime the group address ${config.GADaylightSensor}`)
+                          node.serverKNX.sendKNXTelegramToKNXEngine({
+                            grpaddr: config.GADaylightSensor,
+                            payload: config.invertDayNight === false,
+                            dpt: config.dptDaylightSensor,
+                            outputtype: 'write',
+                            nodecallerid: node.id
+                          })
+                        }
+                      }
+                      node.DayTime = true
+                      RED.log.debug('knxUltimateMatterControllerDevice: node.timerCheckForFastLightSwitch: set daytime to true')
+                    }
+                  }
+                }
+              }
+              // ----------------------------------------------------------
+
+              if (msg.payload === true) {
+                // From HUE Api core concepts:
+                // If you try and control multiple conflicting parameters at once e.g. {"color": {"xy": {"x":0.5,"y":0.5}}, "color_temperature": {"mirek": 250}}
+                // the lights can only physically do one, for this we apply the rule that xy beats ct. Simple.
+                // color_temperature.mirek: color temperature in mirek is null when the light color is not in the ct spectrum
+                if ((node.DayTime === true && config.specifySwitchOnBrightness === 'no') && ((node.isGrouped_light === false && node.HUEDeviceWhileDaytime !== null) || (node.isGrouped_light === true && node.HUELightsBelongingToGroupWhileDaytime !== null))) {
+                  if (node.isGrouped_light === false && node.HUEDeviceWhileDaytime !== null) {
+                    // The DayNight has switched into day, so restore the previous light status
+                    state = { on: { on: true }, dimming: node.HUEDeviceWhileDaytime.dimming, color: node.HUEDeviceWhileDaytime.color, color_temperature: node.HUEDeviceWhileDaytime.color_temperature }
+                    if (node.HUEDeviceWhileDaytime.color_temperature !== undefined && node.HUEDeviceWhileDaytime.color_temperature.mirek === null) delete state.color_temperature // Otherwise the lamp will not turn on due to an error. color_temperature.mirek: color temperature in mirek is null when the light color is not in the ct spectrum
+                    node.writeHueState(state)
+                    node.setNodeStatusHue({
+                      fill: 'green',
+                      shape: 'dot',
+                      text: 'KNX->Matter',
+                      payload: 'Restore light status'
+                    })
+                    node.HUEDeviceWhileDaytime = null // Nullize the object.
+                  } else if (node.isGrouped_light === true && node.HUELightsBelongingToGroupWhileDaytime !== null) {
+                    // The DayNight has switched into day, so restore the previous light state, belonging to the group
+                    let bAtLeastOneIsOn = false
+                    for (let index = 0; index < node.HUELightsBelongingToGroupWhileDaytime.length; index++) { // Ensure, at least 1 lamp was on, otherwise turn all lamps on
+                      const element = node.HUELightsBelongingToGroupWhileDaytime[index].light[0]
+                      if (element.on.on === true) {
+                        bAtLeastOneIsOn = true
+                        break
+                      }
+                    }
+                    for (let index = 0; index < node.HUELightsBelongingToGroupWhileDaytime.length; index++) {
+                      const element = node.HUELightsBelongingToGroupWhileDaytime[index].light[0]
+                      if (bAtLeastOneIsOn === true) {
+                        state = { on: element.on, dimming: element.dimming, color: element.color, color_temperature: element.color_temperature }
+                      } else {
+                        // Failsafe all on
+                        state = { on: { on: true }, dimming: element.dimming, color: element.color, color_temperature: element.color_temperature }
+                      }
+                      if (element.color_temperature !== undefined && element.color_temperature.mirek === null) delete state.color_temperature // Otherwise the lamp will not turn on due to an error. color_temperature.mirek: color temperature in mirek is null when the light color is not in the ct spectrum
+                      node.serverHue.hueManager.writeHueQueueAdd(element.id, state, 'setLight')
+                    }
+                    node.setNodeStatusHue({
+                      fill: 'green',
+                      shape: 'dot',
+                      text: 'KNX->Matter',
+                      payload: "Resuming all group's light"
+                    })
+                    node.HUELightsBelongingToGroupWhileDaytime = null // Nullize the object.
+                    return
+                  }
+                } else {
+                  let colorChoosen
+                  let temperatureChoosen
+                  let brightnessChoosen
+                  // The light must support the temperature (in this case, colorAtSwitchOnNightTime is an object {kelvin:xx, brightness:yy})
+                  if (node.currentHUEDevice.color_temperature !== undefined) {
+                    if (node.DayTime === true && config.specifySwitchOnBrightness === 'temperature') {
+                      temperatureChoosen = config.colorAtSwitchOnDayTime.kelvin
+                    } else if (node.DayTime === false && config.enableDayNightLighting === 'temperature') {
+                      temperatureChoosen = config.colorAtSwitchOnNightTime.kelvin
+                    }
+                  }
+                  if (node.currentHUEDevice.dimming !== undefined) {
+                    // Check wether the user selected specific brightness at switch on (in this case, colorAtSwitchOnNightTime is an object {kelvin:xx, brightness:yy})
+                    if (node.DayTime === true && config.specifySwitchOnBrightness === 'temperature') {
+                      brightnessChoosen = config.colorAtSwitchOnDayTime.brightness
+                    } else if (node.DayTime === false && config.enableDayNightLighting === 'temperature') {
+                      brightnessChoosen = config.colorAtSwitchOnNightTime.brightness
+                    }
+                  }
+                  if (node.currentHUEDevice.color !== undefined) {
+                    // Check wether the user selected specific color at switch on (in this case, colorAtSwitchOnDayTime is a text with HTML web color)
+                    if (node.DayTime === true && config.specifySwitchOnBrightness === 'yes') {
+                      colorChoosen = config.colorAtSwitchOnDayTime
+                    } else if (node.DayTime === false && config.enableDayNightLighting === 'yes') {
+                      colorChoosen = config.colorAtSwitchOnNightTime
+                    }
+                  }
+                  // Create the HUE command
+                  if (colorChoosen !== undefined) {
+                    // Now we have a jColorChoosen. Proceed illuminating the light
+                    let gamut = null
+                    if (node.currentHUEDevice.color.gamut !== undefined) {
+                      gamut = node.currentHUEDevice.color.gamut
+                    }
+                    const dretXY = hueColorConverter.ColorConverter.calculateXYFromRGB(colorChoosen.red, colorChoosen.green, colorChoosen.blue, gamut)
+                    const dbright = hueColorConverter.ColorConverter.getBrightnessFromRGBOrHex(colorChoosen.red, colorChoosen.green, colorChoosen.blue)
+                    node.currentHUEDevice.dimming.brightness = Math.round(dbright, 0)
+                    if (node.currentHUEDevice.color !== undefined) node.currentHUEDevice.color.xy = dretXY // 26/03/2024
+                    node.updateKNXBrightnessState(node.currentHUEDevice.dimming.brightness)
+                    state = dbright > 0 ? { on: { on: true }, dimming: { brightness: dbright }, color: { xy: dretXY } } : { on: { on: false } }
+                    // state = { on: { on: true }, dimming: { brightness: dbright }, color: { xy: dretXY } };
+                  } else if (temperatureChoosen !== undefined) {
+                    // Kelvin
+                    const mirek = hueColorConverter.ColorConverter.kelvinToMirek(temperatureChoosen)
+                    node.currentHUEDevice.color_temperature.mirek = mirek
+                    node.currentHUEDevice.dimming.brightness = brightnessChoosen
+                    node.updateKNXBrightnessState(node.currentHUEDevice.dimming.brightness)
+                    // Kelvin temp
+                    state = brightnessChoosen > 0 ? { on: { on: true }, dimming: { brightness: brightnessChoosen }, color_temperature: { mirek } } : { on: { on: false } }
+                    // state = { on: { on: true }, dimming: { brightness: brightnessChoosen }, color_temperature: { mirek: mirek } };
+                  } else if (brightnessChoosen !== undefined) {
+                    state = brightnessChoosen > 0 ? { on: { on: true }, dimming: { brightness: brightnessChoosen } } : { on: { on: false } }
+                    // state = { on: { on: true }, dimming: { brightness: brightnessChoosen } };
+                  } else {
+                    state = { on: { on: true } }
+                  }
+                }
+              } else {
+                // Stop color cycle
+                if (node.timerColorCycle !== undefined) clearInterval(node.timerColorCycle)
+                // Stop Blinking
+                if (node.timerBlink !== undefined) clearInterval(node.timerBlink)
+                state = { on: { on: false } }
+              }
+
+              node.syncCurrentHUEDeviceFromKNXState(state) // Starting from v 4.1.31
+              node.writeHueState(state)
+              node.setNodeStatusHue({
+                fill: 'green',
+                shape: 'dot',
+                text: 'KNX->Matter',
+                payload: state
+              })
+              break
+            case config.GALightDIM:
+              // { decr_incr: 1, data: 1 } : Start increasing until { decr_incr: 0, data: 0 } is received.
+              // { decr_incr: 0, data: 1 } : Start decreasing until { decr_incr: 0, data: 0 } is received.
+              msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightDIM))
+              node.hueDimming(msg.payload.decr_incr, msg.payload.data, config.dimSpeed)
+              node.setNodeStatusHue({
+                fill: 'green', shape: 'dot', text: 'KNX->Matter', payload: JSON.stringify(msg.payload)
+              })
+              break
+            case config.GALightHSV_H_DIM:
+              // { decr_incr: 1, data: 1 } : Start increasing until { decr_incr: 0, data: 0 } is received.
+              // { decr_incr: 0, data: 1 } : Start decreasing until { decr_incr: 0, data: 0 } is received.
+              msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightDIM))
+              node.hueDimmingHSV_H(msg.payload.decr_incr, msg.payload.data, config.HSVDimSpeed)
+              node.setNodeStatusHue({
+                fill: 'green', shape: 'dot', text: 'KNX->Matter', payload: JSON.stringify(msg.payload)
+              })
+              break
+            case config.GALightHSV_S_DIM:
+              // { decr_incr: 1, data: 1 } : Start increasing until { decr_incr: 0, data: 0 } is received.
+              // { decr_incr: 0, data: 1 } : Start decreasing until { decr_incr: 0, data: 0 } is received.
+              msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightDIM))
+              node.hueDimmingHSV_S(msg.payload.decr_incr, msg.payload.data, config.HSVDimSpeed)
+              node.setNodeStatusHue({
+                fill: 'green', shape: 'dot', text: 'KNX->Matter', payload: JSON.stringify(msg.payload)
+              })
+              break
+            case config.GALightKelvin:
+              let retMirek
+              let kelvinValue = 0
+              msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightKelvin))
+              if (config.dptLightKelvin === '7.600') {
+                if (msg.payload > 6535) msg.payload = 6535
+                if (msg.payload < 2000) msg.payload = 2000
+                kelvinValue = msg.payload// hueColorConverter.ColorConverter.scale(msg.payload, [0, 65535], [2000, 6535]);
+                retMirek = hueColorConverter.ColorConverter.kelvinToMirek(kelvinValue)
+              } else if (config.dptLightKelvin === '9.002') {
+                // Relative temperature in Kelvin. Use HUE scale.
+                if (msg.payload > 6535) msg.payload = 6535
+                if (msg.payload < 2000) msg.payload = 2000
+                retMirek = hueColorConverter.ColorConverter.kelvinToMirek(msg.payload)
+              }
+              state = { color_temperature: { mirek: retMirek } }
+              node.syncCurrentHUEDeviceFromKNXState(state) // Starting from v 4.1.31
+              node.writeHueState(state)
+              node.setNodeStatusHue({
+                fill: 'green',
+                shape: 'dot',
+                text: 'KNX->Matter',
+                payload: kelvinValue
+              })
+              break
+            case config.GADaylightSensor:
+              node.DayTime = Boolean(dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptDaylightSensor)))
+              if (config.invertDayNight === true) node.DayTime = !node.DayTime
+              if (config.specifySwitchOnBrightness === 'no') {
+                // This retains the HUE device status while daytime, to be restored after nighttime elapsed. https://github.com/Supergiovane/node-red-contrib-knx-ultimate/issues/298
+                if (node.DayTime === false) {
+                  if (node.isGrouped_light === false) node.HUEDeviceWhileDaytime = cloneDeep(node.currentHUEDevice) // DayTime has switched to false: save the currentHUEDevice into the HUEDeviceWhileDaytime
+                  if (node.isGrouped_light === true) {
+                    (async () => {
+                      try {
+                        const retLights = await node.serverHue.getAllLightsBelongingToTheGroup(node.hueDevice, false)
+                        node.HUELightsBelongingToGroupWhileDaytime = cloneDeep(retLights) // DayTime has switched to false: save the lights belonging to the group into the HUELightsBelongingToGroupWhileDaytime array
+                      } catch (error) { /* empty */ }
+                    })()
+                  }
+                }
+              } else {
+                node.HUEDeviceWhileDaytime = null
+                node.HUELightsBelongingToGroupWhileDaytime = null
+              }
+              node.setNodeStatusHue({
+                fill: 'green',
+                shape: 'dot',
+                text: 'KNX->Matter Daytime',
+                payload: node.DayTime
+              })
+
+              break
+            case config.GALightKelvinDIM:
+              if (config.dptLightKelvinDIM === '3.007') {
+                // MDT smartbutton will dim the color temperature
+                // { decr_incr: 1, data: 1 } : Start increasing until { decr_incr: 0, data: 0 } is received.
+                // { decr_incr: 0, data: 1 } : Start decreasing until { decr_incr: 0, data: 0 } is received.
+                msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightKelvinDIM))
+                node.hueDimmingTunableWhite(msg.payload.decr_incr, msg.payload.data, 5000)
+                node.setNodeStatusHue({
+                  fill: 'green', shape: 'dot', text: 'KNX->Matter', payload: JSON.stringify(msg.payload)
+                })
+              }
+              break
+            case config.GALightKelvinPercentage:
+              if (config.dptLightKelvinPercentage === '5.001') {
+                // 0-100% tunable white
+                msg.payload = 100 - dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightKelvinPercentage))
+                // msg.payload = msg.payload <= 0 ? 1 : msg.payload
+                const retMirek = hueColorConverter.ColorConverter.scale(msg.payload, [0, 100], [153, 500])
+                msg.payload = retMirek
+                state = { color_temperature: { mirek: msg.payload } }
+                node.syncCurrentHUEDeviceFromKNXState(state) // Starting from v 4.1.31
+                node.writeHueState(state)
+                node.setNodeStatusHue({
+                  fill: 'green',
+                  shape: 'dot',
+                  text: 'KNX->Matter',
+                  payload: state
+                })
+              }
+              break
+            case config.GALightBrightness:
+              msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightBrightness))
+              if (typeof msg.payload !== 'number' || Number.isNaN(msg.payload)) throw new Error('Invalid KNX brightness payload')
+              state = { dimming: { brightness: msg.payload } }
+              if (msg.payload === 0) {
+                state.on = { on: false }
+              } else if (node.currentHUEDevice !== undefined && node.currentHUEDevice.on?.on === true) {
+                state.on = { on: true }
+              }
+              node.syncCurrentHUEDeviceFromKNXState(state) // Starting from v 4.1.31
+              node.writeHueState(state)
+              node.setNodeStatusHue({
+                fill: 'green',
+                shape: 'dot',
+                text: 'KNX->Matter',
+                payload: state
+              })
+              break
+            case config.GALightColor:
+              msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightColor))
+              let gamut = null
+              if (
+                node.currentHUEDevice !== undefined &&
+                node.currentHUEDevice.color !== undefined &&
+                node.currentHUEDevice.color.gamut !== undefined
+              ) {
+                gamut = node.currentHUEDevice.color.gamut
+              }
+              const retXY = hueColorConverter.ColorConverter.calculateXYFromRGB(msg.payload.red, msg.payload.green, msg.payload.blue, gamut)
+              const bright = hueColorConverter.ColorConverter.getBrightnessFromRGBOrHex(msg.payload.red, msg.payload.green, msg.payload.blue)
+              state = { dimming: { brightness: bright }, color: { xy: retXY } }
+              if (node.currentHUEDevice === undefined) {
+                // Grouped light
+                state.on = { on: bright > 0 }
+              } else {
+                // Light
+                if (node.currentHUEDevice.on.on === false && bright > 0) state.on = { on: true }
+                if (node.currentHUEDevice.on.on === true && bright === 0) state = { on: { on: false }, dimming: { brightness: bright } }
+              }
+              node.syncCurrentHUEDeviceFromKNXState(state) // Starting from v 4.1.31
+              node.writeHueState(state)
+              node.setNodeStatusHue({
+                fill: 'green',
+                shape: 'dot',
+                text: 'KNX->Matter',
+                payload: state
+              })
+              break
+            case config.GALightBlink:
+              const gaVal = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightBlink))
+              if (gaVal) {
+                node.timerBlink = setInterval(() => {
+                  if (node.blinkValue === undefined) node.blinkValue = true
+                  node.blinkValue = !node.blinkValue
+                  msg.payload = node.blinkValue
+                  // state = msg.payload === true ? { on: { on: true } } : { on: { on: false } }
+                  state = msg.payload === true
+                    ? { on: { on: true }, dimming: { brightness: 100 }, dynamics: { duration: 0 } }
+                    : { on: { on: false }, dimming: { brightness: 0 }, dynamics: { duration: 0 } }
+                  node.writeHueState(state)
+                }, 1500)
+              } else {
+                if (node.timerBlink !== undefined) clearInterval(node.timerBlink)
+                node.writeHueState({ on: { on: false } })
+              }
+              node.setNodeStatusHue({
+                fill: 'green',
+                shape: 'dot',
+                text: 'KNX->Matter',
+                payload: gaVal
+              })
+              break
+            case config.GALightColorCycle:
+              {
+                if (node.timerColorCycle !== undefined) clearInterval(node.timerColorCycle)
+                const gaValColorCycle = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightColorCycle))
+                if (gaValColorCycle === true) {
+                  node.writeHueState({ on: { on: true } })
+                  node.timerColorCycle = setInterval(() => {
+                    try {
+                      const red = getRandomIntInclusive(0, 255)
+                      const green = getRandomIntInclusive(0, 255)
+                      const blue = getRandomIntInclusive(0, 255)
+                      let gamut = null
+                      if (
+                        node.currentHUEDevice !== undefined &&
+                        node.currentHUEDevice.color !== undefined &&
+                        node.currentHUEDevice.color.gamut !== undefined
+                      ) {
+                        gamut = node.currentHUEDevice.color.gamut
+                      }
+                      const retXY = hueColorConverter.ColorConverter.calculateXYFromRGB(red, green, blue, gamut)
+                      const bright = hueColorConverter.ColorConverter.getBrightnessFromRGBOrHex(red, green, blue)
+                      state = bright > 0 ? { on: { on: true }, dimming: { brightness: bright }, color: { xy: retXY } } : { on: { on: false } }
+                      node.writeHueState(state)
+                    } catch (error) { }
+                  }, 10000)
+                } else {
+                  if (node.timerColorCycle !== undefined) clearInterval(node.timerColorCycle)
+                  node.writeHueState({ on: { on: false } })
+                }
+                node.setNodeStatusHue({
+                  fill: 'green',
+                  shape: 'dot',
+                  text: 'KNX->Matter',
+                  payload: gaValColorCycle
+                })
+              }
+              break
+            default:
+              break
+          }
+        } catch (error) {
+          node.status({
+            fill: 'red',
+            shape: 'dot',
+            text: `KNX->Matter errorRead ${error.message} (${formatTs(new Date())})`
+          })
+          RED.log.error(`knxUltimateMatterControllerDevice: node.handleSend:  if (msg.knx.event !== "GroupValue_Read"): ${error.message} : ${error.stack || ''} `)
+        }
+      }
+
+      // I must respond to query requests (read request) sent from the KNX BUS
+      try {
+        if (msg.knx.event === 'GroupValue_Read' && node.currentHUEDevice !== undefined) {
+          const zeroBrightnessWhenOff = (config.updateKNXBrightnessStatusOnHUEOnOff === undefined || config.updateKNXBrightnessStatusOnHUEOnOff === 'onhueoff')
+          let ret
+          switch (msg.knx.destination) {
+            case config.GALightState:
+              ret = node.currentHUEDevice.on.on
+              if (ret !== undefined) node.updateKNXLightState(ret, 'response')
+              break
+            case config.GALightColorState:
+              ret = node.currentHUEDevice.color.xy
+              if (ret !== undefined) node.updateKNXLightColorState(node.currentHUEDevice.color, 'response')
+              break
+            case config.GALightKelvinPercentageState:
+              // The kelvin level belongs to the group defice, so i don't need to get the first light in the collection (if the device is a grouped_light)
+              ret = node.currentHUEDevice.color_temperature.mirek
+              if (ret !== undefined) node.updateKNXLightKelvinPercentageState(ret, 'response')
+              // if (node.isGrouped_light === false) {
+              //   ret = node.currentHUEDevice.color_temperature.mirek;
+              //   if (ret !== undefined) node.updateKNXLightKelvinPercentageState(ret, "response");
+              // } else {
+              //   (async () => {
+              //     try {
+              //       // Find the first light in the collection, having the color_temperature capabilities
+              //       const devices = await node.serverHue.getAllLightsBelongingToTheGroup(node.hueDevice, false);
+              //       for (let index = 0; index < devices.length; index++) {
+              //         const element = devices[index];
+              //         if (element.light[0].color_temperature !== undefined) {
+              //           ret = element.light[0].color_temperature.mirek;
+              //           break;
+              //         }
+              //       }
+              //       if (ret !== undefined) node.updateKNXLightKelvinPercentageState(ret, "response");
+              //     } catch (error) { /* empty */ }
+              //   })();
+              // }
+              break
+            case config.GALightBrightnessState:
+              // Hue keeps the last brightness even when the light is OFF. If the user enabled "brightness status -> 0 on HUE off",
+              // keep returning 0 while OFF to avoid the KNX status jumping back to the last/start value after some time/read-requests.
+              if (zeroBrightnessWhenOff === true && node.currentHUEDevice?.on?.on === false) {
+                ret = 0
+              } else {
+                ret = node.currentHUEDevice.dimming.brightness
+              }
+              if (ret !== undefined) node.updateKNXBrightnessState(ret, 'response')
+              break
+            case config.GALightKelvinState:
+              // The kelvin level belongs to the group defice, so i don't need to get the first light in the collection (if the device is a grouped_light)
+              ret = node.currentHUEDevice.color_temperature.mirek
+              if (ret !== undefined) node.updateKNXLightKelvinState(ret, 'response')
+              // if (node.isGrouped_light === false) {
+              //   ret = node.currentHUEDevice.color_temperature.mirek;
+              //   if (ret !== undefined) node.updateKNXLightKelvinState(ret, "response");
+              // } else {
+              //   (async () => {
+              //     try {
+              //       // Find the first light in the collection, having the color_temperature capabilities
+              //       const devices = await node.serverHue.getAllLightsBelongingToTheGroup(node.hueDevice, false);
+              //       for (let index = 0; index < devices.length; index++) {
+              //         const element = devices[index];
+              //         if (element.light[0].color_temperature !== undefined) {
+              //           ret = element.light[0].color_temperature.mirek;
+              //           break;
+              //         }
+              //       }
+              //       if (ret !== undefined) node.updateKNXLightKelvinState(ret, "response");
+              //     } catch (error) { /* empty */ }
+              //   })();
+              // }
+              break
+            default:
+              break
+          }
+        }
+      } catch (error) {
+        node.status({
+          fill: 'red',
+          shape: 'dot',
+          text: `KNX->Matter error :-( ${error.message} (${formatTs(new Date())})`
+        })
+        RED.log.error(`knxUltimateMatterControllerDevice: node.handleSend: if (msg.knx.event === "GroupValue_Read" && node.currentHUEDevice !== undefined): ${error.message} : ${error.stack || ''} `)
+      }
+    }
+
+    // Start dimming
+    // ***********************************************************
+    node.hueDimming = function hueDimming (_KNXaction, _KNXbrightness_Direction, _dimSpeedInMillisecs = undefined) {
+      // 31/10/2023 after many attempts to use dimming_delta function of the HueApeV2, loosing days of my life, without a decent success, will use the standard dimming calculations
+      // i decide to go to the "step brightness" way.
+      try {
+        let hueTelegram = {}
+        let numStep = 10 // Steps from 0 to 100 by 10
+        const extendedConf = {}
+
+        if (_KNXbrightness_Direction === 0 && _KNXaction === 0) {
+          // STOP DIM
+          if (node.timerStepDim !== undefined) clearInterval(node.timerStepDim)
+          node.brightnessStep = null
+          node.deleteHueStateQueue() // Clear dimming queue.
+          return
+        }
+
+        // 26/03/2024 set the extended configuration as well, because the light was off (so i've been unable to set it up elsewhere)
+        if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false) {
+          // if (node.currentHUEDevice.color !== undefined) extendedConf.color = { xy: node.currentHUEDevice.color.xy }; // DO NOT ADD THE COLOR, BECAUSE THE COLOR HAS ALSO THE BRIGHTNESS, SO ALL THE DATA NEEDED TO BE SWITCHED ON CORRECLY
+          if (node.currentHUEDevice.color_temperature !== undefined) extendedConf.color_temperature = { mirek: node.currentHUEDevice.color_temperature.mirek }
+        }
+
+        // If i'm dimming up while the light is off, start the dim with the initial brightness set to zero
+        if (_KNXbrightness_Direction > 0 && _KNXaction === 1 && node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false) {
+          node.brightnessStep = null
+          node.currentHUEDevice.dimming.brightness = 0
+        }
+
+        // Set the actual brightness to start with
+        if (node.brightnessStep === null || node.brightnessStep === undefined) node.brightnessStep = node.currentHUEDevice.dimming.brightness !== undefined ? node.currentHUEDevice.dimming.brightness : 50
+        node.brightnessStep = Math.ceil(Number(node.brightnessStep))
+
+        // We have also minDimLevelLight and maxDimLevelLight to take care of.
+        let minDimLevelLight
+        if (config.minDimLevelLight === undefined) {
+          minDimLevelLight = 10
+        } else if (config.minDimLevelLight === 'useHueLightLevel') {
+          minDimLevelLight = node.currentHUEDevice.dimming.min_dim_level === undefined ? 10 : node.currentHUEDevice.dimming.min_dim_level
+        } else {
+          minDimLevelLight = Number(config.minDimLevelLight)
+        }
+        const maxDimLevelLight = config.maxDimLevelLight === undefined ? 100 : Number(config.maxDimLevelLight)
+
+        // Set the speed
+        _dimSpeedInMillisecs /= numStep
+        numStep = Math.round((maxDimLevelLight - minDimLevelLight) / numStep, 0)
+
+        if (_KNXbrightness_Direction > 0 && _KNXaction === 1) {
+          // DIM UP
+          if (node.timerStepDim !== undefined) clearInterval(node.timerStepDim)
+          node.timerStepDim = setInterval(() => {
+            node.updateKNXBrightnessState(node.brightnessStep) // Unnecessary, but necessary to set the KNX Status in real time.
+            node.brightnessStep += numStep
+            if (node.brightnessStep > maxDimLevelLight) node.brightnessStep = maxDimLevelLight
+            hueTelegram = { dimming: { brightness: node.brightnessStep }, dynamics: { duration: _dimSpeedInMillisecs + 500 } } // + is to avoid ladder effect
+            // Switch on the light if off
+            if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false) {
+              hueTelegram.on = { on: true }
+              Object.assign(hueTelegram, extendedConf) // 26/03/2024 add extended conf
+            }
+            // console.log(hueTelegram)
+            node.writeHueState(hueTelegram)
+            if (node.brightnessStep >= maxDimLevelLight) clearInterval(node.timerStepDim)
+          }, _dimSpeedInMillisecs)
+        }
+        if (_KNXbrightness_Direction > 0 && _KNXaction === 0) {
+          if (node.currentHUEDevice.on.on === false) return // Don't dim down, if the light is already off.
+          // DIM DOWN
+          if (node.timerStepDim !== undefined) clearInterval(node.timerStepDim)
+          node.timerStepDim = setInterval(() => {
+            node.updateKNXBrightnessState(node.brightnessStep) // Unnecessary, but necessary to set the KNX Status in real time.
+            node.brightnessStep -= numStep
+            if (node.brightnessStep < minDimLevelLight) node.brightnessStep = minDimLevelLight
+            hueTelegram = { dimming: { brightness: node.brightnessStep }, dynamics: { duration: _dimSpeedInMillisecs + 500 } }// + 100 is to avoid ladder effect
+            // Switch off the light if on
+            if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === true && node.brightnessStep === 0) {
+              hueTelegram.on = { on: false }
+            }
+            node.writeHueState(hueTelegram)
+            if (node.brightnessStep <= minDimLevelLight) clearInterval(node.timerStepDim)
+          }, _dimSpeedInMillisecs)
+        }
+      } catch (error) { }
+    }
+    // ***********************************************************
+
+    // Start dimming tunable white
+    // mirek: required(integer minimum: 153, maximum: 500)
+    // ***********************************************************
+    node.hueDimmingTunableWhite = function hueDimmingTunableWhite (_KNXaction, _KNXbrightness_DirectionTunableWhite, _dimSpeedInMillisecsTunableWhite = undefined) {
+      // 23/23/2023 after many attempts to use dimming_delta function of the HueApeV2, loosing days of my life, without a decent success, will use the standard dimming calculations
+      // i decide to go to the "step brightness" way.
+      try {
+        if (_KNXbrightness_DirectionTunableWhite === 0 && _KNXaction === 0) {
+          // STOP DIM
+          if (node.timerStepDimTunableWhite !== undefined) clearInterval(node.timerStepDimTunableWhite)
+          node.brightnessStepTunableWhite = null
+          node.deleteHueStateQueue() // Clear dimming queue.
+          return
+        }
+
+        let numStepTunableWhite = 10 // Steps from 153 to 500
+        if (config.invertDimTunableWhiteDirection === true) {
+          if (_KNXaction === 1) { _KNXaction = 0 } else { _KNXaction = 1 }
+        }
+
+        // Set the actual brightness to start with
+        if (node.brightnessStepTunableWhite === null || node.brightnessStepTunableWhite === undefined) node.brightnessStepTunableWhite = node.currentHUEDevice.color_temperature.mirek || 372
+        node.brightnessStepTunableWhite = Math.ceil(Number(node.brightnessStepTunableWhite))
+
+        // Set the speed
+        _dimSpeedInMillisecsTunableWhite = Math.ceil(_dimSpeedInMillisecsTunableWhite / numStepTunableWhite)
+
+        const minDimLevelLightTunableWhite = 153
+        const maxDimLevelLightTunableWhite = 500
+        // numStepTunableWhite = hueColorConverter.ColorConverter.scale(numStepTunableWhite, [0, 100], [minDimLevelLightTunableWhite, maxDimLevelLightTunableWhite]);
+        // numStepTunableWhite = hueColorConverter.ColorConverter.scale(numStepTunableWhite, [node.brightnessStepTunableWhite, maxDimLevelLightTunableWhite], [node.brightnessStepTunableWhite, maxDimLevelLightTunableWhite]);
+        numStepTunableWhite = Math.round((maxDimLevelLightTunableWhite - minDimLevelLightTunableWhite) / numStepTunableWhite, 0)
+
+        if (_KNXbrightness_DirectionTunableWhite > 0 && _KNXaction === 1) {
+          // DIM UP
+          if (node.timerStepDimTunableWhite !== undefined) clearInterval(node.timerStepDimTunableWhite)
+          node.timerStepDimTunableWhite = setInterval(() => {
+            node.updateKNXLightKelvinPercentageState(node.brightnessStepTunableWhite) // Unnecessary, but necessary to set the KNX Status in real time.
+            node.brightnessStepTunableWhite += numStepTunableWhite // *2 to speed up the things
+            if (node.brightnessStepTunableWhite > maxDimLevelLightTunableWhite) node.brightnessStepTunableWhite = maxDimLevelLightTunableWhite
+            const hueTelegram = { color_temperature: { mirek: node.brightnessStepTunableWhite }, dynamics: { duration: _dimSpeedInMillisecsTunableWhite } }
+            // Switch on the light if off
+            if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false) {
+              hueTelegram.on = { on: true }
+            }
+            node.writeHueState(hueTelegram)
+            if (node.brightnessStepTunableWhite >= maxDimLevelLightTunableWhite) clearInterval(node.timerStepDimTunableWhite)
+          }, _dimSpeedInMillisecsTunableWhite)
+        }
+        if (_KNXbrightness_DirectionTunableWhite > 0 && _KNXaction === 0) {
+          if (node.currentHUEDevice.on.on === false) return // Don't dim down, if the light is already off.
+          // DIM DOWN
+          if (node.timerStepDimTunableWhite !== undefined) clearInterval(node.timerStepDimTunableWhite)
+          node.timerStepDimTunableWhite = setInterval(() => {
+            node.updateKNXLightKelvinPercentageState(node.brightnessStepTunableWhite) // Unnecessary, but necessary to set the KNX Status in real time.
+            node.brightnessStepTunableWhite -= numStepTunableWhite // *2 to speed up the things
+            if (node.brightnessStepTunableWhite < minDimLevelLightTunableWhite) node.brightnessStepTunableWhite = minDimLevelLightTunableWhite
+            const hueTelegram = { color_temperature: { mirek: node.brightnessStepTunableWhite }, dynamics: { duration: _dimSpeedInMillisecsTunableWhite } }
+            // Switch off the light if on
+            if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === true && node.brightnessStepTunableWhite === 0) {
+              hueTelegram.on = { on: false }
+            }
+            node.writeHueState(hueTelegram)
+            if (node.brightnessStepTunableWhite <= minDimLevelLightTunableWhite) clearInterval(node.timerStepDimTunableWhite)
+          }, _dimSpeedInMillisecsTunableWhite)
+        }
+      } catch (error) { }
+    }
+    // ***********************************************************
+
+    /**
+  * Starts dimming / stop dimming of the HUE
+  * @param {number} _KNXaction 1 for start, 0 for stop
+  * @param {number} _KNXbrightness_DirectionHSV_H 1 for up, 0 for down
+  * @param {number} _dimSpeedInMillisecsHSV Speed time in milliseconds
+  * @returns {}
+  */
+    node.hueDimmingHSV_H = function hueDimmingHSV_H (_KNXaction, _KNXbrightness_DirectionHSV_H, _dimSpeedInMillisecsHSV = undefined) {
+      // After many attempts to use dimming_delta function of the HueApiV2, loosing days of my life, without a decent success, will use the standard dimming calculations
+      // i decide to go to the "step brightness" way.
+      try {
+        if (_KNXbrightness_DirectionHSV_H === 0 && _KNXaction === 0) {
+          // STOP DIM
+          if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H)
+          node.deleteHueStateQueue() // Clear dimming queue.
+          return
+        }
+
+        let xyBrightnessToHsv
+        if (node.currentHUEDevice.color !== undefined && node.currentHUEDevice.color.xy !== undefined) {
+          // Get the XY + brightness from the lamp and transform it into HSV
+          // xyBrightnessToHsv = hueColorConverter.ColorConverter.xyBrightnessToHsv(node.currentHUEDevice.color.xy.x, node.currentHUEDevice.color.xy.y, node.currentHUEDevice.dimming.brightness);
+          xyBrightnessToHsv = hueColorConverter.ColorConverter.xyBrightnessToHsv(hueColorConverter.ColorConverter.scale(node.currentHUEDevice.color.xy.x, [0, 1], [0, 100]), hueColorConverter.ColorConverter.scale(node.currentHUEDevice.color.xy.y, [0, 1], [0, 100]), node.currentHUEDevice.dimming.brightness)
+        } else {
+          return // Something wrong here.
+        }
+        let numStepHSV_H = 10 // Steps from 0 to 100
+
+        // Set the actual brightness to start with
+        if (node.brightnessStepHSV_H === null || node.brightnessStepHSV_H === undefined) node.brightnessStepHSV_H = node.currentHUEDevice.dimming.brightness
+        node.brightnessStepHSV_H = Math.ceil(Number(node.brightnessStepHSV_H))
+
+        const minDimLevelLightHSV_H = 1
+        const maxDimLevelLightHSV_H = 100
+        numStepHSV_H = Math.round((maxDimLevelLightHSV_H - minDimLevelLightHSV_H) / numStepHSV_H, 0)
+        // Set the speed
+        _dimSpeedInMillisecsHSV = Math.ceil(_dimSpeedInMillisecsHSV / (maxDimLevelLightHSV_H / numStepHSV_H))
+
+        if (_KNXbrightness_DirectionHSV_H > 0 && _KNXaction === 1) {
+          // DIM UP
+          if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H)
+          node.timerStepDimHSV_H = setInterval(() => {
+            node.deleteHueStateQueue() // Clear dimming queue.
+            node.brightnessStepHSV_H += numStepHSV_H
+            if (node.brightnessStepHSV_H > maxDimLevelLightHSV_H) node.brightnessStepHSV_H = maxDimLevelLightHSV_H
+            // node.updateKNXLightHSV_H_State(node.brightnessStepHSV_H); // Unnecessary, but necessary to set the KNX Status in real time.
+            xyBrightnessToHsv.h = node.brightnessStepHSV_H
+            const hsvToXYBri = hueColorConverter.ColorConverter.hsvToxyBrightness(xyBrightnessToHsv, node.currentHUEDevice.color.gamut)
+            const hueTelegram = { color: { xy: { x: hsvToXYBri.x, y: hsvToXYBri.y } }, dynamics: { duration: _dimSpeedInMillisecsHSV + 500 } } // Add some ms, to prevent the "ladder" step effect.
+            // Switch on the light if off
+            if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false) {
+              hueTelegram.on = { on: true }
+            }
+            node.currentHUEDevice.color.xy = hsvToXYBri// Unnecessary, but necessary to set the KNX Status in real time.
+            node.updateKNXLightColorState(node.currentHUEDevice.color)
+            node.writeHueState(hueTelegram)
+            if (node.brightnessStepHSV_H >= maxDimLevelLightHSV_H) {
+              if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H)
+            }
+          }, _dimSpeedInMillisecsHSV)
+        }
+        if (_KNXbrightness_DirectionHSV_H > 0 && _KNXaction === 0) {
+          if (node.currentHUEDevice.on.on === false) return // Don't dim down, if the light is already off.
+          // DIM DOWN
+          if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H)
+          node.timerStepDimHSV_H = setInterval(() => {
+            node.deleteHueStateQueue() // Clear dimming queue.
+            node.brightnessStepHSV_H -= numStepHSV_H // *2 to speed up the things
+            if (node.brightnessStepHSV_H < minDimLevelLightHSV_H) node.brightnessStepHSV_H = minDimLevelLightHSV_H
+            // node.updateKNXLightHSV_H_State(node.brightnessStepHSV_H); // Unnecessary, but necessary to set the KNX Status in real time.
+            // Produco l'RGB
+            xyBrightnessToHsv.h = node.brightnessStepHSV_H
+            const hsvToXYBri = hueColorConverter.ColorConverter.hsvToxyBrightness(xyBrightnessToHsv, node.currentHUEDevice.color.gamut)
+            const hueTelegram = { color: { xy: { x: hsvToXYBri.x, y: hsvToXYBri.y } }, dynamics: { duration: _dimSpeedInMillisecsHSV + 500 } }
+            // Switch off the light if on
+            if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === true && node.brightnessStepHSV_H === 0) {
+              hueTelegram.on = { on: false }
+            }
+            node.currentHUEDevice.color.xy = hsvToXYBri// Unnecessary, but necessary to set the KNX Status in real time.
+            node.updateKNXLightColorState(node.currentHUEDevice.color)
+            node.writeHueState(hueTelegram)
+            if (node.brightnessStepHSV_H <= minDimLevelLightHSV_H) {
+              if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H)
+            }
+          }, _dimSpeedInMillisecsHSV)
+        }
+      } catch (error) { /* empty */ }
+    }
+    /**
+  * Starts dimming / stop dimming of the Saturation
+  * @param {number} _KNXaction 1 for start, 0 for stop
+  * @param {number} _KNXbrightness_DirectionHSV_S 1 for up, 0 for down
+  * @param {number} _dimSpeedInMillisecsHSV Speed time in milliseconds
+  * @returns {}
+  */
+    node.hueDimmingHSV_S = function hueDimmingHSV_S (_KNXaction, _KNXbrightness_DirectionHSV_S, _dimSpeedInMillisecsHSV = undefined) {
+      // After many attempts to use dimming_delta function of the HueApiV2, loosing days of my life, without a decent success, will use the standard dimming calculations
+      // i decide to go to the "step brightness" way.
+      try {
+        if (_KNXbrightness_DirectionHSV_S === 0 && _KNXaction === 0) {
+          // STOP DIM
+          if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S)
+          node.deleteHueStateQueue() // Clear dimming queue.
+          return
+        }
+
+        let xyBrightnessToHsv
+        if (node.currentHUEDevice.color !== undefined && node.currentHUEDevice.color.xy !== undefined) {
+          // Get the XY + brightness from the lamp and transform it into HSV
+          xyBrightnessToHsv = hueColorConverter.ColorConverter.xyBrightnessToHsv(hueColorConverter.ColorConverter.scale(node.currentHUEDevice.color.xy.x, [0, 1], [0, 100]), hueColorConverter.ColorConverter.scale(node.currentHUEDevice.color.xy.y, [0, 1], [0, 100]), node.currentHUEDevice.dimming.brightness)
+        } else {
+          return // Something wrong here.
+        }
+        let numStepHSV_S = 10 // Steps from 0 to 100
+
+        // Set the actual brightness to start with
+        if (node.brightnessStepHSV_S === null || node.brightnessStepHSV_S === undefined) node.brightnessStepHSV_S = node.currentHUEDevice.dimming.brightness
+        node.brightnessStepHSV_S = Math.ceil(Number(node.brightnessStepHSV_S))
+
+        const minDimLevelLightHSV_S = 1
+        const maxDimLevelLightHSV_S = 100
+        numStepHSV_S = Math.round((maxDimLevelLightHSV_S - minDimLevelLightHSV_S) / numStepHSV_S, 0)
+        // Set the speed
+        _dimSpeedInMillisecsHSV = Math.ceil(_dimSpeedInMillisecsHSV / (maxDimLevelLightHSV_S / numStepHSV_S))
+
+        if (_KNXbrightness_DirectionHSV_S > 0 && _KNXaction === 1) {
+          // DIM UP
+          if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S)
+          node.timerStepDimHSV_S = setInterval(() => {
+            node.deleteHueStateQueue() // Clear dimming queue.
+            node.brightnessStepHSV_S += numStepHSV_S
+            if (node.brightnessStepHSV_S > maxDimLevelLightHSV_S) node.brightnessStepHSV_S = maxDimLevelLightHSV_S
+            // node.updateKNXLightHSV_S_State(node.brightnessStepHSV_S); // Unnecessary, but necessary to set the KNX Status in real time.
+            xyBrightnessToHsv.s = node.brightnessStepHSV_S
+            const hsvToXYBri = hueColorConverter.ColorConverter.hsvToxyBrightness(xyBrightnessToHsv, node.currentHUEDevice.color.gamut)
+            const hueTelegram = { color: { xy: { x: hsvToXYBri.x, y: hsvToXYBri.y } }, dynamics: { duration: _dimSpeedInMillisecsHSV + 500 } } // Add some ms, to prevent the "ladder" step effect.
+            // Switch on the light if off
+            if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false) {
+              hueTelegram.on = { on: true }
+            }
+            node.currentHUEDevice.color.xy = cloneDeep(hsvToXYBri)// Unnecessary, but necessary to set the KNX Status in real time.
+            node.updateKNXLightColorState(node.currentHUEDevice.color)
+            node.writeHueState(hueTelegram)
+            if (node.brightnessStepHSV_S >= maxDimLevelLightHSV_S) {
+              if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S)
+            }
+          }, _dimSpeedInMillisecsHSV)
+        }
+        if (_KNXbrightness_DirectionHSV_S > 0 && _KNXaction === 0) {
+          if (node.currentHUEDevice.on.on === false) return // Don't dim down, if the light is already off.
+          // DIM DOWN
+          if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S)
+          node.timerStepDimHSV_S = setInterval(() => {
+            node.deleteHueStateQueue() // Clear dimming queue.
+            node.brightnessStepHSV_S -= numStepHSV_S // *2 to speed up the things
+            if (node.brightnessStepHSV_S < minDimLevelLightHSV_S) node.brightnessStepHSV_S = minDimLevelLightHSV_S
+            // node.updateKNXLightHSV_S_State(node.brightnessStepHSV_S); // Unnecessary, but necessary to set the KNX Status in real time.
+            // Produco l'RGB
+            xyBrightnessToHsv.s = node.brightnessStepHSV_S
+            const hsvToXYBri = hueColorConverter.ColorConverter.hsvToxyBrightness(xyBrightnessToHsv, node.currentHUEDevice.color.gamut)
+            const hueTelegram = { color: { xy: { x: hsvToXYBri.x, y: hsvToXYBri.y } }, dynamics: { duration: _dimSpeedInMillisecsHSV + 500 } }
+            // Switch off the light if on
+            if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === true && node.brightnessStepHSV_S === 0) {
+              hueTelegram.on = { on: false }
+            }
+            node.currentHUEDevice.color.xy = cloneDeep(hsvToXYBri)// Unnecessary, but necessary to set the KNX Status in real time.
+            node.updateKNXLightColorState(node.currentHUEDevice.color)
+            node.writeHueState(hueTelegram)
+            if (node.brightnessStepHSV_S <= minDimLevelLightHSV_S) {
+              if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S)
+            }
+          }, _dimSpeedInMillisecsHSV)
+        }
+      } catch (error) { /* empty */ }
+    }
+    // ***********************************************************
+
+    node.handleSendHUE = async (_event) => {
+      if (_event === undefined) return
+      if (_event.type !== 'grouped_light' && _event.type !== 'light') return
+
+      // !!!! >>> if the node is a grouped_light, the only values required, thus present, by HUE apis are "on" and "dimming".
+      // !!!! >>> For all others properties like for example color and tunable white, i must get the data from one of the child lights.
+
+      // (async () => {
+      try {
+        if (node.currentHUEDevice === undefined || node.serverHue === null || node.serverHue === undefined) {
+          node.setNodeStatusHue({
+            fill: 'red',
+            shape: 'ring',
+            text: "Rejected HUE light settings. I'm still not ready...",
+            payload: ''
+          })
+          return
+        }
+
+        const receivedHUEObject = cloneDeep(_event)
+
+        // #region "CALCULATE COLOR AND COLOR TEMPERATURE OF THE LIGHTS BELONGING TO THE GROUPED_LIGHT"
+        // Check wether the incoming _event belongs to a light belonging to the group_light
+        if (node.isGrouped_light === true && receivedHUEObject.type === 'light') {
+          // Handling of not by HUE handled Color Temperature and ColorXY
+          let modifiedLight
+          const groupChilds = []
+          let AverageColorsXYBrightnessAndTemperature // Average color xy and color temp if the node is a grouped light.
+          // If the current node is a grouped lights, i must check wether the receivedHUEObject (containing a light) belongs to the node lights collection.
+          // Find all the lights in the collection, having the color_temperature capabilities, belonging to the group.
+          const devices = await node.serverHue.getAllLightsBelongingToTheGroup(node.hueDevice, false)
+          if (devices.length === 0) {
+            devices.push(receivedHUEObject)
+          }
+
+          for (let index = 0; index < devices.length; index++) {
+            const element = devices[index]
+            if (receivedHUEObject.id === element.id) {
+              modifiedLight = element
+              // The dimming is not necessary, beacause the HUE API already sends a group_light event with the average brightness //if (receivedHUEObject.dimming !== undefined) modifiedLight.dimming = { brightness: receivedHUEObject.dimming.brightness };
+              if (receivedHUEObject.color !== undefined && receivedHUEObject.color.xy !== undefined) modifiedLight.color = receivedHUEObject.color
+              if (receivedHUEObject.color_temperature !== undefined) modifiedLight.color_temperature = receivedHUEObject.color_temperature
+              groupChilds.push(modifiedLight)
+            } else {
+              // Simply append the light
+              if ((element.color_temperature !== undefined && element.color_temperature.mirek !== undefined) ||
+                (element.color !== undefined && element.color.xy !== undefined)) {
+                groupChilds.push(element)
+              }
+            }
+          }
+
+          // Use the arithmetic average of color xy, brightness and color temperature "averageColorXYandKelvinOfGroupedLights"
+          if (groupChilds !== undefined) AverageColorsXYBrightnessAndTemperature = await node.serverHue.getAverageColorsXYBrightnessAndTemperature(groupChilds)
+
+          // Set the new values based on average calculated above
+          // CHECK FIRST THE COLOR_TEMPERATURE, because it can be undefined, because the current selected color
+          // is out of the mirek range, so it cannot be represented with the colore temperature.
+          if (receivedHUEObject.color_temperature !== undefined && AverageColorsXYBrightnessAndTemperature.mirek !== undefined && receivedHUEObject.color_temperature.mirel_valid === true) {
+            receivedHUEObject.color_temperature.mirek = AverageColorsXYBrightnessAndTemperature.mirek
+            node.currentHUEDevice.color_temperature = { mirek: AverageColorsXYBrightnessAndTemperature.mirek }
+            node.updateKNXLightKelvinPercentageState(receivedHUEObject.color_temperature.mirek)
+            node.updateKNXLightKelvinState(receivedHUEObject.color_temperature.mirek)
+          } else if (receivedHUEObject.color !== undefined && receivedHUEObject.color.xy !== undefined && AverageColorsXYBrightnessAndTemperature.x !== undefined) {
+            receivedHUEObject.color.xy.x = AverageColorsXYBrightnessAndTemperature.x
+            receivedHUEObject.color.xy.y = AverageColorsXYBrightnessAndTemperature.y
+            node.currentHUEDevice.color = { xy: { x: AverageColorsXYBrightnessAndTemperature.x, y: AverageColorsXYBrightnessAndTemperature.y } }
+            node.updateKNXLightColorState(receivedHUEObject.color)
+          }
+          // The dimming is not necessary, beacause the HUE API already sends a group_light event with the average brightness
+          // if (receivedHUEObject.dimming !== undefined && AverageColorsXYBrightnessAndTemperature.brightness !== undefined) {
+          //   receivedHUEObject.dimming = { brightness: AverageColorsXYBrightnessAndTemperature.brightness };
+          // }
+          // --------------------------------------------------------------------------------------------------
+          if (modifiedLight !== undefined && modifiedLight.metadata !== undefined && modifiedLight.metadata.name !== undefined) {
+            receivedHUEObject.lightName = modifiedLight.metadata.name
+          }
+          node.send(receivedHUEObject)
+          return
+        }
+        // #endregion
+
+        if (receivedHUEObject.id === node.hueDevice) {
+          // Output the msg to the flow
+          node.send(receivedHUEObject)
+
+          // // DEBUG testing enable/disable HTML UI Tabs
+          // delete _event.dimming;
+          // delete _event.color;
+          // delete _event.color_temperature;
+          // delete _event.color_temperature_delta;
+
+          if (receivedHUEObject.on !== undefined) {
+            node.updateKNXLightState(receivedHUEObject.on.on)
+            // In case of switch off, set the dim to zero
+            if (receivedHUEObject.on.on === false && (config.updateKNXBrightnessStatusOnHUEOnOff === undefined || config.updateKNXBrightnessStatusOnHUEOnOff === 'onhueoff')) {
+              node.updateKNXBrightnessState(0)
+              if (receivedHUEObject.dimming !== undefined) delete receivedHUEObject.dimming // Remove event.dimming, because has beem handled by this function and i don't want the function below to take care of it.
+            } else if (receivedHUEObject.on.on === true && node.currentHUEDevice.on.on === false) {
+              // Turn on: update the dimming KNX Status value as well, but only if we have a reliable value.
+              // For grouped_light, the bridge exposes an aggregated brightness value via /resource/grouped_light/{id}.
+              let brightVal
+              if (receivedHUEObject.dimming !== undefined && receivedHUEObject.dimming.brightness !== undefined) {
+                brightVal = receivedHUEObject.dimming.brightness
+              } else if (node.isGrouped_light === true && typeof node.serverHue?.getHueResourceSnapshot === 'function' && config.GALightBrightnessState) {
+                try {
+                  const snapshot = await node.serverHue.getHueResourceSnapshot(node.hueDevice, { forceRefresh: true })
+                  if (snapshot?.dimming?.brightness !== undefined) brightVal = snapshot.dimming.brightness
+                } catch (error) { /* empty */ }
+              } else if (node.currentHUEDevice.dimming !== undefined && node.currentHUEDevice.dimming.brightness !== undefined) {
+                brightVal = node.currentHUEDevice.dimming.brightness
+              }
+              if (brightVal !== undefined) node.updateKNXBrightnessState(brightVal)
+            }
+            node.currentHUEDevice.on.on = receivedHUEObject.on.on
+          }
+
+          if (receivedHUEObject.color !== undefined && receivedHUEObject.color.xy !== undefined) { // fixed https://github.com/Supergiovane/node-red-contrib-knx-ultimate/issues/287
+            node.updateKNXLightColorState(receivedHUEObject.color)
+            node.currentHUEDevice.color = receivedHUEObject.color
+          }
+
+          if (receivedHUEObject.dimming !== undefined && receivedHUEObject.dimming.brightness !== undefined) {
+            const zeroBrightnessWhenOff = (config.updateKNXBrightnessStatusOnHUEOnOff === undefined || config.updateKNXBrightnessStatusOnHUEOnOff === 'onhueoff')
+            // Once upon n a time, the light transmit the brightness value of 0.39.
+            // To avoid wrongly turn light state on, exit
+            if (receivedHUEObject.dimming.brightness < 1) receivedHUEObject.dimming.brightness = 0
+            // If the light is OFF and the user wants KNX brightness status to stay 0 while OFF,
+            // don't propagate Hue's cached brightness (usually the last/boot brightness) back to KNX.
+            if (zeroBrightnessWhenOff === true && node.currentHUEDevice?.on?.on === false && (receivedHUEObject.on === undefined || receivedHUEObject.on.on === false)) {
+              if (node.currentHUEDevice.dimming !== undefined) node.currentHUEDevice.dimming.brightness = receivedHUEObject.dimming.brightness
+            } else if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false && receivedHUEObject.dimming.brightness === 0) {
+              // Do nothing, because the light is off and the dimming also is 0
+            } else {
+              if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false && (receivedHUEObject.on === undefined || (receivedHUEObject.on !== undefined && receivedHUEObject.on.on === true))) node.updateKNXLightState(receivedHUEObject.dimming.brightness > 0)
+              node.updateKNXBrightnessState(receivedHUEObject.dimming.brightness)
+              // If the brightness reaches zero, the hue lamp "on" property must be set to zero as well
+              if (receivedHUEObject.dimming.brightness === 0 && node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === true) {
+                node.writeHueState({ on: { on: false } })
+                node.currentHUEDevice.on.on = false
+              }
+              node.currentHUEDevice.dimming.brightness = receivedHUEObject.dimming.brightness
+            }
+          }
+
+          if (receivedHUEObject.color_temperature !== undefined && receivedHUEObject.color_temperature.mirek !== undefined) {
+            node.updateKNXLightKelvinPercentageState(receivedHUEObject.color_temperature.mirek)
+            node.updateKNXLightKelvinState(receivedHUEObject.color_temperature.mirek)
+            node.currentHUEDevice.color_temperature.mirek = receivedHUEObject.color_temperature.mirek
+          }
+        }
+      } catch (error) {
+        node.status({
+          fill: 'red',
+          shape: 'dot',
+          text: `Matter->KNX error ${node.id} ${error.message}. Seee Log`
+        })
+        RED.log.error(`knxUltimateMatterControllerDevice: node.handleSendHUE = (_event): ${error.stack}`)
+      }
+      // })();
+    }
+
+    // Leave the name after "function", to avoid <anonymous function> in the stack trace, in caso of errors.
+    // ---- Matter -> KNX feedback (replaces the Hue event stream) -----------------
+    // Applies a feedback patch from the shim: updates the synthetic currentHUEDevice
+    // and reuses the very same updateKNX* writers of the Hue-born logic below.
+    node.applyMatterFeedback = function applyMatterFeedback (patch, _outputtype = 'write') {
+      if (!patch || node.currentHUEDevice === undefined) return
+      const dev = node.currentHUEDevice
+      const zeroBrightnessWhenOff = (config.updateKNXBrightnessStatusOnHUEOnOff === undefined || config.updateKNXBrightnessStatusOnHUEOnOff === 'onhueoff')
+      if (patch.on !== undefined) {
+        dev.on.on = !!patch.on
+        node.updateKNXLightState(dev.on.on, _outputtype)
+        if (zeroBrightnessWhenOff) node.updateKNXBrightnessState(dev.on.on ? dev.dimming.brightness : 0, _outputtype)
+      }
+      if (patch.brightnessPct !== undefined) {
+        dev.dimming.brightness = Number(patch.brightnessPct)
+        if (dev.on.on === true || !zeroBrightnessWhenOff) node.updateKNXBrightnessState(dev.dimming.brightness, _outputtype)
+      }
+      if (patch.mirek !== undefined) {
+        dev.color_temperature.mirek = patch.mirek
+        node.updateKNXLightKelvinState(patch.mirek, _outputtype)
+        node.updateKNXLightKelvinPercentageState(patch.mirek, _outputtype)
+      }
+      if (patch.xyX !== undefined) dev.color.xy.x = patch.xyX
+      if (patch.xyY !== undefined) dev.color.xy.y = patch.xyY
+      if (patch.xyX !== undefined || patch.xyY !== undefined) node.updateKNXLightColorState({ xy: { x: dev.color.xy.x, y: dev.color.xy.y } }, _outputtype)
+    }
+
+    // Called by matter-config on every attribute report of the subscription.
+    node.handleSendMatter = (_event) => {
+      try {
+        if (_event === undefined || _event.attributeName === undefined) return
+        if (String(_event.nodeId) !== String(node.matterNodeId)) return
+        if (Number(_event.endpointId) !== Number(node.matterEndpointId)) return
+        const patch = matterEventToHuePatch(_event)
+        if (patch) node.applyMatterFeedback(patch)
+      } catch (error) {
+        RED.log.error(`knxUltimateMatterControllerDevice: node.handleSendMatter: ${error.message}`)
+      }
+    }
+    node.handleMatterClusterEvent = () => { }
+    node.handleMatterNodeInitialized = () => { }
+
+    node.updateKNXBrightnessState = function updateKNXBrightnessState (_value, _outputtype = 'write') {
+      if (config.GALightBrightnessState !== undefined && config.GALightBrightnessState !== '') {
+        const knxMsgPayload = {}
+        knxMsgPayload.topic = config.GALightBrightnessState
+        knxMsgPayload.dpt = config.dptLightBrightnessState
+        knxMsgPayload.payload = _value
+        // Send to KNX bus
+        if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+          if (node.serverKNX !== null && node.serverKNX !== undefined) {
+            node.serverKNX.sendKNXTelegramToKNXEngine({
+              grpaddr: knxMsgPayload.topic,
+              payload: knxMsgPayload.payload,
+              dpt: knxMsgPayload.dpt,
+              outputtype: _outputtype,
+              nodecallerid: node.id
+            })
+          }
+        }
+        node.setNodeStatusHue({
+          fill: 'blue',
+          shape: 'ring',
+          text: 'Matter->KNX Bright',
+          payload: knxMsgPayload.payload
+        })
+      }
+    }
+
+    node.updateKNXLightState = function updateKNXLightState (_value, _outputtype = 'write') {
+      try {
+        const knxMsgPayload = {}
+        knxMsgPayload.topic = config.GALightState
+        knxMsgPayload.dpt = config.dptLightState
+        knxMsgPayload.payload = _value
+        if (config.GALightState !== undefined && config.GALightState !== '') {
+          // Check not to have already sent the value
+          // Send to KNX bus
+          if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+            if (node.serverKNX !== null && node.serverKNX !== undefined) {
+              node.serverKNX.sendKNXTelegramToKNXEngine({
+                grpaddr: knxMsgPayload.topic,
+                payload: knxMsgPayload.payload,
+                dpt: knxMsgPayload.dpt,
+                outputtype: _outputtype,
+                nodecallerid: node.id
+              })
+            }
+          }
+          node.setNodeStatusHue({
+            fill: 'blue',
+            shape: 'ring',
+            text: 'Matter->KNX On/Off',
+            payload: knxMsgPayload.payload
+          })
+        }
+      } catch (error) {
+        /* empty */
+      }
+    }
+
+    node.updateKNXLightKelvinPercentageState = function updateKNXLightKelvinPercentageState (_value, _outputtype = 'write') {
+      if (config.GALightKelvinPercentageState !== undefined && config.GALightKelvinPercentageState !== '') {
+        const knxMsgPayload = {}
+        knxMsgPayload.topic = config.GALightKelvinPercentageState
+        knxMsgPayload.dpt = config.dptLightKelvinPercentageState
+        if (config.dptLightKelvinPercentageState === '5.001') {
+          const retPercent = hueColorConverter.ColorConverter.scale(_value, [153, 500], [0, 100])
+          knxMsgPayload.payload = 100 - retPercent
+        }
+        // Send to KNX bus
+        if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+          if (node.serverKNX !== null && node.serverKNX !== undefined) {
+            node.serverKNX.sendKNXTelegramToKNXEngine({
+              grpaddr: knxMsgPayload.topic,
+              payload: knxMsgPayload.payload,
+              dpt: knxMsgPayload.dpt,
+              outputtype: _outputtype,
+              nodecallerid: node.id
+            })
+          }
+        }
+        node.setNodeStatusHue({
+          fill: 'blue',
+          shape: 'ring',
+          text: 'Matter->KNX Tunable White',
+          payload: knxMsgPayload.payload
+        })
+      }
+    }
+
+    //     /**
+    //  * Update the internal HSV variable status and send the valuge in % to the KNX BUS
+    //  * @param {number} _value 0-100%
+    //  * @param {string} _outputtype "write" is the default KNX command
+    //  * * @returns {}
+    //  */
+    //     node.updateKNXLightHSV_H_State = function updateKNXLightHSV_H_State(_value, _outputtype = "write") {
+    //       if (config.GALightHSV_H_State !== undefined && config.GALightHSV_H_State !== "") {
+    //         const knxMsgPayload = {};
+    //         knxMsgPayload.topic = config.GALightHSV_H_State;
+    //         knxMsgPayload.dpt = config.dptLightHSV_H_State;
+    //         if (config.dptLightHSV_H_State === "5.001") {
+    //           knxMsgPayload.payload = 100 - _value;
+    //         }
+    //         // Send to KNX bus
+    //         if (knxMsgPayload.topic !== "" && knxMsgPayload.topic !== undefined) {
+    //           if (node.serverKNX !== null && node.serverKNX !== undefined) {
+    //             node.serverKNX.sendKNXTelegramToKNXEngine({
+    //               grpaddr: knxMsgPayload.topic,
+    //               payload: knxMsgPayload.payload,
+    //               dpt: knxMsgPayload.dpt,
+    //               outputtype: _outputtype || "write",
+    //               nodecallerid: node.id,
+    //             });
+    //           }
+    //         }
+    //         node.setNodeStatusHue({
+    //           fill: "blue",
+    //           shape: "ring",
+    //           text: "Matter->KNX HSV (H)",
+    //           payload: knxMsgPayload.payload,
+    //         });
+    //       }
+    //     };
+
+    //     /**
+    //  * Update the internal HSV variable status and send the valuge in % to the KNX BUS
+    //  * @param {number} _value 0-100%
+    //  * @param {string} _outputtype "write" is the default KNX command
+    //  * @returns {}
+    //  */
+    //     node.updateKNXLightHSV_S_State = function updateKNXLightHSV_S_State(_value, _outputtype = "write") {
+    //       if (config.GALightHSV_S_State !== undefined && config.GALightHSV_S_State !== "") {
+    //         const knxMsgPayload = {};
+    //         knxMsgPayload.topic = config.GALightHSV_S_State;
+    //         knxMsgPayload.dpt = config.dptLightHSV_S_State;
+    //         if (config.dptLightHSV_S_State === "5.001") {
+    //           knxMsgPayload.payload = _value;
+    //         }
+    //         // Send to KNX bus
+    //         if (knxMsgPayload.topic !== "" && knxMsgPayload.topic !== undefined) {
+    //           if (node.serverKNX !== null && node.serverKNX !== undefined) {
+    //             node.serverKNX.sendKNXTelegramToKNXEngine({
+    //               grpaddr: knxMsgPayload.topic,
+    //               payload: knxMsgPayload.payload,
+    //               dpt: knxMsgPayload.dpt,
+    //               outputtype: _outputtype || "write",
+    //               nodecallerid: node.id,
+    //             });
+    //           }
+    //         }
+    //         node.setNodeStatusHue({
+    //           fill: "blue",
+    //           shape: "ring",
+    //           text: "Matter->KNX HSV (H)",
+    //           payload: knxMsgPayload.payload,
+    //         });
+    //       }
+    //     };
+
+    /**
+    * Update the KNC colors and HSV states group addresses
+    * @param {object} _value {xy:{x,y}} in 0-1 scale
+    * @param {string} _outputtype "write" is the default KNX command
+    * @returns {}
+    */
+    node.updateKNXLightColorState = function updateKNXLightColorState (_value, _outputtype = 'write') {
+      if (config.GALightColorState !== undefined && config.GALightColorState !== '') {
+        if (_value.xy === undefined || _value.xy.x === undefined) return
+        const knxMsgPayload = {}
+        knxMsgPayload.topic = config.GALightColorState
+        knxMsgPayload.dpt = config.dptLightColorState
+        try {
+          knxMsgPayload.payload = hueColorConverter.ColorConverter.xyBriToRgb(
+            _value.xy.x,
+            _value.xy.y,
+            node.currentHUEDevice !== undefined && node.currentHUEDevice.dimming !== undefined && node.currentHUEDevice.dimming.brightness === undefined ? node.currentHUEDevice.dimming.brightness : 100
+          )
+          knxMsgPayload.payload = { red: knxMsgPayload.payload.r, green: knxMsgPayload.payload.g, blue: knxMsgPayload.payload.b }
+          // Send to KNX bus
+          if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+            if (node.serverKNX !== null && node.serverKNX !== undefined) {
+              node.serverKNX.sendKNXTelegramToKNXEngine({
+                grpaddr: knxMsgPayload.topic,
+                payload: knxMsgPayload.payload,
+                dpt: knxMsgPayload.dpt,
+                outputtype: _outputtype,
+                nodecallerid: node.id
+              })
+            }
+          }
+          node.setNodeStatusHue({
+            fill: 'blue',
+            shape: 'ring',
+            text: 'Matter->KNX Color',
+            payload: knxMsgPayload.payload
+          })
+        } catch (error) { }
+      }
+      if (config.GALightHSV_S_State !== undefined && config.GALightHSV_S_State !== '') {
+        const knxMsgPayload = {}
+        knxMsgPayload.topic = config.GALightHSV_S_State
+        knxMsgPayload.dpt = config.dptLightHSV_S_State
+        if (config.dptLightHSV_S_State === '5.001') {
+          knxMsgPayload.payload = hueColorConverter.ColorConverter.xyBrightnessToHsv(_value.xy.x, _value.xy.y, node.currentHUEDevice !== undefined && node.currentHUEDevice.dimming !== undefined && node.currentHUEDevice.dimming.brightness === undefined ? node.currentHUEDevice.dimming.brightness : 100, false)
+          knxMsgPayload.payload = knxMsgPayload.payload.s
+        }
+        // Send to KNX bus
+        if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+          if (node.serverKNX !== null && node.serverKNX !== undefined) {
+            node.serverKNX.sendKNXTelegramToKNXEngine({
+              grpaddr: knxMsgPayload.topic,
+              payload: knxMsgPayload.payload,
+              dpt: knxMsgPayload.dpt,
+              outputtype: _outputtype || 'write',
+              nodecallerid: node.id
+            })
+          }
+        }
+        node.setNodeStatusHue({
+          fill: 'blue',
+          shape: 'ring',
+          text: 'Matter->KNX HSV (S)',
+          payload: knxMsgPayload.payload
+        })
+      }
+      if (config.GALightHSV_H_State !== undefined && config.GALightHSV_H_State !== '') {
+        const knxMsgPayload = {}
+        knxMsgPayload.topic = config.GALightHSV_H_State
+        knxMsgPayload.dpt = config.dptLightHSV_H_State
+        if (config.dptLightHSV_H_State === '5.001') {
+          knxMsgPayload.payload = hueColorConverter.ColorConverter.xyBrightnessToHsv(_value.xy.x, _value.xy.y, node.currentHUEDevice !== undefined && node.currentHUEDevice.dimming !== undefined && node.currentHUEDevice.dimming.brightness === undefined ? node.currentHUEDevice.dimming.brightness : 100, false)
+          knxMsgPayload.payload = 100 - knxMsgPayload.payload.h
+        }
+        // Send to KNX bus
+        if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+          if (node.serverKNX !== null && node.serverKNX !== undefined) {
+            node.serverKNX.sendKNXTelegramToKNXEngine({
+              grpaddr: knxMsgPayload.topic,
+              payload: knxMsgPayload.payload,
+              dpt: knxMsgPayload.dpt,
+              outputtype: _outputtype || 'write',
+              nodecallerid: node.id
+            })
+          }
+        }
+        node.setNodeStatusHue({
+          fill: 'blue',
+          shape: 'ring',
+          text: 'Matter->KNX HSV (H)',
+          payload: knxMsgPayload.payload
+        })
+      }
+    }
+
+    node.updateKNXLightKelvinState = function updateKNXLightKelvinState (_value, _outputtype = 'write') {
+      if (config.GALightKelvinState !== undefined && config.GALightKelvinState !== '') {
+        const knxMsgPayload = {}
+        const kelvinValue = 0
+        knxMsgPayload.topic = config.GALightKelvinState
+        knxMsgPayload.dpt = config.dptLightKelvinState
+        if (config.dptLightKelvinState === '7.600') {
+          knxMsgPayload.payload = hueColorConverter.ColorConverter.mirekToKelvin(_value)
+          // knxMsgPayload.payload = hueColorConverter.ColorConverter.scale(kelvinValue, [2000, 6535], [0, 65535]);
+        } else if (config.dptLightKelvinState === '9.002') {
+          knxMsgPayload.payload = hueColorConverter.ColorConverter.mirekToKelvin(_value)
+        }
+        // Send to KNX bus
+        if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+          if (node.serverKNX !== null && node.serverKNX !== undefined) {
+            node.serverKNX.sendKNXTelegramToKNXEngine({
+              grpaddr: knxMsgPayload.topic,
+              payload: knxMsgPayload.payload,
+              dpt: knxMsgPayload.dpt,
+              outputtype: _outputtype,
+              nodecallerid: node.id
+            })
+          }
+
+          node.setNodeStatusHue({
+            fill: 'blue',
+            shape: 'ring',
+            text: 'Matter->KNX Kelvin',
+            payload: knxMsgPayload.payload
+          })
+        }
+      }
+    }
+
+    // On each deploy, unsubscribe+resubscribe
+    if (node.serverKNX) {
+      node.serverKNX.removeClient(node)
+      node.serverKNX.addClient(node)
+    } else {
+      node.setNodeStatus({
+        fill: 'yellow',
+        shape: 'ring',
+        text: 'No KNX gateway selected',
+        payload: ''
+      })
+    }
+    if (node.serverHue) {
+      try {
+        node.serverHue.removeClient(node)
+        node.serverHue.addClient(node)
+      } catch (error) {
+        RED.log.error('knxUltimateMatterControllerDevice: if (node.serverKNX): ' + error.message)
+      }
+    }
+
+    node.on('input', (msg, send, done) => {
+      try {
+        const state = RED.util.cloneMessage(msg)
+        node.writeHueState(state)
+        node.setNodeStatusHue({
+          fill: 'green',
+          shape: 'dot',
+          text: '->Matter',
+          payload: 'Flow msg.'
+        })
+      } catch (error) {
+        node.setNodeStatusHue({
+          fill: 'red',
+          shape: 'dot',
+          text: '->Matter',
+          payload: error.message
+        })
+      }
+      // Once finished, call 'done'.
+      // This call is wrapped in a check that 'done' exists
+      // so the node will work in earlier versions of Node-RED (<1.0)
+      if (done) {
+        done()
+      }
+    })
+
+    node.on('close', (done) => {
+      if (node.serverKNX) {
+        node.serverKNX.removeClient(node)
+      }
+      if (node.serverHue) {
+        node.serverHue.removeClient(node)
+      }
+      done()
+    })
+  }
+  RED.nodes.registerType('knxUltimateMatterControllerDevice', knxUltimateMatterControllerDevice)
+}