@homebridge-plugins/homebridge-ewelink 12.3.3

package/lib/device/zigbee/motor.js

@@ -0,0 +1,301 @@
+import platformConsts from '../../utils/constants.js'
+import { generateRandomString, hasProperty, sleep } from '../../utils/functions.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapErr = platform.api.hap.HapStatusError
+    this.hapServ = platform.api.hap.Service
+    this.lang = platform.lang
+    this.log = platform.log
+    this.platform = platform
+
+    // Set up variables from the accessory
+    this.name = accessory.displayName
+    this.accessory = accessory
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.eweDeviceId] || {}
+    this.lowBattThreshold = deviceConf.lowBattThreshold
+      ? Math.min(deviceConf.lowBattThreshold, 100)
+      : platformConsts.defaultValues.lowBattThreshold
+    const showAsMotor = deviceConf.showAsMotor || platformConsts.defaultValues.showAsMotor
+
+    // Set the correct logging variables for this accessory
+    switch (deviceConf.overrideLogging) {
+      case 'standard':
+        this.enableLogging = true
+        this.enableDebugLogging = false
+        break
+      case 'debug':
+        this.enableLogging = true
+        this.enableDebugLogging = true
+        break
+      case 'disable':
+        this.enableLogging = false
+        this.enableDebugLogging = false
+        break
+      default:
+        this.enableLogging = !platform.config.disableDeviceLogging
+        this.enableDebugLogging = platform.config.debug
+        break
+    }
+
+    // Temp override for debugging
+    this.enableLogging = true
+    this.enableDebugLogging = true
+
+    // Add the battery service if it doesn't already exist
+    this.battService = this.accessory.getService(this.hapServ.Battery)
+    || this.accessory.addService(this.hapServ.Battery)
+    this.cacheBatt = this.battService.getCharacteristic(this.hapChar.BatteryLevel).value
+
+    // Add the window covering service if it doesn't already exist
+    let service
+    switch (showAsMotor) {
+      case 'door':
+        service = this.hapServ.Door
+        if (this.accessory.getService(this.hapServ.GarageDoorOpener)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.GarageDoorOpener))
+        }
+        if (this.accessory.getService(this.hapServ.Window)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.Window))
+        }
+        if (this.accessory.getService(this.hapServ.WindowCovering)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.WindowCovering))
+        }
+        break
+      case 'garage':
+        service = this.hapServ.GarageDoorOpener
+        this.isGarage = true
+        if (this.accessory.getService(this.hapServ.Door)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.Door))
+        }
+        if (this.accessory.getService(this.hapServ.Window)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.Window))
+        }
+        if (this.accessory.getService(this.hapServ.WindowCovering)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.WindowCovering))
+        }
+        break
+      case 'window':
+        service = this.hapServ.Window
+        if (this.accessory.getService(this.hapServ.Door)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.Door))
+        }
+        if (this.accessory.getService(this.hapServ.GarageDoorOpener)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.GarageDoorOpener))
+        }
+        if (this.accessory.getService(this.hapServ.WindowCovering)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.WindowCovering))
+        }
+        break
+      default:
+        service = this.hapServ.WindowCovering
+        if (this.accessory.getService(this.hapServ.Door)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.Door))
+        }
+        if (this.accessory.getService(this.hapServ.GarageDoorOpener)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.GarageDoorOpener))
+        }
+        if (this.accessory.getService(this.hapServ.Window)) {
+          this.accessory.removeService(this.accessory.getService(this.hapServ.Window))
+        }
+        break
+    }
+    this.service = this.accessory.getService(service) || this.accessory.addService(service)
+
+    // Add the set handler to the target position characteristic
+    if (this.isGarage) {
+      this.service
+        .getCharacteristic(this.hapChar.TargetDoorState)
+        .onSet(async value => this.internalTargetUpdate(value))
+    } else {
+      this.service
+        .getCharacteristic(this.hapChar.TargetPosition)
+        .onSet(async value => this.internalPositionUpdate(value))
+    }
+
+    // Add the get handlers only if the user hasn't disabled the disableNoResponse setting
+    if (!platform.config.disableNoResponse) {
+      if (this.isGarage) {
+        this.service.getCharacteristic(this.hapChar.CurrentDoorState).onGet(() => {
+          if (!this.isOnline) {
+            throw new this.hapErr(-70402)
+          }
+          return this.service.getCharacteristic(this.hapChar.CurrentDoorState).value
+        })
+        this.service.getCharacteristic(this.hapChar.TargetDoorState).onGet(() => {
+          if (!this.isOnline) {
+            throw new this.hapErr(-70402)
+          }
+          return this.service.getCharacteristic(this.hapChar.TargetDoorState).value
+        })
+      } else {
+        this.service.getCharacteristic(this.hapChar.CurrentPosition).onGet(() => {
+          if (!this.isOnline) {
+            throw new this.hapErr(-70402)
+          }
+          return this.service.getCharacteristic(this.hapChar.CurrentPosition).value
+        })
+        this.service.getCharacteristic(this.hapChar.TargetPosition).onGet(() => {
+          if (!this.isOnline) {
+            throw new this.hapErr(-70402)
+          }
+          return this.service.getCharacteristic(this.hapChar.TargetPosition).value
+        })
+      }
+    }
+
+    // Output the customised options to the log
+    const normalLogging = this.enableLogging ? 'standard' : 'disable'
+    const opts = JSON.stringify({
+      logging: this.enableDebugLogging ? 'debug' : normalLogging,
+      lowBattThreshold: this.lowBattThreshold,
+      showAsMotor,
+    })
+    this.log('[%s] %s %s.', this.name, this.lang.devInitOpts, opts)
+  }
+
+  async internalPositionUpdate(value) {
+    try {
+      if (this.cachePos === value) {
+        return
+      }
+      const updateKey = generateRandomString(5)
+      this.updateKey = updateKey
+      await sleep(500)
+      if (updateKey !== this.updateKey) {
+        return
+      }
+      const params = { openPercent: value }
+      await this.platform.sendDeviceUpdate(this.accessory, params)
+      this.cacheTarg = value
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s%].', this.name, this.lang.curTarg, this.cacheTarg)
+      }
+    } catch (err) {
+      // Catch any errors and let the platform display them
+      this.platform.deviceUpdateError(this.accessory, err, true)
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.TargetPosition, this.cacheTarg)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalTargetUpdate(value) {
+    try {
+      // 0 for open, 1 for closed
+      // this.cachePos is 0 for closed and >0 for open
+
+      const params = { openPercent: value === 1 ? 0 : 100 }
+      await this.platform.sendDeviceUpdate(this.accessory, params)
+      this.cacheTarg = value === 1 ? 0 : 100
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s%].', this.name, this.lang.curTarg, this.cacheTarg)
+      }
+    } catch (err) {
+      // Catch any errors and let the platform display them
+      this.platform.deviceUpdateError(this.accessory, err, true)
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.TargetDoorState, this.cacheTarg)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async externalUpdate(params) {
+    try {
+      if (hasProperty(params, 'battery') && params.battery !== this.cacheBatt) {
+        this.cacheBatt = params.battery
+        this.cacheBattScaled = Math.max(Math.min(this.cacheBatt, 100), 0)
+        this.battService.updateCharacteristic(this.hapChar.BatteryLevel, this.cacheBattScaled)
+        this.battService.updateCharacteristic(
+          this.hapChar.StatusLowBattery,
+          this.cacheBattScaled < this.lowBattThreshold ? 1 : 0,
+        )
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s%].', this.name, this.lang.curBatt, this.cacheBattScaled)
+        }
+      }
+
+      // currLocation is the current position of the motor
+      if (hasProperty(params, 'curPercen')) {
+        if (params.curPercen !== this.cachePos) {
+          this.cachePos = params.curPercen
+          if (!this.isGarage) {
+            this.service.updateCharacteristic(this.hapChar.CurrentPosition, this.cachePos)
+          }
+          if (params.updateSource && this.enableLogging) {
+            this.log('[%s] %s [%s%].', this.name, this.lang.curPos, this.cachePos)
+          }
+        }
+      }
+
+      // location is the target position of the motor
+      if (hasProperty(params, 'openPercent')) {
+        if (params.openPercent !== this.cacheTarg) {
+          this.cacheTarg = params.openPercent
+          if (!this.isGarage) {
+            this.service.updateCharacteristic(this.hapChar.TargetPosition, this.cacheTarg)
+          }
+          if (params.updateSource && this.enableLogging) {
+            this.log('[%s] %s [%s%].', this.name, this.lang.curTarg, this.cacheTarg)
+          }
+        }
+      }
+
+      // Get the target door state characteristic for use later
+      let targetChar
+      if (this.isGarage) {
+        targetChar = this.service.getCharacteristic(this.TargetDoorState)
+      }
+
+      // If the two are equal then the motor must have stopped at this position
+      if (this.cacheTarg === this.cachePos) {
+        if (this.isGarage) {
+          if (this.cachePos === 0) {
+            // CLOSED
+            this.service.updateCharacteristic(this.hapChar.CurrentDoorState, 1)
+            if (targetChar.value !== 1) {
+              targetChar.updateValue(1)
+            }
+          } else {
+            // OPEN
+            this.service.updateCharacteristic(this.hapChar.CurrentDoorState, 0)
+            if (targetChar.value !== 0) {
+              targetChar.updateValue(0)
+            }
+          }
+        } else {
+          // PositionState 2 === STOPPED
+          this.service.updateCharacteristic(this.hapChar.PositionState, 2)
+        }
+      } else if (this.cacheTarg > this.cachePos) {
+        if (this.isGarage) {
+          // OPENING
+          this.service.updateCharacteristic(this.hapChar.CurrentDoorState, 2)
+          if (targetChar.value !== 0) {
+            targetChar.updateValue(0)
+          }
+        } else {
+          // PositionState 1 === INCREASING
+          this.service.updateCharacteristic(this.hapChar.PositionState, 1)
+        }
+      } else if (this.isGarage) {
+        // CLOSING
+        this.service.updateCharacteristic(this.hapChar.CurrentDoorState, 3)
+        if (targetChar.value !== 1) {
+          targetChar.updateValue(1)
+        }
+      } else {
+        // PositionState 0 === DECREASING
+        this.service.updateCharacteristic(this.hapChar.PositionState, 0)
+      }
+    } catch (err) {
+      this.platform.deviceUpdateError(this.accessory, err, false)
+    }
+  }
+}

package/lib/device/zigbee/sensor-ambient.js

@@ -0,0 +1,177 @@
+import platformConsts from '../../utils/constants.js'
+import { hasProperty, parseError } from '../../utils/functions.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapServ = platform.api.hap.Service
+    this.lang = platform.lang
+    this.log = platform.log
+    this.platform = platform
+
+    // Set up variables from the accessory
+    this.name = accessory.displayName
+    this.accessory = accessory
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.eweDeviceId] || {}
+    this.lowBattThreshold = deviceConf.lowBattThreshold
+      ? Math.min(deviceConf.lowBattThreshold, 100)
+      : platformConsts.defaultValues.lowBattThreshold
+    this.tempOffset = deviceConf.offset || platformConsts.defaultValues.offset
+    this.tempOffsetFactor = deviceConf.offsetFactor
+    this.humiOffset = deviceConf.humidityOffset
+      ? Number.parseInt(deviceConf.humidityOffset, 10)
+      : platformConsts.defaultValues.humidityOffset
+    this.humiOffsetFactor = deviceConf.humidityOffsetFactor
+
+    // Set the correct logging variables for this accessory
+    switch (deviceConf.overrideLogging) {
+      case 'standard':
+        this.enableLogging = true
+        this.enableDebugLogging = false
+        break
+      case 'debug':
+        this.enableLogging = true
+        this.enableDebugLogging = true
+        break
+      case 'disable':
+        this.enableLogging = false
+        this.enableDebugLogging = false
+        break
+      default:
+        this.enableLogging = !platform.config.disableDeviceLogging
+        this.enableDebugLogging = platform.config.debug
+        break
+    }
+
+    // Add the temperature sensor service if it doesn't already exist
+    this.tempService = this.accessory.getService(this.hapServ.TemperatureSensor)
+    || this.accessory.addService(this.hapServ.TemperatureSensor)
+
+    // Add options to the current temperature characteristic
+    this.tempService.getCharacteristic(this.hapChar.CurrentTemperature).setProps({
+      minStep: 0.1,
+    })
+    this.cacheTemp = this.tempService.getCharacteristic(this.hapChar.CurrentTemperature).value
+    this.updateCache()
+
+    // Add the humidity sensor service if it doesn't already exist
+    this.humiService = this.accessory.getService(this.hapServ.HumiditySensor)
+    || this.accessory.addService(this.hapServ.HumiditySensor)
+
+    // Add the battery service if it doesn't already exist
+    this.battService = this.accessory.getService(this.hapServ.Battery)
+    || this.accessory.addService(this.hapServ.Battery)
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('weather', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const normalLogging = this.enableLogging ? 'standard' : 'disable'
+    const opts = JSON.stringify({
+      humidityOffset: this.humiOffset,
+      humidityOffsetFactor: this.humiOffsetFactor,
+      logging: this.enableDebugLogging ? 'debug' : normalLogging,
+      lowBattThreshold: this.lowBattThreshold,
+      offset: this.tempOffset,
+      offsetFactor: this.tempOffsetFactor,
+    })
+    this.log('[%s] %s %s.', this.name, this.lang.devInitOpts, opts)
+  }
+
+  async externalUpdate(params) {
+    try {
+      if (hasProperty(params, 'battery') && params.battery !== this.cacheBatt) {
+        this.cacheBatt = params.battery
+        this.cacheBattScaled = Math.max(Math.min(this.cacheBatt, 100), 0)
+        this.battService.updateCharacteristic(this.hapChar.BatteryLevel, this.cacheBattScaled)
+        this.battService.updateCharacteristic(
+          this.hapChar.StatusLowBattery,
+          this.cacheBattScaled < this.lowBattThreshold ? 1 : 0,
+        )
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s%].', this.name, this.lang.curBatt, this.cacheBattScaled)
+        }
+      }
+      if (hasProperty(params, 'temperature')) {
+        let newTemp = Number.parseInt(params.temperature, 10) / 100
+        if (this.tempOffsetFactor) {
+          newTemp *= this.tempOffset
+        } else {
+          newTemp += this.tempOffset
+        }
+        if (newTemp !== this.cacheTemp) {
+          this.cacheTemp = newTemp
+          this.tempService.updateCharacteristic(this.hapChar.CurrentTemperature, this.cacheTemp)
+          this.accessory.eveService.addEntry({ temp: this.cacheTemp })
+          if (params.updateSource && this.enableLogging) {
+            this.log('[%s] %s [%s°C].', this.name, this.lang.curTemp, this.cacheTemp)
+          }
+
+          // Update the cache file with the new temperature
+          this.updateCache()
+        }
+      }
+      if (hasProperty(params, 'humidity')) {
+        let newHumi = Number.parseInt(params.humidity, 10) / 100
+        if (this.humiOffsetFactor) {
+          newHumi *= this.humiOffset
+        } else {
+          newHumi += this.humiOffset
+        }
+        newHumi = Math.max(Math.min(Number.parseInt(newHumi, 10), 100), 0)
+        if (newHumi !== this.cacheHumi) {
+          this.cacheHumi = newHumi
+          this.humiService.updateCharacteristic(
+            this.hapChar.CurrentRelativeHumidity,
+            this.cacheHumi,
+          )
+          this.accessory.eveService.addEntry({ humidity: this.cacheHumi })
+          if (params.updateSource && this.enableLogging) {
+            this.log('[%s] %s [%s%].', this.name, this.lang.curHumi, this.cacheHumi)
+          }
+        }
+      }
+    } catch (err) {
+      this.platform.deviceUpdateError(this.accessory, err, false)
+    }
+  }
+
+  async updateCache() {
+    // Don't continue if the storage client hasn't initialised properly
+    if (!this.platform.storageClientData) {
+      return
+    }
+
+    // Attempt to save the new temperature to the cache
+    try {
+      await this.platform.storageData.setItem(
+        `${this.accessory.context.eweDeviceId}_temp`,
+        this.cacheTemp,
+      )
+    } catch (err) {
+      if (this.enableLogging) {
+        this.log.warn('[%s] %s %s.', this.name, this.lang.storageWriteErr, parseError(err))
+      }
+    }
+  }
+
+  currentState() {
+    const toReturn = {}
+    toReturn.services = ['temperature', 'humidity', 'battery']
+    toReturn.temperature = {
+      current: this.tempService.getCharacteristic(this.hapChar.CurrentTemperature).value,
+    }
+    toReturn.humidity = {
+      current: this.humiService.getCharacteristic(this.hapChar.CurrentRelativeHumidity).value,
+    }
+    toReturn.battery = {
+      current: this.battService.getCharacteristic(this.hapChar.BatteryLevel).value,
+    }
+    return toReturn
+  }
+}

package/lib/device/zigbee/sensor-contact.js

@@ -0,0 +1,137 @@
+import platformConsts from '../../utils/constants.js'
+import { hasProperty } from '../../utils/functions.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.eveChar = platform.eveChar
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapServ = platform.api.hap.Service
+    this.lang = platform.lang
+    this.log = platform.log
+    this.platform = platform
+
+    // Set up variables from the accessory
+    this.name = accessory.displayName
+    this.accessory = accessory
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.eweDeviceId] || {}
+    this.scaleBattery = deviceConf.scaleBattery
+    this.lowBattThreshold = deviceConf.lowBattThreshold
+      ? Math.min(deviceConf.lowBattThreshold, 100)
+      : platformConsts.defaultValues.lowBattThreshold
+
+    // Set the correct logging variables for this accessory
+    switch (deviceConf.overrideLogging) {
+      case 'standard':
+        this.enableLogging = true
+        this.enableDebugLogging = false
+        break
+      case 'debug':
+        this.enableLogging = true
+        this.enableDebugLogging = true
+        break
+      case 'disable':
+        this.enableLogging = false
+        this.enableDebugLogging = false
+        break
+      default:
+        this.enableLogging = !platform.config.disableDeviceLogging
+        this.enableDebugLogging = platform.config.debug
+        break
+    }
+
+    // Add the contact sensor service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.ContactSensor)
+    if (!this.service) {
+      this.service = this.accessory.addService(this.hapServ.ContactSensor)
+      this.service.addCharacteristic(this.eveChar.LastActivation)
+      this.service.addCharacteristic(this.eveChar.ResetTotal)
+      this.service.addCharacteristic(this.eveChar.OpenDuration)
+      this.service.addCharacteristic(this.eveChar.ClosedDuration)
+      this.service.addCharacteristic(this.eveChar.TimesOpened)
+    }
+
+    // Add the set handler to the contact sensor reset total characteristic
+    this.service.getCharacteristic(this.eveChar.ResetTotal).onSet(() => {
+      this.service.updateCharacteristic(this.eveChar.TimesOpened, 0)
+    })
+
+    // Add the battery service if it doesn't already exist
+    this.battService = this.accessory.getService(this.hapServ.Battery)
+    || this.accessory.addService(this.hapServ.Battery)
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('door', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const normalLogging = this.enableLogging ? 'standard' : 'disable'
+    const opts = JSON.stringify({
+      logging: this.enableDebugLogging ? 'debug' : normalLogging,
+      lowBattThreshold: this.lowBattThreshold,
+      scaleBattery: this.scaleBattery,
+    })
+    this.log('[%s] %s %s.', this.name, this.lang.devInitOpts, opts)
+  }
+
+  async externalUpdate(params) {
+    try {
+      if (hasProperty(params, 'battery') && params.battery !== this.cacheBatt) {
+        this.cacheBatt = params.battery
+        this.cacheBattScaled = this.scaleBattery ? this.cacheBatt * 10 : this.cacheBatt
+        this.cacheBattScaled = Math.max(Math.min(this.cacheBattScaled, 100), 0)
+        this.battService.updateCharacteristic(this.hapChar.BatteryLevel, this.cacheBattScaled)
+        this.battService.updateCharacteristic(
+          this.hapChar.StatusLowBattery,
+          this.cacheBattScaled < this.lowBattThreshold ? 1 : 0,
+        )
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s%].', this.name, this.lang.curBatt, this.cacheBattScaled)
+        }
+      }
+      if (
+        hasProperty(params, 'lock')
+        && [0, 1].includes(params.lock)
+        && params.lock !== this.cacheState
+      ) {
+        this.cacheState = params.lock
+        if (params.lock === 1) {
+          this.service.updateCharacteristic(this.hapChar.ContactSensorState, 1)
+          this.accessory.eveService.addEntry({ status: 1 })
+          const initialTime = this.accessory.eveService.getInitialTime()
+          this.service.updateCharacteristic(
+            this.eveChar.LastActivation,
+            Math.round(new Date().valueOf() / 1000) - initialTime,
+          )
+          const newTO = this.service.getCharacteristic(this.eveChar.TimesOpened).value + 1
+          this.service.updateCharacteristic(this.eveChar.TimesOpened, newTO)
+        } else {
+          this.service.updateCharacteristic(this.hapChar.ContactSensorState, 0)
+          this.accessory.eveService.addEntry({ status: 0 })
+        }
+        if (params.updateSource && this.enableLogging) {
+          this.log(
+            '[%s] %s [%s].',
+            this.name,
+            this.lang.curState,
+            params.lock === 0 ? this.lang.contactYes : this.lang.contactNo,
+          )
+        }
+      }
+    } catch (err) {
+      this.platform.deviceUpdateError(this.accessory, err, false)
+    }
+  }
+
+  currentState() {
+    return {
+      services: ['contact'],
+      contact: {
+        state: this.service.getCharacteristic(this.hapChar.ContactSensorState).value,
+      },
+    }
+  }
+}