node-red-contrib-knx-ultimate 4.1.32 → 4.1.33

package/CHANGELOG.md

@@ -6,6 +6,12 @@
 
 # CHANGELOG
 
+**Version 4.1.33** - March 2026<br/>
+
+- FIX: **KNX Hue Light** grouped light handling: when a `grouped_light` is OFF, writes for dimming, color temperature, color/xy and related dynamic updates are now fanned out to the member `light` resources when needed, instead of relying only on the grouped resource.<br/>
+- CHANGE: **KNX Hue Light** advanced option **Update local cached Hue state from KNX bus writes** is now enabled by default for new nodes.<br/>
+- UI/help/wiki/docs: clarified the tradeoff of the local Hue cache synchronization option in the editor, node help and documentation pages across supported languages.<br/>
+
 **Version 4.1.32** - March 2026<br/>
 
 - KNX Engine bumped to 5.2.11.<br/>

package/nodes/knxUltimateHueLight.html

@@ -130,7 +130,7 @@
         hueDeviceObject: { value: {} },
 
         restoreDayMode: { value: "no" }, // Starting from v 4.1.31
-        updateLocalStateFromKNXWrite: { value: false } // Starting from v 4.1.31
+        updateLocalStateFromKNXWrite: { value: true } // Starting from v 4.1.31
       },
       inputs: 0,
       outputs: 0,
@@ -1263,9 +1263,9 @@
               }
               // Check temperature (if the light supports temperature, it support dimming as well)
               if (oLight.color_temperature !== undefined) {
-              $("#tabs").tabs("enable", "#tabs-3");
-              //$("#tabs").tabs("enable", "#tabs-2");
-              $("#node-input-specifySwitchOnBrightness").append(
+                $("#tabs").tabs("enable", "#tabs-3");
+                //$("#tabs").tabs("enable", "#tabs-2");
+                $("#node-input-specifySwitchOnBrightness").append(
                   $("<option>")
                     .val("temperature")
                     .text(node._("knxUltimateHueLight.select_temperature_brightness"))
@@ -2265,6 +2265,7 @@
           </label>
           <input type="checkbox" id="node-input-updateLocalStateFromKNXWrite" style="display:inline-block; width:auto; vertical-align:top;" />
         </div>
+        <div class="form-tips" style="margin-left:260px;" data-i18n="knxUltimateHueLight.update_local_state_from_knx_write_hint"></div><br/>
         <div id ="divBehaviourBrightness">
           <div class="form-row">
             <label for="node-input-specifySwitchOnBrightness" style="width:260px;">
@@ -2365,4 +2366,4 @@
       </div>
     </div>
   </div>
-<br />
+<br />

package/nodes/knxUltimateHueLight.js

@@ -156,6 +156,81 @@ module.exports = function (RED) {
       } 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 actionableKeys = ["dimming", "color", "color_temperature", "gradient"];
+      const hasActionablePayload = stateKeys.some((key) => actionableKeys.includes(key));
+
+      if (!isGroupedLightOff || !hasActionablePayload) {
+        node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, _state, defaultOperation);
+        return;
+      }
+
+      (async () => {
+        try {
+          const groupLights = await node.serverHue.getAllLightsBelongingToTheGroup(node.hueDevice, false);
+          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.on !== undefined) lightState.on = cloneDeep(_state.on);
+            if (_state.dynamics !== undefined) lightState.dynamics = cloneDeep(_state.dynamics);
+
+            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) {
+            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, _state, defaultOperation);
+          }
+        } catch (error) {
+          RED.log.debug(`knxUltimateHueLight: 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(`knxUltimateHueLight: node.deleteHueStateQueue: ${error.message}`);
+        }
+      })();
+    };
+
     function getRandomIntInclusive(min, max) {
       min = Math.ceil(min);
       max = Math.floor(max);
@@ -225,7 +300,7 @@ module.exports = function (RED) {
                     // 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.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+                    node.writeHueState(state);
                     node.setNodeStatusHue({
                       fill: "green",
                       shape: "dot",
@@ -330,7 +405,7 @@ module.exports = function (RED) {
               }
 
               node.syncCurrentHUEDeviceFromKNXState(state); // Starting from v 4.1.31
-              node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+              node.writeHueState(state);
               node.setNodeStatusHue({
                 fill: "green",
                 shape: "dot",
@@ -382,7 +457,7 @@ module.exports = function (RED) {
               }
               state = { color_temperature: { mirek: retMirek } };
               node.syncCurrentHUEDeviceFromKNXState(state); // Starting from v 4.1.31
-              node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+              node.writeHueState(state);
               node.setNodeStatusHue({
                 fill: "green",
                 shape: "dot",
@@ -439,7 +514,7 @@ module.exports = function (RED) {
                 msg.payload = retMirek;
                 state = { color_temperature: { mirek: msg.payload } };
                 node.syncCurrentHUEDeviceFromKNXState(state); // Starting from v 4.1.31
-                node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+                node.writeHueState(state);
                 node.setNodeStatusHue({
                   fill: "green",
                   shape: "dot",
@@ -460,7 +535,7 @@ module.exports = function (RED) {
                 if (node.currentHUEDevice.on.on === true && msg.payload === 0) state.on = { on: false };
               }
               node.syncCurrentHUEDeviceFromKNXState(state); // Starting from v 4.1.31
-              node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+              node.writeHueState(state);
               node.setNodeStatusHue({
                 fill: "green",
                 shape: "dot",
@@ -490,7 +565,7 @@ module.exports = function (RED) {
                 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.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+              node.writeHueState(state);
               node.setNodeStatusHue({
                 fill: "green",
                 shape: "dot",
@@ -509,15 +584,11 @@ module.exports = function (RED) {
                   state = msg.payload === true
                     ? { on: { on: true }, dimming: { brightness: 100 }, dynamics: { duration: 0 } }
                     : { on: { on: false }, dimming: { brightness: 0 }, dynamics: { duration: 0 } };
-                  node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+                  node.writeHueState(state);
                 }, 1500);
               } else {
                 if (node.timerBlink !== undefined) clearInterval(node.timerBlink);
-                node.serverHue.hueManager.writeHueQueueAdd(
-                  node.hueDevice,
-                  { on: { on: false } },
-                  node.isGrouped_light === false ? "setLight" : "setGroupedLight",
-                );
+                node.writeHueState({ on: { on: false } });
               }
               node.setNodeStatusHue({
                 fill: "green",
@@ -531,7 +602,7 @@ module.exports = function (RED) {
                 if (node.timerColorCycle !== undefined) clearInterval(node.timerColorCycle);
                 const gaValColorCycle = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightColorCycle));
                 if (gaValColorCycle === true) {
-                  node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, { on: { on: true } }, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+                  node.writeHueState({ on: { on: true } });
                   node.timerColorCycle = setInterval(() => {
                     try {
                       const red = getRandomIntInclusive(0, 255);
@@ -548,16 +619,12 @@ module.exports = function (RED) {
                       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.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+                      node.writeHueState(state);
                     } catch (error) { }
                   }, 10000);
                 } else {
                   if (node.timerColorCycle !== undefined) clearInterval(node.timerColorCycle);
-                  node.serverHue.hueManager.writeHueQueueAdd(
-                    node.hueDevice,
-                    { on: { on: false } },
-                    node.isGrouped_light === false ? "setLight" : "setGroupedLight",
-                  );
+                  node.writeHueState({ on: { on: false } });
                 }
                 node.setNodeStatusHue({
                   fill: "green",
@@ -680,7 +747,7 @@ module.exports = function (RED) {
           // STOP DIM
           if (node.timerStepDim !== undefined) clearInterval(node.timerStepDim);
           node.brightnessStep = null;
-          node.serverHue.hueManager.deleteHueQueue(node.hueDevice); // Clear dimming queue.
+          node.deleteHueStateQueue(); // Clear dimming queue.
           return;
         }
 
@@ -729,7 +796,7 @@ module.exports = function (RED) {
               Object.assign(hueTelegram, extendedConf); // 26/03/2024 add extended conf
             }
             //console.log(hueTelegram)
-            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, hueTelegram, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+            node.writeHueState(hueTelegram);
             if (node.brightnessStep >= maxDimLevelLight) clearInterval(node.timerStepDim);
           }, _dimSpeedInMillisecs);
         }
@@ -746,7 +813,7 @@ module.exports = function (RED) {
             if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === true && node.brightnessStep === 0) {
               hueTelegram.on = { on: false };
             }
-            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, hueTelegram, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+            node.writeHueState(hueTelegram);
             if (node.brightnessStep <= minDimLevelLight) clearInterval(node.timerStepDim);
           }, _dimSpeedInMillisecs);
         }
@@ -766,7 +833,7 @@ module.exports = function (RED) {
           // STOP DIM
           if (node.timerStepDimTunableWhite !== undefined) clearInterval(node.timerStepDimTunableWhite);
           node.brightnessStepTunableWhite = null;
-          node.serverHue.hueManager.deleteHueQueue(node.hueDevice); // Clear dimming queue.
+          node.deleteHueStateQueue(); // Clear dimming queue.
           return;
         }
 
@@ -800,7 +867,7 @@ module.exports = function (RED) {
             if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === false) {
               hueTelegram.on = { on: true };
             }
-            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, hueTelegram, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+            node.writeHueState(hueTelegram);
             if (node.brightnessStepTunableWhite >= maxDimLevelLightTunableWhite) clearInterval(node.timerStepDimTunableWhite);
           }, _dimSpeedInMillisecsTunableWhite);
         }
@@ -817,7 +884,7 @@ module.exports = function (RED) {
             if (node.currentHUEDevice.on !== undefined && node.currentHUEDevice.on.on === true && node.brightnessStepTunableWhite === 0) {
               hueTelegram.on = { on: false };
             }
-            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, hueTelegram, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+            node.writeHueState(hueTelegram);
             if (node.brightnessStepTunableWhite <= minDimLevelLightTunableWhite) clearInterval(node.timerStepDimTunableWhite);
           }, _dimSpeedInMillisecsTunableWhite);
         }
@@ -839,7 +906,7 @@ module.exports = function (RED) {
         if (_KNXbrightness_DirectionHSV_H === 0 && _KNXaction === 0) {
           // STOP DIM
           if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H);
-          node.serverHue.hueManager.deleteHueQueue(node.hueDevice); // Clear dimming queue.
+          node.deleteHueStateQueue(); // Clear dimming queue.
           return;
         }
 
@@ -867,7 +934,7 @@ module.exports = function (RED) {
           // DIM UP
           if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H);
           node.timerStepDimHSV_H = setInterval(() => {
-            node.serverHue.hueManager.deleteHueQueue(node.hueDevice); // Clear dimming queue.
+            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.
@@ -880,7 +947,7 @@ module.exports = function (RED) {
             }
             node.currentHUEDevice.color.xy = hsvToXYBri;// Unnecessary, but necessary to set the KNX Status in real time.
             node.updateKNXLightColorState(node.currentHUEDevice.color);
-            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, hueTelegram, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+            node.writeHueState(hueTelegram);
             if (node.brightnessStepHSV_H >= maxDimLevelLightHSV_H) {
               if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H);
             }
@@ -891,7 +958,7 @@ module.exports = function (RED) {
           // DIM DOWN
           if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H);
           node.timerStepDimHSV_H = setInterval(() => {
-            node.serverHue.hueManager.deleteHueQueue(node.hueDevice); // Clear dimming queue.
+            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.
@@ -905,7 +972,7 @@ module.exports = function (RED) {
             }
             node.currentHUEDevice.color.xy = hsvToXYBri;// Unnecessary, but necessary to set the KNX Status in real time.
             node.updateKNXLightColorState(node.currentHUEDevice.color);
-            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, hueTelegram, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+            node.writeHueState(hueTelegram);
             if (node.brightnessStepHSV_H <= minDimLevelLightHSV_H) {
               if (node.timerStepDimHSV_H !== undefined) clearInterval(node.timerStepDimHSV_H);
             }
@@ -927,7 +994,7 @@ module.exports = function (RED) {
         if (_KNXbrightness_DirectionHSV_S === 0 && _KNXaction === 0) {
           // STOP DIM
           if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S);
-          node.serverHue.hueManager.deleteHueQueue(node.hueDevice); // Clear dimming queue.
+          node.deleteHueStateQueue(); // Clear dimming queue.
           return;
         }
 
@@ -954,7 +1021,7 @@ module.exports = function (RED) {
           // DIM UP
           if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S);
           node.timerStepDimHSV_S = setInterval(() => {
-            node.serverHue.hueManager.deleteHueQueue(node.hueDevice); // Clear dimming queue.
+            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.
@@ -967,7 +1034,7 @@ module.exports = function (RED) {
             }
             node.currentHUEDevice.color.xy = cloneDeep(hsvToXYBri);// Unnecessary, but necessary to set the KNX Status in real time.
             node.updateKNXLightColorState(node.currentHUEDevice.color);
-            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, hueTelegram, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+            node.writeHueState(hueTelegram);
             if (node.brightnessStepHSV_S >= maxDimLevelLightHSV_S) {
               if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S);
             }
@@ -978,7 +1045,7 @@ module.exports = function (RED) {
           // DIM DOWN
           if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S);
           node.timerStepDimHSV_S = setInterval(() => {
-            node.serverHue.hueManager.deleteHueQueue(node.hueDevice); // Clear dimming queue.
+            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.
@@ -992,7 +1059,7 @@ module.exports = function (RED) {
             }
             node.currentHUEDevice.color.xy = cloneDeep(hsvToXYBri);// Unnecessary, but necessary to set the KNX Status in real time.
             node.updateKNXLightColorState(node.currentHUEDevice.color);
-            node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, hueTelegram, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+            node.writeHueState(hueTelegram);
             if (node.brightnessStepHSV_S <= minDimLevelLightHSV_S) {
               if (node.timerStepDimHSV_S !== undefined) clearInterval(node.timerStepDimHSV_S);
             }
@@ -1140,11 +1207,7 @@ module.exports = function (RED) {
               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.serverHue.hueManager.writeHueQueueAdd(
-                  node.hueDevice,
-                  { on: { on: false } },
-                  node.isGrouped_light === false ? "setLight" : "setGroupedLight",
-                );
+                node.writeHueState({ on: { on: false } });
                 node.currentHUEDevice.on.on = false;
               }
               node.currentHUEDevice.dimming.brightness = receivedHUEObject.dimming.brightness;
@@ -1476,7 +1539,7 @@ module.exports = function (RED) {
     node.on('input', (msg, send, done) => {
       try {
         const state = RED.util.cloneMessage(msg);
-        node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
+        node.writeHueState(state);
         node.setNodeStatusHue({
           fill: "green",
           shape: "dot",

package/nodes/locales/de/knxUltimateHueLight.html

@@ -99,7 +99,7 @@ Die Tabelle **Hue-native Effekte** ordnet KNX-Werte den vom Bridge gemeldeten Ef
 |--|--|
 | Read status at startup | Beim Start/Voll-Deploy Status aus HUE lesen und an KNX ausgeben |
 | KNX brightness status | Verhalten der Helligkeits-Status-GA bei Ein/Aus (0 % senden und letzten Wert wiederherstellen vs. "as is") |
-| Lokalen Hue-Cache durch KNX-Bus-Schreibtelegramme aktualisieren | Erweiterte Option. Wenn aktiviert, aktualisieren Schreibtelegramme vom KNX-Bus sofort auch den lokal gecachten Hue-Zustand des Nodes, ohne auf Feedback/Ereignisse der Hue Bridge zu warten. Nützlich für konsistente KNX-Leseantworten oder einen stimmigen Cache, auch wenn Leuchte oder Gruppe AUS sind. |
+| Lokalen Hue-Cache durch KNX-Bus-Schreibtelegramme aktualisieren | Erweiterte Option, standardmaessig aktiviert. Wenn aktiv, aktualisieren Schreibtelegramme vom KNX-Bus sofort auch den lokal gecachten Hue-Zustand des Nodes, ohne auf Feedback/Ereignisse der Hue Bridge zu warten. Das sorgt fuer schnellere lokale Reaktionen und konsistentere sofortige KNX-Leseantworten, besonders wenn Leuchte oder Gruppe AUS sind. Deaktivieren Sie die Option, wenn der Cache nur echten Rueckmeldungen/Ereignissen der Hue Bridge folgen soll. |
 | On behaviour | Verhalten beim Einschalten (Farbe wählen / Temperatur+Helligkeit wählen / none) |
 | Night lighting | Nacht-Profil (Farbe oder Temperatur/Helligkeit) |
 | Day/Night | GA zur Umschaltung Tag/Nacht (_true_ = Tag, _false_ = Nacht) |

package/nodes/locales/de/knxUltimateHueLight.json

@@ -50,6 +50,7 @@
     "knx_brightness_onhueoff": "Wenn HUE aus: 0% senden. Wenn HUE an: vorherigen Wert wiederherstellen (Standard KNX Verhalten)",
     "knx_brightness_no": "Unverändert lassen (Standard HUE Verhalten)",
     "update_local_state_from_knx_write": "Lokalen Hue-Cache durch KNX-Bus-Schreibtelegramme aktualisieren",
+    "update_local_state_from_knx_write_hint": "Aktiviert: schnellere lokale Reaktionen und konsistentere sofortige KNX-Leseantworten. Deaktiviert: Cache nur durch echte Hue-Bridge-Ereignisse aktualisieren.",
     "use_min_brightness": "Minimale Helligkeit der HUE Lampe verwenden",
     "k_suffix": "K",
     "temp_desc_2200": "(Beginn der Philips White Ambiance Reihe)",

package/nodes/locales/en/knxUltimateHueLight.html

@@ -98,7 +98,7 @@ Use the **Hue native effects** table to map your KNX values to the effects suppo
 | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Read status at startup | Read the Hue light status at node-red's startup or node-red's full deploy, and send that status to the KNX BUS |
 | KNX Brightness Status | Updates the KNX brightness group address status, whenever the Hue lamp is switched ON/OFF. The options are **When Hue light is Off send 0%. When Hue On, restore previous value (Default KNX behaviour) ** and**Leave as is (default Hue behaviour) ** . If you have KNX dimmer with brightness status, like MDT, the suggested option is _**When Hue light is Off send 0%. When Hue On, restore previous value (Default KNX behaviour)** _ |
-| Update local cached Hue state from KNX bus writes | Advanced option. When enabled, writes arriving from the KNX bus also update the node's local cached Hue state immediately, without waiting for feedback/events from the Hue bridge. Useful when you need consistent KNX read responses or cached state even while the light or grouped light is OFF. |
+| Update local cached Hue state from KNX bus writes | Advanced option, enabled by default. When enabled, writes arriving from the KNX bus also update the node's local cached Hue state immediately, without waiting for feedback/events from the Hue bridge. This gives faster local reactions and more consistent immediate KNX read responses, especially while the light or grouped light is OFF. Disable it if you prefer the cache to follow only real feedback/events from the Hue bridge. |
 | Switch on behaviour | It sets the behaviour of your lights when switched on. You can choose from differents behaviours.<br/> **Select color: ** the light will be switched on with the color of your choice. To change color, just CLICK on the color selector (under the _Select color_ control).<br/>**Select temperature and brightness: ** the light will be switched on with the temperature (Kelvin) and brightness (0-100) of your choice.<br/>**None:** the light will retain its last status. In case you've enable the night lighting, after the night time ends, the lamp will resume the color/temperature/brightness state set at day time. |
 | Night Lighting | It allows to set a particular light color/brightness at nighttime. The options are the same as the daytime. You could select either a temperature/brightness or color. A cozy temperature of 2700 Kelvin, with a brightness of 10% or 20%, is a good choice for bathroom's night light.|
 | Day/Night | Select the group address used to set the day/night behaviour. The group address value is _true_ if daytime, _false_ if nighttime. |

package/nodes/locales/en/knxUltimateHueLight.json

@@ -50,6 +50,7 @@
     "knx_brightness_onhueoff": "When Hue light is Off send 0%. When Hue On, restore previous value (Default KNX behaviour)",
     "knx_brightness_no": "Leave as is (default Hue behaviour)",
     "update_local_state_from_knx_write": "Update local cached Hue state from KNX bus writes",
+    "update_local_state_from_knx_write_hint": "Enabled: faster local reactions and consistent immediate KNX read responses. Disabled: keep the cache aligned only with real Hue bridge events.",
     "use_min_brightness": "Use minimum brightness specified in the Hue light",
     "k_suffix": "K",
     "temp_desc_2200": "(start of Philips White Ambiance lights range)",

package/nodes/locales/es/knxUltimateHueLight.html

@@ -98,7 +98,7 @@ Use la tabla **Hue Native Effects** para asignar sus valores de KNX a los efecto
 | ----------------------------------------- | --------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- |
 | Leer el estado al inicio | Lea el estado de la luz del tono en la inicio de nodo-rojo o el despliegue completo de Node-Red, y envíe ese estado al bus KNX |
 | Estado de brillo KNX | Actualiza el estado de la dirección del grupo de brillo KNX, siempre que la lámpara de tono se encienda/apague. Las opciones son **cuando la luz del tono está apagada, envíe 0%. Cuando se enciende, restaure el valor anterior (comportamiento de KNX predeterminado) ** y**dejar como es (comportamiento de tono predeterminado) ** . Si tiene KNX Dimmer con estado de brillo, como MDT, la opción sugerida es _**cuando la luz del tono está apagada, envíe 0%. Cuando se enciende, restaure el valor anterior (comportamiento predeterminado KNX)** _ |
-| Actualizar el estado local en caché de Hue a partir de escrituras del bus KNX | Opción avanzada. Si está activada, las escrituras que llegan desde el bus KNX también actualizan inmediatamente el estado local en caché de Hue del nodo, sin esperar al feedback/evento del bridge Hue. Útil cuando necesita respuestas de lectura KNX coherentes o un estado en caché alineado incluso mientras la luz o el grupo están apagados. |
+| Actualizar el estado local en caché de Hue a partir de escrituras del bus KNX | Opcion avanzada, activada por defecto. Si esta activa, las escrituras que llegan desde el bus KNX tambien actualizan inmediatamente el estado local en cache de Hue del nodo, sin esperar al feedback/evento del bridge Hue. Esto da reacciones locales mas rapidas y respuestas inmediatas de lectura KNX mas coherentes, especialmente cuando la luz o el grupo estan apagados. Desactivela si prefiere que la cache siga solo el feedback/evento real del bridge Hue. |
 | Encender el comportamiento | Establece el comportamiento de sus luces cuando se enciende. Puede elegir entre diferentes comportamientos. <br/> **Seleccione Color: ** La luz se encenderá con el color de su elección. Para cambiar el color, simplemente haga clic en el selector de color (debajo del control de color_select). <br/>**Seleccione la temperatura y el brillo: ** La luz se encenderá con la temperatura (Kelvin) y el brillo (0-100) de su elección. <br/>**Ninguna:** La luz retendrá su último estado. En caso de que haya habilitado la iluminación nocturna, después de finalizar la noche, la lámpara reanudará el estado de color/temperatura/brillo establecido durante el día. |
 | Iluminación nocturna | Permite establecer un color/brillo de luz particular por la noche. Las opciones son las mismas que el día. Puede seleccionar una temperatura/brillo o color. Una temperatura acogedora de 2700 Kelvin, con un brillo del 10% o 20%, es una buena opción para la luz nocturna del baño. |
 | Día/noche | Seleccione la dirección de grupo utilizada para establecer el comportamiento diurno/nocturno. El valor de la dirección de grupo es _true_ if Daytime, _false_ si nocturno. |

package/nodes/locales/es/knxUltimateHueLight.json

@@ -50,6 +50,7 @@
     "knx_brightness_onhueoff": "Cuando la luz del tono está apagada, envíe 0%. Cuando se enciende, restaure el valor anterior (comportamiento de KNX predeterminado)",
     "knx_brightness_no": "Salir como está (comportamiento de tono predeterminado)",
     "update_local_state_from_knx_write": "Actualizar el estado local en caché de Hue a partir de escrituras del bus KNX",
+    "update_local_state_from_knx_write_hint": "Activado: reacciones locales mas rapidas y respuestas inmediatas de lectura KNX mas coherentes. Desactivado: la cache se actualiza solo con eventos reales del bridge Hue.",
     "use_min_brightness": "Use brillo mínimo especificado en la luz del tono",
     "k_suffix": "K",
     "temp_desc_2200": "(Inicio de Philips White Ambiance Lights Range)",

package/nodes/locales/fr/knxUltimateHueLight.html

@@ -98,7 +98,7 @@ Utilisez le tableau des effets natifs **Hue** pour cartographier vos valeurs KNX
 | ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Lire l'état au démarrage | Lisez l'état de la lumière de Hue au démarrage de Node-Red ou le déploiement complet de Node-Red, et envoyez ce statut au bus KNX |
 | Statut de luminosité KNX | Met à jour l'état de l'adresse du groupe de luminosité KNX, chaque fois que la lampe à teinte est allumée / désactivée. Les options sont **lorsque Hue Light est éteint Envoyer 0%. Lorsque Hue On, restaurez la valeur précédente (comportement KNX par défaut) ** et**Laissez tel quel (comportement de teinte par défaut) ** . Si vous avez un gradateur KNX avec un statut de luminosité, comme le MDT, l'option suggérée est _**lorsque la lumière de Hue est éteinte envoyez 0%. Lorsque Hue on, restaurez la valeur précédente (comportement KNX par défaut)** _ |
-| Mettre à jour l'état Hue local en cache à partir des écritures du bus KNX | Option avancée. Si elle est activée, les écritures reçues depuis le bus KNX mettent aussi à jour immédiatement l'état Hue local en cache du nœud, sans attendre les retours/événements du pont Hue. Utile si vous avez besoin de réponses de lecture KNX cohérentes ou d'un cache aligné même lorsque la lumière ou le groupe est éteint. |
+| Mettre à jour l'état Hue local en cache à partir des écritures du bus KNX | Option avancee, activee par defaut. Lorsqu'elle est activee, les ecritures recues depuis le bus KNX mettent aussi a jour immediatement l'etat Hue local en cache du noeud, sans attendre les retours/evenements du pont Hue. Cela apporte des reactions locales plus rapides et des reponses immediates de lecture KNX plus coherentes, surtout lorsque la lumiere ou le groupe est eteint. Desactivez-la si vous preferez que le cache suive uniquement les retours/evenements reels du pont Hue. |
 | Affoncher le comportement | Il définit le comportement de vos lumières lorsqu'il est allumé. Vous pouvez choisir parmi les différents comportements. <br/> **Sélectionner la couleur: ** La lumière sera allumée avec la couleur de votre choix. Pour modifier la couleur, cliquez simplement sur le sélecteur de couleurs (sous le contrôle de couleur _Select). <br/>**Sélectionnez la température et la luminosité: ** La lumière sera allumée avec la température (Kelvin) et la luminosité (0-100) de votre choix. <br/>**Aucun:** La lumière conservera son dernier statut. Dans le cas où vous permettez l'éclairage nocturne, après la fin de la nuit, la lampe reprendra l'état de couleur / température / luminosité réglé pendant le jour. |
 | Éclairage nocturne | Il permet de définir une couleur / luminosité claire particulière la nuit. Les options sont les mêmes que la journée. Vous pouvez sélectionner une température / une luminosité ou une couleur. Une température confortable de 2700 Kelvin, avec une luminosité de 10% ou 20%, est un bon choix pour la veilleuse de la salle de bain. |
 | Jour / nuit | Sélectionnez l'adresse de groupe utilisée pour définir le comportement de jour / nuit. La valeur d'adresse du groupe est _true_ si le jour, _false_ si nocturne. |

package/nodes/locales/fr/knxUltimateHueLight.json

@@ -42,6 +42,7 @@
     "knx_brightness_onhueoff": "Lorsque Hue Light est éteint, envoyez 0%. Lorsque Hue On, restaurez la valeur précédente (comportement KNX par défaut)",
     "knx_brightness_no": "Laisser tel quel (comportement de teinte par défaut)",
     "update_local_state_from_knx_write": "Mettre à jour l'état Hue local en cache à partir des écritures du bus KNX",
+    "update_local_state_from_knx_write_hint": "Active: reactions locales plus rapides et reponses immediates de lecture KNX plus coherentes. Desactive: le cache ne suit que les evenements reels du bridge Hue.",
     "use_min_brightness": "Utilisez une luminosité minimale spécifiée dans la lumière des teintes",
     "k_suffix": "K",
     "temp_desc_2200": "(Début de la gamme Philips White Ambiance Lights)",

package/nodes/locales/it/knxUltimateHueLight.html

@@ -98,7 +98,7 @@ La tabella **Effetti nativi HUE** consente di associare valori KNX agli effetti
 |------------------------------------------------- |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 |Leggi lo stato all'avvio |Leggi lo stato della luce HUE all'avvio del nodo-rosso o al rosso nodo-rosso del nodo e invia quello stato al bus KNX |
 |Stato di luminosità KNX |Aggiorna lo stato dell'indirizzo del gruppo di luminosità KNX, ogni volta che la lampada Hue viene accesa/disattivata.Le opzioni sono \*\* quando Hue Light è spento, inviare lo 0%.Quando accesa, ripristinare il valore precedente (comportamento KNX predefinito) \*\* e \*\* lasciano come (comportamento di tonalità predefinito) \*\*.Se si dispone di Dimmer KNX con stato di luminosità, come MDT, l'opzione suggerita è \*\*\*quando la luce della tonalità è disattivata, inviare lo 0%.Quando accesa, ripristinare il valore precedente (comportamento KNX predefinito) \*\*\* |
-|Aggiorna lo stato HUE locale in cache dai write KNX |Opzione avanzata. Se abilitata, i write che arrivano dal bus KNX aggiornano subito anche lo stato HUE locale in cache del nodo, senza attendere feedback/eventi dalla Hue Bridge. Utile quando servono risposte KNX in lettura coerenti o uno stato in cache allineato anche mentre la luce o il gruppo sono spenti. |
+|Aggiorna lo stato HUE locale in cache dai write KNX |Opzione avanzata, abilitata di default. Se attiva, i write che arrivano dal bus KNX aggiornano subito anche lo stato HUE locale in cache del nodo, senza attendere feedback/eventi dal bridge Hue. Questo rende le reazioni locali piu rapide e le risposte immediate ai read KNX piu coerenti, soprattutto quando la luce o il grouped_light sono spenti. Disattivala se preferisci che la cache segua solo il feedback/evento reale del bridge Hue. |
 |Accendi comportamento |Imposta il comportamento delle luci quando acceso.Puoi scegliere tra comportamenti diversi. <br/> \*\* Seleziona colore: \*\* La luce verrà accesa con il colore di tua scelta.Per cambiare il colore, fai clic sul selettore dei colori (sotto il controll&#x6F;_&#x53;eleziona colore_). <br/> \*\* Seleziona temperatura e luminosità: \*\* La luce verrà accesa con la temperatura (kelvin) e la luminosità (0-100) di tua scelta. <br/> \*\* Nessuna: \*\* La luce manterrà il suo ultimo stato.Nel caso in cui tu abbia abilitato l'illuminazione notturna, dopo la fine della notte, la lampada riprenderà lo stato del colore/temperatura/luminosità fissata al giorno.|
 |Illuminazione notturna |Permette di impostare un particolare colore/luminosità della luce di notte.Le opzioni sono le stesse del giorno.È possibile selezionare una temperatura/luminosità o colore.Una temperatura accogliente di 2700 Kelvin, con una luminosità del 10% o 20%, è una buona scelta per la luce notturna del bagno |
 |Giorno/notte |Seleziona l'indirizzo di gruppo utilizzato per impostare il comportamento giorno/notte.Il valore dell'indirizzo di gruppo è _true_ se giorno, _false_ se notturno.|

package/nodes/locales/it/knxUltimateHueLight.json

@@ -50,6 +50,7 @@
     "knx_brightness_onhueoff": "Se la luce HUE è spenta invia 0%. Se è accesa, ripristina il valore precedente (Comportamento KNX predefinito)",
     "knx_brightness_no": "Lascia invariato (comportamento HUE predefinito)",
     "update_local_state_from_knx_write": "Aggiorna lo stato HUE locale in cache dai write provenienti dal bus KNX",
+    "update_local_state_from_knx_write_hint": "Abilitato: reazioni locali piu rapide e risposte immediate ai read KNX piu coerenti. Disabilitato: la cache si aggiorna solo dagli eventi reali del bridge Hue.",
     "use_min_brightness": "Usa la luminosità minima specificata nella luce HUE",
     "k_suffix": "K",
     "temp_desc_2200": "(inizio della gamma Philips White Ambiance)",

package/nodes/locales/zh-CN/knxUltimateHueLight.html

@@ -98,7 +98,7 @@ _Hue 原生效果_
 |----------------------------------------------------- |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 |在启动时阅读状态|在Node-Red的启动或Node-Red的完整部署中阅读色相灯状态，然后将该状态发送到KNX总线|
 |KNX亮度状态|每当打开/关闭色调灯时，都会更新KNX亮度组地址状态。选项是 **当色相关闭时发送0％。当色相打开时，还原以前的值（默认的KNX行为） ** 和**如IS（默认色调行为）** 。如果您具有具有亮度状态的KNX调光器，例如MDT，则建议的选项为\*\*\*，当Hue Light关闭时，请发送0％。色调打开时，还原以前的值（默认的KNX行为）\*\*\* |
-|根据 KNX 总线写入更新本地缓存的 Hue 状态|高级选项。启用后，来自 KNX 总线的写入也会立即更新节点本地缓存的 Hue 状态，而无需等待 Hue Bridge 的反馈或事件。当你需要一致的 KNX 读响应，或者希望在灯或分组灯关闭时缓存状态也保持同步时，这个选项会很有用。 |
+|根据 KNX 总线写入更新本地缓存的 Hue 状态|高级选项，默认启用。启用后，来自 KNX 总线的写入会立即更新节点本地缓存的 Hue 状态，无需等待 Hue Bridge 的反馈或事件。这样本地响应会更快，KNX 的即时读回也会更一致，尤其是在灯或分组灯关闭时。如果你希望缓存只跟随 Hue Bridge 的真实反馈/事件，请关闭此选项。 |
 |打开行为|打开时，它设置了灯的行为。您可以从不同的行为中进行选择。<br/> \*\*选择颜色：\*\*将使用您选择的颜色打开灯。要更改颜色，只需单击颜色选择器（&#x5728;_&#x9009;择颜&#x8272;_&#x63A7;制下）。<br/> \*\*选择温度和亮度： **您选择的温度（kelvin）和亮度（0-100）将打开灯。<br/> none：** 无：如果您启用夜间照明，夜间结束后，灯将恢复白天设置的颜色/温度/亮度状态。|
 |夜照明|它允许在夜间设置特定的浅色/亮度。选项与白天相同。您可以选择温度/亮度或颜色。舒适的温度为2700开Kelvin，亮度为10％或20％，是浴室夜灯的不错选择。 |
 |白天/夜|选择用于设置白天/夜行为的组地址。组地址值为\_true\_如果白天，\_false\_如果夜间。|

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

@@ -42,6 +42,7 @@
     "knx_brightness_onhueoff": "当 HUE 灯关闭时发送 0%。当 HUE 打开时恢复先前值（默认 KNX 行为）",
     "knx_brightness_no": "保持不变（默认 HUE 行为）",
     "update_local_state_from_knx_write": "根据 KNX 总线写入更新本地缓存的 Hue 状态",
+    "update_local_state_from_knx_write_hint": "启用：本地响应更快，KNX 即时读回更一致。禁用：缓存只根据 Hue 网关的真实事件更新。",
     "use_min_brightness": "使用 HUE 灯中设置的最小亮度",
     "k_suffix": "K",
     "temp_desc_2200": "（飞利浦 White Ambiance 系列起始）",

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "4.1.32",
+  "version": "4.1.33",
   "description": "Control your KNX and KNX Secure intallation via Node-Red! A bunch of KNX nodes, with integrated Philips HUE control, ETS group address importer, and KNX routing between interfaces. Easy to use and highly configurable.",
   "files": [
     "nodes/",
@@ -104,4 +104,4 @@
     "mocha": "^10.4.0",
     "marked": "^14.1.0"
   }
-}
+}