@homebridge-plugins/homebridge-govee 11.32.2-beta.3 → 11.32.2-beta.30

package/CHANGELOG.md

@@ -6,10 +6,46 @@ All notable changes to `@homebridge-plugins/homebridge-govee` will be documented
 
 ### Changed
 
+- fix: stop shipping the test files to npm, since they are only needed in the repository
 - 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 ice size derived from the govee app (pending owner confirmation)
+- 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: 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
+- refactor: give every device one shared starting point, so the way a failed command is reported and undone is decided in one place rather than a hundred
+- feat: recognise eleven more meat thermometers, which report what they send so their readings can be worked out, and stop the one already known printing its whole update as a warning
+- feat: add the H5161 power strip and give the H7184 kitchen composter an on and off switch
+- feat: recognise three more sensors, which report what they send, and say plainly in the log why a sensor has no tile yet
+- feat: add ble encryption for the H3001 solar string lights, which silently ignore unencrypted frames (#1328) (@dominick-han)
+- fix: mention an unrecognised bluetooth broadcast once, and only when the device is on your own account, since a scan also hears the neighbours
 
 ## 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

@@ -3,10 +3,13 @@ import process from 'node:process'
 
 import btClient from '@stoprocent/noble'
 
+import { buildHandshake, isHandshakeFrame, parseHandshakeResponse, V2Session } from '../utils/ble-crypto.js'
 import { BLE_STAGE_TIMEOUTS, UUID } from '../utils/ble-protocol.js'
 import { decodeAny } from '../utils/decode.js'
+import { getDeviceCapabilities } from '../utils/device-capabilities.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
@@ -19,6 +22,7 @@ const H5101_UUID = '0001'
 const POWER_ON_TIMEOUT = BLE_STAGE_TIMEOUTS.powerOn
 const CONNECTION_TIMEOUT = BLE_STAGE_TIMEOUTS.connect
 const WRITE_TIMEOUT = BLE_STAGE_TIMEOUTS.write
+const HANDSHAKE_TIMEOUT = BLE_STAGE_TIMEOUTS.handshake
 const SETTLE_DELAY = BLE_STAGE_TIMEOUTS.settle
 
 /*
@@ -120,8 +124,40 @@ export default class BLEConnection {
     try {
       const { uuid, address, rssi, advertisement } = peripheral
 
-      // Skip if not a valid Govee sensor
+      // A broadcast this plugin cannot decode is worth reporting rather than
+      // dropping in silence, since the hex is the one thing needed to add a
+      // model and an owner has no other way 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'
+
+          // A device rebroadcasts constantly, so say this once and then stay
+          // quiet about it for the rest of the session. This has to come first:
+          // gating it on the warning below would leave every other broadcast
+          // ungoverned, and a debug log would fill with the same line.
+          if (isFirstReport(`ble|${address}|${raw}`)) {
+            const line = `[BLE] unrecognised broadcast from a govee device - please include this line if you report it: ${JSON.stringify({
+              name: unknownName,
+              address,
+              source: 'BLE',
+              kind: 'broadcast',
+              raw,
+            })}`
+
+            // Bluetooth is a broadcast medium, so this scan hears every Govee
+            // device in range - including a neighbour's, which is not something
+            // the owner can do anything about. Only a device on this account is
+            // worth putting in front of them.
+            if (this.platform.hasBleDevice(address)) {
+              this.log.warn(line)
+            } else {
+              this.log.debug(line)
+            }
+          }
+        }
         return
       }
 
@@ -240,8 +276,19 @@ export default class BLEConnection {
       const finalBuffer = this.prepareCommandBuffer(params)
       accessory.logDebug(`sending command: ${finalBuffer.toString('hex')}`)
 
+      // Encrypted models refuse the plain frame. Because writes are
+      // unacknowledged, they refuse it silently, so the handshake has to happen
+      // here rather than being discovered by a failed write. It is per
+      // connection: the frame counter resets with the link.
+      let payload = finalBuffer
+      if (getDeviceCapabilities(accessory.context.gvModel).bleEncryption === 'v2') {
+        const session = await this.negotiateSession(accessory, characteristic, characteristics)
+        payload = session.seal(finalBuffer)
+        accessory.logDebug(`encrypted as: ${payload.toString('hex')}`)
+      }
+
       // Write without response then allow time for the BLE controller to transmit before disconnecting
-      await this.writeWithTimeout(characteristic, finalBuffer, WRITE_TIMEOUT)
+      await this.writeWithTimeout(characteristic, payload, WRITE_TIMEOUT)
       accessory.logDebug('command sent successfully')
       await sleep(SETTLE_DELAY)
     } catch (err) {
@@ -274,6 +321,70 @@ export default class BLEConnection {
     }
   }
 
+  /**
+   * Exchange a session key with an encrypted model.
+   *
+   * Unlike every other path in this client we need a reply, which arrives as a
+   * notification on UUID.NOTIFY. Note that we deliberately do NOT subscribe:
+   * these lights push notifications without the client ever writing the client
+   * characteristic configuration descriptor.
+   * Calling subscribeAsync() here makes the descriptor write hang and the light
+   * then drops the connection, so listening is both sufficient and required.
+   *
+   * The reply is authenticated - parseHandshakeResponse throws if the GCM tag
+   * does not verify - which turns a wrong key into a real error rather than a
+   * light that silently ignores every command.
+   *
+   * Returns a V2Session that wraps outgoing frames.
+   */
+  async negotiateSession(accessory, writeCharacteristic, characteristics) {
+    const notifyCharacteristic = Object.values(characteristics).find(
+      char => char.uuid.replace(HYPHEN_REGEX, '') === UUID.NOTIFY,
+    )
+    if (!notifyCharacteristic) {
+      throw new Error('Notify characteristic not found, cannot negotiate encryption')
+    }
+
+    let resolveReply
+    let rejectReply
+    const reply = new Promise((resolve, reject) => {
+      resolveReply = resolve
+      rejectReply = reject
+    })
+    // Attach a handler immediately: if the write below throws, the timeout would
+    // otherwise reject an unawaited promise and crash the process.
+    reply.catch(() => {})
+
+    const onData = (data) => {
+      // The light also pushes state frames here; take only the handshake.
+      if (isHandshakeFrame(data)) {
+        resolveReply(data)
+      }
+    }
+    notifyCharacteristic.on('data', onData)
+    const timer = setTimeout(
+      () => rejectReply(new Error('Encryption handshake timeout')),
+      HANDSHAKE_TIMEOUT,
+    )
+
+    try {
+      const { frame, txIvKey } = buildHandshake()
+      accessory.logDebug(`sending handshake: ${frame.toString('hex')}`)
+      await this.writeWithTimeout(writeCharacteristic, frame, WRITE_TIMEOUT)
+
+      const response = await reply
+      accessory.logDebug(`handshake reply: ${response.toString('hex')}`)
+
+      const { devInfo, sku, mac } = parseHandshakeResponse(response)
+      accessory.logDebug(`handshake verified for ${sku} at ${mac}`)
+
+      return new V2Session({ txIvKey, devInfo })
+    } finally {
+      clearTimeout(timer)
+      notifyCharacteristic.removeListener('data', onData)
+    }
+  }
+
   async connectWithTimeout(address, timeout) {
     let timeoutId
     try {

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,372 @@
+import { describeSources, resolveControls } from '../utils/capabilities.js'
+import { base64ToHex, getTwoItemPosition, hexToTwoItems } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+import { logUnknownData, reportUnsupportedControl } from '../utils/report-unknown.js'
+import GoveeDevice from './base.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 extends GoveeDevice {
+  constructor(platform, accessory, config) {
+    super(platform, accessory)
+    // Set up variables from the 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' || serviceName === 'Switch'
+    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.failUpdate(err, () => {
+        this.service.updateCharacteristic(characteristic, previous)
+      })
+    }
+  }
+
+  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) {
+      this.failUpdate(err, () => {
+        this.service.updateCharacteristic(this.hapChar.Active, this.cacheState === 'on' ? 1 : 0)
+      })
+    }
+  }
+
+  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
+})
+
+// A composter is on or off. It has a mode and a light too, but neither is
+// worked out, so they are left off rather than shown as controls that do nothing
+export const deviceComposterBasic = makeBasicAppliance({
+  family: 'composter',
+  service: 'Switch',
+})
+
+export const devicePurifierBasic = makeBasicAppliance({
+  family: 'purifier',
+  service: 'AirPurifier',
+  variableChar: 'RotationSpeed',
+  variableLabel: 'fan speed',
+  currentStateChar: 'CurrentAirPurifierState',
+  currentStateOn: 2, // purifying air
+  currentStateOff: 0, // inactive
+})