homebridge-deconz 0.0.10 → 0.0.13

package/lib/DeconzService/Daylight.js

@@ -0,0 +1,132 @@
+// homebridge-deconz/lib/DeconzService/Daylight.js
+// Copyright © 2022 Erik Baauw. All rights reserved.
+//
+// Homebridge plugin for deCONZ.
+
+'use strict'
+
+const DeconzService = require('../DeconzService')
+const Deconz = require('../Deconz')
+
+const { dateToString, lightLevelToLux } = Deconz.ApiClient
+
+const daylightEvents = {
+  100: { name: 'Solar Midnight', period: 'Night' },
+  110: { name: 'Astronomical Dawn', period: 'Astronomical Twilight' },
+  120: { name: 'Nautical Dawn', period: 'Nautical Twilight' },
+  130: { name: 'Dawn', period: 'Twilight' },
+  140: { name: 'Sunrise', period: 'Sunrise' },
+  150: { name: 'End Sunrise', period: 'Golden Hour' },
+  160: { name: 'End Golden Hour', period: 'Day' },
+  170: { name: 'Solar Noon', period: 'Day' },
+  180: { name: 'Start Golden Hour', period: 'Golden Hour' },
+  190: { name: 'Start Sunset', period: 'Sunset' },
+  200: { name: 'Sunset', period: 'Twilight' },
+  210: { name: 'Dusk', period: 'Nautical Twilight' },
+  220: { name: 'Nautical Dusk', period: 'Astronomical Twilight' },
+  230: { name: 'Astronomical Dusk', period: 'Night' }
+}
+
+const daylightPeriods = {
+  Night: { lightlevel: 0, daylight: false, dark: true },
+  'Astronomical Twilight': { lightlevel: 100, daylight: false, dark: true },
+  'Nautical Twilight': { lightlevel: 1000, daylight: false, dark: true },
+  Twilight: { lightlevel: 10000, daylight: false, dark: false },
+  Sunrise: { lightlevel: 15000, daylight: true, dark: false },
+  Sunset: { lightlevel: 20000, daylight: true, dark: false },
+  'Golden Hour': { lightlevel: 40000, daylight: true, dark: false },
+  Day: { lightlevel: 65535, daylight: true, dark: false }
+}
+
+/**
+  * @memberof DeconzService
+  */
+class Daylight extends DeconzService.SensorsResource {
+  constructor (accessory, resource, params = {}) {
+    params.Service = accessory.Services.hap.LightSensor
+    super(accessory, resource, params)
+
+    this.addCharacteristicDelegate({
+      key: 'lightlevel',
+      Characteristic: this.Characteristics.hap.CurrentAmbientLightLevel,
+      unit: ' lux'
+    })
+
+    this.addCharacteristicDelegate({
+      key: 'dark',
+      Characteristic: this.Characteristics.my.Dark
+    })
+
+    this.addCharacteristicDelegate({
+      key: 'daylight',
+      Characteristic: this.Characteristics.my.Daylight
+    })
+
+    this.addCharacteristicDelegate({
+      key: 'status',
+      Characteristic: this.Characteristics.my.Status,
+      props: {
+        minValue: 100,
+        maxValue: 230,
+        perms: [
+          this.Characteristic.Perms.READ,
+          this.Characteristic.Perms.NOTIFY]
+      },
+      value: resource.body.state.status
+    })
+
+    this.addCharacteristicDelegate({
+      key: 'lastEvent',
+      Characteristic: this.Characteristics.my.LastEvent
+    })
+
+    this.addCharacteristicDelegate({
+      key: 'period',
+      Characteristic: this.Characteristics.my.Period
+    })
+
+    this.addCharacteristicDelegates()
+
+    this.addCharacteristicDelegate({
+      key: 'sunrise',
+      Characteristic: this.Characteristics.my.Sunrise
+    })
+
+    this.addCharacteristicDelegate({
+      key: 'sunset',
+      Characteristic: this.Characteristics.my.Sunset
+    })
+
+    if (!resource.body.config.configured) {
+      this.warn('%s: %s not configured', resource.rpath, resource.body.type)
+    }
+
+    this.update(resource.body)
+  }
+
+  updateState (state) {
+    if (state.status != null) {
+      this.values.status = state.status
+      const { name, period } = daylightEvents[state.status]
+      this.values.lastEvent = name
+      this.values.period = period
+      const { lightlevel } = daylightPeriods[period]
+      this.values.lightlevel = lightLevelToLux(lightlevel)
+    }
+    if (state.dark != null) {
+      this.values.dark = state.dark
+    }
+    if (state.daylight != null) {
+      this.values.daylight = state.daylight
+    }
+    if (state.sunrise != null) {
+      this.values.sunrise = dateToString(state.sunrise)
+    }
+    if (state.sunset != null) {
+      this.values.sunset = dateToString(state.sunset)
+    }
+    super.updateState(state)
+  }
+}
+
+module.exports = Daylight

package/lib/DeconzService/DeviceSettings.js

@@ -16,6 +16,8 @@ class DeviceSettings extends homebridgeLib.ServiceDelegate {
     params.Service = accessory.Services.my.DeconzDevice
     super(accessory, params)
 
+    this.debug('settings: %j', params)
+
     this.addCharacteristicDelegate({
       key: 'expose',
       Characteristic: this.Characteristics.my.Expose,
@@ -25,6 +27,15 @@ class DeviceSettings extends homebridgeLib.ServiceDelegate {
       accessory.gateway.exposeDevice(params.subtype, value)
     })
 
+    if (params.hasRepeat != null) {
+      this.addCharacteristicDelegate({
+        key: 'repeat',
+        Characteristic: this.Characteristics.my.Repeat,
+        props: { minValue: 0, maxValue: 1, minStep: 1 },
+        value: 0
+      })
+    }
+
     if (params.logLevel != null) {
       this.addCharacteristicDelegate({
         key: 'logLevel',

package/lib/DeconzService/Flag.js

@@ -0,0 +1,52 @@
+// homebridge-deconz/lib/DeconzService/Flag.js
+// Copyright © 2022 Erik Baauw. All rights reserved.
+//
+// Homebridge plugin for deCONZ.
+
+'use strict'
+
+const DeconzService = require('../DeconzService')
+
+/**
+  * @memberof DeconzService
+  */
+class Flag extends DeconzService.SensorsResource {
+  constructor (accessory, resource, params = {}) {
+    params.Service = accessory.Services.hap.Switch
+    super(accessory, resource, params)
+
+    if (resource.capabilities.readonly) {
+      this.addCharacteristicDelegate({
+        key: 'on',
+        Characteristic: this.Characteristics.hap.On,
+        props: {
+          perms: [
+            this.Characteristic.Perms.READ, this.Characteristic.Perms.NOTIFY
+          ]
+        }
+      })
+    } else {
+      this.addCharacteristicDelegate({
+        key: 'on',
+        Characteristic: this.Characteristics.hap.On
+      }).on('didSet', async (value, fromHomeKit) => {
+        if (fromHomeKit) {
+          await this.put('/state', { flag: value })
+        }
+      })
+    }
+
+    this.addCharacteristicDelegates()
+
+    this.update(resource.body)
+  }
+
+  updateState (state) {
+    if (state.flag != null) {
+      this.values.on = state.flag
+    }
+    super.updateState(state)
+  }
+}
+
+module.exports = Flag

package/lib/DeconzService/Humidity.js

@@ -0,0 +1,37 @@
+// homebridge-deconz/lib/DeconzService/Humidity.js
+// Copyright © 2022 Erik Baauw. All rights reserved.
+//
+// Homebridge plugin for deCONZ.
+
+'use strict'
+
+const DeconzService = require('../DeconzService')
+
+/**
+  * @memberof DeconzService
+  */
+class Humidity extends DeconzService.SensorsResource {
+  constructor (accessory, resource, params = {}) {
+    params.Service = accessory.Services.hap.HumiditySensor
+    super(accessory, resource, params)
+
+    this.addCharacteristicDelegate({
+      key: 'humidity',
+      Characteristic: this.Characteristics.hap.CurrentRelativeHumidity,
+      unit: '%'
+    })
+
+    this.addCharacteristicDelegates()
+
+    this.update(resource.body)
+  }
+
+  updateState (state) {
+    if (state.humidity != null) {
+      this.values.humidity = Math.round(state.humidity / 10) / 10
+    }
+    super.updateState(state)
+  }
+}
+
+module.exports = Humidity

package/lib/DeconzService/Leak.js

@@ -0,0 +1,38 @@
+// homebridge-deconz/lib/DeconzService/Leak.js
+// Copyright © 2022 Erik Baauw. All rights reserved.
+//
+// Homebridge plugin for deCONZ.
+
+'use strict'
+
+const DeconzService = require('../DeconzService')
+
+/**
+  * @memberof DeconzService
+  */
+class Leak extends DeconzService.SensorsResource {
+  constructor (accessory, resource, params = {}) {
+    params.Service = accessory.Services.hap.LeakSensor
+    super(accessory, resource, params)
+
+    this.addCharacteristicDelegate({
+      key: 'leak',
+      Characteristic: this.Characteristics.hap.LeakDetected
+    })
+
+    super.addCharacteristicDelegates()
+
+    this.update(resource.body)
+  }
+
+  updateState (state) {
+    if (state.water != null || state.test != null) {
+      this.values.leak = state.water || state.test
+        ? this.Characteristics.hap.LeakDetected.LEAK_DETECTED
+        : this.Characteristics.hap.LeakDetected.LEAK_NOT_DETECTED
+    }
+    super.updateState(state)
+  }
+}
+
+module.exports = Leak

package/lib/DeconzService/Light.js

@@ -1,4 +1,4 @@
-// homebridge-deconz/lib/DeconzService/Sensor.js
+// homebridge-deconz/lib/DeconzService/Light.js
 // Copyright © 2022 Erik Baauw. All rights reserved.
 //
 // Homebridge plugin for deCONZ.
@@ -6,34 +6,15 @@
 'use strict'
 
 const homebridgeLib = require('homebridge-lib')
-const Deconz = require('../Deconz')
+const DeconzService = require('../DeconzService')
 
-const { dateToString } = Deconz.ApiClient
 const { timeout } = homebridgeLib
 const { xyToHsv, hsvToXy, ctToXy } = homebridgeLib.Colour
 
-class Light extends homebridgeLib.ServiceDelegate {
-  constructor (accessory, resource) {
-    super(accessory, {
-      id: resource.id,
-      name: resource.body.name,
-      subtype: resource.subtype,
-      Service: accessory.Services.hap.Lightbulb
-    })
-    this.id = resource.id
-    this.gateway = accessory.gateway
-    this.client = accessory.client
-    this.resource = resource
-    this.rtype = resource.rtype
-    this.rid = resource.rid
-    this.rpath = resource.rpath +
-      (resource.rtype === 'groups' ? '/action' : '/state')
-    this.capabilities = resource.capabilities
-
-    this.debug('%s: capabilities: %j', this.resource.rpath, this.capabilities)
-
-    this.targetState = {}
-    this.deferrals = []
+class Light extends DeconzService.LightsResource {
+  constructor (accessory, resource, params = {}) {
+    params.Service = accessory.Services.hap.Lightbulb
+    super(accessory, resource, params)
 
     this.addCharacteristicDelegate({
       key: 'on',
@@ -66,10 +47,10 @@ class Light extends homebridgeLib.ServiceDelegate {
         key: 'brightness',
         Characteristic: this.Characteristics.hap.Brightness,
         unit: '%',
-        value: this.resource.body.state.bri
+        value: Math.round(this.resource.body.state.bri / 2.54)
       }).on('didSet', (value, fromHomeKit) => {
         if (fromHomeKit) {
-          const bri = Math.round(value * 254.0 / 100.0)
+          const bri = Math.round(value * 2.54)
           this.put({ bri: bri })
           this.updateAdaptiveLighting()
         }
@@ -206,23 +187,18 @@ class Light extends homebridgeLib.ServiceDelegate {
       })
     }
 
-    this.addCharacteristicDelegate({
-      key: 'lastSeen',
-      Characteristic: this.Characteristics.my.LastSeen,
-      silent: true
-    })
-
-    this.addCharacteristicDelegate({
-      key: 'statusFault',
-      Characteristic: this.Characteristics.hap.StatusFault
-    })
+    this.addCharacteristicDelegates()
 
     if (this.capabilities.bri && this.capabilities.ct && !this.capabilities.hs) {
       this.addCharacteristicDelegate({
         key: 'supportedTransitionConfiguration',
         Characteristic: this.Characteristics.hap
           .SupportedCharacteristicValueTransitionConfiguration,
-        silent: true
+        silent: true,
+        getter: async () => {
+          this.initAdaptiveLighting()
+          return this.adaptiveLighting.generateConfiguration()
+        }
       })
       this.addCharacteristicDelegate({
         key: 'transitionControl',
@@ -230,11 +206,9 @@ class Light extends homebridgeLib.ServiceDelegate {
           .CharacteristicValueTransitionControl,
         silent: true,
         getter: async () => {
-          this.initAdaptiveLighting()
           return this.adaptiveLighting.generateControl()
         },
         setter: async (value) => {
-          this.initAdaptiveLighting()
           const control = this.adaptiveLighting.parseControl(value)
           this.context.transitionControl = value
           const response = this.adaptiveLighting.generateControlResponse()
@@ -259,9 +233,107 @@ class Light extends homebridgeLib.ServiceDelegate {
           this.updateAdaptiveLighting()
         }
       })
-      if (this.values.supportedTransitionConfiguration != null) {
-        this.initAdaptiveLighting()
+    }
+
+    if (this.resource.rtype === 'groups') {
+      this.sceneServices = []
+      for (const scene of this.resource.body.scenes) {
+        const service = new homebridgeLib.ServiceDelegate(accessory, {
+          name: this.resource.body.name + ' ' + scene.name,
+          Service: this.Services.hap.Switch,
+          subtype: this.subtype + '-S' + scene.id
+        })
+        service.addCharacteristicDelegate({
+          key: 'on',
+          Characteristic: this.Characteristics.hap.On,
+          value: false
+        }).on('didSet', async (value, fromHomeKit) => {
+          this.checkAdaptiveLighting()
+          if (fromHomeKit && value) {
+            try {
+              const path = this.resource.rpath + '/scenes/' + scene.id + '/recall'
+              this.debug('PUT %s', path)
+              await this.client.put(path)
+            } catch (error) { this.error(error) }
+            await timeout(this.platform.config.waitTimeReset)
+            service.values.on = false
+          }
+        })
+        this.sceneServices.push(service)
+      }
+    }
+
+    if (this.capabilities.effects != null) {
+      this.effectServices = []
+      this.addCharacteristicDelegate({
+        key: 'effect',
+        value: -1,
+        silent: true
+      }).on('didSet', (value) => {
+        for (const i in this.capabilities.effects) {
+          this.effectServices[i].values.on = value === i
+        }
+      })
+      for (const i in this.capabilities.effects) {
+        const effect = this.capabilities.effects[i]
+        const service = new homebridgeLib.ServiceDelegate(accessory, {
+          name: this.resource.body.name + ' ' + effect,
+          Service: this.Services.hap.Switch,
+          subtype: this.subtype + '-E' + i
+        })
+        service.addCharacteristicDelegate({
+          key: 'on',
+          Characteristic: this.Characteristics.hap.On
+        }).on('didSet', (value, fromHomeKit) => {
+          if (fromHomeKit) {
+            this.checkAdaptiveLighting()
+            this.values.effect = value ? i : -1
+            const newEffect = value
+              ? effect.toLowerCase()
+              : 'none'
+            this.put({ effect: newEffect })
+          }
+        })
+        this.effectServices.push(service)
       }
+      // if (this.capabilities.effectSpeed) {
+      //   this.addCharacteristicDelegate({
+      //     key: 'effectSpeed',
+      //     Characteristic: this.Characteristics.my.EffectSpeed,
+      //     value: 50
+      //   }).on('didSet', (value) => {
+      //     this.setEffectSpeed(value)
+      //   })
+      //   this.hk.effectColours = []
+      //   for (let i = 0; i <= 5; i++) {
+      //     const service = new this.Service.Lightbulb(
+      //       this.name + ' Effect Color ' + (i + 1), this.subtype + '-C' + i
+      //     )
+      //     service.addCharacteristicDelegate({
+      //       key: 'on',
+      //       Characteristic: this.Characteristics.hap.On,
+      //       value: true
+      //     }).on('didSet', (value) => {
+      //       this.setEffectOn(i, value)
+      //     })
+      //     service.addCharacteristicDelegate({
+      //       key: 'hue',
+      //       Characteristic: this.Characteristics.hap.Hue,
+      //       value: i * 60
+      //     }).on('didSet', (value) => {
+      //       this.setEffectHue(i, value)
+      //     })
+      //     service.addCharacteristicDelegate({
+      //       key: 'saturation',
+      //       Characteristic: this.Characteristics.hap.Saturation,
+      //       value: 100
+      //     }).on('didSet', (value) => {
+      //       this.setEffectSat(i, value)
+      //     })
+      //     this.effectServices.push(service)
+      //   }
+      // }
+      // this.checkEffect(this.obj.state.effect)
     }
 
     this.settings = {
@@ -272,50 +344,6 @@ class Light extends homebridgeLib.ServiceDelegate {
     }
   }
 
-  update (body) {
-    if (this.updating) {
-      return
-    }
-    for (const key in body) {
-      const value = body[key]
-      switch (key) {
-        case 'action':
-          // Copied to `state` by `Resource` during polling.
-          break
-        case 'state':
-          this.updateState(value)
-          break
-        case 'lastannounced':
-          // this.values.lastBoot = dateToString(value)
-          break
-        case 'lastseen':
-          this.resource.body.lastseen = value
-          this.values.lastSeen = dateToString(value)
-          break
-        case 'colorcapabilities':
-        case 'ctmax':
-        case 'ctmin':
-        case 'devicemembership':
-        case 'etag':
-        case 'id':
-        case 'lights':
-        case 'hascolor':
-        case 'manufacturername':
-        case 'modelid':
-        case 'name':
-        case 'powerup':
-        case 'scenes':
-        case 'swversion':
-        case 'type':
-        case 'uniqueid':
-          break
-        default:
-          this.warn('%s: unknown %s attribute', key, this.rtype)
-          break
-      }
-    }
-  }
-
   updateState (state) {
     let updateAdaptiveLighting = false
     for (const key in state) {
@@ -330,11 +358,9 @@ class Light extends homebridgeLib.ServiceDelegate {
           this.values.anyOn = value
           updateAdaptiveLighting = true
           break
-        case 'alert':
-          break
         case 'bri':
           if (!this.recentlyUpdated) {
-            this.values.brightness = Math.round(value * 100.0 / 254.0)
+            this.values.brightness = Math.round(value / 2.54)
             updateAdaptiveLighting = true
           }
           break
@@ -347,6 +373,11 @@ class Light extends homebridgeLib.ServiceDelegate {
           }
           break
         case 'effect':
+          this.values.colorLoop = value === 'colorloop'
+          if (this.capabilities.effects != null) {
+            const effectName = value[0].toUpperCase() + value.slice(1)
+            this.values.effect = '' + this.capabilities.effects.indexOf(effectName)
+          }
           break
         case 'hue':
           if (!this.capabilities.xy) {
@@ -356,18 +387,11 @@ class Light extends homebridgeLib.ServiceDelegate {
         case 'on':
           this.values.on = value
           break
-        case 'reachable':
-          this.values.statusFault = value
-            ? this.Characteristics.hap.StatusFault.NO_FAULT
-            : this.Characteristics.hap.StatusFault.GENERAL_FAULT
-          break
         case 'sat':
           if (!this.capabilities.xy) {
             this.values.hue = value
           }
           break
-        case 'scene':
-          break
         case 'xy':
           if (
             !this.recentlyUpdated &&
@@ -379,30 +403,13 @@ class Light extends homebridgeLib.ServiceDelegate {
           }
           break
         default:
-          this.warn('state.%s: unknown %s attribute', key, this.rtype)
           break
       }
     }
     if (updateAdaptiveLighting) {
       this.updateAdaptiveLighting()
     }
-  }
-
-  async identify () {
-    try {
-      if (this.capabilities.alert) {
-        if (this.capabilities.breathe) {
-          await this.client.put({ alert: 'breathe' })
-          await timeout(1500)
-          return this.client.put({ alert: 'stop' })
-        }
-        return this.put({ alert: 'select' })
-      }
-    } catch (error) {
-      if (!(error instanceof Deconz.ApiClient.HttpError)) {
-        this.warn(error)
-      }
-    }
+    super.updateState(state)
   }
 
   initAdaptiveLighting () {
@@ -410,8 +417,6 @@ class Light extends homebridgeLib.ServiceDelegate {
       this.adaptiveLighting = new homebridgeLib.AdaptiveLighting(
         this.brightnessDelegate, this.colorTemperatureDelegate
       )
-      this.values.supportedTransitionConfiguration =
-        this.adaptiveLighting.generateConfiguration()
       if (this.values.activeTransitionCount > 0) {
         const control = this.adaptiveLighting.parseControl(
           this.context.transitionControl
@@ -462,67 +467,12 @@ class Light extends homebridgeLib.ServiceDelegate {
   }
 
   checkAdaptiveLighting (key, value) {
-    if (this.fromAdaptiveLighting) {
+    if (this.adaptiveLighting == null || this.fromAdaptiveLighting) {
       return
     }
     this.adaptiveLighting.deactivate()
     this.values.activeTransitionCount = 0
   }
-
-  // Collect changes into a combined request.
-  put (state) {
-    for (const key in state) {
-      this.resource.body.state[key] = state[key]
-      this.targetState[key] = state[key]
-    }
-    this._put()
-  }
-
-  // Send the request (for the combined changes) to the gateway.
-  async _put () {
-    try {
-      if (this.updating) {
-        return
-      }
-      this.updating = true
-      if (this.settings.waitTimeUpdate > 0) {
-        await timeout(this.settings.waitTimeUpdate)
-      }
-      const targetState = this.targetState
-      this.targetState = {}
-      this.updating = false
-      if (
-        this.gateway.transitionTime !== this.gateway.defaultTransitionTime &&
-        targetState.transitiontime === undefined
-      ) {
-        targetState.transitiontime = this.gateway.transitionTime * 10
-        this.gateway.resetTransitionTime()
-      }
-      if (this.capabilities.noTransition) {
-        if (
-          (
-            targetState.on != null || targetState.bri != null ||
-            targetState.bri_inc != null
-          ) && (
-            targetState.xy != null || targetState.ct != null ||
-            targetState.hue != null || targetState.sat != null ||
-            targetState.effect != null
-          )
-        ) {
-          targetState.transitiontime = 0
-        }
-      }
-      this.debug('PUT %s %j', this.rpath, targetState)
-      await this.client.put(this.rpath, targetState)
-      this.recentlyUpdated = true
-      await timeout(500)
-      this.recentlyUpdated = false
-    } catch (error) {
-      if (!(error instanceof Deconz.ApiClient.HttpError)) {
-        this.warn(error)
-      }
-    }
-  }
 }
 
 module.exports = Light