@homebridge-plugins/homebridge-govee 10.12.1

package/lib/device/index.js

@@ -0,0 +1,105 @@
+import deviceCoolerSingle from './cooler-single.js'
+import deviceDehumidifierH7150 from './dehumidifier-H7150.js'
+import deviceDehumidifierH7151 from './dehumidifier-H7151.js'
+import deviceDiffuserH7161 from './diffuser-H7161.js'
+import deviceDiffuserH7162 from './diffuser-H7162.js'
+import deviceFanH7100 from './fan-H7100.js'
+import deviceFanH7101 from './fan-H7101.js'
+import deviceFanH7102 from './fan-H7102.js'
+import deviceFanH7105 from './fan-H7105.js'
+import deviceFanH7106 from './fan-H7106.js'
+import deviceFanH7111 from './fan-H7111.js'
+import deviceHeaterSingle from './heater-single.js'
+import deviceHeater1A from './heater1a.js'
+import deviceHeater1B from './heater1b.js'
+import deviceHeater2 from './heater2.js'
+import deviceHumidifierH7140 from './humidifier-H7140.js'
+import deviceHumidifierH7141 from './humidifier-H7141.js'
+import deviceHumidifierH7142 from './humidifier-H7142.js'
+import deviceHumidifierH7143 from './humidifier-H7143.js'
+import deviceHumidifierH7148 from './humidifier-H7148.js'
+import deviceHumidifierH7160 from './humidifier-H7160.js'
+import deviceIceMakerH7162 from './ice-maker-H7162.js'
+import deviceKettle from './kettle.js'
+import deviceLight from './light.js'
+import deviceLightSwitch from './light-switch.js'
+import deviceOutletDouble from './outlet-double.js'
+import deviceOutletSingle from './outlet-single.js'
+import deviceOutletTriple from './outlet-triple.js'
+import devicePurifierH712C from './purifier-H712C.js'
+import devicePurifierH7120 from './purifier-H7120.js'
+import devicePurifierH7121 from './purifier-H7121.js'
+import devicePurifierH7122 from './purifier-H7122.js'
+import devicePurifierH7123 from './purifier-H7123.js'
+import devicePurifierH7124 from './purifier-H7124.js'
+import devicePurifierH7126 from './purifier-H7126.js'
+import devicePurifierH7127 from './purifier-H7127.js'
+import devicePurifierSingle from './purifier-single.js'
+import deviceSensorButton from './sensor-button.js'
+import deviceSensorContact from './sensor-contact.js'
+import deviceSensorLeak from './sensor-leak.js'
+import deviceSensorMonitor from './sensor-monitor.js'
+import deviceSensorPresence from './sensor-presence.js'
+import deviceSensorThermo from './sensor-thermo.js'
+import deviceSensorThermo4 from './sensor-thermo4.js'
+import deviceSwitchDouble from './switch-double.js'
+import deviceSwitchSingle from './switch-single.js'
+import deviceSwitchTriple from './switch-triple.js'
+import deviceTapSingle from './tap-single.js'
+import deviceTemplate from './template.js'
+import deviceTVSingle from './tv-single.js'
+import deviceValveSingle from './valve-single.js'
+
+export default {
+  deviceCoolerSingle,
+  deviceDehumidifierH7150,
+  deviceDehumidifierH7151,
+  deviceDiffuserH7161,
+  deviceDiffuserH7162,
+  deviceFanH7100,
+  deviceFanH7101,
+  deviceFanH7102,
+  deviceFanH7105,
+  deviceFanH7106,
+  deviceFanH7111,
+  deviceHeaterSingle,
+  deviceHeater1A,
+  deviceHeater1B,
+  deviceHeater2,
+  deviceHumidifierH7140,
+  deviceHumidifierH7141,
+  deviceHumidifierH7142,
+  deviceHumidifierH7143,
+  deviceHumidifierH7148,
+  deviceHumidifierH7160,
+  deviceIceMakerH7162,
+  deviceKettle,
+  deviceLight,
+  deviceLightSwitch,
+  deviceOutletDouble,
+  deviceOutletSingle,
+  deviceOutletTriple,
+  devicePurifierH712C,
+  devicePurifierH7120,
+  devicePurifierH7121,
+  devicePurifierH7122,
+  devicePurifierH7123,
+  devicePurifierH7124,
+  devicePurifierH7126,
+  devicePurifierH7127,
+  devicePurifierSingle,
+  deviceSensorButton,
+  deviceSensorContact,
+  deviceSensorLeak,
+  deviceSensorMonitor,
+  deviceSensorPresence,
+  deviceSensorThermo,
+  deviceSensorThermo4,
+  deviceSwitchDouble,
+  deviceSwitchSingle,
+  deviceSwitchTriple,
+  deviceTapSingle,
+  deviceTemplate,
+  deviceTVSingle,
+  deviceValveSingle,
+}

package/lib/device/kettle.js

@@ -0,0 +1,269 @@
+import {
+  base64ToHex,
+  getTwoItemPosition,
+  hexToTwoItems,
+  parseError,
+  sleep,
+} from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+/*
+  Custom Mode:                                 aa050001010000000000000000000000000000af
+
+  Green Tea:      MwUAAgAAAAAAAAAAAAAAAAAAADQ= 3305000200000000000000000000000000000034 [switch]
+                  MwEBAgAAAAAAAAAAAAAAAAAAADk= 3301010200000000000000000000000000000039 [enable]
+
+  Oolong Tea:     MwUAAwAAAAAAAAAAAAAAAAAAADU= 3305000300000000000000000000000000000035 [switch]
+                  MwEBAwAAAAAAAAAAAAAAAAAAADg= 3301010300000000000000000000000000000038 [enable]
+
+  Coffee:         MwUABAAAAAAAAAAAAAAAAAAAADI= 3305000400000000000000000000000000000032 [switch]
+                  MwEBBAAAAAAAAAAAAAAAAAAAADc= 3301010400000000000000000000000000000037 [enable]
+
+  Black Tea/Boil: MwUABQAAAAAAAAAAAAAAAAAAADM= 3305000500000000000000000000000000000033 [switch]
+                  MwEBBQAAAAAAAAAAAAAAAAAAADY= 3301010500000000000000000000000000000036 [enable]
+ */
+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.platform = platform
+
+    // Set up variables from the accessory
+    this.accessory = accessory
+    const deviceConf = platform.deviceConf[accessory.context.gvDeviceId] || {}
+
+    this.codes = {
+      greenTea: 'MwUAAgAAAAAAAAAAAAAAAAAAADQ=',
+      oolongTea: 'MwUAAwAAAAAAAAAAAAAAAAAAADU=',
+      coffee: 'MwUABAAAAAAAAAAAAAAAAAAAADI=',
+      blackTea: 'MwUABQAAAAAAAAAAAAAAAAAAADM=',
+      customMode1: 'MwUAAQEAAAAAAAAAAAAAAAAAADY=',
+      customMode2: 'MwUAAQIAAAAAAAAAAAAAAAAAADU=',
+    }
+
+    // Add a switch service for Green Tea
+    this.service1 = this.accessory.getService('Green Tea')
+    if (deviceConf.hideModeGreenTea) {
+      if (this.service1) {
+        this.accessory.removeService(this.service1)
+      }
+    } else if (!this.service1) {
+      this.service1 = this.accessory.addService(this.hapServ.Switch, 'Green Tea', 'greenTea')
+      this.service1.addCharacteristic(this.hapChar.ConfiguredName)
+      this.service1.updateCharacteristic(this.hapChar.ConfiguredName, 'Green Tea')
+      this.service1.addCharacteristic(this.hapChar.ServiceLabelIndex)
+      this.service1.updateCharacteristic(this.hapChar.ServiceLabelIndex, 1)
+    }
+
+    // Add a switch service for Oolong Tea
+    this.service2 = this.accessory.getService('Oolong Tea')
+    if (deviceConf.hideModeOolongTea) {
+      if (this.service2) {
+        this.accessory.removeService(this.service2)
+      }
+    } else if (!this.service2) {
+      this.service2 = this.accessory.addService(this.hapServ.Switch, 'Oolong Tea', 'oolongTea')
+      this.service2.addCharacteristic(this.hapChar.ConfiguredName)
+      this.service2.updateCharacteristic(this.hapChar.ConfiguredName, 'Oolong Tea')
+      this.service2.addCharacteristic(this.hapChar.ServiceLabelIndex)
+      this.service2.updateCharacteristic(this.hapChar.ServiceLabelIndex, 2)
+    }
+
+    // Add a switch service for Coffee
+    this.service3 = this.accessory.getService('Coffee')
+    if (deviceConf.hideModeCoffee) {
+      if (this.service3) {
+        this.accessory.removeService(this.service3)
+      }
+    } else if (!this.service3) {
+      this.service3 = this.accessory.addService(this.hapServ.Switch, 'Coffee', 'coffee')
+      this.service3.addCharacteristic(this.hapChar.ConfiguredName)
+      this.service3.updateCharacteristic(this.hapChar.ConfiguredName, 'Coffee')
+      this.service3.addCharacteristic(this.hapChar.ServiceLabelIndex)
+      this.service3.updateCharacteristic(this.hapChar.ServiceLabelIndex, 3)
+    }
+
+    // Add a switch service for Black Tea/Boil
+    this.service4 = this.accessory.getService('Black Tea/Boil')
+    if (deviceConf.hideModeBlackTeaBoil) {
+      if (this.service4) {
+        this.accessory.removeService(this.service4)
+      }
+    } else if (!this.service4) {
+      this.service4 = this.accessory.addService(this.hapServ.Switch, 'Black Tea/Boil', 'blackTeaBoil')
+      this.service4.addCharacteristic(this.hapChar.ConfiguredName)
+      this.service4.updateCharacteristic(this.hapChar.ConfiguredName, 'Black Tea/Boil')
+      this.service4.addCharacteristic(this.hapChar.ServiceLabelIndex)
+      this.service4.updateCharacteristic(this.hapChar.ServiceLabelIndex, 4)
+    }
+
+    // Add a switch service for Custom Mode 1
+    this.service5 = this.accessory.getService('Custom Mode 1')
+    if (deviceConf.showCustomMode1) {
+      if (!this.service5) {
+        this.service5 = this.accessory.addService(this.hapServ.Switch, 'Custom Mode 1', 'customMode1')
+        this.service5.addCharacteristic(this.hapChar.ConfiguredName)
+        this.service5.updateCharacteristic(this.hapChar.ConfiguredName, 'Custom Mode 1')
+        this.service5.addCharacteristic(this.hapChar.ServiceLabelIndex)
+        this.service5.updateCharacteristic(this.hapChar.ServiceLabelIndex, 5)
+      }
+    } else if (this.service5) {
+      this.accessory.removeService(this.service5)
+    }
+
+    // Add a switch service for Custom Mode 2
+    this.service6 = this.accessory.getService('Custom Mode 2')
+    if (deviceConf.showCustomMode2) {
+      if (!this.service6) {
+        this.service6 = this.accessory.addService(this.hapServ.Switch, 'Custom Mode 2', 'customMode2')
+        this.service6.addCharacteristic(this.hapChar.ConfiguredName)
+        this.service6.updateCharacteristic(this.hapChar.ConfiguredName, 'Custom Mode 2')
+        this.service6.addCharacteristic(this.hapChar.ServiceLabelIndex)
+        this.service6.updateCharacteristic(this.hapChar.ServiceLabelIndex, 6)
+      }
+    } else if (this.service6) {
+      this.accessory.removeService(this.service6)
+    }
+
+    // Remove the temperature sensor service if it exists
+    if (this.accessory.getService(this.hapServ.TemperatureSensor)) {
+      this.accessory.removeService(this.accessory.getService(this.hapServ.TemperatureSensor))
+    }
+
+    // Add the set handler to the green tea switch if it exists
+    if (this.service1) {
+      this.service1.getCharacteristic(this.hapChar.On)
+        .updateValue(false)
+        .onSet(async value => this.internalStateUpdate(this.service1, value, this.codes.greenTea))
+    }
+
+    // Add the set handler to the oolong tea switch if it exists
+    if (this.service2) {
+      this.service2.getCharacteristic(this.hapChar.On)
+        .updateValue(false)
+        .onSet(async value => this.internalStateUpdate(this.service2, value, this.codes.oolongTea))
+    }
+
+    // Add the set handler to the coffee switch if it exists
+    if (this.service3) {
+      this.service3.getCharacteristic(this.hapChar.On)
+        .updateValue(false)
+        .onSet(async value => this.internalStateUpdate(this.service3, value, this.codes.coffee))
+    }
+
+    // Add the set handler to the black tea/boil switch if it exists
+    if (this.service4) {
+      this.service4.getCharacteristic(this.hapChar.On)
+        .updateValue(false)
+        .onSet(async value => this.internalStateUpdate(this.service4, value, this.codes.blackTea))
+    }
+
+    // Add the set handler to the custom mode 1 switch if it exists
+    if (this.service5) {
+      this.service5.getCharacteristic(this.hapChar.On)
+        .updateValue(false)
+        .onSet(async value => this.internalStateUpdate(this.service5, value, this.codes.customMode1))
+    }
+
+    // Add the set handler to the custom mode 2 switch if it exists
+    if (this.service6) {
+      this.service6.getCharacteristic(this.hapChar.On)
+        .updateValue(false)
+        .onSet(async value => this.internalStateUpdate(this.service6, value, this.codes.customMode2))
+    }
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({})
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  async internalStateUpdate(service, value, b64Code) {
+    try {
+      if (!value) {
+        return
+      }
+
+      // Send the request to the platform sender function to change the mode
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        cmd: 'ptReal',
+        value: b64Code,
+      })
+
+      await sleep(1000)
+
+      // Send the request to the platform sender function to turn to boiling mode
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        cmd: 'ptReal',
+        value: 'MwEBAAAAAAAAAAAAAAAAAAAAADM=',
+      })
+
+      // Cache the new state and log if appropriate
+      this.cacheState = 'on'
+      this.accessory.log(`${platformLang.curMode} [${service.displayName}]`)
+      setTimeout(() => {
+        service.updateCharacteristic(this.hapChar.On, false)
+      }, 3000)
+    } catch (err) {
+      // Catch any errors during the process
+      this.accessory.logWarn(`${platformLang.devNotUpdated} ${parseError(err)}`)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        service.updateCharacteristic(this.hapChar.On, false)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  externalUpdate(params) {
+    // Check for some other scene/mode change
+    (params.commands || []).forEach((command) => {
+      const hexString = base64ToHex(command)
+      const hexParts = hexToTwoItems(hexString)
+
+      // Return now if not a device query update code
+      if (getTwoItemPosition(hexParts, 1) !== 'aa') {
+        return
+      }
+
+      const deviceFunction = `${getTwoItemPosition(hexParts, 2)}${getTwoItemPosition(hexParts, 3)}`
+
+      switch (deviceFunction) {
+        case '0500': { // current mode
+          // switch to green tea_: aa050002000000000000000000000000000000ad
+          // switch to oolong tea: aa050003000000000000000000000000000000ac
+          // switch to coffee____: aa050004000000000000000000000000000000ab
+          // switch to black tea_: aa050005000000000000000000000000000000aa
+          // switch to preset1___: aa050001010000000000000000000000000000af
+          // switch to preset2___: aa050001020000000000000000000000000000ac
+          // No point in changing any switches for the sake of three seconds, no action taken here
+          break
+        }
+        case '1001': { // current temperature in F
+          // const currentTempInF = hexToDecimal(`${getTwoItemPosition(hexParts, 4)}${getTwoItemPosition(hexParts, 5)}`);
+          // const currentTempInC = farToCen(currentTempInF / 100);
+          break
+        }
+        case '1700': { // on/off base?
+          const onBase = getTwoItemPosition(hexParts, 4) === '00' ? 'yes' : 'no'
+          if (this.cacheOnBase !== onBase) {
+            this.cacheOnBase = onBase
+            this.accessory.log(`current on base [${this.cacheOnBase}]`)
+          }
+          break
+        }
+        case '2200': // keep warm off
+        case '2201': // keep warm on
+        case '2300': // scheduled start off
+        case '2301': { // scheduled start on
+          break
+        }
+        default:
+          this.accessory.logDebugWarn(`${platformLang.newScene}: [${command}] [${hexString}]`)
+          break
+      }
+    })
+  }
+}

package/lib/device/light-switch.js

@@ -0,0 +1,86 @@
+import { parseError } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.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.platform = platform
+
+    // Set up variables from the accessory
+    this.accessory = accessory
+
+    // Remove any lightbulb service
+    if (accessory.getService(this.hapServ.Lightbulb)) {
+      accessory.removeService(accessory.getService(this.hapServ.Lightbulb))
+    }
+
+    // Add the main switch service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.Switch)
+    || this.accessory.addService(this.hapServ.Switch)
+
+    // Add the set handler to the lightbulb on/off characteristic
+    this.service.getCharacteristic(this.hapChar.On).onSet(async (value) => {
+      await this.internalStateUpdate(value)
+    })
+    this.cacheState = this.service.getCharacteristic(this.hapChar.On).value ? 'on' : 'off'
+
+    // Output the customised options to the log
+    const useAWSControl = accessory.context.useAWSControl ? 'enabled' : 'disabled'
+    const useBLEControl = accessory.context.useBLEControl ? 'enabled' : 'disabled'
+    const useLANControl = accessory.context.useLANControl ? 'enabled' : 'disabled'
+    const opts = JSON.stringify({
+      aws: accessory.context.hasAWSControl ? useAWSControl : 'unsupported',
+      ble: accessory.context.hasBLEControl ? useBLEControl : 'unsupported',
+      lan: accessory.context.hasLANControl ? useLANControl : 'unsupported',
+      showAs: 'switch',
+    })
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  async internalStateUpdate(value) {
+    try {
+      const newValue = value ? 'on' : 'off'
+
+      // Don't continue if the new value is the same as before
+      if (newValue === this.cacheState) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        cmd: 'state',
+        value: newValue,
+      })
+
+      // Cache the new state and log if appropriate
+      if (this.cacheState !== newValue) {
+        this.cacheState = newValue
+        this.accessory.log(`${platformLang.curState} [${this.cacheState}]`)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      this.accessory.logWarn(`${platformLang.devNotUpdated} ${parseError(err)}`)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.On, this.cacheState === 'on')
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  externalUpdate(params) {
+    // Check to see if the provided state is different from the cached value
+    if (params.state && params.state !== this.cacheState) {
+      // State is different so update Homebridge with new values
+      this.cacheState = params.state
+      this.service.updateCharacteristic(this.hapChar.On, this.cacheState === 'on')
+
+      // Log the change
+      this.accessory.log(`${platformLang.curState} [${this.cacheState}]`)
+    }
+  }
+}