@homebridge-plugins/homebridge-govee 11.34.2-beta.1 → 11.34.2-beta.11

package/CHANGELOG.md

@@ -9,6 +9,22 @@ All notable changes to `@homebridge-plugins/homebridge-govee` will be documented
 - feat: control the H1250 zones with the device's own frame, as govee ignores its toggles (#1343) (@Principe1218)
 - fix: explain in the log when zone tiles are missing because aws credentials are not set
 - fix: restore debug logging when the plugin runs in a child bridge
+- fix: turn adaptive lighting off when a colour is chosen outside HomeKit
+- fix: send a colour change when only the saturation moves, on every night light
+- fix: listen for saturation on the main light too, not only hue
+- fix: accept 20-byte H5106 status frames (#1345) (@danieloleary)
+- fix: stop rescaling the H1250's brightness, since it already counts to 100 over AWS (#1347) (@Principe1218)
+- feat: give the H1250's zones independent color and brightness (#1346) (@Principe1218)
+- fix: stop a lan scan that cannot reach the network from crashing the bridge
+- fix: apply the openapi disable and refresh settings instead of asking for them to be removed
+- fix: say once when a bluetooth reading arrives for an unknown device, not on every broadcast
+- fix: reject a refresh time so large it would make the plugin poll every millisecond
+- fix(H5054): don't let a slow leak warning block other sensors (#1348) (@danieloleary)
+- fix: mark sensor batteries low at the configured threshold (#1349) (@danieloleary)
+- feat: show whether the kettle is heating, keeping warm or idle (#1337)
+- fix: give the H5106 a battery service, so its low battery setting does something
+- fix: stop a light's broadcast being mistaken for an h5101 sensor reading
+- fix: follow a device renamed in the govee app, instead of keeping its first name forever (#1344)
 
 ## v11.34.1 (2026-08-06)
 

package/config.schema.json

@@ -49,7 +49,8 @@
         "type": "integer",
         "description": "An interval (in seconds) in which your HTTP devices will refresh with the plugin. Must be 30 or more.",
         "placeholder": 30,
-        "minimum": 30
+        "minimum": 30,
+        "maximum": 2073600
       },
       "awsDisable": {
         "title": "Disable AWS",
@@ -69,7 +70,8 @@
         "minimum": 60,
         "condition": {
           "functionBody": "return (!model.bleDisable);"
-        }
+        },
+        "maximum": 2073600
       },
       "lanDisable": {
         "title": "Disable LAN",
@@ -84,7 +86,8 @@
         "minimum": 10,
         "condition": {
           "functionBody": "return (!model.lanDisable);"
-        }
+        },
+        "maximum": 2073600
       },
       "lanScanInterval": {
         "title": "LAN Scan Interval",
@@ -94,7 +97,8 @@
         "minimum": 30,
         "condition": {
           "functionBody": "return (!model.lanDisable);"
-        }
+        },
+        "maximum": 2073600
       },
       "lanScanSubnets": {
         "title": "LAN Scan Subnets",
@@ -118,7 +122,8 @@
         "minimum": 30,
         "condition": {
           "functionBody": "return (!model.openApiDisable);"
-        }
+        },
+        "maximum": 2073600
       },
       "bleControlInterval": {
         "title": "BLE Control Interval",

package/lib/connection/lan.js

@@ -181,6 +181,12 @@ export default class {
         reject(err)
       })
 
+      // Handle errors on the sending socket. Without a listener here, node throws
+      // the error object instead of emitting it, which takes the bridge down.
+      this.sender.on('error', (err) => {
+        this.log.warn('[LAN] client error: %s.', parseError(err))
+      })
+
       // Handle started listening for messages
       this.receiver.on('listening', () => {
         const { address, port } = this.receiver.address()
@@ -233,16 +239,25 @@ export default class {
   sendScanCommand() {
     const scanCommand = JSON.stringify({ msg: { cmd: commands.scan, data: { account_topic: 'reserve' } } })
     this.log.debug('[LAN] scanning for devices over LAN...')
-    this.sender.send(scanCommand, scanCommandPort, multicastIp)
+    this.sender.send(scanCommand, scanCommandPort, multicastIp, err => this.logScanSendError(multicastIp, err))
 
     // Also scan any configured subnets directly. Multicast doesn't cross
     // between subnets, so devices on a different subnet than Homebridge are
     // reached by sending the scan straight to each host (they reply on 4002).
     this.scanHosts.forEach((host) => {
-      this.sender.send(scanCommand, scanCommandPort, host)
+      this.sender.send(scanCommand, scanCommandPort, host, err => this.logScanSendError(host, err))
     })
   }
 
+  // A scan send can fail on a host with no route to the target, for example when
+  // multicast is unavailable. Report it and carry on rather than letting dgram
+  // emit an unhandled 'error' event, which would crash the bridge every scan.
+  logScanSendError(target, err) {
+    if (err) {
+      this.log.debug('[LAN] scan request to %s failed [%s].', target, parseError(err))
+    }
+  }
+
   // Get all available LAN devices
   async getDevices() {
     return new Promise((resolve) => {

package/lib/device/base.js

@@ -53,6 +53,27 @@ export default class GoveeDevice {
     return !!existing
   }
 
+  updateBattery(battery) {
+    if (!this.battService || !Number.isFinite(battery) || battery < 0 || battery > 100) {
+      return
+    }
+
+    if (battery !== this.cacheBatt) {
+      this.cacheBatt = battery
+      this.battService.updateCharacteristic(this.hapChar.BatteryLevel, this.cacheBatt)
+      this.accessory.log(`${platformLang.curBatt} [${this.cacheBatt}%]`)
+    }
+
+    const lowBattery = battery <= this.lowBattThreshold ? 1 : 0
+    const currentLowBattery = Number(this.battService
+      .getCharacteristic(this.hapChar.StatusLowBattery)
+      .value)
+
+    if (lowBattery !== currentLowBattery) {
+      this.battService.updateCharacteristic(this.hapChar.StatusLowBattery, lowBattery)
+    }
+  }
+
   /**
    * Give up on a control, put it back the way it was, and tell HomeKit.
    *

package/lib/device/fan-H7105.js

@@ -111,6 +111,14 @@ export default class extends GoveeDevice {
       this.lightService.getCharacteristic(this.hapChar.Hue).onSet(async (value) => {
         await this.internalColourUpdate(value)
       })
+      // Saturation needs a handler of its own. HomeKit writes hue and saturation
+      // separately, so with only hue listened for, dragging saturation alone -
+      // the same colour made paler or richer - reached nothing and the light
+      // never changed. Both handlers share one update, and the debounce inside
+      // it collapses a hue-and-saturation pair into a single command.
+      this.lightService.getCharacteristic(this.hapChar.Saturation).onSet(async () => {
+        await this.internalColourUpdate(this.lightService.getCharacteristic(this.hapChar.Hue).value)
+      })
       this.cacheHue = this.lightService.getCharacteristic(this.hapChar.Hue).value
       this.cacheSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
     }
@@ -319,13 +327,16 @@ export default class extends GoveeDevice {
         return
       }
 
-      // Don't continue if the new value is the same as before
-      if (value === this.cacheHue) {
+      // Don't continue if the new colour is the same as before. Saturation is
+      // part of that question: comparing hue alone meant a change of saturation
+      // at the same hue looked like no change at all, and nothing was sent.
+      const currentSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
+      if (value === this.cacheHue && currentSat === this.cacheSat) {
         return
       }
 
       // Calculate RGB values
-      const newRGB = hs2rgb(value, this.lightService.getCharacteristic(this.hapChar.Saturation).value)
+      const newRGB = hs2rgb(value, currentSat)
 
       // Generate the hex values for the code
       const hexValues = [0x3A, 0x1B, 0x05, 0x0D, ...newRGB]
@@ -336,7 +347,10 @@ export default class extends GoveeDevice {
         value: generateCodeFromHexValues(hexValues),
       })
 
-      // Cache the new state and log if appropriate
+      // Cache the new state and log if appropriate. Saturation is cached on
+      // every send, not only when the hue moved, or a change of saturation at
+      // the same hue would be sent once and then look unchanged ever after.
+      this.cacheSat = currentSat
       if (this.cacheHue !== value) {
         this.cacheHue = value
         this.accessory.log(`${platformLang.curColour} [rgb ${newRGB.join(' ')}]`)
@@ -450,12 +464,14 @@ export default class extends GoveeDevice {
 
             const hs = rgb2hs(newR, newG, newB)
 
-            // Check for a colour change
-            if (hs[0] !== this.cacheHue) {
+            // Check for a colour change. Saturation counts as much as hue, or a
+            // change of saturation made in the Govee app is reported back and
+            // ignored, leaving the tile showing the old colour.
+            if (hs[0] !== this.cacheHue || hs[1] !== this.cacheSat) {
               // Colour is different so update Homebridge with new values
               this.lightService.updateCharacteristic(this.hapChar.Hue, hs[0])
               this.lightService.updateCharacteristic(this.hapChar.Saturation, hs[1]);
-              [this.cacheHue] = hs
+              [this.cacheHue, this.cacheSat] = hs
 
               // Log the change
               this.accessory.log(`${platformLang.curColour} [rgb ${newR} ${newG} ${newB}]`)

package/lib/device/fan-H7107.js

@@ -111,6 +111,14 @@ export default class extends GoveeDevice {
       this.lightService.getCharacteristic(this.hapChar.Hue).onSet(async (value) => {
         await this.internalColourUpdate(value)
       })
+      // Saturation needs a handler of its own. HomeKit writes hue and saturation
+      // separately, so with only hue listened for, dragging saturation alone -
+      // the same colour made paler or richer - reached nothing and the light
+      // never changed. Both handlers share one update, and the debounce inside
+      // it collapses a hue-and-saturation pair into a single command.
+      this.lightService.getCharacteristic(this.hapChar.Saturation).onSet(async () => {
+        await this.internalColourUpdate(this.lightService.getCharacteristic(this.hapChar.Hue).value)
+      })
       this.cacheHue = this.lightService.getCharacteristic(this.hapChar.Hue).value
       this.cacheSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
     }
@@ -323,13 +331,16 @@ export default class extends GoveeDevice {
         return
       }
 
-      // Don't continue if the new value is the same as before
-      if (value === this.cacheHue) {
+      // Don't continue if the new colour is the same as before. Saturation is
+      // part of that question: comparing hue alone meant a change of saturation
+      // at the same hue looked like no change at all, and nothing was sent.
+      const currentSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
+      if (value === this.cacheHue && currentSat === this.cacheSat) {
         return
       }
 
       // Calculate RGB values
-      const newRGB = hs2rgb(value, this.lightService.getCharacteristic(this.hapChar.Saturation).value)
+      const newRGB = hs2rgb(value, currentSat)
 
       // Generate the hex values for the code
       const hexValues = [0x3A, 0x1B, 0x05, 0x0D, ...newRGB]
@@ -340,7 +351,10 @@ export default class extends GoveeDevice {
         value: generateCodeFromHexValues(hexValues),
       })
 
-      // Cache the new state and log if appropriate
+      // Cache the new state and log if appropriate. Saturation is cached on
+      // every send, not only when the hue moved, or a change of saturation at
+      // the same hue would be sent once and then look unchanged ever after.
+      this.cacheSat = currentSat
       if (this.cacheHue !== value) {
         this.cacheHue = value
         this.accessory.log(`${platformLang.curColour} [rgb ${newRGB.join(' ')}]`)
@@ -454,12 +468,14 @@ export default class extends GoveeDevice {
 
             const hs = rgb2hs(newR, newG, newB)
 
-            // Check for a colour change
-            if (hs[0] !== this.cacheHue) {
+            // Check for a colour change. Saturation counts as much as hue, or a
+            // change of saturation made in the Govee app is reported back and
+            // ignored, leaving the tile showing the old colour.
+            if (hs[0] !== this.cacheHue || hs[1] !== this.cacheSat) {
               // Colour is different so update Homebridge with new values
               this.lightService.updateCharacteristic(this.hapChar.Hue, hs[0])
               this.lightService.updateCharacteristic(this.hapChar.Saturation, hs[1]);
-              [this.cacheHue] = hs
+              [this.cacheHue, this.cacheSat] = hs
 
               // Log the change
               this.accessory.log(`${platformLang.curColour} [rgb ${newR} ${newG} ${newB}]`)

package/lib/device/heater2.js

@@ -221,6 +221,14 @@ export default class extends GoveeDevice {
     this.lightService.getCharacteristic(this.hapChar.Hue).onSet(async (value) => {
       await this.internalColourUpdate(value)
     })
+    // Saturation needs a handler of its own. HomeKit writes hue and saturation
+    // separately, so with only hue listened for, dragging saturation alone -
+    // the same colour made paler or richer - reached nothing and the light
+    // never changed. Both handlers share one update, and the debounce inside
+    // it collapses a hue-and-saturation pair into a single command.
+    this.lightService.getCharacteristic(this.hapChar.Saturation).onSet(async () => {
+      await this.internalColourUpdate(this.lightService.getCharacteristic(this.hapChar.Hue).value)
+    })
     this.cacheHue = this.lightService.getCharacteristic(this.hapChar.Hue).value
     this.cacheSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
 
@@ -574,13 +582,16 @@ export default class extends GoveeDevice {
         return
       }
 
-      // Don't continue if the new value is the same as before
-      if (value === this.cacheHue) {
+      // Don't continue if the new colour is the same as before. Saturation is
+      // part of that question: comparing hue alone meant a change of saturation
+      // at the same hue looked like no change at all, and nothing was sent.
+      const currentSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
+      if (value === this.cacheHue && currentSat === this.cacheSat) {
         return
       }
 
       // Calculate RGB values
-      const newRGB = hs2rgb(value, this.lightService.getCharacteristic(this.hapChar.Saturation).value)
+      const newRGB = hs2rgb(value, currentSat)
 
       // Generate the hex values for the code
       const hexValues = [0x3A, 0x1B, 0x05, 0x0D, ...newRGB]
@@ -591,7 +602,10 @@ export default class extends GoveeDevice {
         value: generateCodeFromHexValues(hexValues),
       })
 
-      // Cache the new state and log if appropriate
+      // Cache the new state and log if appropriate. Saturation is cached on
+      // every send, not only when the hue moved, or a change of saturation at
+      // the same hue would be sent once and then look unchanged ever after.
+      this.cacheSat = currentSat
       if (this.cacheHue !== value) {
         this.cacheHue = value
         this.accessory.log(`${platformLang.curColour} [rgb ${newRGB.join(' ')}]`)
@@ -731,12 +745,14 @@ export default class extends GoveeDevice {
 
           const hs = rgb2hs(newR, newG, newB)
 
-          // Check for a colour change
-          if (hs[0] !== this.cacheHue) {
+          // Check for a colour change. Saturation counts as much as hue, or a
+          // change of saturation made in the Govee app is reported back and
+          // ignored, leaving the tile showing the old colour.
+          if (hs[0] !== this.cacheHue || hs[1] !== this.cacheSat) {
             // Colour is different so update Homebridge with new values
             this.lightService.updateCharacteristic(this.hapChar.Hue, hs[0])
             this.lightService.updateCharacteristic(this.hapChar.Saturation, hs[1]);
-            [this.cacheHue] = hs
+            [this.cacheHue, this.cacheSat] = hs
 
             // Log the change
             this.accessory.log(`${platformLang.curColour} [rgb ${newR} ${newG} ${newB}]`)

package/lib/device/humidifier-H7142.js

@@ -122,6 +122,14 @@ export default class extends GoveeDevice {
     this.lightService.getCharacteristic(this.hapChar.Hue).onSet(async (value) => {
       await this.internalColourUpdate(value)
     })
+    // Saturation needs a handler of its own. HomeKit writes hue and saturation
+    // separately, so with only hue listened for, dragging saturation alone -
+    // the same colour made paler or richer - reached nothing and the light
+    // never changed. Both handlers share one update, and the debounce inside
+    // it collapses a hue-and-saturation pair into a single command.
+    this.lightService.getCharacteristic(this.hapChar.Saturation).onSet(async () => {
+      await this.internalColourUpdate(this.lightService.getCharacteristic(this.hapChar.Hue).value)
+    })
     this.cacheHue = this.lightService.getCharacteristic(this.hapChar.Hue).value
     this.cacheSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
 
@@ -318,15 +326,18 @@ export default class extends GoveeDevice {
         return
       }
 
-      // Don't continue if the new value is the same as before
-      if (value === this.cacheHue) {
+      // Don't continue if the new colour is the same as before. Saturation is
+      // part of that question: comparing hue alone meant a change of saturation
+      // at the same hue looked like no change at all, and nothing was sent.
+      const currentSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
+      if (value === this.cacheHue && currentSat === this.cacheSat) {
         return
       }
 
       // Generate the hex values for the code
       const newRGB = hs2rgb(
         value,
-        this.lightService.getCharacteristic(this.hapChar.Saturation).value,
+        currentSat,
       )
       const hexValues = [0x33, 0x1B, 0x01, this.cacheBright, ...newRGB]
 
@@ -336,7 +347,10 @@ export default class extends GoveeDevice {
         value: generateCodeFromHexValues(hexValues),
       })
 
-      // Cache the new state and log if appropriate
+      // Cache the new state and log if appropriate. Saturation is cached on
+      // every send, not only when the hue moved, or a change of saturation at
+      // the same hue would be sent once and then look unchanged ever after.
+      this.cacheSat = currentSat
       if (this.cacheHue !== value) {
         this.cacheHue = value
         this.accessory.log(`${platformLang.curColour} [rgb ${newRGB.join(' ')}]`)
@@ -487,12 +501,14 @@ export default class extends GoveeDevice {
             const newB = hexToDecimal(getTwoItemPosition(hexParts, 7))
             const hs = rgb2hs(newR, newG, newB)
 
-            // Check for a colour change
-            if (hs[0] !== this.cacheHue) {
+            // Check for a colour change. Saturation counts as much as hue, or a
+            // change of saturation made in the Govee app is reported back and
+            // ignored, leaving the tile showing the old colour.
+            if (hs[0] !== this.cacheHue || hs[1] !== this.cacheSat) {
               // Colour is different so update Homebridge with new values
               this.lightService.updateCharacteristic(this.hapChar.Hue, hs[0])
               this.lightService.updateCharacteristic(this.hapChar.Saturation, hs[1]);
-              [this.cacheHue] = hs
+              [this.cacheHue, this.cacheSat] = hs
 
               // Log the change
               this.accessory.log(`${platformLang.curColour} [rgb ${newR} ${newG} ${newB}]`)

package/lib/device/humidifier-H7160.js

@@ -85,6 +85,14 @@ export default class extends GoveeDevice {
     this.lightService.getCharacteristic(this.hapChar.Hue).onSet(async (value) => {
       await this.internalColourUpdate(value)
     })
+    // Saturation needs a handler of its own. HomeKit writes hue and saturation
+    // separately, so with only hue listened for, dragging saturation alone -
+    // the same colour made paler or richer - reached nothing and the light
+    // never changed. Both handlers share one update, and the debounce inside
+    // it collapses a hue-and-saturation pair into a single command.
+    this.lightService.getCharacteristic(this.hapChar.Saturation).onSet(async () => {
+      await this.internalColourUpdate(this.lightService.getCharacteristic(this.hapChar.Hue).value)
+    })
     this.cacheHue = this.lightService.getCharacteristic(this.hapChar.Hue).value
     this.cacheSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
 
@@ -266,15 +274,18 @@ export default class extends GoveeDevice {
         return
       }
 
-      // Don't continue if the new value is the same as before
-      if (value === this.cacheHue) {
+      // Don't continue if the new colour is the same as before. Saturation is
+      // part of that question: comparing hue alone meant a change of saturation
+      // at the same hue looked like no change at all, and nothing was sent.
+      const currentSat = this.lightService.getCharacteristic(this.hapChar.Saturation).value
+      if (value === this.cacheHue && currentSat === this.cacheSat) {
         return
       }
 
       // Generate the hex values for the code
       const newRGB = hs2rgb(
         value,
-        this.lightService.getCharacteristic(this.hapChar.Saturation).value,
+        currentSat,
       )
       const hexValues = [0x33, 0x1B, 0x01, this.cacheBright, ...newRGB]
 
@@ -284,7 +295,10 @@ export default class extends GoveeDevice {
         value: generateCodeFromHexValues(hexValues),
       })
 
-      // Cache the new state and log if appropriate
+      // Cache the new state and log if appropriate. Saturation is cached on
+      // every send, not only when the hue moved, or a change of saturation at
+      // the same hue would be sent once and then look unchanged ever after.
+      this.cacheSat = currentSat
       if (this.cacheHue !== value) {
         this.cacheHue = value
         this.accessory.log(`${platformLang.curColour} [rgb ${newRGB.join(' ')}]`)
@@ -411,12 +425,14 @@ export default class extends GoveeDevice {
             const newB = hexToDecimal(getTwoItemPosition(hexParts, 7))
             const hs = rgb2hs(newR, newG, newB)
 
-            // Check for a colour change
-            if (hs[0] !== this.cacheHue) {
+            // Check for a colour change. Saturation counts as much as hue, or a
+            // change of saturation made in the Govee app is reported back and
+            // ignored, leaving the tile showing the old colour.
+            if (hs[0] !== this.cacheHue || hs[1] !== this.cacheSat) {
               // Colour is different so update Homebridge with new values
               this.lightService.updateCharacteristic(this.hapChar.Hue, hs[0])
               this.lightService.updateCharacteristic(this.hapChar.Saturation, hs[1]);
-              [this.cacheHue] = hs
+              [this.cacheHue, this.cacheSat] = hs
 
               // Log the change
               this.accessory.log(`${platformLang.curColour} [rgb ${newR} ${newG} ${newB}]`)

package/lib/device/kettle.js

@@ -28,12 +28,16 @@ import GoveeDevice from './base.js'
 /**
  * The water temperature out of a status frame, in celsius.
  *
- * The frame carries it as two bytes of hundredths of a degree fahrenheit. That
- * layout has never been confirmed against a kettle sitting at a known
- * temperature, so the result is checked before it is used: a kettle holds
- * water, and a figure outside freezing to a little past boiling is not a
- * temperature at all - it means this model packs the frame differently.
- * Returning nothing then leaves the tile absent rather than wrong.
+ * The frame carries it as two bytes of hundredths of a degree fahrenheit. An
+ * owner confirmed that layout against three known points on an H7171 (#1337):
+ * cold water read 0x1edc = 79.00F, the moment the kettle beeped at its 142F
+ * target it read 0x3778 = 142.00F, and it drifted to 0x39d0 = 148.00F after.
+ *
+ * The result is still checked before it is used, because only the one model has
+ * been seen: a kettle holds water, and a figure outside freezing to a little
+ * past boiling is not a temperature at all - it means that model packs the
+ * frame differently. Returning nothing then leaves the tile absent rather than
+ * wrong.
  *
  * @param {string[]} hexParts the frame split into bytes
  * @returns {number|undefined} the reading in celsius, or undefined if the
@@ -51,6 +55,33 @@ function readingToCelsius(hexParts) {
   return farToCen(fahrenheit)
 }
 
+/**
+ * What the kettle says it is doing, from the state byte of an `aa 19` frame.
+ *
+ * Worked out from a full run an owner instrumented for us (#1337), matching the
+ * frames against a running commentary of what the kettle was doing:
+ *
+ *   00  idle      two seconds after they switched it off
+ *   01  heating   the moment they turned it on, and a second after setting a
+ *                 temperature on an earlier run
+ *   04  reached   as the water hit the target and the kettle beeped
+ *   02  warming   held for the next three and a half minutes of keep warm
+ *
+ * `04` and `02` arrive in the same second, so which of the pair marks reaching
+ * the target and which marks entering keep warm is read from their order, not
+ * proven separately. Both leave the kettle no longer heating, which is what the
+ * sensor reflects, so the distinction only affects the wording in the log.
+ *
+ * Only these four have been seen, all with keep warm switched on. Anything else
+ * falls through to the unknown-data report, which is how these were found.
+ */
+const HEATING_STATES = {
+  '00': { label: 'idle', heating: false },
+  '01': { label: 'heating', heating: true },
+  '02': { label: 'keeping warm', heating: false },
+  '04': { label: 'reached target', heating: false },
+}
+
 export default class extends GoveeDevice {
   constructor(platform, accessory) {
     super(platform, accessory)
@@ -294,6 +325,45 @@ export default class extends GoveeDevice {
     }
   }
 
+  /**
+   * Reflect what the kettle says it is doing.
+   *
+   * The tile is added the first time a state frame arrives rather than up
+   * front, for the same reason as the temperature tile above: only the H7171
+   * has been seen sending these, and a tile that never updates cannot be told
+   * apart from a real reading.
+   *
+   * @param {string} stateByte the state byte of an `aa 19` frame
+   */
+  updateHeatingState(stateByte) {
+    const state = HEATING_STATES[stateByte]
+    if (!state) {
+      return
+    }
+
+    if (!this.serviceHeating) {
+      this.serviceHeating = this.accessory.getService('Heating')
+      if (!this.serviceHeating) {
+        this.serviceHeating = this.accessory.addService(this.hapServ.ContactSensor, 'Heating', 'heating')
+        this.serviceHeating.addCharacteristic(this.hapChar.ConfiguredName)
+        this.serviceHeating.updateCharacteristic(this.hapChar.ConfiguredName, 'Heating')
+      }
+    }
+
+    if (this.cacheHeatingState === state.label) {
+      return
+    }
+    this.cacheHeatingState = state.label
+
+    this.serviceHeating.updateCharacteristic(
+      this.hapChar.ContactSensorState,
+      state.heating
+        ? this.hapChar.ContactSensorState.CONTACT_DETECTED
+        : this.hapChar.ContactSensorState.CONTACT_NOT_DETECTED,
+    )
+    this.accessory.log(`current status [${state.label}]`)
+  }
+
   externalUpdate(params) {
     // Handle OpenAPI workMode
     if (params.workMode) {
@@ -369,13 +439,23 @@ export default class extends GoveeDevice {
         case '2301': { // scheduled start on
           break
         }
+        // What the kettle is doing - see HEATING_STATES above. `1900` used to be
+        // treated as a startup frame, which it only looked like because a kettle
+        // is usually idle when it connects; it is really the idle state and is
+        // sent whenever the kettle reaches it.
+        case '1900':
+        case '1901':
+        case '1902':
+        case '1904': {
+          this.updateHeatingState(getTwoItemPosition(hexParts, 3))
+          break
+        }
         // Also sent on startup, alongside the preset list above. What each one
         // carries has not been worked out, and nothing here needs them, so they
         // are known-and-ignored rather than reported every time (#1337)
         case '1701': // a second form of the on-base report
         case '1f06':
-        case '1f08':
-        case '1900': {
+        case '1f08': {
           this.accessory.logDebug(`startup status [${deviceFunction}]: ${hexString}`)
           break
         }