homebridge-nuheat2 1.2.11 → 1.2.12

package/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project should be documented in this file
 
 ## [Unreleased]
 
+## [1.2.12] - 2026-04-21
+
+### Fixed
+
+- Treat Nuheat thermostats as heat-only in HomeKit so the target mode no longer advertises a misleading off option
+- Translate any incoming HomeKit off request into the minimum Nuheat setpoint instead of bouncing back after refresh
+- Apply the Nuheat account temperature scale to the thermostat display-units characteristic so HomeKit shows the correct hardware display unit
+- Coalesce and briefly de-duplicate repeated SignalR thermostat and group notifications to reduce redundant full refreshes and log noise
+
 ## [1.2.11] - 2026-04-21
 
 ### Fixed

package/index.js

@@ -189,7 +189,7 @@ class NuHeatPlatform {
                 entry = { uuid };
                 this.accessories.push(entry);
             }
-            entry.accessory = new NuHeatThermostat(this.log, deviceData, this.config.holdLength || 1440, getPlatformAccessory(deviceAccessory), this.NuHeatAPI, Homebridge);
+            entry.accessory = new NuHeatThermostat(this.log, deviceData, this.config.holdLength || 1440, getPlatformAccessory(deviceAccessory), this.NuHeatAPI, Homebridge, this.account?.temperatureScale);
             entry.existsInConfig = true;
             this.log.info("Loaded thermostat " +
                 deviceData.serialNumber +

package/lib/NuHeatListener.js

@@ -1,16 +1,19 @@
 "use strict";
 const signalR = require("@microsoft/signalr");
+const NOTIFICATION_DEDUPE_WINDOW_MS = 2000;
 class NuHeatListener {
     nuHeatAPI;
     nuHeatPlatform;
     log;
     notificationTypes;
     connection;
+    recentNotifications;
     constructor(nuHeatAPI, nuheatPlatform) {
         this.nuHeatAPI = nuHeatAPI;
         this.nuHeatPlatform = nuheatPlatform;
         this.log = nuheatPlatform.log;
         this.notificationTypes = ["2", "4"];
+        this.recentNotifications = new Map();
         this.connection = new signalR.HubConnectionBuilder()
             .withUrl("https://api.mynuheat.com/notificationsHost", {
             accessTokenFactory: async () => {
@@ -73,8 +76,10 @@ class NuHeatListener {
         });
     }
     traceNotification(notificationList) {
+        let shouldRefreshThermostats = false;
+        let shouldRefreshGroups = false;
         notificationList.forEach((notification) => {
-            let notificationType = "";
+            let notificationType = "Unknown";
             switch (notification.type) {
                 case 0:
                 case 1:
@@ -82,15 +87,15 @@ class NuHeatListener {
                     break;
                 case 2:
                     notificationType = "Thermostat";
-                    void this.nuHeatPlatform.refreshThermostats();
+                    shouldRefreshThermostats = shouldRefreshThermostats || !this.isDuplicateNotification(notification);
                     break;
                 case 3:
                     notificationType = "Schedule";
-                    void this.nuHeatPlatform.refreshThermostats();
+                    shouldRefreshThermostats = shouldRefreshThermostats || !this.isDuplicateNotification(notification);
                     break;
                 case 4:
                     notificationType = "Group";
-                    void this.nuHeatPlatform.refreshGroups();
+                    shouldRefreshGroups = shouldRefreshGroups || !this.isDuplicateNotification(notification);
                     break;
             }
             this.log.debug(notificationType +
@@ -98,10 +103,38 @@ class NuHeatListener {
                 notification.id +
                 " at " +
                 notification.timeStamp +
-                ". Refreshing data for all " +
-                notificationType +
-                "s");
+                ".");
         });
+        if (shouldRefreshThermostats) {
+            void this.nuHeatPlatform.refreshThermostats();
+        }
+        if (shouldRefreshGroups) {
+            void this.nuHeatPlatform.refreshGroups();
+        }
+    }
+    isDuplicateNotification(notification) {
+        const key = String(notification.type) +
+            ":" +
+            String(notification.id) +
+            ":" +
+            notification.timeStamp;
+        const now = Date.now();
+        this.cleanupRecentNotifications(now);
+        const lastSeenAt = this.recentNotifications.get(key);
+        if (lastSeenAt !== undefined &&
+            now - lastSeenAt < NOTIFICATION_DEDUPE_WINDOW_MS) {
+            this.log.debug("Ignoring duplicate notification " + key + ".");
+            return true;
+        }
+        this.recentNotifications.set(key, now);
+        return false;
+    }
+    cleanupRecentNotifications(now) {
+        for (const [key, seenAt] of this.recentNotifications.entries()) {
+            if (now - seenAt >= NOTIFICATION_DEDUPE_WINDOW_MS) {
+                this.recentNotifications.delete(key);
+            }
+        }
     }
 }
 module.exports = NuHeatListener;

package/lib/NuHeatThermostat.js

@@ -2,13 +2,16 @@
 const NuHeatModels_1 = require("./NuHeatModels");
 let Characteristic;
 let ThermostatService;
+const MIN_TARGET_TEMPERATURE_C = 10;
+const MAX_TARGET_TEMPERATURE_C = 38;
 class NuHeatThermostat {
     log;
     deviceData;
     holdLength;
     accessory;
     NuHeatAPI;
-    constructor(log, deviceData, holdLength, accessory, NuHeatAPI, homebridge) {
+    temperatureScale;
+    constructor(log, deviceData, holdLength, accessory, NuHeatAPI, homebridge, temperatureScale) {
         Characteristic = homebridge.hap.Characteristic;
         ThermostatService = homebridge.hap.Service.Thermostat;
         this.log = log;
@@ -16,6 +19,7 @@ class NuHeatThermostat {
         this.holdLength = holdLength;
         this.accessory = accessory;
         this.NuHeatAPI = NuHeatAPI;
+        this.temperatureScale = temperatureScale;
         this.accessory
             .getService(homebridge.hap.Service.AccessoryInformation)
             .setCharacteristic(Characteristic.Manufacturer, "NuHeat")
@@ -25,39 +29,48 @@ class NuHeatThermostat {
         this.setupListeners();
     }
     setupListeners() {
+        const thermostatService = this.accessory.getService(ThermostatService);
         this.log.info("holdLength: " + this.holdLength, this.deviceData.name);
-        this.accessory
-            .getService(ThermostatService)
+        thermostatService
             .getCharacteristic(Characteristic.TargetHeatingCoolingState)
             .setProps({
-            validValues: [0, 1],
+            validValues: [Characteristic.TargetHeatingCoolingState.HEAT],
         })
             .on("set", this.setTargetHeatingCooling.bind(this));
-        this.accessory
-            .getService(ThermostatService)
-            .getCharacteristic(Characteristic.CurrentTemperature)
-            .setProps({
+        thermostatService.getCharacteristic(Characteristic.CurrentTemperature).setProps({
             minValue: -100,
             maxValue: 100,
         });
-        this.accessory
-            .getService(ThermostatService)
+        thermostatService
             .getCharacteristic(Characteristic.TargetTemperature)
             .setProps({
             minStep: 0.5,
         })
             .on("set", this.setTargetTemperature.bind(this));
+        this.updateTemperatureDisplayUnits();
     }
-    setTargetHeatingCooling(_value, callback) {
+    async setTargetHeatingCooling(value, callback) {
+        if (value !== Characteristic.TargetHeatingCoolingState.OFF) {
+            callback(null);
+            void this.updateAccessory();
+            return;
+        }
+        this.log.info("NuHeat does not support an off mode. Setting the thermostat to its minimum target temperature instead.", this.deviceData.name);
+        const response = await this.NuHeatAPI.setHeatSetpoint(this.deviceData.serialNumber ?? "", this.toNuHeatTemperature(MIN_TARGET_TEMPERATURE_C), this.holdLength);
+        if (!response) {
+            this.log.error("Error setting minimum target temperature for off request", this.deviceData.name);
+            callback(new Error("Error: setTargetHeatingCooling"));
+            return;
+        }
+        this.updateValues(response);
         callback(null);
-        void this.updateAccessory();
     }
     async setTargetTemperature(value, callback) {
-        this.log.info("Setting target temperature to " + value + "°C", this.deviceData.name);
-        if (value < 10)
-            value = 10;
-        if (value > 38)
-            value = 38;
+        this.log.info("Setting target temperature to " + value + " C", this.deviceData.name);
+        if (value < MIN_TARGET_TEMPERATURE_C)
+            value = MIN_TARGET_TEMPERATURE_C;
+        if (value > MAX_TARGET_TEMPERATURE_C)
+            value = MAX_TARGET_TEMPERATURE_C;
         const heatSetPoint = this.toNuHeatTemperature(value);
         this.log.debug("setTargetTemperature " + heatSetPoint, this.deviceData.name);
         const response = await this.NuHeatAPI.setHeatSetpoint(this.deviceData.serialNumber ?? "", heatSetPoint, this.holdLength);
@@ -81,25 +94,29 @@ class NuHeatThermostat {
     }
     updateValues(newValues) {
         if (this.isOnline(newValues)) {
+            this.updateTemperatureDisplayUnits();
             let currentTemperature = Number(this.toHBTemperature(newValues.currentTemperature ?? 0));
-            this.log.debug("Current temperature is " + currentTemperature + "°C", this.deviceData.name);
+            this.log.debug("Current temperature is " + currentTemperature + " C", this.deviceData.name);
             this.accessory
                 .getService(ThermostatService)
                 .getCharacteristic(Characteristic.CurrentTemperature)
                 .updateValue(currentTemperature);
             let setPointTemperature = Number(this.toHBTemperature(newValues.setPointTemp ?? 0));
-            if (setPointTemperature < 10)
-                setPointTemperature = 10;
-            if (setPointTemperature > 38)
-                setPointTemperature = 38;
-            this.log.debug("Setpoint temperature is " + setPointTemperature + "°C", this.deviceData.name);
+            if (setPointTemperature < MIN_TARGET_TEMPERATURE_C) {
+                setPointTemperature = MIN_TARGET_TEMPERATURE_C;
+            }
+            if (setPointTemperature > MAX_TARGET_TEMPERATURE_C) {
+                setPointTemperature = MAX_TARGET_TEMPERATURE_C;
+            }
+            this.log.debug("Setpoint temperature is " + setPointTemperature + " C", this.deviceData.name);
             this.accessory
                 .getService(ThermostatService)
                 .getCharacteristic(Characteristic.TargetTemperature)
                 .updateValue(setPointTemperature);
-            let currentHeatingCoolingState = 0;
+            let currentHeatingCoolingState = Characteristic.CurrentHeatingCoolingState.OFF;
             if (newValues.isHeating) {
-                currentHeatingCoolingState = 1;
+                currentHeatingCoolingState =
+                    Characteristic.CurrentHeatingCoolingState.HEAT;
             }
             this.log.debug("Current heating state is " + currentHeatingCoolingState, this.deviceData.name);
             this.accessory
@@ -153,5 +170,29 @@ class NuHeatThermostat {
         }
         return true;
     }
+    updateTemperatureDisplayUnits() {
+        const displayUnits = this.toHomeKitDisplayUnits(this.temperatureScale);
+        if (displayUnits === undefined ||
+            !Characteristic.TemperatureDisplayUnits) {
+            return;
+        }
+        this.accessory
+            .getService(ThermostatService)
+            .getCharacteristic(Characteristic.TemperatureDisplayUnits)
+            .updateValue(displayUnits);
+    }
+    toHomeKitDisplayUnits(temperatureScale) {
+        if (!temperatureScale || !Characteristic.TemperatureDisplayUnits) {
+            return undefined;
+        }
+        const normalizedScale = temperatureScale.trim().toLowerCase();
+        if (normalizedScale.startsWith("f")) {
+            return Characteristic.TemperatureDisplayUnits.FAHRENHEIT;
+        }
+        if (normalizedScale.startsWith("c")) {
+            return Characteristic.TemperatureDisplayUnits.CELSIUS;
+        }
+        return undefined;
+    }
 }
 module.exports = NuHeatThermostat;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-nuheat2",
-  "version": "1.2.11",
+  "version": "1.2.12",
   "description": "Homebridge Platform for NuHeat Signature Thermostats",
   "main": "index.js",
   "scripts": {