node-red-contrib-knx-ultimate 2.2.20 → 2.2.22

package/nodes/knxUltimateHueLight.js

@@ -35,6 +35,32 @@ module.exports = function (RED) {
     node.isGrouped_light = config.hueDevice.split("#")[1] === "grouped_light";
     node.hueDevice = config.hueDevice.split("#")[0];
     node.initializingAtStart = (config.readStatusAtStartup === undefined || config.readStatusAtStartup === "yes");
+    config.specifySwitchOnBrightness === undefined ? "yes" : config.specifySwitchOnBrightness;
+    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;
+
+    // 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 {
+      config.colorAtSwitchOnDayTime = JSON.parse(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 {
+      config.colorAtSwitchOnNightTime = JSON.parse(config.colorAtSwitchOnNightTime);
+    }
 
     // Used to call the status update from the config node.
     node.setNodeStatus = ({
@@ -71,42 +97,42 @@ module.exports = function (RED) {
           case config.GALightSwitch:
             msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightSwitch));
             if (msg.payload === true) {
-              // The user selected specific color/brightness at switch on.
+              // Check wether the user selected specific color/brightness at switch on.
               let jColorChoosen = null;
-              if (node.DayTime === true && (config.specifySwitchOnBrightness === undefined || config.specifySwitchOnBrightness === "yes")) {
-                try {
-                  jColorChoosen = JSON.parse(config.colorAtSwitchOnDayTime);
-                  if (jColorChoosen.green === undefined) jColorChoosen.green = jColorChoosen.hasOwnProperty("geen") ? jColorChoosen.geen : jColorChoosen.green;
-                } catch (error) {
-                  jColorChoosen = { red: 255, green: 255, blue: 255 };
-                }
-              } else if (node.DayTime === false && config.enableDayNightLighting === "yes") {
-                try {
-                  jColorChoosen = JSON.parse(config.colorAtSwitchOnNightTime);
-                } catch (error) {
-                  jColorChoosen = { red: 10, green: 10, blue: 10 };
-                }
+              if (node.DayTime === true && (config.specifySwitchOnBrightness === "yes" || config.specifySwitchOnBrightness === "temperature")) {
+                jColorChoosen = config.colorAtSwitchOnDayTime;
+              } else if (node.DayTime === false && (config.enableDayNightLighting === "yes" || config.enableDayNightLighting === "temperature")) {
+                jColorChoosen = config.colorAtSwitchOnNightTime;
               }
-              if (jColorChoosen !== null) {
+
+              // Now we have a jColorChoosen. Proceed illuminating the light
+              if (jColorChoosen !== null && jColorChoosen.kelvin === undefined) {
+                // RGB
                 let gamut = null;
-                if (
-                  node.currentHUEDevice !== undefined
-                  && node.currentHUEDevice.hasOwnProperty("color")
-                  && node.currentHUEDevice.color.hasOwnProperty("gamut_type")
-                ) {
+                if (node.currentHUEDevice !== undefined && node.currentHUEDevice.hasOwnProperty("color") && node.currentHUEDevice.color.hasOwnProperty("gamut_type")) {
                   gamut = node.currentHUEDevice.color.gamut_type;
                 }
                 const dretXY = hueColorConverter.ColorConverter.rgbToXy(jColorChoosen.red, jColorChoosen.green, jColorChoosen.blue, gamut);
-                const dbright = hueColorConverter.ColorConverter.getBrightnessFromRGB(jColorChoosen.red, jColorChoosen.green, jColorChoosen.blue);
-                node.currentHUEDevice.dimming.brightness = dbright;
+                const dbright = hueColorConverter.ColorConverter.getBrightnessFromRGBOrHex(jColorChoosen.red, jColorChoosen.green, jColorChoosen.blue);
+                node.currentHUEDevice.dimming.brightness = Math.round(dbright, 0);
                 node.updateKNXBrightnessState(node.currentHUEDevice.dimming.brightness);
                 state = dbright > 0 ? { on: { on: true }, dimming: { brightness: dbright }, color: { xy: dretXY } } : { on: { on: false } };
-              } else {
+              } if (jColorChoosen !== null && jColorChoosen.kelvin !== undefined) {
+                // Kelvin
+                const dbright = jColorChoosen.brightness;
+                const mirek = hueColorConverter.ColorConverter.kelvinToMirek(jColorChoosen.kelvin);
+                node.currentHUEDevice.color_temperature.mirek = mirek;
+                node.currentHUEDevice.dimming.brightness = dbright;
+                node.updateKNXBrightnessState(node.currentHUEDevice.dimming.brightness);
+                // Kelvin temp
+                state = dbright > 0 ? { on: { on: true }, dimming: { brightness: dbright }, color_temperature: { mirek: mirek } } : { on: { on: false } };
+              } else if (jColorChoosen === null || jColorChoosen === undefined) {
                 state = { on: { on: true } };
               }
             } else {
               state = { on: { on: false } };
             }
+
             node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
             node.setNodeStatusHue({
               fill: "green",
@@ -125,30 +151,37 @@ module.exports = function (RED) {
             });
             break;
           case config.GALightKelvin:
+            let retMirek;
             msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightKelvin));
-            let retMirek = hueColorConverter.ColorConverter.scale(msg.payload, [0, 65535], [153, 500]);
+            if (config.dptLightKelvin === "7.600") {
+              if (msg.payload > 65535) msg.payload = 65535;
+              if (msg.payload < 0) msg.payload = 0;
+              retMirek = hueColorConverter.ColorConverter.scale(msg.payload, [0, 65535], [500, 153]);
+            } 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.scale(msg.payload, [2000, 6535], [500, 153]);
+            }
             state = { color_temperature: { mirek: retMirek } };
             node.serverHue.hueManager.writeHueQueueAdd(node.hueDevice, state, node.isGrouped_light === false ? "setLight" : "setGroupedLight");
             node.setNodeStatusHue({
               fill: "green",
               shape: "dot",
               text: "KNX->HUE",
-              payload: state,
+              payload: msg.payload,
             });
             break;
           case config.GADaylightSensor:
-            if (config.enableDayNightLighting === "yes") {
-              node.DayTime = Boolean(dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptDaylightSensor)));
-              if (config.invertDayNight !== undefined && config.invertDayNight === true) node.DayTime = !node.DayTime;
-              node.setNodeStatusHue({
-                fill: "green",
-                shape: "dot",
-                text: "KNX->HUE Daytime",
-                payload: node.DayTime,
-              });
-            } else {
-              node.DayTime = true;
-            }
+            node.DayTime = Boolean(dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptDaylightSensor)));
+            if (config.invertDayNight !== undefined && config.invertDayNight === true) node.DayTime = !node.DayTime;
+            node.setNodeStatusHue({
+              fill: "green",
+              shape: "dot",
+              text: "KNX->HUE Daytime",
+              payload: node.DayTime,
+            });
+
             break;
           case config.GALightHSV:
             if (config.dptLightHSV === "3.007") {
@@ -209,7 +242,7 @@ module.exports = function (RED) {
               gamut = node.currentHUEDevice.color.gamut_type;
             }
             const retXY = hueColorConverter.ColorConverter.rgbToXy(msg.payload.red, msg.payload.green, msg.payload.blue, gamut);
-            const bright = hueColorConverter.ColorConverter.getBrightnessFromRGB(msg.payload.red, msg.payload.green, msg.payload.blue);
+            const bright = hueColorConverter.ColorConverter.getBrightnessFromRGBOrHex(msg.payload.red, msg.payload.green, msg.payload.blue);
             // state = bright > 0 ? { on: { on: true }, dimming: { brightness: bright }, color: { xy: retXY } } : { on: { on: false } }
             state = { dimming: { brightness: bright }, color: { xy: retXY } };
             if (node.currentHUEDevice === undefined) {
@@ -276,7 +309,7 @@ module.exports = function (RED) {
                       gamut = node.currentHUEDevice.color.gamut_type;
                     }
                     const retXY = hueColorConverter.ColorConverter.rgbToXy(red, green, blue, gamut);
-                    const bright = hueColorConverter.ColorConverter.getBrightnessFromRGB(red, green, blue);
+                    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");
                   } catch (error) { }
@@ -455,10 +488,10 @@ module.exports = function (RED) {
             if (node.currentHUEDevice.hasOwnProperty("on") && node.currentHUEDevice.on.on === false && _event.dimming.brightness === 0) {
               // Do nothing, because the light is off and the dimming also is 0
             } else {
-              if (node.currentHUEDevice.on.on === false && (!_event.hasOwnProperty("on") || (_event.hasOwnProperty("on") && _event.on.on === true))) node.updateKNXLightState(_event.dimming.brightness > 0);
+              if (node.currentHUEDevice.hasOwnProperty("on") && node.currentHUEDevice.on.on === false && (!_event.hasOwnProperty("on") || (_event.hasOwnProperty("on") && _event.on.on === true))) node.updateKNXLightState(_event.dimming.brightness > 0);
               node.updateKNXBrightnessState(_event.dimming.brightness);
               // If the brightness reaches zero, the hue lamp "on" property must be set to zero as well
-              if (_event.dimming.brightness === 0) {
+              if (_event.dimming.brightness === 0 && node.currentHUEDevice.hasOwnProperty("on") && node.currentHUEDevice.on.on === true) {
                 node.serverHue.hueManager.writeHueQueueAdd(
                   node.hueDevice,
                   { on: { on: false } },
@@ -481,6 +514,7 @@ module.exports = function (RED) {
           shape: "dot",
           text: `HUE->KNX error ${node.id} ${error.message}`,
         });
+        RED.log.error(`knxUltimateHueLight: node.handleSendHUE = (_event): ${error.message}`);
       }
     };
 
@@ -604,17 +638,20 @@ module.exports = function (RED) {
         knxMsgPayload.topic = config.GALightKelvinState;
         knxMsgPayload.dpt = config.dptLightKelvinState;
         if (config.dptLightKelvinState === "7.600") {
-          knxMsgPayload.payload = hueColorConverter.ColorConverter.scale(_value, [153, 500], [0, 65535]);
-          // Send to KNX bus
-          if (knxMsgPayload.topic !== "" && knxMsgPayload.topic !== undefined) {
-            node.server.writeQueueAdd({
-              grpaddr: knxMsgPayload.topic,
-              payload: knxMsgPayload.payload,
-              dpt: knxMsgPayload.dpt,
-              outputtype: "write",
-              nodecallerid: node.id,
-            });
-          }
+          knxMsgPayload.payload = hueColorConverter.ColorConverter.scale(_value, [153, 500], [65535, 0]);
+        } else if (config.dptLightKelvinState === "9.002") {
+          knxMsgPayload.payload = hueColorConverter.ColorConverter.scale(_value, [153, 500], [6535, 2000]);
+        }
+        // Send to KNX bus
+        if (knxMsgPayload.topic !== "" && knxMsgPayload.topic !== undefined) {
+          node.server.writeQueueAdd({
+            grpaddr: knxMsgPayload.topic,
+            payload: knxMsgPayload.payload,
+            dpt: knxMsgPayload.dpt,
+            outputtype: "write",
+            nodecallerid: node.id,
+          });
+
           node.setNodeStatusHue({
             fill: "blue",
             shape: "ring",

package/nodes/knxUltimateHueLightSensor.html

@@ -1,3 +1,5 @@
+<script type="text/javascript" src="resources/node-red-contrib-knx-ultimate/11f26b4500.js"></script>
+
 <script type="text/javascript">
     RED.nodes.registerType('knxUltimateHueLightSensor', {
         category: "KNX Ultimate",
@@ -228,8 +230,7 @@
 
 
 </script>
-<script type="application/javascript;charset=utf-8" src="https://kit.fontawesome.com/11f26b4500.js"
-    crossorigin="anonymous"></script>
+
 
 <script type="text/markdown" data-help-name="knxUltimateHueLightSensor">
 This node lets you get the events from your HUE motion device.  

package/nodes/knxUltimateHueMotion.html

@@ -1,3 +1,5 @@
+<script type="text/javascript" src="resources/node-red-contrib-knx-ultimate/11f26b4500.js"></script>
+
 <script type="text/javascript">
     RED.nodes.registerType('knxUltimateHueMotion', {
         category: "KNX Ultimate",
@@ -217,8 +219,6 @@
 
 
 </script>
-<script type="application/javascript;charset=utf-8" src="https://kit.fontawesome.com/11f26b4500.js"
-    crossorigin="anonymous"></script>
 
 <script type="text/markdown" data-help-name="knxUltimateHueMotion">
 This node lets you get the events from your HUE motion device.  

package/nodes/knxUltimateHueScene.html

@@ -1,3 +1,5 @@
+<script type="text/javascript" src="resources/node-red-contrib-knx-ultimate/11f26b4500.js"></script>
+
 <script type="text/javascript">
     RED.nodes.registerType('knxUltimateHueScene', {
         category: "KNX Ultimate",
@@ -283,8 +285,6 @@
 
 
 </script>
-<script type="application/javascript;charset=utf-8" src="https://kit.fontawesome.com/11f26b4500.js"
-    crossorigin="anonymous"></script>
 
 <script type="text/markdown" data-help-name="knxUltimateHueScene">
 This node lets you recall a HUE scene, via KNX.  

package/nodes/knxUltimateHueTapDial.html

@@ -1,3 +1,5 @@
+<script type="text/javascript" src="resources/node-red-contrib-knx-ultimate/11f26b4500.js"></script>
+
 <script type="text/javascript">
     RED.nodes.registerType('knxUltimateHueTapDial', {
         category: "KNX Ultimate",
@@ -219,8 +221,6 @@
 
 
 </script>
-<script type="application/javascript;charset=utf-8" src="https://kit.fontawesome.com/11f26b4500.js"
-    crossorigin="anonymous"></script>
 
 <script type="text/markdown" data-help-name="knxUltimateHueTapDial">
 This node lets you get the events from your HUE rotary device, for example the Tap Dial.  

package/nodes/knxUltimateHueTemperatureSensor.html

@@ -1,3 +1,5 @@
+<script type="text/javascript" src="resources/node-red-contrib-knx-ultimate/11f26b4500.js"></script>
+
 <script type="text/javascript">
     RED.nodes.registerType('knxUltimateHueTemperatureSensor', {
         category: "KNX Ultimate",
@@ -227,8 +229,6 @@
 
 
 </script>
-<script type="application/javascript;charset=utf-8" src="https://kit.fontawesome.com/11f26b4500.js"
-    crossorigin="anonymous"></script>
 
 <script type="text/markdown" data-help-name="knxUltimateHueTemperatureSensor" This node lets you get the events from
     your HUE temperature device. Here you can get the HUE temperature events, that represents a celsius value, evetytime

package/nodes/utils/hueColorConverter.js

@@ -1,7 +1,165 @@
-const convert = require('color-convert');
-
+// Part of this code, thanks to https://github.com/Shnoo/js-CIE-1931-rgb-color-converter
 class ColorConverter {
+  // static getBrightnessFromRGBOrHex(red, green, blue) {
+  //   const hsv = convert.rgb.hsv(red, green, blue);
+  //   const brightness = hsv[2];
+  //   return brightness;
+  // }
+
+
+  static getBrightnessFromRGBOrHex(Rint, Gint, Bint) { // takes sRGB channels as 8 bit integers
+
+    var Rlin = (Rint / 255.0) ** 2.218;   // Convert int to decimal 0-1 and linearize
+    var Glin = (Gint / 255.0) ** 2.218;   // ** is the exponentiation operator, older JS needs Math.pow() instead
+    var Blin = (Bint / 255.0) ** 2.218;   // 2.218 Gamma for sRGB linearization. 2.218 sets unity with the piecewise sRGB at #777 .... 2.2 or 2.223 could be used instead
+
+    var Ylum = Rlin * 0.2126 + Glin * 0.7156 + Blin * 0.0722;   // convert to Luminance Y
+
+    return Math.pow(Ylum, 0.43) * 100;  // Convert to lightness (0 to 100)
+  }
+
+  static convert_1_255_ToPercentage(number) {
+    const percentage = (number / 255) * 100;
+    return percentage;
+  }
+
+  static kelvinToMirek(_kelvin) {
+    return Math.round(1000000 / _kelvin, 0);
+  }
+
+  static mirekToKelvin(_mirek) {
+    return Math.round(1000000 / _mirek, 0);
+  }
+
+  // Linear interpolation of input y given starting and ending ranges
+  static scale(y, range1 = [0, 100], range2 = [0, 255]) {
+    const [xMin, xMax] = range2;
+    const [yMin, yMax] = range1;
+    const percent = (y - yMin) / (yMax - yMin);
+    const ans = percent * (xMax - xMin) + xMin;
+    return Math.round(ans);
+  }
+
+  // Thanks to: https://github.com/sindresorhus/rgb-hex
+  static rgbHex(red, green, blue, alpha) {
+    const toHex = (red, green, blue, alpha) => ((blue | green << 8 | red << 16) | 1 << 24).toString(16).slice(1) + alpha;
+    const parseCssRgbString = (input) => {
+      const parts = input.replace(/rgba?\(([^)]+)\)/, '$1').split(/[,\s/]+/).filter(Boolean);
+      if (parts.length < 3) {
+        return;
+      }
+
+      const parseValue = (value, max) => {
+        value = value.trim();
+
+        if (value.endsWith('%')) {
+          return Math.min(Number.parseFloat(value) * max / 100, max);
+        }
+
+        return Math.min(Number.parseFloat(value), max);
+      };
+
+      const red = parseValue(parts[0], 255);
+      const green = parseValue(parts[1], 255);
+      const blue = parseValue(parts[2], 255);
+      let alpha;
+
+      if (parts.length === 4) {
+        alpha = parseValue(parts[3], 1);
+      }
+
+      return [red, green, blue, alpha];
+    };
+
+    let isPercent = (red + (alpha || '')).toString().includes('%');
+
+    if (typeof red === 'string' && !green) { // Single string parameter.
+      const parsed = parseCssRgbString(red);
+      if (!parsed) {
+        throw new TypeError('Invalid or unsupported color format.');
+      }
+
+      isPercent = false;
+      [red, green, blue, alpha] = parsed;
+    } else if (alpha !== undefined) {
+      alpha = Number.parseFloat(alpha);
+    }
 
+    if (typeof red !== 'number'
+      || typeof green !== 'number'
+      || typeof blue !== 'number'
+      || red > 255
+      || green > 255
+      || blue > 255
+    ) {
+      throw new TypeError('Expected three numbers below 256');
+    }
+
+    if (typeof alpha === 'number') {
+      if (!isPercent && alpha >= 0 && alpha <= 1) {
+        alpha = Math.round(255 * alpha);
+      } else if (isPercent && alpha >= 0 && alpha <= 100) {
+        alpha = Math.round(255 * alpha / 100);
+      } else {
+        throw new TypeError(`Expected alpha value (${alpha}) as a fraction or percentage`);
+      }
+
+      alpha = (alpha | 1 << 8).toString(16).slice(1); // eslint-disable-line no-mixed-operators
+    } else {
+      alpha = '';
+    }
+
+    return toHex(red, green, blue, alpha);
+  }
+
+  // Thanks to: https://github.com/sindresorhus/hex-rgb
+  static hexRgb(hex, options = {}) {
+    const hexCharacters = 'a-f\\d';
+    const match3or4Hex = `#?[${hexCharacters}]{3}[${hexCharacters}]?`;
+    const match6or8Hex = `#?[${hexCharacters}]{6}([${hexCharacters}]{2})?`;
+    const nonHexChars = new RegExp(`[^#${hexCharacters}]`, 'gi');
+    const validHexSize = new RegExp(`^${match3or4Hex}$|^${match6or8Hex}$`, 'i');
+
+    if (typeof hex !== 'string' || nonHexChars.test(hex) || !validHexSize.test(hex)) {
+      throw new TypeError('Expected a valid hex string');
+    }
+
+    hex = hex.replace(/^#/, '');
+    let alphaFromHex = 1;
+
+    if (hex.length === 8) {
+      alphaFromHex = Number.parseInt(hex.slice(6, 8), 16) / 255;
+      hex = hex.slice(0, 6);
+    }
+
+    if (hex.length === 4) {
+      alphaFromHex = Number.parseInt(hex.slice(3, 4).repeat(2), 16) / 255;
+      hex = hex.slice(0, 3);
+    }
+
+    if (hex.length === 3) {
+      hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+    }
+
+    const number = Number.parseInt(hex, 16);
+    const red = number >> 16;
+    const green = (number >> 8) & 255;
+    const blue = number & 255;
+    const alpha = typeof options.alpha === 'number' ? options.alpha : alphaFromHex;
+
+    if (options.format === 'array') {
+      return [red, green, blue, alpha];
+    }
+
+    if (options.format === 'css') {
+      const alphaString = alpha === 1 ? '' : ` / ${Number((alpha * 100).toFixed(2))}%`;
+      return `rgb(${red} ${green} ${blue}${alphaString})`;
+    }
+
+    return {
+      red, green, blue, alpha,
+    };
+  }
 
   static getGamutRanges() {
     const gamutA = {
@@ -33,31 +191,52 @@ class ColorConverter {
     };
   }
 
-  static getLightColorGamutRange(gamutTypeABC = null) {
+  static getLightColorGamutRange(modelId = null) {
     const ranges = ColorConverter.getGamutRanges();
     const { gamutA } = ranges;
     const { gamutB } = ranges;
     const { gamutC } = ranges;
 
     const philipsModels = {
-      A: gamutA,
-      B: gamutB,
-      C: gamutC,
+      LST001: gamutA,
+      LLC010: gamutA,
+      LLC011: gamutA,
+      LLC012: gamutA,
+      LLC006: gamutA,
+      LLC005: gamutA,
+      LLC007: gamutA,
+      LLC014: gamutA,
+      LLC013: gamutA,
+
+      LCT001: gamutB,
+      LCT007: gamutB,
+      LCT002: gamutB,
+      LCT003: gamutB,
+      LLM001: gamutB,
+
+      LCT010: gamutC,
+      LCT014: gamutC,
+      LCT015: gamutC,
+      LCT016: gamutC,
+      LCT011: gamutC,
+      LLC020: gamutC,
+      LST002: gamutC,
+      LCT012: gamutC,
     };
 
-    if (philipsModels[gamutTypeABC]) {
-      return philipsModels[gamutTypeABC];
+    if (philipsModels[modelId]) {
+      return philipsModels[modelId];
     }
 
     return ranges.default;
   }
 
-  static rgbToXy(red, green, blue, gamutTypeABC = null) {
+  static rgbToXy(red, green, blue, modelId = null) {
     function getGammaCorrectedValue(value) {
       return (value > 0.04045) ? ((value + 0.055) / (1.0 + 0.055)) ** 2.4 : (value / 12.92);
     }
 
-    const colorGamut = ColorConverter.getLightColorGamutRange(gamutTypeABC);
+    const colorGamut = ColorConverter.getLightColorGamutRange(modelId);
 
     red = parseFloat(red / 255);
     green = parseFloat(green / 255);
@@ -83,17 +262,6 @@ class ColorConverter {
     return xy;
   }
 
-  static getBrightnessFromRGB(red, green, blue) {
-    const hsv = convert.rgb.hsv(red, green, blue);
-    const brightness = hsv[2];
-    return brightness;
-  }
-
-  static convert_1_255_ToPercentage(number) {
-    const percentage = (number / 255) * 100;
-    return percentage;
-  }
-
   static xyIsInGamutRange(xy, gamut) {
     gamut = gamut || ColorConverter.getGamutRanges().gamutC;
     if (Array.isArray(xy)) {
@@ -211,9 +379,9 @@ class ColorConverter {
     const Y = bri / 255;
     const X = (Y / y) * x;
     const Z = (Y / y) * z;
-    let r = X * 1.612 - Y * 0.203 - Z * 0.302;
-    let g = -X * 0.509 + Y * 1.412 + Z * 0.066;
-    let b = X * 0.026 - Y * 0.072 + Z * 0.962;
+    let r = X * 1.656492 - Y * 0.354851 - Z * 0.255038;
+    let g = -X * 0.707196 + Y * 1.655397 + Z * 0.036152;
+    let b = X * 0.051713 - Y * 0.121364 + Z * 1.011530;
 
     r = getReversedGammaCorrectedValue(r);
     g = getReversedGammaCorrectedValue(g);
@@ -233,19 +401,10 @@ class ColorConverter {
     }
 
     return {
-      red: Math.floor(r * 255),
-      green: Math.floor(g * 255),
-      blue: Math.floor(b * 255),
+      r: Math.floor(r * 255),
+      g: Math.floor(g * 255),
+      b: Math.floor(b * 255),
     };
   }
-
-  // Linear interpolation of input y given starting and ending ranges
-  static scale(y, range1 = [0, 100], range2 = [0, 255]) {
-    const [xMin, xMax] = range2;
-    const [yMin, yMax] = range1;
-    const percent = (y - yMin) / (yMax - yMin);
-    const ans = percent * (xMax - xMin) + xMin;
-    return Math.round(ans);
-  }
 }
 exports.ColorConverter = ColorConverter;

package/package.json

@@ -3,11 +3,10 @@
   "engines": {
     "node": ">=16.0.0"
   },
-  "version": "2.2.20",
+  "version": "2.2.22",
   "description": "Control your KNX intallation via Node-Red! Single Node KNX IN/OUT with optional ETS group address importer. Easy to use and highly configurable. With integrated Philips HUE devices control.",
   "dependencies": {
     "binary-parser": "2.2.1",
-    "color-convert": "2.0.1",
     "crypto-js": "4.2.0",
     "dns-sync": "0.2.1",
     "eventsource": "2.0.2",