homebridge-nuheat2 1.2.4-beta.0 → 1.2.4

package/CHANGELOG.md

@@ -4,15 +4,23 @@ All notable changes to this project should be documented in this file
 
 ## [Unreleased]
 
-## [1.2.4-beta.0] - 2026-04-11
+## [1.2.4] - 2026-04-11
+
+### Added
+
+- Swagger-aligned internal model helpers for account, thermostat, schedule, group, and energy responses
+- Optional per-thermostat schedule switches that can resume schedule mode from HomeKit
+- Account, schedule, and energy log API helpers for future UI and automation features
 
 ### Changed
 
 - Delay platform startup until Homebridge finishes restoring cached accessories
 - Allow overriding Nuheat OAuth client settings through config or environment variables
 - Improve SignalR reconnection handling and token refresh behavior
-- Add basic regression tests and modernize package metadata for Homebridge 1.8+ and 2.0 betas
-- Publish the maintained fork under the new npm package identity `homebridge-nuheat2`
+- Add regression tests and modernize package metadata for current Homebridge releases
+- Publish the maintained fork under the npm package identity `homebridge-nuheat2`
+- Simplify thermostat operating-mode handling to match the documented Nuheat Swagger model
+- Refresh thermostats when Nuheat sends schedule notifications
 
 ### Fixed
 

package/README.md

@@ -14,6 +14,7 @@ This fork focuses on modernizing the plugin for current Homebridge releases, imp
 - Supports permanent, scheduled, and timed holds
 - Uses Nuheat's OAuth-based API instead of legacy site scraping
 - Includes compatibility improvements for Homebridge 1.8+ and 2.0 betas
+- Can optionally expose a schedule switch for each thermostat
 - Allows advanced OAuth overrides for long-term API stability
 
 ## Compatibility
@@ -51,6 +52,7 @@ Most users should configure the plugin through Homebridge Config UI X, but the e
   "password": "password123",
   "devices": [{ "serialNumber": "1111111" }, { "serialNumber": "2222222" }],
   "autoPopulateAwayModeSwitches": true,
+  "exposeScheduleSwitches": false,
   "holdLength": 1440,
   "refresh": 60
 }
@@ -61,16 +63,18 @@ Most users should configure the plugin through Homebridge Config UI X, but the e
 - `platform`: Must be `NuHeat`
 - `name`: Display name used in Homebridge logs
 - `email`: MyNuheat account email address
+- `Email`: Legacy alias still accepted for backward compatibility, but `email` is the preferred documented field
 - `password`: MyNuheat account password
-- `devices`: Optional list of thermostats to expose
+- `devices`: Optional list of thermostats to expose. If omitted or empty, every thermostat on the account will be discovered automatically
 - `serialNumber`: Thermostat serial number from MyNuheat
-- `autoPopulateAwayModeSwitches`: Automatically expose switches for all groups on the account
-- `groups`: Optional allow-list of groups to expose as away-mode switches
+- `autoPopulateAwayModeSwitches`: Automatically expose away-mode switches for all groups on the account
+- `exposeScheduleSwitches`: Optionally expose a switch per thermostat that reflects whether the thermostat is following its schedule and can be turned on to resume the schedule
+- `groups`: Optional allow-list of groups to expose as away-mode switches. This only affects group/away-mode accessories
 - `groupName`: Group name as shown in MyNuheat
 - `holdLength`: Hold duration in minutes
 - `refresh`: Poll interval in seconds, default `60`
 - `debug`: Enables verbose logging
-- `clientId`: Optional advanced override for the Nuheat OAuth client ID
+- `clientId`: Optional advanced override for the Nuheat OAuth client ID. This is recommended once you have official Nuheat API credentials
 - `clientSecret`: Optional advanced override for the Nuheat OAuth client secret
 - `redirectUri`: Optional advanced override for the Nuheat OAuth redirect URI, default `http://localhost`
 
@@ -86,6 +90,8 @@ If `devices` is omitted or empty, the plugin will automatically expose every the
 
 If `groups` is omitted and `autoPopulateAwayModeSwitches` is enabled, the plugin will automatically expose away-mode switches for all groups on the account.
 
+If `exposeScheduleSwitches` is enabled, the plugin will also create one switch per thermostat that turns on when the thermostat is following its Nuheat schedule and can be used to resume that schedule from HomeKit.
+
 ## Nuheat API Access
 
 Nuheat's public OpenAPI documentation indicates that third-party developers should request their own API credentials:
@@ -93,7 +99,7 @@ Nuheat's public OpenAPI documentation indicates that third-party developers shou
 - [Nuheat OpenAPI docs](https://api.mynuheat.com/)
 - [Nuheat API access request page](https://www.nuheat.com/openapi)
 
-This fork still supports the legacy built-in OAuth client settings as a fallback, but using your own `clientId` and `clientSecret` is the recommended long-term path.
+This fork still supports the legacy built-in OAuth client settings as a fallback, but using your own `clientId` and `clientSecret` is the recommended long-term path once Nuheat issues them for your integration.
 
 ## What's New In This Fork
 
@@ -104,6 +110,7 @@ This fork still supports the legacy built-in OAuth client settings as a fallback
 - Added regression tests for the key thermostat behavior fixes
 - Updated package metadata and dependency overrides for a cleaner modern release
 - Published under the maintainer-owned package identity `homebridge-nuheat2`
+- Added Swagger-aligned account, schedule, and energy API helpers for future enhancements
 
 ## Development
 

package/config.schema.json

@@ -60,6 +60,11 @@
         "title": "Auto populate Away Mode switches for all available groups",
         "type": "boolean"
       },
+      "exposeScheduleSwitches": {
+        "title": "Expose per-thermostat schedule switches",
+        "type": "boolean",
+        "description": "Creates a switch for each thermostat that reflects whether its schedule is active and can be turned on to resume the configured schedule."
+      },
       "groups": {
         "title": "Groups",
         "type": "array",

package/index.js

@@ -2,6 +2,7 @@
 
 let NuHeatAPI = require("./lib/NuHeatAPI.js");
 let NuHeatGroup = require("./lib/NuHeatGroup.js");
+let NuHeatScheduleSwitch = require("./lib/NuHeatScheduleSwitch.js");
 let NuHeatThermostat = require("./lib/NuHeatThermostat.js");
 let NuHeatListener = require("./lib/NuHeatListener.js");
 const logger = require("./lib/logger");
@@ -88,6 +89,7 @@ class NuHeatPlatform {
     );
 
     if (await this.NuHeatAPI.returnAccessToken()) {
+      await this.loadAccount();
       await this.setupGroups();
       await this.setupThermostats();
       this.cleanupRemovedAccessories();
@@ -270,10 +272,58 @@ class NuHeatPlatform {
         this.accessories
           .find((accessory) => accessory.uuid === uuid)
           .accessory.updateValues(deviceData);
+
+        if (this.config.exposeScheduleSwitches) {
+          this.setupScheduleSwitch(deviceData);
+        }
       }),
     );
   }
 
+  setupScheduleSwitch(deviceData) {
+    const uuid = UUIDGen.generate(
+      deviceData.serialNumber.toString() + "-schedule",
+    );
+    let deviceAccessory = false;
+
+    if (this.accessories.find((accessory) => accessory.uuid === uuid)) {
+      deviceAccessory = this.accessories.find(
+        (accessory) => accessory.uuid === uuid,
+      ).accessory;
+    }
+
+    if (!deviceAccessory) {
+      this.log.info("Creating schedule switch for thermostat", deviceData.name);
+      const accessory = new PlatformAccessory(
+        deviceData.name + " Schedule",
+        uuid,
+      );
+      accessory.addService(Service.Switch, deviceData.name + " Schedule");
+      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [
+        accessory,
+      ]);
+      deviceAccessory = accessory;
+      this.accessories.push({ uuid });
+    }
+
+    this.accessories.find((accessory) => accessory.uuid === uuid).accessory =
+      new NuHeatScheduleSwitch(
+        this.log,
+        deviceData,
+        deviceAccessory instanceof NuHeatScheduleSwitch
+          ? deviceAccessory.accessory
+          : deviceAccessory,
+        this.NuHeatAPI,
+        Homebridge,
+      );
+    this.accessories.find(
+      (accessory) => accessory.uuid === uuid,
+    ).existsInConfig = true;
+    this.accessories
+      .find((accessory) => accessory.uuid === uuid)
+      .accessory.updateValues(deviceData);
+  }
+
   cleanupRemovedAccessories() {
     this.accessories.forEach(function (thisAccessory) {
       if (thisAccessory.existsInConfig !== true) {
@@ -341,11 +391,35 @@ class NuHeatPlatform {
       if (thisAccessory) {
         thisAccessory.accessory.updateValues(deviceData);
       }
+
+      const scheduleAccessory = this.accessories.find(
+        (accessory) =>
+          accessory.uuid ===
+          UUIDGen.generate(deviceData.serialNumber.toString() + "-schedule"),
+      );
+      if (scheduleAccessory) {
+        scheduleAccessory.accessory.updateValues(deviceData);
+      }
     }, this);
 
     return true;
   }
 
+  async loadAccount() {
+    const account = await this.NuHeatAPI.getAccount();
+    if (!account) {
+      return;
+    }
+
+    this.account = account;
+    this.log.debug(
+      "NuHeat account preferences loaded. Temperature scale: " +
+        (account.temperatureScale || "unknown") +
+        ", 12-hour clock: " +
+        String(account.use12Hour),
+    );
+  }
+
   teardown() {
     if (this.refreshTimer) {
       clearInterval(this.refreshTimer);

package/lib/NuHeatAPI.js

@@ -18,6 +18,14 @@ const {
   NUHEAT_API_TOKEN_URI,
   NUHEAT_API_CONSENT_URI,
 } = require("./settings");
+const {
+  SCHEDULE_MODE,
+  normalizeAccount,
+  normalizeEnergyUsage,
+  normalizeGroup,
+  normalizeSchedule,
+  normalizeThermostat,
+} = require("./NuHeatModels");
 
 module.exports = class NuHeatAPI {
   constructor(email, password, log, options = {}) {
@@ -108,12 +116,37 @@ module.exports = class NuHeatAPI {
     return returnedData;
   }
 
+  async resumeSchedule(serialNumber) {
+    return this.updateThermostat({
+      serialNumber,
+      scheduleMode: SCHEDULE_MODE.AUTO,
+    });
+  }
+
+  async updateThermostat(thermostatUpdate) {
+    const callURL = "https://api.mynuheat.com/api/v1/Thermostat";
+    const callOptions = {
+      body: JSON.stringify(thermostatUpdate),
+      method: "PUT",
+    };
+
+    return await this.makeAPICall(callURL, callOptions, {
+      normalize: normalizeThermostat,
+    });
+  }
+
   // get data for a group
   async refreshGroup(groupId) {
     // set the URL for the call
     const callURL = "https://api.mynuheat.com/api/v1/Group/" + groupId;
 
-    let returnedData = await this.makeAPICall(callURL);
+    let returnedData = await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeGroup,
+      },
+    );
     return returnedData;
   }
 
@@ -122,7 +155,14 @@ module.exports = class NuHeatAPI {
     // set the URL for the call
     const callURL = "https://api.mynuheat.com/api/v1/Group";
 
-    let returnedData = await this.makeAPICall(callURL);
+    let returnedData = await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeGroup,
+        normalizeArray: true,
+      },
+    );
     return returnedData;
   }
 
@@ -132,7 +172,13 @@ module.exports = class NuHeatAPI {
     const callURL =
       "https://api.mynuheat.com/api/v1/Thermostat/" + serialNumber;
 
-    let returnedData = await this.makeAPICall(callURL);
+    let returnedData = await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeThermostat,
+      },
+    );
     return returnedData;
   }
 
@@ -141,11 +187,111 @@ module.exports = class NuHeatAPI {
     // set the URL for the call
     const callURL = "https://api.mynuheat.com/api/v1/Thermostat";
 
-    let returnedData = await this.makeAPICall(callURL);
+    let returnedData = await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeThermostat,
+        normalizeArray: true,
+      },
+    );
     return returnedData;
   }
 
-  async makeAPICall(callURL, callOptions = {}) {
+  async getAccount() {
+    const callURL = "https://api.mynuheat.com/api/v1/Account";
+    return await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeAccount,
+      },
+    );
+  }
+
+  async refreshSchedule(serialNumber) {
+    const callURL = "https://api.mynuheat.com/api/v1/Schedule/" + serialNumber;
+    return await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeSchedule,
+      },
+    );
+  }
+
+  async refreshSchedules() {
+    const callURL = "https://api.mynuheat.com/api/v1/Schedule";
+    return await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeSchedule,
+        normalizeArray: true,
+      },
+    );
+  }
+
+  async updateSchedule(scheduleModel) {
+    const callURL = "https://api.mynuheat.com/api/v1/Schedule";
+    return await this.makeAPICall(
+      callURL,
+      {
+        body: JSON.stringify(scheduleModel),
+        method: "PUT",
+      },
+      {
+        treatNoContentAsSuccess: true,
+      },
+    );
+  }
+
+  async refreshEnergyLogDay(serialNumber, date) {
+    const callURL =
+      "https://api.mynuheat.com/api/v1/EnergyLog/Day/" +
+      serialNumber +
+      "/" +
+      date;
+    return await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeEnergyUsage,
+      },
+    );
+  }
+
+  async refreshEnergyLogWeek(serialNumber, date) {
+    const callURL =
+      "https://api.mynuheat.com/api/v1/EnergyLog/Week/" +
+      serialNumber +
+      "/" +
+      date;
+    return await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeEnergyUsage,
+      },
+    );
+  }
+
+  async refreshEnergyLogMonth(serialNumber, year) {
+    const callURL =
+      "https://api.mynuheat.com/api/v1/EnergyLog/Month/" +
+      serialNumber +
+      "/" +
+      year;
+    return await this.makeAPICall(
+      callURL,
+      {},
+      {
+        normalize: normalizeEnergyUsage,
+      },
+    );
+  }
+
+  async makeAPICall(callURL, callOptions = {}, options = {}) {
     // Validate and potentially refresh our access token.
     if (!(await this.refreshAccessToken())) {
       return false;
@@ -161,9 +307,21 @@ module.exports = class NuHeatAPI {
     }
     //handle PUT successes that don't return a body
     if (response.status === 204) {
+      if (options.treatNoContentAsSuccess) {
+        return true;
+      }
       return true;
     }
     let returnedData = await response.json();
+
+    if (options.normalize) {
+      if (options.normalizeArray && Array.isArray(returnedData)) {
+        return returnedData.map(options.normalize);
+      }
+
+      return options.normalize(returnedData);
+    }
+
     return returnedData;
   }
 

package/lib/NuHeatListener.js

@@ -112,6 +112,7 @@ module.exports = class NuHeatListener {
           break;
         case 3:
           notificationType = "Schedule";
+          this.nuHeatPlatform.refreshThermostats();
           break;
         case 4:
           notificationType = "Group";

package/lib/NuHeatModels.js

@@ -0,0 +1,136 @@
+"use strict";
+
+const SCHEDULE_MODE = {
+  AUTO: 1,
+  HOLD: 2,
+  PERMANENT_HOLD: 3,
+};
+
+const OPERATING_MODE = {
+  AUTO: 1,
+  MANUAL: 2,
+};
+
+function coalesce(...values) {
+  return values.find((value) => value !== undefined && value !== null);
+}
+
+function normalizeAccount(account = {}) {
+  return {
+    firstName: coalesce(account.firstName, account.FirstName),
+    lastName: coalesce(account.lastName, account.LastName),
+    email: coalesce(account.email, account.Email),
+    use12Hour: coalesce(account.use12Hour, account.Use12Hour),
+    temperatureScale: coalesce(
+      account.temperatureScale,
+      account.TemperatureScale,
+    ),
+  };
+}
+
+function normalizeGroup(group = {}) {
+  return {
+    groupId: coalesce(group.groupId, group.GroupId),
+    groupName: coalesce(group.groupName, group.GroupName),
+    awayMode: coalesce(group.awayMode, group.AwayMode),
+    awaySetPointTemp: coalesce(group.awaySetPointTemp, group.AwaySetPointTemp),
+  };
+}
+
+function normalizeScheduleEvent(event = {}) {
+  return {
+    clock: coalesce(event.clock, event.Clock),
+    scheduleType: coalesce(event.scheduleType, event.ScheduleType),
+    active: coalesce(event.active, event.Active),
+    temperature: coalesce(event.temperature, event.Temperature),
+  };
+}
+
+function normalizeScheduleDay(day = {}) {
+  return {
+    weekDay: coalesce(day.weekDay, day.WeekDay),
+    weekDayGroupNumber: coalesce(
+      day.weekDayGroupNumber,
+      day.WeekDayGroupNumber,
+    ),
+    events: (coalesce(day.events, day.Events) || []).map(
+      normalizeScheduleEvent,
+    ),
+  };
+}
+
+function normalizeSchedule(schedule = {}) {
+  return {
+    serialNumber: coalesce(schedule.serialNumber, schedule.SerialNumber),
+    days: (coalesce(schedule.days, schedule.Days) || []).map(
+      normalizeScheduleDay,
+    ),
+  };
+}
+
+function normalizeThermostat(thermostat = {}) {
+  return {
+    serialNumber: coalesce(thermostat.serialNumber, thermostat.SerialNumber),
+    name: coalesce(thermostat.name, thermostat.Name),
+    setPointTemp: coalesce(thermostat.setPointTemp, thermostat.SetPointTemp),
+    scheduleMode: coalesce(thermostat.scheduleMode, thermostat.ScheduleMode),
+    holdSetPointDateTime: coalesce(
+      thermostat.holdSetPointDateTime,
+      thermostat.HoldSetPointDateTime,
+    ),
+    groupId: coalesce(thermostat.groupId, thermostat.GroupId),
+    swVersion: coalesce(thermostat.swVersion, thermostat.SwVersion),
+    online: coalesce(thermostat.online, thermostat.Online),
+    operatingMode: coalesce(thermostat.operatingMode, thermostat.OperatingMode),
+    isHeating: coalesce(thermostat.isHeating, thermostat.IsHeating),
+    currentTemperature: coalesce(
+      thermostat.currentTemperature,
+      thermostat.CurrentTemperature,
+    ),
+    tzOffset: coalesce(thermostat.tzOffset, thermostat.TZOffset),
+    error: coalesce(thermostat.error, thermostat.Error),
+  };
+}
+
+function normalizeEnergyUsageEntry(entry = {}) {
+  return {
+    entry: coalesce(entry.entry, entry.Entry),
+    minutes: coalesce(entry.minutes, entry.Minutes),
+    energyKWattHour: coalesce(entry.energyKWattHour, entry.EnergyKWattHour),
+    chargeKWattHour: coalesce(entry.chargeKWattHour, entry.ChargeKWattHour),
+  };
+}
+
+function normalizeEnergyUsage(energyUsage = {}) {
+  return {
+    energyUsageType: coalesce(
+      energyUsage.energyUsageType,
+      energyUsage.EnergyUsageType,
+    ),
+    energyUsageFrom: coalesce(
+      energyUsage.energyUsageFrom,
+      energyUsage.EnergyUsageFrom,
+    ),
+    energyUsageTo: coalesce(
+      energyUsage.energyUsageTo,
+      energyUsage.EnergyUsageTo,
+    ),
+    mondayIsFirstDay: coalesce(
+      energyUsage.mondayIsFirstDay,
+      energyUsage.MondayIsFirstDay,
+    ),
+    energyUsage: (
+      coalesce(energyUsage.energyUsage, energyUsage.EnergyUsage) || []
+    ).map(normalizeEnergyUsageEntry),
+  };
+}
+
+module.exports = {
+  OPERATING_MODE,
+  SCHEDULE_MODE,
+  normalizeAccount,
+  normalizeEnergyUsage,
+  normalizeGroup,
+  normalizeSchedule,
+  normalizeThermostat,
+};

package/lib/NuHeatScheduleSwitch.js

@@ -0,0 +1,69 @@
+"use strict";
+
+let Characteristic, SwitchService;
+
+const { SCHEDULE_MODE } = require("./NuHeatModels");
+
+module.exports = class NuHeatScheduleSwitch {
+  constructor(log, deviceData, accessory, nuHeatAPI, homebridge) {
+    Characteristic = homebridge.hap.Characteristic;
+    SwitchService = homebridge.hap.Service.Switch;
+    this.log = log;
+    this.deviceData = deviceData;
+    this.accessory = accessory;
+    this.nuHeatAPI = nuHeatAPI;
+
+    this.accessory
+      .getService(homebridge.hap.Service.AccessoryInformation)
+      .setCharacteristic(Characteristic.Manufacturer, "NuHeat")
+      .setCharacteristic(Characteristic.Model, "Signature Schedule")
+      .setCharacteristic(
+        Characteristic.SerialNumber,
+        this.deviceData.serialNumber + "-schedule",
+      );
+
+    this.setupListeners();
+  }
+
+  setupListeners() {
+    this.accessory
+      .getService(SwitchService)
+      .getCharacteristic(Characteristic.On)
+      .on("set", this.setScheduleEnabled.bind(this));
+  }
+
+  async setScheduleEnabled(value, callback) {
+    if (!value) {
+      callback(null);
+      this.updateValues(this.deviceData);
+      return;
+    }
+
+    this.log.debug(
+      "Resuming schedule for thermostat " + this.deviceData.serialNumber,
+      this.deviceData.name,
+    );
+
+    const response = await this.nuHeatAPI.resumeSchedule(
+      this.deviceData.serialNumber,
+    );
+
+    if (!response) {
+      this.log.error("Error resuming schedule", this.deviceData.name);
+      callback(new Error("Error: resumeSchedule"));
+      return;
+    }
+
+    this.updateValues(response);
+    callback(null);
+  }
+
+  updateValues(newValues) {
+    this.deviceData = newValues;
+    const scheduleEnabled = newValues.scheduleMode === SCHEDULE_MODE.AUTO;
+    this.accessory
+      .getService(SwitchService)
+      .getCharacteristic(Characteristic.On)
+      .updateValue(scheduleEnabled);
+  }
+};

package/lib/NuHeatThermostat.js

@@ -1,3 +1,5 @@
+const { OPERATING_MODE, SCHEDULE_MODE } = require("./NuHeatModels");
+
 let Characteristic, ThermostatService;
 module.exports = class NuHeatThermostat {
   constructor(log, deviceData, holdLength, accessory, NuHeatAPI, homebridge) {
@@ -52,7 +54,7 @@ module.exports = class NuHeatThermostat {
       .on("set", this.setTargetTemperature.bind(this));
   }
 
-  // This is to change the system switch to a different mode - that doesn't work for us, its always in heat
+  // Nuheat exposes heat-only thermostats, so this characteristic is informational.
   setTargetHeatingCooling(value, callback) {
     callback(null);
     this.updateAccessory();
@@ -145,9 +147,8 @@ module.exports = class NuHeatThermostat {
         .updateValue(CurrentHeatingCoolingState);
 
       // system switch mode
-      var TargetHeatingCooling = this.toHomeBridgeisHeatingCoolingSystem(
-        newValues.operatingMode,
-      );
+      var TargetHeatingCooling =
+        this.toHomeBridgeHeatingCoolingState(newValues);
       this.log.debug(
         "Target heating state is " + TargetHeatingCooling,
         this.deviceData.name,
@@ -176,55 +177,23 @@ module.exports = class NuHeatThermostat {
     return ((((temperature - 33) / 56 + 33 - 32) * 5) / 9).toFixed(1);
   }
 
-  toHomeBridgeisHeatingCoolingSystem(isHeatingCoolingSystem) {
-    switch (isHeatingCoolingSystem) {
-      case 0:
-      // emergency heat
-      case 1:
-      case 2:
-        // heat, including manual mode
+  toHomeBridgeHeatingCoolingState(newValues) {
+    if (!this.isOnline(newValues)) {
+      return Characteristic.TargetHeatingCoolingState.OFF;
+    }
+
+    switch (newValues.operatingMode) {
+      case OPERATING_MODE.AUTO:
+      case OPERATING_MODE.MANUAL:
         return Characteristic.TargetHeatingCoolingState.HEAT;
-        break;
-      case 3:
-      // cool
-      case 7:
-        // "Drying" (MHK1)
-        return Characteristic.TargetHeatingCoolingState.COOL;
-        break;
-      case 4:
-      // autoheat
-      case 5:
-        // autocool
-        return Characteristic.TargetHeatingCoolingState.AUTO;
-        break;
-      case 6:
-      // "Southern Away" humidity control
       default:
-        return Characteristic.TargetHeatingCoolingState.OFF;
+        // The Swagger spec currently documents only AUTO=1 and MANUAL=2.
+        return Characteristic.TargetHeatingCoolingState.HEAT;
     }
   }
 
-  toNuHeatisHeatingCoolingSystem(isHeatingCoolingSystem) {
-    switch (isHeatingCoolingSystem) {
-      case Characteristic.TargetHeatingCoolingState.OFF:
-        // off
-        return 2;
-        break;
-      case Characteristic.TargetHeatingCoolingState.HEAT:
-        // heat
-        return 1;
-        break;
-      case Characteristic.TargetHeatingCoolingState.COOL:
-        // cool
-        return 3;
-        break;
-      case Characteristic.TargetHeatingCoolingState.AUTO:
-        // auto
-        return 4;
-        break;
-      default:
-        return 0;
-    }
+  isScheduleEnabled(newValues) {
+    return newValues.scheduleMode === SCHEDULE_MODE.AUTO;
   }
 
   isOnline(newValues) {

package/package.json

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