@homebridge-plugins/homebridge-govee 11.32.2-beta.2 → 11.32.2-beta.20

package/CHANGELOG.md

@@ -9,6 +9,37 @@ All notable changes to `@homebridge-plugins/homebridge-govee` will be documented
 - fix: implement the H7107's oscillation toggle, which threw a not-implemented error when tapped (#1334)
 - fix: also send the H7107's oscillation command as the multiSync frame the fan itself uses, since the first shape only turned it off sometimes (#1334)
 - fix: send the H7107's oscillation-off command without the swing-range bytes, matching the zero-tailed frame the fan echoes back (#1334)
+- feat: add support for the H8121 and H8122 ice makers, with small, medium and large ice sizes (pending owner confirmation)
+- fix: send the H6102 the colour command its firmware expects, since the previous one was accepted but ignored (#1332)
+- fix: read the H5179 sensor's temperature from its own bytes, since it was picking up part of the humidity and reporting slightly wrong
+- feat: log govee sensors whose bluetooth broadcast is not recognised, so unsupported models can be identified
+- feat: report unrecognised device data in one line with the model, firmware and connection, so it can be sent in without follow-up questions
+- feat: work out for itself whether a heater reports the room temperature, and add the H7137 and H713E
+- feat: add support for 85 more light models, covering everything currently sold that was missing
+- feat: add 24 more light models, three thermo-hygrometers and a leak detector
+- feat: add the H7103 and H7112 fans and the H5085 plug, with unknown controls saying so instead of guessing
+- feat: give every appliance type a starting handler, so a new model works for on and off and asks for the rest
+- refactor: point models that behave identically at one shared handler instead of copies of the same file
+- fix: stop shipping the test files to npm, since they are only needed in the repository
+- fix: refuse to send a bluetooth command too long to fit in a packet, rather than sending a longer one the device quietly ignores
+- test: record what every supported model turns into, so a change can be shown to have altered nothing
+- feat: work out what an appliance can do from what the device itself reports, so a model nobody has written down still gets the right controls
+- feat: offer oscillation and the child lock on any appliance that reports having them, driven through govee's api rather than needing that model's command codes
+- refactor: point three more models at a shared handler instead of a near-copy of the same file, keeping each one's behaviour exactly as it was
+- fix: give the H7124 the air quality handling the H7123 already had, so a poor reading is named properly and stops being logged over and over (#1261)
+- refactor: point the H7151 and H7111 at the handlers they were byte-for-byte copies of
+- refactor: build the ice maker size codes from the model rather than writing both orderings out by hand
+- refactor: build the switch and outlet tiles of a multi-socket device from one handler instead of two copies of it
+- fix: move the H7152 dehumidifier's speed slider when it reports a new speed, which until now only the H7150 and H7151 did
+- refactor: point the H7101 and H7111 fans at the H7100 handler they matched command for command
+- feat: give a diffuser model that has not been worked out yet the same starting handler the other appliances have, so it works for on and off
+- refactor: choose a device handler from a table, so adding a device type no longer means editing the platform
+- refactor: move the settings parsing into its own file, away from the code that talks to devices
+- refactor: move the work of describing a device to its handler into its own file
+- refactor: move the rules for combining govee's device lists, and for letting go of a device that has gone, into their own file with tests
+- test: check what the plugin sends over aws, the local network and the public api, none of which was covered before
+- feat: say when govee has not listed a capability the plugin is about to use, since the request then succeeds and the device does nothing
+- docs: note that the local network api accepts the raw command form, which is how scenes work without the cloud
 
 ## v11.32.1 (2026-08-02)
 

package/config.schema.json

@@ -1260,7 +1260,7 @@
             "tempReporting": {
               "type": "boolean",
               "title": "Temperature Reporting",
-              "description": "Enable this if your H7130 device reports ambient temperature.",
+              "description": "Only needed to override the plugin. It works out on its own whether this heater reports the room temperature, and picks the right tile.",
               "condition": {
                 "functionBody": "return (model.heaterDevices && model.heaterDevices[arrayIndices] && model.heaterDevices[arrayIndices].deviceId && model.heaterDevices[arrayIndices].deviceId.length === 23);"
               }

package/lib/connection/ble.js

@@ -7,6 +7,7 @@ import { BLE_STAGE_TIMEOUTS, UUID } from '../utils/ble-protocol.js'
 import { decodeAny } from '../utils/decode.js'
 import { base64ToHex, generateCodeFromHexValues, hexToTwoItems, sleep } from '../utils/functions.js'
 import platformLang from '../utils/lang-en.js'
+import { isFirstReport } from '../utils/report-unknown.js'
 import { isValidPeripheral } from '../utils/validation.js'
 
 const HYPHEN_REGEX = /-/g
@@ -120,8 +121,32 @@ export default class BLEConnection {
     try {
       const { uuid, address, rssi, advertisement } = peripheral
 
-      // Skip if not a valid Govee sensor
+      // Skip if not a valid Govee sensor. Sensors whose broadcast the plugin
+      // cannot decode yet are logged rather than dropped in silence, since the
+      // hex is the one thing needed to add a model, and there is no other way
+      // for an owner to get hold of it.
       if (!isValidPeripheral(peripheral)) {
+        const unknownName = advertisement?.localName
+        if (unknownName && unknownName.toLowerCase().startsWith('govee')) {
+          const raw = advertisement.manufacturerData
+            ? advertisement.manufacturerData.toString('hex')
+            : 'no manufacturer data'
+          const line = `[BLE] unrecognised govee sensor - please include this line if you report it: ${JSON.stringify({
+            name: unknownName,
+            address,
+            source: 'BLE',
+            kind: 'broadcast',
+            raw,
+          })}`
+
+          // Say it once so it is actually noticed, then stay quiet about this
+          // sensor for the rest of the session - it rebroadcasts constantly.
+          if (isFirstReport(`ble|${address}|${raw}`)) {
+            this.log.warn(line)
+          } else {
+            this.log.debug(line)
+          }
+        }
         return
       }
 

package/lib/connection/openapi.js

@@ -3,6 +3,7 @@ import mqtt from 'mqtt'
 
 import { k2rgb } from '../utils/colour.js'
 import { describeControlFailure, parseError } from '../utils/functions.js'
+import { isFirstReport } from '../utils/report-unknown.js'
 
 const BASE_URL = 'https://openapi.api.govee.com'
 
@@ -381,6 +382,23 @@ export default class {
     if (capability?.type && capability?.instance) {
       return capability
     }
+
+    // The device never listed this one. Govee will still accept the request and
+    // answer as though it worked, then do nothing - so without saying something
+    // here the control simply appears broken with no clue why. Said once per
+    // device and capability, then dropped to debug
+    const fingerprint = `openapi-unlisted|${accessory.context.gvDeviceId}|${instance}`
+    const message = `govee did not list [${instance}] for this device, so that command may be ignored - please report this line if the control does not work: ${JSON.stringify({
+      model: accessory.context.gvModel,
+      instance,
+      listed: Object.keys(lookup),
+    })}`
+    if (isFirstReport(fingerprint)) {
+      accessory.logDebugWarn(message)
+    } else {
+      accessory.logDebug(message)
+    }
+
     return {
       type: fallbackType,
       instance,

package/lib/device/appliance-basic.js

@@ -0,0 +1,377 @@
+import { describeSources, resolveControls } from '../utils/capabilities.js'
+import { base64ToHex, getTwoItemPosition, hexToTwoItems, parseError } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+import { logUnknownData, reportUnsupportedControl } from '../utils/report-unknown.js'
+
+/**
+ * A starting point for any appliance whose power command is known but whose
+ * other controls are not.
+ *
+ * Govee uses the same on/off command for every appliance the plugin handles, so
+ * power can be offered with confidence for a model nobody has tested. The
+ * settings that differ per model - speeds, modes, sizes - are the risky part,
+ * and getting one wrong is worse than not offering it. So those controls appear
+ * but report what they need and fail the request, rather than sending a guess.
+ *
+ * Failing rather than doing nothing is deliberate: HomeKit shows the control as
+ * not responding, which is what sends the owner to the log, where they find a
+ * line to paste into an issue. That turns every owner of an untested model into
+ * the source of the data needed to finish it.
+ *
+ * Once that data arrives the model gets a proper handler and stops using this.
+ */
+class ApplianceBasic {
+  constructor(platform, accessory, config) {
+    // 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
+    this.config = config
+
+    // Work out what this particular device can do, rather than what its model
+    // generally can - for a model nobody has written down, what the device
+    // itself reported is all there is to go on
+    const resolved = resolveControls({
+      model: accessory.context.gvModel,
+      family: config.family,
+      firmware: accessory.context.firmware,
+      openApiCapabilities: accessory.context.openApiCapabilities,
+      deviceConf: platform.deviceConf?.[accessory.context.gvDeviceId],
+    })
+    this.controls = resolved.controls
+    this.cacheToggles = {}
+    this.discoveredControls = []
+
+    // Some appliances can have a richer tile, but only if the device reports
+    // the reading that tile needs - HomeKit's humidifier, for example, has to
+    // show a current humidity, and plenty of Govee humidifiers never send one.
+    // Where the device says it has that sensor, use the better tile; otherwise
+    // fall back to the plain one, which needs nothing extra.
+    const hasSensor = config.richControl && this.controls[config.richControl]
+    const serviceName = (config.richService && hasSensor) ? config.richService : config.service
+    this.usingRichService = serviceName === config.richService
+
+    // Drop the other service if this device has switched between the two
+    const otherName = this.usingRichService ? config.service : config.richService
+    if (otherName && this.hapServ[otherName]) {
+      const stale = this.accessory.getService(this.hapServ[otherName])
+      if (stale) {
+        this.accessory.removeService(stale)
+      }
+    }
+
+    const serviceType = this.hapServ[serviceName]
+    this.service = this.accessory.getService(serviceType)
+      || this.accessory.addService(serviceType)
+
+    // The plain Fan service switches on a boolean `On`, while Fanv2 and
+    // AirPurifier use `Active`. Follow whichever this service uses, so these
+    // tiles behave like the hand-written handlers for the same kind of device.
+    const usesOn = serviceName === 'Fan'
+    this.powerChar = usesOn ? this.hapChar.On : this.hapChar.Active
+    this.powerOn = usesOn ? true : 1
+    this.powerOff = usesOn ? false : 0
+
+    // Add the set handler to the power characteristic
+    this.service
+      .getCharacteristic(this.powerChar)
+      .onSet(async value => this.internalStateUpdate(value))
+    this.cacheState = this.service.getCharacteristic(this.powerChar).value ? 'on' : 'off'
+
+    // Some services need a current-state characteristic to look right in the
+    // Home app. It belongs to the richer tile, so it is skipped when a device
+    // has fallen back to the plain fan for want of a sensor.
+    const fellBackToPlain = !!config.richService && !this.usingRichService
+    if (config.currentStateChar && !fellBackToPlain) {
+      this.currentStateChar = this.hapChar[config.currentStateChar]
+      this.service.updateCharacteristic(
+        this.currentStateChar,
+        this.cacheState === 'on' ? config.currentStateOn : config.currentStateOff,
+      )
+    }
+
+    // Offer the variable control so the device can be asked about it, but make
+    // it clear it does nothing yet rather than sending a guessed command. The
+    // richer services name this control differently, so follow the service.
+    const variableChar = this.usingRichService && config.richVariableChar
+      ? config.richVariableChar
+      : config.variableChar
+    if (variableChar) {
+      this.variableChar = this.hapChar[variableChar]
+      this.service
+        .getCharacteristic(this.variableChar)
+        .onSet(async value => this.internalVariableUpdate(value))
+      this.cacheVariable = this.service.getCharacteristic(this.variableChar).value
+    }
+
+    // A control the device told us about can be driven through Govee's own api
+    // by name, without knowing this model's command bytes. So unlike the
+    // settings above, these work rather than asking to be reported.
+    this.addDiscoveredToggle('swing', 'SwingMode', 'oscillationToggle')
+    this.addDiscoveredToggle('lock', 'LockPhysicalControls', 'lockToggle')
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({})
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+    this.accessory.logDebug(`controls: ${describeSources(resolved.sources)}`)
+
+    const working = ['on and off', ...this.discoveredControls]
+    this.accessory.log(`${working.join(', ')} ${working.length > 1 ? 'are' : 'is'} supported for this model, the ${config.variableLabel || 'other settings'} are not known yet`)
+  }
+
+  /**
+   * Offer a control the device said it has, driven through Govee's api by the
+   * name the device gave it.
+   *
+   * This is the one place a model nobody has tested gets something that really
+   * works beyond power: the api takes the capability name, so the command bytes
+   * for this model never have to be known.
+   */
+  addDiscoveredToggle(control, characteristic, instance) {
+    const char = this.hapChar[characteristic]
+
+    // The device has to have named this capability itself. Knowing the model
+    // usually has a turning head is not enough - the api is driven by the name
+    // the device reported, so without it there is nothing to send, and the
+    // switch would fail every time it was touched.
+    const reported = !!this.accessory.context.openApiCapabilities?.[instance]
+
+    if (!reported || !this.controls[control] || !char) {
+      if (this.service.testCharacteristic?.(char)) {
+        this.service.removeCharacteristic(this.service.getCharacteristic(char))
+      }
+      return
+    }
+
+    this.service
+      .getCharacteristic(char)
+      .onSet(async value => this.internalToggleUpdate(control, char, instance, value))
+    this.cacheToggles[control] = this.service.getCharacteristic(char).value
+
+    this.discoveredControls.push(control === 'swing' ? 'oscillation' : 'the child lock')
+  }
+
+  async internalToggleUpdate(control, characteristic, instance, value) {
+    const previous = this.cacheToggles[control]
+    try {
+      if (previous === value) {
+        return
+      }
+
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        cmd: 'openApi',
+        openApi: {
+          instance,
+          capabilityType: 'devices.capabilities.toggle',
+          value: value ? 1 : 0,
+        },
+      })
+
+      this.cacheToggles[control] = value
+      this.accessory.log(`current ${control} [${value ? 'on' : 'off'}]`)
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.devNotUpdated} ${parseError(err)}`)
+      setTimeout(() => {
+        this.service.updateCharacteristic(characteristic, previous)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalStateUpdate(value) {
+    try {
+      const newValue = value ? 'on' : 'off'
+
+      // Don't continue if the new value is the same as before
+      if (this.cacheState === newValue) {
+        return
+      }
+
+      // This power command is the same for every govee appliance, so it is safe
+      // to send for a model that has not been tested
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        cmd: 'ptReal',
+        value: value ? 'MwEBAAAAAAAAAAAAAAAAAAAAADM=' : 'MwEAAAAAAAAAAAAAAAAAAAAAADI=',
+        openApi: this.accessory.context.openApiCapabilities?.powerSwitch
+          ? { instance: 'powerSwitch', capabilityType: 'devices.capabilities.on_off', value: value ? 1 : 0 }
+          : undefined,
+      })
+
+      // Cache the new state and log if appropriate
+      this.cacheState = newValue
+      if (this.currentStateChar) {
+        this.service.updateCharacteristic(
+          this.currentStateChar,
+          value ? this.config.currentStateOn : this.config.currentStateOff,
+        )
+      }
+      this.accessory.log(`${platformLang.curState} [${newValue}]`)
+    } 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)
+    }
+  }
+
+  async internalVariableUpdate(value) {
+    // 0 is the control following the device being turned off, not a request
+    if (value === 0) {
+      return
+    }
+
+    reportUnsupportedControl(this.accessory, {
+      control: this.config.variableLabel || 'setting',
+      value,
+    })
+
+    // Put the control back, and fail the request so HomeKit shows it as not
+    // responding - that is what sends the owner to the log
+    setTimeout(() => {
+      this.service.updateCharacteristic(this.variableChar, this.cacheVariable)
+    }, 2000)
+    throw new this.hapErr(-70402)
+  }
+
+  externalUpdate(params) {
+    // Feed the sensor reading through when the richer tile is in use - HomeKit
+    // needs it, and it is the reason that tile was chosen
+    if (this.usingRichService && this.config.richReadingChar && params.humidity !== undefined) {
+      const reading = Number(params.humidity)
+      if (Number.isFinite(reading) && reading !== this.cacheReading) {
+        this.cacheReading = reading
+        this.service.updateCharacteristic(this.hapChar[this.config.richReadingChar], reading)
+      }
+    }
+
+    // Power is the one thing that can be read back with confidence
+    if (params.state && params.state !== this.cacheState) {
+      this.cacheState = params.state
+      this.service.updateCharacteristic(this.hapChar.Active, this.cacheState === 'on' ? 1 : 0)
+      if (this.currentStateChar) {
+        this.service.updateCharacteristic(
+          this.currentStateChar,
+          this.cacheState === 'on' ? this.config.currentStateOn : this.config.currentStateOff,
+        )
+      }
+      this.accessory.log(`${platformLang.curState} [${this.cacheState}]`)
+    }
+
+    // Everything else gets reported so the model can be finished off
+    ;(params.commands || []).forEach((command) => {
+      const hexString = base64ToHex(command)
+      const hexParts = hexToTwoItems(hexString)
+
+      if (getTwoItemPosition(hexParts, 1) !== 'aa') {
+        return
+      }
+
+      // The power report is understood, anything else is worth sending in
+      if (getTwoItemPosition(hexParts, 2) === '01') {
+        const newState = getTwoItemPosition(hexParts, 3) === '01' ? 'on' : 'off'
+        if (this.cacheState !== newState) {
+          this.cacheState = newState
+          this.service.updateCharacteristic(this.hapChar.Active, this.cacheState === 'on' ? 1 : 0)
+          this.accessory.log(`${platformLang.curState} [${this.cacheState}]`)
+        }
+        return
+      }
+
+      logUnknownData(this.accessory, {
+        kind: 'scene',
+        source: params.source,
+        raw: command,
+        hex: hexString,
+      })
+    })
+  }
+}
+
+/**
+ * Build a basic handler for a kind of appliance.
+ *
+ * @param {object} config how this kind of appliance should appear
+ * @returns {Function} a handler class the platform can construct
+ */
+export function makeBasicAppliance(config) {
+  return class extends ApplianceBasic {
+    constructor(platform, accessory) {
+      super(platform, accessory, config)
+    }
+  }
+}
+
+// Fan-shaped appliances: a speed slider that is not worked out yet
+export const deviceFanBasic = makeBasicAppliance({
+  family: 'fan',
+  service: 'Fanv2',
+  variableChar: 'RotationSpeed',
+  variableLabel: 'fan speed',
+})
+
+// Ice makers reuse the fan tile, with the slider standing in for ice size
+export const deviceIceMakerBasic = makeBasicAppliance({
+  family: 'iceMaker',
+  service: 'Fanv2',
+  variableChar: 'RotationSpeed',
+  variableLabel: 'ice size',
+})
+
+// Humidifiers get the plain fan tile by default, because HomeKit's humidifier
+// has to show a current humidity and many Govee humidifiers never report one.
+// A model that does report it gets the proper humidifier tile instead.
+export const deviceHumidifierBasic = makeBasicAppliance({
+  family: 'humidifier',
+  service: 'Fan',
+  variableChar: 'RotationSpeed',
+  variableLabel: 'mist level',
+  richService: 'HumidifierDehumidifier',
+  richControl: 'humiditySensor',
+  richVariableChar: 'RelativeHumidityHumidifierThreshold',
+  richReadingChar: 'CurrentRelativeHumidity',
+  currentStateChar: 'CurrentHumidifierDehumidifierState',
+  currentStateOn: 2, // humidifying
+  currentStateOff: 0, // inactive
+})
+
+export const deviceDehumidifierBasic = makeBasicAppliance({
+  family: 'dehumidifier',
+  service: 'Fan',
+  variableChar: 'RotationSpeed',
+  variableLabel: 'fan speed',
+  richService: 'HumidifierDehumidifier',
+  richControl: 'humiditySensor',
+  richVariableChar: 'RelativeHumidityDehumidifierThreshold',
+  richReadingChar: 'CurrentRelativeHumidity',
+  currentStateChar: 'CurrentHumidifierDehumidifierState',
+  currentStateOn: 3, // dehumidifying
+  currentStateOff: 0, // inactive
+})
+
+// Diffusers are power only, so there is no variable control to offer. They use
+// the same tile as the models already handled, so a new one looks the same
+export const deviceDiffuserBasic = makeBasicAppliance({
+  family: 'diffuser',
+  service: 'AirPurifier',
+  currentStateChar: 'CurrentAirPurifierState',
+  currentStateOn: 2, // purifying air
+  currentStateOff: 0, // inactive
+})
+
+export const devicePurifierBasic = makeBasicAppliance({
+  family: 'purifier',
+  service: 'AirPurifier',
+  variableChar: 'RotationSpeed',
+  variableLabel: 'fan speed',
+  currentStateChar: 'CurrentAirPurifierState',
+  currentStateOn: 2, // purifying air
+  currentStateOff: 0, // inactive
+})

package/lib/device/dehumidifier-H7150.js

@@ -5,9 +5,10 @@ import {
   parseError,
 } from '../utils/functions.js'
 import platformLang from '../utils/lang-en.js'
+import { logUnknownData } from '../utils/report-unknown.js'
 
 /*
-  H7150
+  H7150, H7151 and H7152
   {
     "mode": {
       "options": [
@@ -31,7 +32,7 @@ import platformLang from '../utils/lang-en.js'
     }
   }
  */
-export default class {
+export default class GoveeDehumidifierH7150 {
   constructor(platform, accessory) {
     // Set up variables from the platform
     this.hapChar = platform.api.hap.Characteristic
@@ -206,7 +207,12 @@ export default class {
           break
         }
         default:
-          this.accessory.logDebugWarn(`${platformLang.newScene}: [${command}] [${hexString}]`)
+          logUnknownData(this.accessory, {
+            kind: 'scene',
+            source: params.source,
+            raw: command,
+            hex: hexString,
+          })
           break
       }
     })

package/lib/device/diffuser-H7161.js

@@ -5,6 +5,7 @@ import {
   parseError,
 } from '../utils/functions.js'
 import platformLang from '../utils/lang-en.js'
+import { logUnknownData } from '../utils/report-unknown.js'
 
 export default class {
   constructor(platform, accessory) {
@@ -115,7 +116,12 @@ export default class {
 
       switch (deviceFunction) {
         default:
-          this.accessory.logDebugWarn(`${platformLang.newScene}: [${command}] [${hexString}]`)
+          logUnknownData(this.accessory, {
+            kind: 'scene',
+            source: params.source,
+            raw: command,
+            hex: hexString,
+          })
           break
       }
     })

package/lib/device/fan-H1370.js

@@ -10,6 +10,7 @@ import {
   sleep,
 } from '../utils/functions.js'
 import platformLang from '../utils/lang-en.js'
+import { logUnknownData } from '../utils/report-unknown.js'
 
 /*
   Codes below were decoded from a real device's AWS status reports in
@@ -365,7 +366,12 @@ export default class {
           break
         }
         default:
-          this.accessory.logDebugWarn(`${platformLang.newScene}: [${command}] [${hexString}]`)
+          logUnknownData(this.accessory, {
+            kind: 'scene',
+            source: params.source,
+            raw: command,
+            hex: hexString,
+          })
           break
       }
     })

package/lib/device/fan-H7100.js

@@ -1,3 +1,4 @@
+import { getDeviceCapabilities } from '../utils/device-capabilities.js'
 import {
   base64ToHex,
   fanSpeedToHkPercent,
@@ -7,8 +8,19 @@ import {
   parseError,
 } from '../utils/functions.js'
 import platformLang from '../utils/lang-en.js'
+import { logUnknownData } from '../utils/report-unknown.js'
 
-export default class {
+/*
+  The models on this handler and the modes each offers:
+
+  H7100, H7102, H7106 -> Sleep, Nature, Custom, Auto
+  H7101               -> Sleep, Nature, Turbo, Custom, Auto
+  H7111               -> Sleep, Nature, Custom, Auto
+  H1310, R1310        -> as the H7100, but its oscillation status message has
+                         never been confirmed, so it is not read back
+ */
+
+export default class GoveeFanH7100 {
   constructor(platform, accessory) {
     // Set up variables from the platform
     this.hapChar = platform.api.hap.Characteristic
@@ -19,6 +31,10 @@ export default class {
     // Set up variables from the accessory
     this.accessory = accessory
 
+    // Which of the models on this handler have a confirmed meaning for the
+    // oscillation status message
+    this.readsSwingStatus = getDeviceCapabilities(accessory.context.gvModel).readsSwingStatus
+
     // Codes etc
     this.speedCodes = {
       1: 'MwUBAQAAAAAAAAAAAAAAAAAAADY=',
@@ -261,12 +277,23 @@ export default class {
             this.cacheSpeed = this.autoSpeed
             // Cache auto so we can tell it apart from "user asked for max speed"
             this.service.updateCharacteristic(this.hapChar.RotationSpeed, 100)
-            this.accessory.log(`${platformLang.curSpeed} [auto]`)
+            this.accessory.log(`${platformLang.curSpeed} [auto -> 100%]`)
           }
           break
         }
         case '1f01': {
-          // Swing Mode
+          // Not every model on this handler is known to mean oscillation by
+          // this message, so one that has not been confirmed falls through and
+          // reports it instead - which is how it gets confirmed
+          if (!this.readsSwingStatus) {
+            logUnknownData(this.accessory, {
+              kind: 'scene',
+              source: params.source,
+              raw: command,
+              hex: hexString,
+            })
+            break
+          }
           const newSwing = getTwoItemPosition(hexParts, 4) === '01' ? 'on' : 'off'
           if (this.cacheSwing !== newSwing) {
             this.cacheSwing = newSwing
@@ -276,7 +303,12 @@ export default class {
           break
         }
         default:
-          this.accessory.logDebugWarn(`${platformLang.newScene}: [${command}] [${hexString}]`)
+          logUnknownData(this.accessory, {
+            kind: 'scene',
+            source: params.source,
+            raw: command,
+            hex: hexString,
+          })
           break
       }
     })

package/lib/device/fan-H7105.js

@@ -12,6 +12,7 @@ import {
   sleep,
 } from '../utils/functions.js'
 import platformLang from '../utils/lang-en.js'
+import { logUnknownData } from '../utils/report-unknown.js'
 
 export default class {
   constructor(platform, accessory) {
@@ -514,7 +515,12 @@ export default class {
           break
         }
         default:
-          this.accessory.logDebugWarn(`${platformLang.newScene}: [${command}] [${hexString}]`)
+          logUnknownData(this.accessory, {
+            kind: 'scene',
+            source: params.source,
+            raw: command,
+            hex: hexString,
+          })
           break
       }
     })