@homebridge-plugins/homebridge-meross 10.20.0 → 10.20.2-beta.0

package/lib/device/thermostat-mts960.js

@@ -0,0 +1,213 @@
+import PQueue from 'p-queue'
+
+import mqttClient from '../connection/mqtt.js'
+import platformConsts from '../utils/constants.js'
+import { hasProperty, isTimeoutError, parseError } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+// The MTS960 plug-in thermostat speaks Appliance.Control.Thermostat.ModeB, not
+// the .Mode the MTS200 uses. Its digest arrives as `thermostat.modeB`, its
+// temperatures are hundredths of a degree, and it uses 1 for on and 2 for off.
+// Read with the MTS200 handler, none of that matched, so the temperature sat at
+// HomeKit's default of 0 and the heat switch never moved (#809).
+const ON = 1
+const OFF = 2
+const WORKING_HEAT = 1
+const WORKING_COOL = 2
+const MODE_HEAT_COOL = 1
+
+export default class {
+  constructor(platform, accessory) {
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapErr = platform.api.hap.HapStatusError
+    this.hapServ = platform.api.hap.Service
+    this.platform = platform
+    this.accessory = accessory
+    this.name = accessory.displayName
+    const cloudRefreshRate = hasProperty(platform.config, 'cloudRefreshRate')
+      ? platform.config.cloudRefreshRate
+      : platformConsts.defaultValues.cloudRefreshRate
+    const localRefreshRate = hasProperty(platform.config, 'refreshRate')
+      ? platform.config.refreshRate
+      : platformConsts.defaultValues.refreshRate
+    this.pollInterval = accessory.context.connection === 'local'
+      ? localRefreshRate
+      : cloudRefreshRate
+    this.tempScale = 100
+
+    this.service = this.accessory.getService(this.hapServ.Thermostat)
+      || this.accessory.addService(this.hapServ.Thermostat)
+
+    // Off, heat and cool - the plug drives either a heater or a cooler
+    this.service
+      .getCharacteristic(this.hapChar.TargetHeatingCoolingState)
+      .setProps({ minValue: 0, maxValue: 2, validValues: [0, 1, 2] })
+      .onSet(async value => this.internalStateUpdate(value))
+    this.cacheState = this.service.getCharacteristic(this.hapChar.TargetHeatingCoolingState).value
+
+    this.service
+      .getCharacteristic(this.hapChar.TargetTemperature)
+      .setProps({ minValue: 5, maxValue: 35, minStep: 0.5 })
+      .onSet(async value => this.internalTargetUpdate(value))
+    this.cacheTarg = this.service.getCharacteristic(this.hapChar.TargetTemperature).value
+    this.cacheTemp = this.service.getCharacteristic(this.hapChar.CurrentTemperature).value
+
+    this.accessory.eveService = new platform.eveService('custom', this.accessory, { log: () => {} })
+
+    this.updateInProgress = false
+    this.queue = new PQueue({ concurrency: 1, interval: 250, intervalCap: 1, timeout: 10000, throwOnTimeout: true })
+    this.queue.addEventListener('idle', () => {
+      this.updateInProgress = false
+    })
+
+    if (accessory.context.connection !== 'local') {
+      this.accessory.mqtt = new mqttClient(platform, this.accessory)
+      this.accessory.mqtt.connect()
+    }
+
+    setTimeout(() => this.requestUpdate(true), 2000)
+    this.accessory.refreshInterval = setInterval(() => this.requestUpdate(), this.pollInterval * 1000)
+
+    platform.log('[%s] %s %s.', this.name, platformLang.devInitOpts, JSON.stringify({
+      connection: this.accessory.context.connection,
+    }))
+  }
+
+  async sendModeB(fields) {
+    await this.platform.sendUpdate(this.accessory, {
+      namespace: 'Appliance.Control.Thermostat.ModeB',
+      payload: { modeB: [{ channel: 0, ...fields }] },
+    })
+  }
+
+  async internalStateUpdate(value) {
+    try {
+      await this.queue.add(async () => {
+        if (value === this.cacheState) {
+          return
+        }
+        this.updateInProgress = true
+        await this.sendModeB(value === 0
+          ? { onoff: OFF }
+          : { onoff: ON, mode: MODE_HEAT_COOL, working: value === 2 ? WORKING_COOL : WORKING_HEAT })
+        this.cacheState = value
+        this.accessory.log(`${platformLang.curState} [${['off', 'heat', 'cool'][value]}]`)
+      })
+    } catch (err) {
+      const eText = isTimeoutError(err) ? platformLang.timeout : parseError(err)
+      this.accessory.logWarn(`${platformLang.sendFailed} ${eText}`)
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.TargetHeatingCoolingState, this.cacheState)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalTargetUpdate(value) {
+    try {
+      await this.queue.add(async () => {
+        if (value === this.cacheTarg) {
+          return
+        }
+        this.updateInProgress = true
+        await this.sendModeB({
+          mode: MODE_HEAT_COOL,
+          working: this.cacheState === 2 ? WORKING_COOL : WORKING_HEAT,
+          targetTemp: Math.round(value * this.tempScale),
+        })
+        this.cacheTarg = value
+        this.accessory.log(`${platformLang.curTarg} [${value}°C]`)
+      })
+    } catch (err) {
+      const eText = isTimeoutError(err) ? platformLang.timeout : parseError(err)
+      this.accessory.logWarn(`${platformLang.sendFailed} ${eText}`)
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.TargetTemperature, this.cacheTarg)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async requestUpdate(firstRun = false) {
+    try {
+      if (this.updateInProgress) {
+        return
+      }
+      await this.queue.add(async () => {
+        this.updateInProgress = true
+        const res = await this.platform.sendUpdate(this.accessory, {
+          namespace: 'Appliance.System.All',
+          payload: {},
+        })
+        this.accessory.logDebug(`${platformLang.incPoll}: ${JSON.stringify(res.data)}`)
+        const data = res.data.payload
+        if (data.all?.digest?.thermostat) {
+          this.applyUpdate(data.all.digest.thermostat)
+        }
+        if (firstRun && data.all?.system?.hardware) {
+          this.accessory.context.macAddress = data.all.system.hardware.macAddress.toUpperCase()
+          this.accessory.context.hardware = data.all.system.hardware.version
+          this.accessory.context.firmware = data.all.system.firmware?.version
+          this.platform.updateAccessory(this.accessory)
+        }
+      })
+    } catch (err) {
+      const eText = isTimeoutError(err) ? platformLang.timeout : parseError(err)
+      this.accessory.logDebugWarn(`${platformLang.reqFailed}: ${eText}`)
+    }
+  }
+
+  receiveUpdate(params) {
+    try {
+      this.accessory.logDebug(`${platformLang.incMQTT}: ${JSON.stringify(params)}`)
+      if (params.payload) {
+        this.applyUpdate(params.payload)
+      }
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.refFailed} ${parseError(err)}`)
+    }
+  }
+
+  applyUpdate(data) {
+    const modeData = data.modeB?.[0]
+    if (!modeData) {
+      return
+    }
+    if (hasProperty(modeData, 'onoff') || hasProperty(modeData, 'working')) {
+      const onoff = modeData.onoff ?? (this.cacheState === 0 ? OFF : ON)
+      const working = modeData.working ?? (this.cacheState === 2 ? WORKING_COOL : WORKING_HEAT)
+      const newState = onoff === ON ? (working === WORKING_COOL ? 2 : 1) : 0
+      if (this.cacheState !== newState) {
+        this.service.updateCharacteristic(this.hapChar.TargetHeatingCoolingState, newState)
+        this.cacheState = newState
+        this.accessory.log(`${platformLang.curState} [${['off', 'heat', 'cool'][newState]}]`)
+      }
+    }
+    // Schedule and timer modes report a target of 0, which is not a setpoint
+    if (modeData.targetTemp > 0) {
+      const newTarg = Math.min(35, Math.max(5, Math.round(modeData.targetTemp / 50) / 2))
+      if (this.cacheTarg !== newTarg) {
+        this.service.updateCharacteristic(this.hapChar.TargetTemperature, newTarg)
+        this.cacheTarg = newTarg
+        this.accessory.log(`${platformLang.curTarg} [${newTarg}°C]`)
+      }
+    }
+    if (hasProperty(modeData, 'currentTemp')) {
+      const newTemp = modeData.currentTemp / this.tempScale
+      if (this.cacheTemp !== newTemp) {
+        this.service.updateCharacteristic(this.hapChar.CurrentTemperature, newTemp)
+        this.cacheTemp = newTemp
+        this.accessory.eveService.addEntry({ temp: newTemp })
+        this.accessory.log(`${platformLang.curTemp} [${newTemp}°C]`)
+      }
+    }
+    // `state` is the relay: 1 when the plug is powering the heater or cooler
+    if (hasProperty(modeData, 'state')) {
+      const relayOn = modeData.state === ON && this.cacheState !== 0
+      this.service.updateCharacteristic(
+        this.hapChar.CurrentHeatingCoolingState,
+        relayOn ? this.cacheState : 0,
+      )
+    }
+  }
+}

package/lib/device/thermostat.js

@@ -1,9 +1,8 @@
 import PQueue from 'p-queue'
-import { TimeoutError } from 'p-timeout'
 
 import mqttClient from '../connection/mqtt.js'
 import platformConsts from '../utils/constants.js'
-import { hasProperty, parseError } from '../utils/functions.js'
+import { hasProperty, isTimeoutError, parseError } from '../utils/functions.js'
 import platformLang from '../utils/lang-en.js'
 
 export default class {
@@ -112,7 +111,7 @@ export default class {
       timeout: 10000,
       throwOnTimeout: true,
     })
-    this.queue.on('idle', () => {
+    this.queue.addEventListener('idle', () => {
       this.updateInProgress = false
     })
 
@@ -171,7 +170,7 @@ export default class {
       })
     } catch (err) {
       // Catch any errors whilst updating the device
-      const eText = err instanceof TimeoutError ? platformLang.timeout : parseError(err)
+      const eText = isTimeoutError(err) ? platformLang.timeout : parseError(err)
       this.accessory.logWarn(`${platformLang.sendFailed} ${eText}`)
       setTimeout(() => {
         this.service.updateCharacteristic(this.hapChar.TargetHeatingCoolingState, this.cacheState)
@@ -227,7 +226,7 @@ export default class {
       })
     } catch (err) {
       // Catch any errors whilst updating the device
-      const eText = err instanceof TimeoutError ? platformLang.timeout : parseError(err)
+      const eText = isTimeoutError(err) ? platformLang.timeout : parseError(err)
       this.accessory.logWarn(`${platformLang.sendFailed} ${eText}`)
       setTimeout(() => {
         this.service.updateCharacteristic(this.mode2Char[newMode], false)
@@ -285,7 +284,7 @@ export default class {
       })
     } catch (err) {
       // Catch any errors whilst updating the device
-      const eText = err instanceof TimeoutError ? platformLang.timeout : parseError(err)
+      const eText = isTimeoutError(err) ? platformLang.timeout : parseError(err)
       this.accessory.logWarn(`${platformLang.sendFailed} ${eText}`)
       setTimeout(() => {
         this.service.updateCharacteristic(this.hapChar.TargetTemperature, this.cacheTarg)
@@ -381,7 +380,7 @@ export default class {
         }
       })
     } catch (err) {
-      const eText = err instanceof TimeoutError ? platformLang.timeout : parseError(err)
+      const eText = isTimeoutError(err) ? platformLang.timeout : parseError(err)
       this.accessory.logDebugWarn(`${platformLang.reqFailed}: ${eText}`)
 
       // Set the homebridge-ui status of the device to offline if local and error is timeout

package/lib/homebridge-ui/config-key.js

@@ -0,0 +1,57 @@
+import platformConsts from '../utils/constants.js'
+
+/**
+ * Which config array the settings page should put a device in, by its model.
+ *
+ * A model missing here cannot be added or hidden from the My Devices tab -
+ * the page just reports it as unsupported, even though the plugin itself runs
+ * it fine (#816).
+ *
+ * @param {string} model the device model, as the plugin stores it
+ * @returns {string|null} the config array, or null when the model is unknown
+ */
+export function getDeviceConfigKey(model) {
+  if (!model) {
+    return null
+  }
+  const m = platformConsts.models
+  if (m.switchSingle.includes(model)) {
+    return 'singleDevices'
+  }
+  if (Object.hasOwn(m.switchMulti, model)) {
+    return 'multiDevices'
+  }
+  if (m.lightDimmer.includes(model) || m.lightRGB.includes(model) || m.lightCCT.includes(model)) {
+    return 'lightDevices'
+  }
+  if (m.fan.includes(model)) {
+    return 'fanDevices'
+  }
+  if (m.diffuser.includes(model)) {
+    return 'diffuserDevices'
+  }
+  if (m.purifier.includes(model)) {
+    return 'purifierDevices'
+  }
+  if (m.humidifier.includes(model)) {
+    return 'humidifierDevices'
+  }
+  if (m.thermostat.includes(model) || m.thermostatMts215.includes(model) || m.thermostatMts300.includes(model) || m.thermostatMts960.includes(model)) {
+    return 'thermostatDevices'
+  }
+  if (m.garage.includes(model)) {
+    return 'garageDevices'
+  }
+  if (m.roller.includes(model)) {
+    return 'rollerDevices'
+  }
+  if (m.baby.includes(model)) {
+    return 'babyDevices'
+  }
+  // A hub's config entry is where its sensors' settings live, including the
+  // list of sensors to hide (#816)
+  if (m.sensorPresence.includes(model) || m.hubMain.includes(model)) {
+    return 'sensorDevices'
+  }
+  return null
+}

package/lib/homebridge-ui/public/index.html

@@ -270,6 +270,14 @@
       // by hand in a different format still counts as the same device
       const looseId = id => (id || '').toString().toLowerCase().replace(/[^a-z0-9]+/g, '')
 
+      // A hub's sensors share the hub's config entry, so hiding one sensor
+      // lists its id in the entry's ignoreSubdevices - ignoreDevice there would
+      // hide the hub and every sensor on it (#816)
+      const subIdsOf = entry => (entry?.ignoreSubdevices || '').split(',').map(id => id.trim()).filter(Boolean)
+      const isHiddenIn = (entry, acc) => acc.context.subSerialNumber
+        ? subIdsOf(entry).includes(acc.context.subSerialNumber)
+        : !!entry?.ignoreDevice
+
       const getConfigBlocks = async () => {
         const blocks = await homebridge.getPluginConfig()
         if (!blocks.length) {
@@ -332,7 +340,9 @@
         if (!Array.isArray(config[arrayKey])) {
           config[arrayKey] = []
         }
-        config[arrayKey].push({ name: acc.displayName, serialNumber: looseId(acc.context.serialNumber) })
+        // A hub sensor's entry is the hub's own, so name it after the hub
+        const name = acc.context.subSerialNumber ? `${acc.context.model} hub` : acc.displayName
+        config[arrayKey].push({ name, serialNumber: looseId(acc.context.serialNumber) })
         return true
       }
 
@@ -351,7 +361,7 @@
             // re-check and never add a duplicate - just correct the button
             if (found) {
               setConfigButton(true)
-              setHideControl(!!config[found.key][found.index].ignoreDevice)
+              setHideControl(isHiddenIn(config[found.key][found.index], acc))
               homebridge.toast.info(acc.displayName + ' is already in the config.', 'Not Added')
               return
             }
@@ -418,7 +428,13 @@
               }
               found = findInConfig(config, acc.context.serialNumber)
             }
-            config[found.key][found.index].ignoreDevice = true
+            const entry = config[found.key][found.index]
+            const subId = acc.context.subSerialNumber
+            if (subId) {
+              entry.ignoreSubdevices = [...new Set([...subIdsOf(entry), subId])].join(',')
+            } else {
+              entry.ignoreDevice = true
+            }
             await homebridge.updatePluginConfig(blocks)
             setConfigButton(true)
             setHideControl(true)
@@ -427,7 +443,18 @@
             if (found) {
               // Drop the flag rather than storing ignoreDevice false, to keep
               // the entry clean
-              delete config[found.key][found.index].ignoreDevice
+              const entry = config[found.key][found.index]
+              const subId = acc.context.subSerialNumber
+              if (subId) {
+                const rest = subIdsOf(entry).filter(id => id !== subId)
+                if (rest.length > 0) {
+                  entry.ignoreSubdevices = rest.join(',')
+                } else {
+                  delete entry.ignoreSubdevices
+                }
+              } else {
+                delete entry.ignoreDevice
+              }
               await homebridge.updatePluginConfig(blocks)
             }
             setConfigButton(!!found)
@@ -475,7 +502,7 @@
             const nowFound = findInConfig(config, acc.context.serialNumber)
             setConfigButton(!!nowFound)
             if (nowFound) {
-              setHideControl(!!config[nowFound.key][nowFound.index].ignoreDevice)
+              setHideControl(isHiddenIn(config[nowFound.key][nowFound.index], acc))
             }
           }
         } catch (err) {
@@ -607,7 +634,7 @@
           const configBlocks = await getConfigBlocks()
           const configEntry = findInConfig(configBlocks[0], context.serialNumber)
           setConfigButton(!!configEntry)
-          setHideControl(!!(configEntry && configBlocks[0][configEntry.key][configEntry.index].ignoreDevice))
+          setHideControl(!!configEntry && isHiddenIn(configBlocks[0][configEntry.key][configEntry.index], { context }))
           document.getElementById('configActionList').style.display = 'block'
           homebridge.hideSpinner()
         }

package/lib/homebridge-ui/server.js

@@ -1,50 +1,6 @@
 import { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
 
-import platformConsts from '../utils/constants.js'
-
-function getDeviceConfigKey(model) {
-  if (!model) {
-    return null
-  }
-  const m = platformConsts.models
-  if (m.switchSingle.includes(model)) {
-    return 'singleDevices'
-  }
-  if (Object.hasOwn(m.switchMulti, model)) {
-    return 'multiDevices'
-  }
-  if (m.lightDimmer.includes(model) || m.lightRGB.includes(model) || m.lightCCT.includes(model)) {
-    return 'lightDevices'
-  }
-  if (m.fan.includes(model)) {
-    return 'fanDevices'
-  }
-  if (m.diffuser.includes(model)) {
-    return 'diffuserDevices'
-  }
-  if (m.purifier.includes(model)) {
-    return 'purifierDevices'
-  }
-  if (m.humidifier.includes(model)) {
-    return 'humidifierDevices'
-  }
-  if (m.thermostat.includes(model) || m.thermostatMts215.includes(model) || m.thermostatMts300.includes(model)) {
-    return 'thermostatDevices'
-  }
-  if (m.garage.includes(model)) {
-    return 'garageDevices'
-  }
-  if (m.roller.includes(model)) {
-    return 'rollerDevices'
-  }
-  if (m.baby.includes(model)) {
-    return 'babyDevices'
-  }
-  if (m.sensorPresence.includes(model)) {
-    return 'sensorDevices'
-  }
-  return null
-}
+import { getDeviceConfigKey } from './config-key.js'
 
 class PluginUiServer extends HomebridgePluginUiServer {
   constructor() {

package/lib/platform.js

@@ -863,6 +863,17 @@ export default class {
         this.applyAccessoryLogging(accessory)
         accessory.control = new deviceTypes.deviceThermostatMts300(this, accessory)
         /** */
+      } else if (platformConsts.models.thermostatMts960.includes(device.model)) {
+        /**
+         ********
+         THERMOSTATS (MTS960)
+         *********
+         */
+        accessory = this.devicesInHB.get(hbUUID) || this.addAccessory(device)
+        accessory.context = { ...accessory.context, ...context }
+        this.applyAccessoryLogging(accessory)
+        accessory.control = new deviceTypes.deviceThermostatMts960(this, accessory)
+        /** */
       } else if (platformConsts.models.thermostatMts215.includes(device.model)) {
         /**
          ********

package/lib/utils/constants.js

@@ -240,6 +240,7 @@ export default {
       'MSS710',
       'MSS710R',
       'MSS810',
+      'MSS815',
       'P11',
       'R10',
       'R11',
@@ -316,8 +317,9 @@ export default {
     garage: ['MSG100', 'MSG150', 'MSG200'],
     roller: ['MRS100', 'MRS105', 'MRS200'],
     baby: ['HP110A', 'HP110AHK'],
-    thermostat: ['MTS200', 'MTS200B', 'MTS205', 'MTS205B', 'MTS960'],
+    thermostat: ['MTS200', 'MTS200B', 'MTS205', 'MTS205B'],
     thermostatMts300: ['MTS300'],
+    thermostatMts960: ['MTS960'],
     thermostatMts215: ['MTS215', 'MTS215B'],
     sensorPresence: ['MS600'],
     hubMain: ['MSH300', 'MSH300HK', 'MSH400', 'MSH450'],
@@ -387,6 +389,7 @@ export default {
     MSP844: ['5', '9'], // https://github.com/homebridge-plugins/homebridge-meross/issues/578, https://github.com/homebridge-plugins/homebridge-meross/issues/585
     MSS115: ['9'], // https://github.com/homebridge-plugins/homebridge-meross/issues/549
     MSS315: ['9'], // https://github.com/homebridge-plugins/homebridge-meross/issues/537
+    MSS815: ['9'], // https://github.com/homebridge-plugins/homebridge-meross/issues/813
   },
 
   noLocalControl: ['MSH300', 'MSH300HK', 'MSH400', 'MSH450'],

package/lib/utils/functions.js

@@ -13,6 +13,19 @@ function generateRandomString(length) {
 
 const hasProperty = (obj, prop) => Object.hasOwn(obj, prop)
 
+/**
+ * Whether an error means a request ran out of time, whichever library threw it.
+ *
+ * The device queue and the connection both time requests out, but they report
+ * it differently: the queue throws a DOMException named TimeoutError, and the
+ * connection throws p-timeout's own TimeoutError class. Checking for the class
+ * alone would miss the queue's timeouts and log them as a raw error instead of
+ * the plain "timed out" message. Both carry the same name, so check that.
+ */
+function isTimeoutError(err) {
+  return err?.name === 'TimeoutError'
+}
+
 function parseError(err, hideStack = []) {
   let toReturn = err.message
   if (err?.stack?.length > 0 && !hideStack.includes(err.message)) {
@@ -34,6 +47,7 @@ export {
   encodeParams,
   generateRandomString,
   hasProperty,
+  isTimeoutError,
   parseError,
   sleep,
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@homebridge-plugins/homebridge-meross",
   "alias": "Meross",
   "type": "module",
-  "version": "10.20.0",
+  "version": "10.20.2-beta.0",
   "description": "Homebridge plugin to integrate Meross devices into HomeKit.",
   "author": {
     "name": "bwp91",
@@ -61,16 +61,16 @@
     "changelog:sync": "node .github/scripts/sync-changelog.mjs"
   },
   "dependencies": {
-    "@homebridge/plugin-ui-utils": "^2.2.5",
-    "axios": "^1.19.0",
-    "mqtt": "^5.15.2",
+    "@homebridge/plugin-ui-utils": "^2.2.6",
+    "axios": "^1.20.0",
+    "mqtt": "^5.16.1",
     "node-persist": "^4.0.4",
-    "p-queue": "^9.3.3",
-    "p-timeout": "^7.0.1"
+    "p-queue": "^10.0.0",
+    "p-timeout": "^8.0.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^9.3.0",
-    "@vitest/coverage-v8": "^4.1.10",
-    "vitest": "^4.1.10"
+    "@antfu/eslint-config": "^9.5.1",
+    "@vitest/coverage-v8": "^5.0.5",
+    "vitest": "^5.0.5"
   }
 }