@homebridge-plugins/homebridge-govee 10.12.1

package/lib/device/purifier-single.js

@@ -0,0 +1,119 @@
+import { generateRandomString, 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 old services from simulations
+    ['HeaterCooler', 'Lightbulb', 'Outlet', 'Switch', 'Valve'].forEach((service) => {
+      if (this.accessory.getService(this.hapServ[service])) {
+        this.accessory.removeService(this.accessory.getService(this.hapServ[service]))
+      }
+    })
+
+    // Add the purifier service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.AirPurifier)
+    || this.accessory.addService(this.hapServ.AirPurifier)
+
+    // Add the set handler to the switch on/off characteristic
+    this.service.getCharacteristic(this.hapChar.Active).onSet(async (value) => {
+      await this.internalStateUpdate(value)
+    })
+    this.cacheState = this.service.getCharacteristic(this.hapChar.Active).value === 1 ? 'on' : 'off'
+
+    // Add options to the purifier target state characteristic
+    this.service
+      .getCharacteristic(this.hapChar.TargetAirPurifierState)
+      .updateValue(1)
+      .setProps({
+        minValue: 1,
+        maxValue: 1,
+        validValues: [1],
+      })
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('switch', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({
+      showAs: 'purifier',
+    })
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  async internalStateUpdate(value) {
+    try {
+      const newValue = value === 1 ? 'on' : 'off'
+
+      // Don't continue if the new value is the same as before
+      if (newValue === this.cacheState) {
+        return
+      }
+
+      // Set up a one-minute timeout for the plugin to ignore incoming updates
+      const timerKey = generateRandomString(5)
+      this.updateTimeout = timerKey
+      setTimeout(() => {
+        if (this.updateTimeout === timerKey) {
+          this.updateTimeout = false
+        }
+      }, 60000)
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        cmd: 'stateOutlet',
+        value: newValue,
+      })
+
+      // Cache the new state and log if appropriate
+      if (this.cacheState !== newValue) {
+        this.cacheState = newValue
+        this.accessory.log(`${platformLang.curState} [${this.cacheState}]`)
+      }
+
+      // Add the entry to the Eve history service
+      this.accessory.eveService.addEntry({ status: value ? 1 : 0 })
+      this.service.updateCharacteristic(this.hapChar.CurrentAirPurifierState, value === 1 ? 2 : 0)
+    } 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.Active, this.cacheState === 'on' ? 1 : 0)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  externalUpdate(params) {
+    // Check to see if the provided state is different from the cached state
+    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.Active, this.cacheState === 'on' ? 1 : 0)
+      this.service.updateCharacteristic(
+        this.hapChar.CurrentAirPurifierState,
+        this.cacheState === 'on' ? 2 : 0,
+      )
+
+      // Log the change
+      this.accessory.log(`${platformLang.curState} [${this.cacheState}]`)
+
+      // Add the entry to the Eve history service
+      this.accessory.eveService.addEntry({
+        status: this.cacheState === 'on' ? 1 : 0,
+      })
+    }
+  }
+}

package/lib/device/sensor-button.js

@@ -0,0 +1,22 @@
+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
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({})
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  externalUpdate(params) {
+    this.accessory.logWarn(`${platformLang.newScene}: [${params.scene}]`)
+  }
+}

package/lib/device/sensor-contact.js

@@ -0,0 +1,22 @@
+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
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({})
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  externalUpdate(params) {
+    this.accessory.logWarn(`${platformLang.newScene}: [${params.scene}]`)
+  }
+}

package/lib/device/sensor-leak.js

@@ -0,0 +1,87 @@
+import platformConsts from '../utils/constants.js'
+import { hasProperty } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.eveChar = platform.eveChar
+    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
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.gvDeviceId]
+    this.lowBattThreshold = deviceConf && deviceConf.lowBattThreshold
+      ? Math.min(deviceConf.lowBattThreshold, 100)
+      : platformConsts.defaultValues.lowBattThreshold
+
+    // Add the leak sensor service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.LeakSensor)
+    if (!this.service) {
+      this.service = this.accessory.addService(this.hapServ.LeakSensor)
+
+      // Adding the characteristic here avoids Homebridge characteristic warnings
+      this.service.addCharacteristic(this.eveChar.LastActivation)
+    }
+    this.cacheLeak = !!this.service.getCharacteristic(this.hapChar.LeakDetected).value
+
+    // 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
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('motion', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({})
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  externalUpdate(params) {
+    // Check to see if the provided online status is different from the cache value
+    if (hasProperty(params, 'online') && this.cacheOnline !== params.online) {
+      this.cacheOnline = params.online
+      this.platform.updateAccessoryStatus(this.accessory, this.cacheOnline)
+    }
+
+    // Check to see if the provided battery is different from the cached state
+    if (params.battery !== this.cacheBatt) {
+      // Battery is different so update Homebridge with new values
+      this.cacheBatt = params.battery
+      this.battService.updateCharacteristic(this.hapChar.BatteryLevel, this.cacheBatt)
+      this.battService.updateCharacteristic(
+        this.hapChar.StatusLowBattery,
+        this.cacheBatt < this.lowBattThreshold ? 1 : 0,
+      )
+
+      // Log the change
+      this.accessory.log(`${platformLang.curBatt} [${this.cacheBatt}%]`)
+    }
+
+    // Check to see if the provided leak status is different from the cached state
+    if (params.leakDetected !== this.cacheLeak) {
+      // Leak status is different so update Homebridge with new values
+      this.cacheLeak = params.leakDetected
+      this.service.updateCharacteristic(this.hapChar.LeakDetected, this.cacheLeak ? 1 : 0)
+
+      // Add the alert to Eve if a leak has been detected
+      if (this.cacheLeak) {
+        this.service.updateCharacteristic(
+          this.eveChar.LastActivation,
+          Math.round(new Date().valueOf() / 1000) - this.accessory.eveService.getInitialTime(),
+        )
+      }
+
+      // Log the change
+      this.accessory.log(`${platformLang.curLeak} [${this.cacheLeak ? platformLang.labelYes : platformLang.labelNo}]`)
+    }
+  }
+}

package/lib/device/sensor-monitor.js

@@ -0,0 +1,190 @@
+import platformConsts from '../utils/constants.js'
+import {
+  base64ToHex,
+  cenToFar,
+  getTwoItemPosition,
+  hexToDecimal,
+  hexToTwoItems,
+  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
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.gvDeviceId]
+    this.lowBattThreshold = deviceConf && deviceConf.lowBattThreshold
+      ? Math.min(deviceConf.lowBattThreshold, 100)
+      : platformConsts.defaultValues.lowBattThreshold
+
+    // Add the temperature service if it doesn't already exist
+    this.tempService = this.accessory.getService(this.hapServ.TemperatureSensor)
+    || this.accessory.addService(this.hapServ.TemperatureSensor)
+    this.cacheTemp = this.tempService.getCharacteristic(this.hapChar.CurrentTemperature).value
+    this.updateCache()
+
+    // Add the humidity service if it doesn't already exist
+    this.humiService = this.accessory.getService(this.hapServ.HumiditySensor)
+    || this.accessory.addService(this.hapServ.HumiditySensor)
+    this.cacheHumi = this.humiService.getCharacteristic(this.hapChar.CurrentRelativeHumidity).value
+
+    // Add the air quality service if it doesn't already exist
+    this.airService = this.accessory.getService(this.hapServ.AirQualitySensor)
+
+    if (!this.airService) {
+      this.airService = this.accessory.addService(this.hapServ.AirQualitySensor)
+      this.airService.addCharacteristic(this.hapChar.PM2_5Density)
+    }
+    this.cacheAir = this.airService.getCharacteristic(this.hapChar.PM2_5Density).value
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('custom', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({
+      lowBattThreshold: this.lowBattThreshold,
+    })
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  async externalUpdate(params) {
+    // Check for some other scene/mode change
+    (params.commands || []).forEach((command) => {
+      const hexString = base64ToHex(command)
+      const hexParts = hexToTwoItems(hexString)
+
+      const deviceFunction = `${getTwoItemPosition(hexParts, 1)}${getTwoItemPosition(hexParts, 2)}`
+
+      switch (deviceFunction) {
+        case '0000':
+        case '0003':
+        case '0100':
+        case '0101':
+        case '0102':
+        case '0103':
+        case '331a':
+        case '3315':
+        case 'aa0d':
+        case 'aa0e':
+          break
+        default: {
+          const tempInCen = Math.round((hexToDecimal(`0x${deviceFunction}`) + (this.accessory.context.offTemp / 100)) / 10) / 10
+
+          // Check to see if the provided temperature is different from the cached state
+          if (tempInCen !== this.cacheTemp) {
+            // Temperature is different so update Homebridge with new values
+            this.cacheTemp = tempInCen
+            this.tempService.updateCharacteristic(this.hapChar.CurrentTemperature, this.cacheTemp)
+            this.accessory.eveService.addEntry({ temp: this.cacheTemp })
+
+            // Log the change
+            this.accessory.log(`${platformLang.curTemp} [${this.cacheTemp}°C / ${cenToFar(tempInCen)}°F]`)
+
+            // Update the cache file with the new temperature
+            this.updateCache()
+          }
+
+          // Check to see if the provided humidity is different from the cached state
+          const humiHex = `${getTwoItemPosition(hexParts, 10)}${getTwoItemPosition(hexParts, 11)}`
+          const humiDec = Math.round(`0x${humiHex}` / 100) + (this.accessory.context.offHumi / 100)
+          if (humiDec !== this.cacheHumi) {
+            // Humidity is different so update Homebridge with new values
+            this.cacheHumi = humiDec
+            this.humiService.updateCharacteristic(this.hapChar.CurrentRelativeHumidity, this.cacheHumi)
+            this.accessory.eveService.addEntry({ humidity: this.cacheHumi })
+
+            // Log the change
+            this.accessory.log(`${platformLang.curHumi} [${this.cacheHumi}%]`)
+          }
+
+          // Check air quality reading
+          const qualHex = `${getTwoItemPosition(hexParts, 19)}${getTwoItemPosition(hexParts, 20)}`
+          const qualDec = hexToDecimal(`0x${qualHex}`)
+          if (qualDec !== this.cacheAir) {
+            // Air quality is different so update Homebridge with new values
+            this.cacheAir = qualDec
+            this.airService.updateCharacteristic(this.hapChar.PM2_5Density, this.cacheAir)
+
+            // Log the change
+            this.accessory.log(`${platformLang.curPM25} [${qualDec}µg/m³]`)
+
+            // Check for any change to the main air quality characteristic
+            // PM2.5 has a range of 0-1000µg/m³
+            // HK characteristic ranges from 1-5 (excellent, good, fair, inferior, poor)
+            // Scales based on Govee manual
+            // 0-12.0µg/m³ = excellent
+            // 12-35µg/m³ = good
+            // 35-75µg/m³ = fair
+            // 75-115µg/m³ = inferior
+            // 115-500µg/m³ = poor (use 1000 for HK)
+            if (this.cacheAir <= 12) {
+              const newValue = 'excellent'
+              if (this.cacheAirQual !== newValue) {
+                this.cacheAirQual = newValue
+                this.airService.updateCharacteristic(this.hapChar.AirQuality, 1)
+                this.accessory.log(`${platformLang.curAirQual} [${newValue}]`)
+              }
+            } else if (this.cacheAir <= 35) {
+              const newValue = 'good'
+              if (this.cacheAirQual !== newValue) {
+                this.cacheAirQual = newValue
+                this.airService.updateCharacteristic(this.hapChar.AirQuality, 2)
+                this.accessory.log(`${platformLang.curAirQual} [${newValue}]`)
+              }
+            } else if (this.cacheAir <= 75) {
+              const newValue = 'fair'
+              if (this.cacheAirQual !== newValue) {
+                this.cacheAirQual = newValue
+                this.airService.updateCharacteristic(this.hapChar.AirQuality, 3)
+                this.accessory.log(`${platformLang.curAirQual} [${newValue}]`)
+              }
+            } else if (this.cacheAir <= 115) {
+              const newValue = 'inferior'
+              if (this.cacheAirQual !== newValue) {
+                this.cacheAirQual = newValue
+                this.airService.updateCharacteristic(this.hapChar.AirQuality, 4)
+                this.accessory.log(`${platformLang.curAirQual} [${newValue}]`)
+              }
+            } else {
+              const newValue = 'poor'
+              if (this.cacheAirQual !== newValue) {
+                this.cacheAirQual = newValue
+                this.airService.updateCharacteristic(this.hapChar.AirQuality, 5)
+                this.accessory.log(`${platformLang.curAirQual} [${newValue}]`)
+              }
+            }
+          }
+          break
+        }
+      }
+    })
+  }
+
+  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.gvDeviceId}_temp`,
+        this.cacheTemp,
+      )
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.storageWriteErr} ${parseError(err)}`)
+    }
+  }
+}

package/lib/device/sensor-presence.js

@@ -0,0 +1,53 @@
+import { base64ToHex, getTwoItemPosition, hexToTwoItems } 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
+
+    // Add the occupancy sensor if it does not already exist
+    this.service = this.accessory.getService(this.hapServ.OccupancySensor) || this.accessory.addService(this.hapServ.OccupancySensor)
+    this.cacheState = this.service.getCharacteristic(this.hapChar.OccupancyDetected).value
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({})
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  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, 1)}${getTwoItemPosition(hexParts, 2)}`
+
+      switch (deviceFunction) {
+        case 'aa01': { // lock
+          const newState = getTwoItemPosition(hexParts, 3) === '01' ? 1 : 0
+          if (newState !== this.cacheState) {
+            this.cacheState = newState
+            this.service.updateCharacteristic(this.hapChar.OccupancyDetected, this.cacheState)
+            this.accessory.log(`${platformLang.curOcc} [${this.cacheState === 1 ? 'yes' : 'no'}]`)
+          }
+          break
+        }
+        default:
+          this.accessory.logDebugWarn(`${platformLang.newScene}: [${command}] [${hexString}]`)
+          break
+      }
+    })
+  }
+}

package/lib/device/sensor-thermo.js

@@ -0,0 +1,144 @@
+import platformConsts from '../utils/constants.js'
+import {
+  cenToFar,
+  generateRandomString,
+  hasProperty,
+  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
+    this.httpTimeout = platform.config.bleRefreshTime * 4.5 * 1000
+
+    // Set up variables from the accessory
+    this.accessory = accessory
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.gvDeviceId]
+    this.lowBattThreshold = deviceConf && deviceConf.lowBattThreshold
+      ? Math.min(deviceConf.lowBattThreshold, 100)
+      : platformConsts.defaultValues.lowBattThreshold
+
+    // Add the temperature service if it doesn't already exist
+    this.tempService = this.accessory.getService(this.hapServ.TemperatureSensor)
+    || this.accessory.addService(this.hapServ.TemperatureSensor)
+    this.cacheTemp = this.tempService.getCharacteristic(this.hapChar.CurrentTemperature).value
+    this.updateCache()
+
+    // Add the humidity service if it doesn't already exist
+    this.humiService = this.accessory.getService(this.hapServ.HumiditySensor)
+    || this.accessory.addService(this.hapServ.HumiditySensor)
+    this.cacheHumi = this.humiService.getCharacteristic(this.hapChar.CurrentRelativeHumidity).value
+
+    // 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
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('custom', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({
+      lowBattThreshold: this.lowBattThreshold,
+    })
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+  }
+
+  async externalUpdate(params) {
+    // Check to see if the provided online status is different from the cache value
+    if (hasProperty(params, 'online') && this.cacheOnline !== params.online) {
+      this.cacheOnline = params.online
+      this.platform.updateAccessoryStatus(this.accessory, this.cacheOnline)
+    }
+
+    if (params.source === 'BLE') {
+      // If we have a BLE update then we should ignore HTTP updates for the next 4 BLE refresh cycles
+      // Since BLE will be more accurate and may not have updated with the cloud yet
+      // Generate a random key
+      const bleKey = generateRandomString(5)
+      this.bleKey = bleKey
+      setTimeout(() => {
+        if (this.bleKey === bleKey) {
+          this.bleKey = false
+        }
+      }, this.httpTimeout)
+    }
+    if (params.source === 'HTTP' && this.bleKey) {
+      return
+    }
+
+    // Check to see if the provided battery is different from the cached state
+    if (params.battery !== this.cacheBatt && this.battService) {
+      // Battery is different so update Homebridge with new values
+      this.cacheBatt = params.battery
+      this.battService.updateCharacteristic(this.hapChar.BatteryLevel, this.cacheBatt)
+      this.battService.updateCharacteristic(
+        this.hapChar.StatusLowBattery,
+        this.cacheBatt < this.lowBattThreshold ? 1 : 0,
+      )
+
+      // Log the change
+      this.accessory.log(`${platformLang.curBatt} [${this.cacheBatt}%]`)
+    }
+
+    // Check to see if the provided temperature is different from the cached state
+    if (hasProperty(params, 'temperature')) {
+      let newTemp = Number.parseInt(params.temperature + this.accessory.context.offTemp, 10)
+      newTemp /= 100
+      if (newTemp !== this.cacheTemp) {
+        // Temperature is different so update Homebridge with new values
+        this.cacheTemp = newTemp
+        this.tempService.updateCharacteristic(this.hapChar.CurrentTemperature, this.cacheTemp)
+        this.accessory.eveService.addEntry({ temp: this.cacheTemp })
+
+        // Log the change
+        this.accessory.log(`${platformLang.curTemp} [${this.cacheTemp}°C / ${cenToFar(this.cacheTemp)}°F]`)
+
+        // Update the cache file with the new temperature
+        this.updateCache()
+      }
+    }
+
+    // Check to see if the provided humidity is different from the cached state
+    if (hasProperty(params, 'humidity')) {
+      let newHumi = Number.parseInt(params.humidity + this.accessory.context.offHumi, 10)
+      newHumi /= 100
+      newHumi = Math.max(Math.min(newHumi, 100), 0)
+      if (newHumi !== this.cacheHumi) {
+        // Humidity is different so update Homebridge with new values
+        this.cacheHumi = newHumi
+        this.humiService.updateCharacteristic(this.hapChar.CurrentRelativeHumidity, this.cacheHumi)
+        this.accessory.eveService.addEntry({ humidity: this.cacheHumi })
+
+        // Log the change
+        this.accessory.log(`${platformLang.curHumi} [${this.cacheHumi}%]`)
+      }
+    }
+  }
+
+  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.gvDeviceId}_temp`,
+        this.cacheTemp,
+      )
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.storageWriteErr} ${parseError(err)}`)
+    }
+  }
+}