node-red-contrib-knx-ultimate 2.0.0 → 2.0.2

package/nodes/knxUltimateHueLight.js

@@ -1,7 +1,23 @@
 module.exports = function (RED) {
   const dptlib = require('./../KNXEngine/dptlib')
+  const hueColorConverter = require('./utils/hueColorConverter')
 
 
+  async function getLightState(node, _lightID) {
+    return new Promise((resolve, reject) => {
+      try {
+        if (node !== null && node.serverHue !== null && node.serverHue.hueManager !== null) {
+          node.serverHue.hueManager.getLight(_lightID).then(ret => {
+            node.currentHUEDevice = ret[0]
+            resolve(ret)
+          })
+        }
+      } catch (error) {
+        reject(error)
+      }
+    })
+  }
+
   function knxUltimateHueLight(config) {
     RED.nodes.createNode(this, config)
     const node = this
@@ -27,6 +43,16 @@ module.exports = function (RED) {
     node.formatnegativevalue = 'leave'
     node.formatdecimalsvalue = 2
 
+
+
+    // Read the state of the light and store it in the holding object
+    try {
+      if (config.hueDevice !== undefined && config.hueDevice !== '') getLightState(node, config.hueDevice)
+    } catch (error) {
+    }
+
+
+
     // Used to call the status update from the config node.
     node.setNodeStatus = ({ fill, shape, text, payload }) => {
 
@@ -34,38 +60,69 @@ module.exports = function (RED) {
 
     // This function is called by the knx-ultimate config node, to output a msg.payload.
     node.handleSend = msg => {
-      let state
+      let state = {}
       try {
         switch (msg.knx.destination) {
           case config.GALightSwitch:
             msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightSwitch))
             state = msg.payload === true ? { on: { on: true } } : { on: { on: false } }
-            node.serverHue.setLightState(config.hueLight.split('#')[1], state)
+            node.serverHue.hueManager.setLightState(config.hueDevice, state)
             break
           case config.GALightDIM:
             msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightDIM))
             state = msg.payload.decr_incr === 1 ? { dimming_delta: { action: 'up', brightness_delta: 20 } } : { dimming_delta: { action: 'down', brightness_delta: 20 } }
-            node.serverHue.setLightState(config.hueLight.split('#')[1], state)
+            node.serverHue.hueManager.setLightState(config.hueDevice, state)
+            break
+          case config.GALightBrightness:
+            msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightBrightness))
+            state = { dimming: { brightness: msg.payload } }
+            node.serverHue.hueManager.setLightState(config.hueDevice, state)
+            break
+          case config.GALightColor:
+            // Behavior like ISE HUE CONNECT, by setting the brightness and on/off as well
+            msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightColor))
+            const gamut = node.currentHUEDevice.color.gamut_type || null
+            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)
+            bright > 0 ? state = { on: { on: true }, dimming: { brightness: bright }, color: { xy: retXY } } : state = { on: { on: false } }
+            node.serverHue.hueManager.setLightState(config.hueDevice, state)
             break
           default:
             break
         }
       } catch (error) {
-
+        node.status({ fill: 'red', shape: 'dot', text: 'KNX->HUE error ' + error.message + ' (' + new Date().getDate() + ', ' + new Date().toLocaleTimeString() + ')' })
       }
-      //node.exposedGAs.push({ address: msg.knx.destination, addressRAW: sAddressRAW, dpt: msg.knx.dpt, payload: msg.payload, devicename: sDeviceName, lastupdate: new Date(), rawPayload: 'HEX Raw: ' + msg.knx.rawValue.toString('hex') || '?', payloadmeasureunit: (msg.payloadmeasureunit !== 'unknown' ? ' ' + msg.payloadmeasureunit : '') })
+      // node.exposedGAs.push({ address: msg.knx.destination, addressRAW: sAddressRAW, dpt: msg.knx.dpt, payload: msg.payload, devicename: sDeviceName, lastupdate: new Date(), rawPayload: 'HEX Raw: ' + msg.knx.rawValue.toString('hex') || '?', payloadmeasureunit: (msg.payloadmeasureunit !== 'unknown' ? ' ' + msg.payloadmeasureunit : '') })
     }
 
-
     node.handleSendHUE = _event => {
-      if (_event.id === config.hueLight.split('#')[1]) {
-        let knxMsgPayload = undefined
-        if (_event.hasOwnProperty('on')) knxMsgPayload = _event.on.on
-        // Send to KNX bus
-        if (knxMsgPayload !== undefined) {
-          node.status({ fill: 'green', shape: 'dot', text: 'HUE Status ' + knxMsgPayload + ' (' + new Date().getDate() + ', ' + new Date().toLocaleTimeString() + ')' })
-          if (config.GALightState !== '') node.server.writeQueueAdd({ grpaddr: config.GALightState, payload: knxMsgPayload, dpt: config.dptLightState, outputtype: 'write', nodecallerid: node.id })
+      try {
+        if (_event.id === config.hueDevice) {
+          let knxMsgPayload = {}
+          if (_event.hasOwnProperty('on')) {
+            knxMsgPayload.ga = config.GALightState
+            knxMsgPayload.dpt = config.dptLightState
+            knxMsgPayload.payload = _event.on.on
+          }
+          if (_event.hasOwnProperty('color')) {
+            knxMsgPayload.ga = config.GALightColorState
+            knxMsgPayload.dpt = config.dptLightColorState
+            knxMsgPayload.payload = hueColorConverter.ColorConverter.xyBriToRgb(_event.color.xy.x, _event.color.xy.y, node.currentHUEDevice.dimming.brightness)
+          }
+          if (_event.hasOwnProperty('dimming')) {
+            knxMsgPayload.ga = config.GALightBrightnessState
+            knxMsgPayload.dpt = config.dptLightBrightnessState
+            knxMsgPayload.payload = _event.dimming.brightness
+          }
+          // Send to KNX bus
+          if (knxMsgPayload.ga !== undefined) {
+            node.status({ fill: 'green', shape: 'dot', text: 'HUE->KNX State ' + JSON.stringify(knxMsgPayload.payload) + ' (' + new Date().getDate() + ', ' + new Date().toLocaleTimeString() + ')' })
+            if (knxMsgPayload.ga !== '' && knxMsgPayload.ga !== undefined) node.server.writeQueueAdd({ grpaddr: knxMsgPayload.ga, payload: knxMsgPayload.payload, dpt: knxMsgPayload.dpt, outputtype: 'write', nodecallerid: node.id })
+          }
         }
+      } catch (error) {
+        node.status({ fill: 'red', shape: 'dot', text: 'HUE->KNX error ' + error.message + ' (' + new Date().getDate() + ', ' + new Date().toLocaleTimeString() + ')' })
       }
     }
 

package/nodes/locales/en-US/knxUltimateHueLight.json

@@ -3,12 +3,12 @@
         "helplink": "&nbsp<i class=\"fa fa-question-circle\"></i>&nbsp<a target=\"_blank\" href=\"https://github.com/Supergiovane/node-red-contrib-knx-ultimate/wiki/en-hue-configuration\"><u>Configuration</u></a>",
         "title": "HUE node",
         "node-input-name": "Name",
-        "node-input-nameLightSwitch": "Switch (bit)",
+        "node-input-nameLightSwitch": "Switch",
         "node-input-GALightSwitch": "GA",
         "node-input-dptLightSwitch": "dpt",
-        "node-input-nameLightState": "State (bit)",
+        "node-input-nameLightState": "Switch State",
         "node-input-GALightState": "GA",
         "node-input-dptLightState": "dpt",
-        "node-input-hueLight": "HUE light"
+        "node-input-hueLight": "HUE Light"
     }
 }

package/nodes/utils/hueColorConverter.js

@@ -0,0 +1,237 @@
+const convert = require('color-convert')
+class ColorConverter {
+  static getGamutRanges() {
+    const gamutA = {
+      red: [0.704, 0.296],
+      green: [0.2151, 0.7106],
+      blue: [0.138, 0.08]
+    }
+
+    const gamutB = {
+      red: [0.675, 0.322],
+      green: [0.409, 0.518],
+      blue: [0.167, 0.04]
+    }
+
+    const gamutC = {
+      red: [0.692, 0.308],
+      green: [0.17, 0.7],
+      blue: [0.153, 0.048]
+    }
+
+    const defaultGamut = {
+      red: [1.0, 0],
+      green: [0.0, 1.0],
+      blue: [0.0, 0.0]
+    }
+
+    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
+
+    const philipsModels = {
+      A: gamutA,
+      B: gamutB,
+      C: gamutC
+    }
+
+    if (philipsModels[gamutTypeABC]) {
+      return philipsModels[gamutTypeABC]
+    }
+
+    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)
+    }
+
+    const colorGamut = ColorConverter.getLightColorGamutRange(gamutTypeABC)
+
+    red = parseFloat(red / 255)
+    green = parseFloat(green / 255)
+    blue = parseFloat(blue / 255)
+
+    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
+
+    let xy = {
+      x: x / (x + y + z),
+      y: y / (x + y + z)
+    }
+
+    if (!ColorConverter.xyIsInGamutRange(xy, colorGamut)) {
+      xy = ColorConverter.getClosestColor(xy, colorGamut)
+    }
+
+    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)) {
+      xy = {
+        x: xy[0],
+        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 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 u = (dot11 * dot02 - dot01 * dot12) * invDenom
+    const v = (dot00 * dot12 - dot01 * dot02) * invDenom
+
+    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)
+    }
+
+    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
+
+      return {
+        x: pointA.x + a2b[0] * t,
+        y: pointA.y + a2b[1] * t
+      }
+    }
+
+    const greenBlue = {
+      a: {
+        x: gamut.green[0],
+        y: gamut.green[1]
+      },
+      b: {
+        x: gamut.blue[0],
+        y: gamut.blue[1]
+      }
+    }
+
+    const greenRed = {
+      a: {
+        x: gamut.green[0],
+        y: gamut.green[1]
+      },
+      b: {
+        x: gamut.red[0],
+        y: gamut.red[1]
+      }
+    }
+
+    const blueRed = {
+      a: {
+        x: gamut.red[0],
+        y: gamut.red[1]
+      },
+      b: {
+        x: gamut.blue[0],
+        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)
+    }
+
+    const distance = {
+      greenBlue: getLineDistance(xy, closestColorPoints.greenBlue),
+      greenRed: getLineDistance(xy, closestColorPoints.greenRed),
+      blueRed: getLineDistance(xy, closestColorPoints.blueRed)
+    }
+
+    let closestDistance
+    let closestColor
+    for (const i in distance) {
+      if (distance.hasOwnProperty(i)) {
+        if (!closestDistance) {
+          closestDistance = distance[i]
+          closestColor = i
+        }
+
+        if (closestDistance > distance[i]) {
+          closestDistance = distance[i]
+          closestColor = i
+        }
+      }
+    }
+    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
+    }
+
+    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)
+
+    // Bring all negative components to zero
+    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)
+    if (max > 1) {
+      r = r / max
+      g = g / max
+      b = b / max
+    }
+
+    return {
+      red: Math.floor(r * 255),
+      geen: Math.floor(g * 255),
+      blue: Math.floor(b * 255)
+    }
+  }
+}
+exports.ColorConverter = ColorConverter

package/nodes/utils/hueUtils.js

@@ -1,6 +1,6 @@
 'use strict'
 
-//const hueApi = require('node-hue-api')
+// const hueApi = require('node-hue-api')
 const hueApiV2 = require('node-hue')
 const { EventEmitter } = require('events')
 
@@ -13,30 +13,37 @@ class classHUE extends EventEmitter {
     this.bridgeid = _bridgeid
     this.startPushEvents()
     this.timerWatchDog = undefined
+    this.hue = undefined
   }
 
-  getAllLights = async () => {
+  // Get all devices and join it with relative rooms, by adding the room name to the device name
+  getDevices = async (_rtype) => {
     try {
       // V2
       const hue = hueApiV2.connect({ host: this.HUEBridgeIP, key: this.username })
-      const allLights = await hue.getLights()
-      //  allLights.forEach(light => {
-      //    console.log(JSON.stringify(light))
-      //    console.log("\n")
-      //    console.log("\n")
-      //  })
-
-      // V2
-      // const bridgeHUE = await hueApi.v3.api.createLocal(this.HUEBridgeIP).connect(this.username)
-      // const allLights = await bridgeHUE.lights.getAll()
-      // allLights.forEach(light => {
-      //   console.log(light.toStringDetailed())
-      // })
-
-      return { lights: allLights }
+      const retArray = []
+      const allResources = await hue.getResources()
+      const allRooms = await hue.getRooms()
+      const newArray = allResources.filter(x => x.type === _rtype)
+      // Add room name to the device name
+      newArray.forEach(device => {
+        // const Room = allRooms.find(room => {
+        //   return room.children.find(child => child.rid === device.id)
+        // })
+        const Room = allRooms.find(room => room.children.find(child => child.rid === device.owner.rid))
+        const linkedDevName = allResources.find(dev => dev.type === 'device' && dev.services.find(serv => serv.rid === device.id)).metadata.name || ''
+        if (_rtype === 'button') {
+          const controlID = device.metadata !== undefined ? (device.metadata.control_id || '') : ''
+          retArray.push({ name: linkedDevName + (controlID !== '' ? ', button ' + controlID : '') + (Room !== undefined ? ', room ' + Room.metadata.name : ''), id: device.id })
+        }
+        if (_rtype === 'light') {
+          retArray.push({ name: linkedDevName + (Room !== undefined ? ', room ' + Room.metadata.name : ''), id: device.id })
+        }
+      })
+      return { devices: retArray }
     } catch (error) {
-      console.log('KNXUltimateHue: classHUE: error ' + error.message)
-      return ({ lights: error.message })
+      console.log('KNXUltimateHue: HueUtils: classHUE: getDevices: error ' + error.message)
+      return ({ devices: error.message })
     }
   }
 
@@ -54,11 +61,21 @@ class classHUE extends EventEmitter {
     }
   }
 
+  // Get light state
+  getLight = async (_LightID) => {
+    try {
+      const hue = hueApiV2.connect({ host: this.HUEBridgeIP, key: this.username })
+      return await hue.getLight(_LightID)
+    } catch (error) {
+      return ({ error: error.message })
+    }
+  }
+
   // Check the bridge for disconnections
   handleTheDog = async () => {
     this.timerWatchDog = setInterval(async () => {
       try {
-        //const hue = hueApiV2.connect({ host: this.HUEBridgeIP, key: this.username })
+        // const hue = hueApiV2.connect({ host: this.HUEBridgeIP, key: this.username })
         if (this.hue !== undefined) {
           const sRet = await this.hue.getBridges()
           if (sRet.filter(e => e.bridge_id.toString().toLowerCase() === this.bridgeid.toString().toLowerCase()).length === 0) {
@@ -96,4 +113,3 @@ class classHUE extends EventEmitter {
   }
 }
 module.exports.classHUE = classHUE
-

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-red-contrib-knx-ultimate",
-  "version": "2.0.0",
-  "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.",
+  "version": "2.0.2",
+  "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": {
     "mkdirp": "1.0.4",
     "ping": "0.4.1",
@@ -14,7 +14,8 @@
     "xml2js": "0.5.0",
     "dns-sync": "0.2.1",
     "node-hue-api": "5.0.0-beta.16",
-    "node-hue": "1.0.3"
+    "node-hue": "1.0.3",
+    "color-convert": "2.0.1"
   },
   "node-red": {
     "nodes": {
@@ -28,7 +29,8 @@
       "knxUltimateLoadControl": "/nodes/knxUltimateLoadControl.js",
       "knxUltimateViewer": "/nodes/knxUltimateViewer.js",
       "hueConfig": "/nodes/hue-config.js",
-      "knxUltimateHueLight": "/nodes/knxUltimateHueLight.js"
+      "knxUltimateHueLight": "/nodes/knxUltimateHueLight.js",
+      "knxUltimateHueButton": "/nodes/knxUltimateHueButton.js"
     }
   },
   "repository": {

package/nodes/locales/en-US/knxUltimateHueLight.html

@@ -1,10 +0,0 @@
-<script type="text/x-red" data-help-name="knxUltimateHueLight">
-    <h1>KNX Ultimate - Nodo HUE</h1>
-    
-
-  
-    <p>
-        <a href="https://www.paypal.me/techtoday" target="_blank"><img src='https://img.shields.io/badge/Donate-PayPal-blue.svg?style=flat-square' width='30%'></a>
-      
-    </p>
-</script>