node-red-contrib-knx-ultimate 2.1.61 → 2.1.62

package/CHANGELOG.md

@@ -6,6 +6,10 @@
 
 # CHANGELOG
 <p>
+<b>Version 2.1.62</b> - October 2023<br/>
+- HUE Light: FIX: a typo error could prevent the light to switch on, if the light was set to specified RGB color at switch on.<br/>
+</p>
+<p>
 <b>Version 2.1.61</b> - October 2023<br/>
 - HUE Light: NEW color picker. A Color picker is shown in the right TABS of node-red, as soon as you open the light node. You can choose the color you want, and paste the RGB color into the HUE light node.<br/>
 - HUE Light: the color getter is now not shown, whenever you select a grouped light. You can use the color picker instead.<br/>

package/nodes/knxUltimateHueLight.js

@@ -73,6 +73,7 @@ module.exports = function (RED) {
               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 };
                 }
@@ -431,9 +432,7 @@ module.exports = function (RED) {
             // To avoid wrongly turn light state on, exit
             if (_event.dimming.brightness < 1) _event.dimming.brightness = 0;
             if (node.currentHUEDevice.hasOwnProperty('on') && node.currentHUEDevice.on.on === false && _event.dimming.brightness === 0) return;
-            // if (config.specifySwitchOnBrightness === undefined || config.specifySwitchOnBrightness === "yes") {
             if (node.currentHUEDevice.on.on === false) node.updateKNXLightState(_event.dimming.brightness > 0);
-            // }
             node.updateKNXBrightnessState(_event.dimming.brightness);
             if (node.currentHUEDevice !== undefined) node.currentHUEDevice.dimming = _event.dimming; // Update the internal object representing the current light
             // If the brightness reaches zero, the hue lamp "on" property must be set to zero as well

package/nodes/utils/hueColorConverter.js

@@ -1,241 +1,244 @@
-const convert = require('color-convert')
+const convert = require('color-convert');
+
 class ColorConverter {
-  static getGamutRanges () {
+  static getGamutRanges() {
     const gamutA = {
       red: [0.704, 0.296],
       green: [0.2151, 0.7106],
-      blue: [0.138, 0.08]
-    }
+      blue: [0.138, 0.08],
+    };
 
     const gamutB = {
       red: [0.675, 0.322],
       green: [0.409, 0.518],
-      blue: [0.167, 0.04]
-    }
+      blue: [0.167, 0.04],
+    };
 
     const gamutC = {
       red: [0.692, 0.308],
       green: [0.17, 0.7],
-      blue: [0.153, 0.048]
-    }
+      blue: [0.153, 0.048],
+    };
 
     const defaultGamut = {
       red: [1.0, 0],
       green: [0.0, 1.0],
-      blue: [0.0, 0.0]
-    }
+      blue: [0.0, 0.0],
+    };
 
-    return { gamutA, gamutB, gamutC, default: defaultGamut }
+    return {
+      gamutA, gamutB, gamutC, default: defaultGamut,
+    };
   }
 
-  static getLightColorGamutRange (gamutTypeABC = null) {
-    const ranges = ColorConverter.getGamutRanges()
-    const gamutA = ranges.gamutA
-    const gamutB = ranges.gamutB
-    const gamutC = ranges.gamutC
+  static getLightColorGamutRange(gamutTypeABC = null) {
+    const ranges = ColorConverter.getGamutRanges();
+    const { gamutA } = ranges;
+    const { gamutB } = ranges;
+    const { gamutC } = ranges;
 
     const philipsModels = {
       A: gamutA,
       B: gamutB,
-      C: gamutC
-    }
+      C: gamutC,
+    };
 
     if (philipsModels[gamutTypeABC]) {
-      return philipsModels[gamutTypeABC]
+      return philipsModels[gamutTypeABC];
     }
 
-    return ranges.default
+    return ranges.default;
   }
 
-  static rgbToXy (red, green, blue, gamutTypeABC = null) {
-    function getGammaCorrectedValue (value) {
-      return (value > 0.04045) ? Math.pow((value + 0.055) / (1.0 + 0.055), 2.4) : (value / 12.92)
+  static rgbToXy(red, green, blue, gamutTypeABC = 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(gamutTypeABC);
 
-    red = parseFloat(red / 255)
-    green = parseFloat(green / 255)
-    blue = parseFloat(blue / 255)
+    red = parseFloat(red / 255);
+    green = parseFloat(green / 255);
+    blue = parseFloat(blue / 255);
 
-    red = getGammaCorrectedValue(red)
-    green = getGammaCorrectedValue(green)
-    blue = getGammaCorrectedValue(blue)
+    red = getGammaCorrectedValue(red);
+    green = getGammaCorrectedValue(green);
+    blue = getGammaCorrectedValue(blue);
 
-    const x = red * 0.649926 + green * 0.103455 + blue * 0.197109
-    const y = red * 0.234327 + green * 0.743075 + blue * 0.022598
-    const z = red * 0.0000000 + green * 0.053077 + blue * 1.035763
+    const x = red * 0.649926 + green * 0.103455 + blue * 0.197109;
+    const y = red * 0.234327 + green * 0.743075 + blue * 0.022598;
+    const z = red * 0.0000000 + green * 0.053077 + blue * 1.035763;
 
     let xy = {
       x: x / (x + y + z),
-      y: y / (x + y + z)
-    }
+      y: y / (x + y + z),
+    };
 
     if (!ColorConverter.xyIsInGamutRange(xy, colorGamut)) {
-      xy = ColorConverter.getClosestColor(xy, colorGamut)
+      xy = ColorConverter.getClosestColor(xy, colorGamut);
     }
 
-    return xy
+    return xy;
   }
 
-  static getBrightnessFromRGB (red, green, blue) {
-    const hsv = convert.rgb.hsv(red, green, blue)
-    const brightness = hsv[2]
-    return brightness
+  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 convert_1_255_ToPercentage(number) {
+    const percentage = (number / 255) * 100;
+    return percentage;
   }
 
-  static xyIsInGamutRange (xy, gamut) {
-    gamut = gamut || ColorConverter.getGamutRanges().gamutC
+  static xyIsInGamutRange(xy, gamut) {
+    gamut = gamut || ColorConverter.getGamutRanges().gamutC;
     if (Array.isArray(xy)) {
       xy = {
         x: xy[0],
-        y: xy[1]
-      }
+        y: xy[1],
+      };
     }
 
-    const v0 = [gamut.blue[0] - gamut.red[0], gamut.blue[1] - gamut.red[1]]
-    const v1 = [gamut.green[0] - gamut.red[0], gamut.green[1] - gamut.red[1]]
-    const v2 = [xy.x - gamut.red[0], xy.y - gamut.red[1]]
+    const v0 = [gamut.blue[0] - gamut.red[0], gamut.blue[1] - gamut.red[1]];
+    const v1 = [gamut.green[0] - gamut.red[0], gamut.green[1] - gamut.red[1]];
+    const v2 = [xy.x - gamut.red[0], xy.y - gamut.red[1]];
 
-    const dot00 = (v0[0] * v0[0]) + (v0[1] * v0[1])
-    const dot01 = (v0[0] * v1[0]) + (v0[1] * v1[1])
-    const dot02 = (v0[0] * v2[0]) + (v0[1] * v2[1])
-    const dot11 = (v1[0] * v1[0]) + (v1[1] * v1[1])
-    const dot12 = (v1[0] * v2[0]) + (v1[1] * v2[1])
+    const dot00 = (v0[0] * v0[0]) + (v0[1] * v0[1]);
+    const dot01 = (v0[0] * v1[0]) + (v0[1] * v1[1]);
+    const dot02 = (v0[0] * v2[0]) + (v0[1] * v2[1]);
+    const dot11 = (v1[0] * v1[0]) + (v1[1] * v1[1]);
+    const dot12 = (v1[0] * v2[0]) + (v1[1] * v2[1]);
 
-    const invDenom = 1 / (dot00 * dot11 - dot01 * dot01)
+    const invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
 
-    const u = (dot11 * dot02 - dot01 * dot12) * invDenom
-    const v = (dot00 * dot12 - dot01 * dot02) * invDenom
+    const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
+    const v = (dot00 * dot12 - dot01 * dot02) * invDenom;
 
-    return ((u >= 0) && (v >= 0) && (u + v < 1))
+    return ((u >= 0) && (v >= 0) && (u + v < 1));
   }
 
-  static getClosestColor (xy, gamut) {
-    function getLineDistance (pointA, pointB) {
-      return Math.hypot(pointB.x - pointA.x, pointB.y - pointA.y)
+  static getClosestColor(xy, gamut) {
+    function getLineDistance(pointA, pointB) {
+      return Math.hypot(pointB.x - pointA.x, pointB.y - pointA.y);
     }
 
-    function getClosestPoint (xy, pointA, pointB) {
-      const xy2a = [xy.x - pointA.x, xy.y - pointA.y]
-      const a2b = [pointB.x - pointA.x, pointB.y - pointA.y]
-      const a2bSqr = Math.pow(a2b[0], 2) + Math.pow(a2b[1], 2)
-      const xy2a_dot_a2b = xy2a[0] * a2b[0] + xy2a[1] * a2b[1]
-      const t = xy2a_dot_a2b / a2bSqr
+    function getClosestPoint(xy, pointA, pointB) {
+      const xy2a = [xy.x - pointA.x, xy.y - pointA.y];
+      const a2b = [pointB.x - pointA.x, pointB.y - pointA.y];
+      const a2bSqr = a2b[0] ** 2 + a2b[1] ** 2;
+      const xy2a_dot_a2b = xy2a[0] * a2b[0] + xy2a[1] * a2b[1];
+      const t = xy2a_dot_a2b / a2bSqr;
 
       return {
         x: pointA.x + a2b[0] * t,
-        y: pointA.y + a2b[1] * t
-      }
+        y: pointA.y + a2b[1] * t,
+      };
     }
 
     const greenBlue = {
       a: {
         x: gamut.green[0],
-        y: gamut.green[1]
+        y: gamut.green[1],
       },
       b: {
         x: gamut.blue[0],
-        y: gamut.blue[1]
-      }
-    }
+        y: gamut.blue[1],
+      },
+    };
 
     const greenRed = {
       a: {
         x: gamut.green[0],
-        y: gamut.green[1]
+        y: gamut.green[1],
       },
       b: {
         x: gamut.red[0],
-        y: gamut.red[1]
-      }
-    }
+        y: gamut.red[1],
+      },
+    };
 
     const blueRed = {
       a: {
         x: gamut.red[0],
-        y: gamut.red[1]
+        y: gamut.red[1],
       },
       b: {
         x: gamut.blue[0],
-        y: gamut.blue[1]
-      }
-    }
+        y: gamut.blue[1],
+      },
+    };
 
     const closestColorPoints = {
       greenBlue: getClosestPoint(xy, greenBlue.a, greenBlue.b),
       greenRed: getClosestPoint(xy, greenRed.a, greenRed.b),
-      blueRed: getClosestPoint(xy, blueRed.a, blueRed.b)
-    }
+      blueRed: getClosestPoint(xy, blueRed.a, blueRed.b),
+    };
 
     const distance = {
       greenBlue: getLineDistance(xy, closestColorPoints.greenBlue),
       greenRed: getLineDistance(xy, closestColorPoints.greenRed),
-      blueRed: getLineDistance(xy, closestColorPoints.blueRed)
-    }
+      blueRed: getLineDistance(xy, closestColorPoints.blueRed),
+    };
 
-    let closestDistance
-    let closestColor
+    let closestDistance;
+    let closestColor;
     for (const i in distance) {
       if (distance.hasOwnProperty(i)) {
         if (!closestDistance) {
-          closestDistance = distance[i]
-          closestColor = i
+          closestDistance = distance[i];
+          closestColor = i;
         }
 
         if (closestDistance > distance[i]) {
-          closestDistance = distance[i]
-          closestColor = i
+          closestDistance = distance[i];
+          closestColor = i;
         }
       }
     }
-    return closestColorPoints[closestColor]
+    return closestColorPoints[closestColor];
   }
 
-  static xyBriToRgb (x, y, bri) {
-    function getReversedGammaCorrectedValue (value) {
-      return value <= 0.0031308 ? 12.92 * value : (1.0 + 0.055) * Math.pow(value, (1.0 / 2.4)) - 0.055
+  static xyBriToRgb(x, y, bri) {
+    function getReversedGammaCorrectedValue(value) {
+      return value <= 0.0031308 ? 12.92 * value : (1.0 + 0.055) * value ** (1.0 / 2.4) - 0.055;
     }
 
-    const z = 1.0 - x - y
-    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
+    const z = 1.0 - x - y;
+    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;
 
-    r = getReversedGammaCorrectedValue(r)
-    g = getReversedGammaCorrectedValue(g)
-    b = getReversedGammaCorrectedValue(b)
+    r = getReversedGammaCorrectedValue(r);
+    g = getReversedGammaCorrectedValue(g);
+    b = getReversedGammaCorrectedValue(b);
 
     // Bring all negative components to zero
-    r = Math.max(r, 0)
-    g = Math.max(g, 0)
-    b = Math.max(b, 0)
+    r = Math.max(r, 0);
+    g = Math.max(g, 0);
+    b = Math.max(b, 0);
 
     // If one component is greater than 1, weight components by that value
-    const max = Math.max(r, g, b)
+    const max = Math.max(r, g, b);
     if (max > 1) {
-      r = r / max
-      g = g / max
-      b = b / max
+      r /= max;
+      g /= max;
+      b /= max;
     }
 
     return {
       red: Math.floor(r * 255),
-      geen: Math.floor(g * 255),
-      blue: Math.floor(b * 255)
-    }
+      green: Math.floor(g * 255),
+      blue: Math.floor(b * 255),
+    };
   }
 
   // Linear interpolation of input y given starting and ending ranges
-  static scale(y, range1 = [0,100], range2 = [0,255]) {
+  static scale(y, range1 = [0, 100], range2 = [0, 255]) {
     const [xMin, xMax] = range2;
     const [yMin, yMax] = range1;
     const percent = (y - yMin) / (yMax - yMin);
@@ -243,4 +246,4 @@ class ColorConverter {
     return Math.round(ans);
   }
 }
-exports.ColorConverter = ColorConverter
+exports.ColorConverter = ColorConverter;

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=16.0.0"
   },
-  "version": "2.1.61",
+  "version": "2.1.62",
   "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 handling.",
   "dependencies": {
     "binary-parser": "2.2.1",