homebridge-ac-freedom 1.0.0

package/config.schema.json

@@ -0,0 +1,131 @@
+{
+  "pluginAlias": "AcFreedom",
+  "pluginType": "platform",
+  "singular": false,
+  "headerDisplay": "AUX Air Conditioner control via Broadlink (local) or AUX Cloud API.",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "name": {
+        "title": "Platform Name",
+        "type": "string",
+        "default": "AC Freedom",
+        "required": true
+      },
+      "devices": {
+        "title": "Devices",
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "title": "Device Name",
+              "type": "string",
+              "default": "AC Freedom",
+              "required": true
+            },
+            "connection": {
+              "title": "Connection Mode",
+              "type": "string",
+              "default": "cloud",
+              "oneOf": [
+                { "title": "Cloud (AUX Cloud API)", "enum": ["cloud"] },
+                { "title": "Local (Broadlink UDP)", "enum": ["local"] }
+              ],
+              "required": true
+            },
+            "cloud": {
+              "title": "Cloud Settings",
+              "type": "object",
+              "condition": { "functionBody": "return model.devices[arrayIndices[0]].connection === 'cloud';" },
+              "properties": {
+                "email": {
+                  "title": "Email",
+                  "type": "string",
+                  "required": true
+                },
+                "password": {
+                  "title": "Password",
+                  "type": "string",
+                  "required": true
+                },
+                "region": {
+                  "title": "Region",
+                  "type": "string",
+                  "default": "eu",
+                  "oneOf": [
+                    { "title": "Europe", "enum": ["eu"] },
+                    { "title": "USA", "enum": ["usa"] },
+                    { "title": "China", "enum": ["cn"] },
+                    { "title": "Russia", "enum": ["rus"] }
+                  ]
+                },
+                "deviceId": {
+                  "title": "Device ID (endpointId, leave empty for auto-detect)",
+                  "type": "string"
+                }
+              }
+            },
+            "local": {
+              "title": "Local Settings",
+              "type": "object",
+              "condition": { "functionBody": "return model.devices[arrayIndices[0]].connection === 'local';" },
+              "properties": {
+                "ip": {
+                  "title": "IP Address",
+                  "type": "string",
+                  "required": true
+                },
+                "mac": {
+                  "title": "MAC Address (AA:BB:CC:DD:EE:FF)",
+                  "type": "string",
+                  "required": true
+                }
+              }
+            },
+            "hvacModes": {
+              "title": "Enabled HVAC Modes",
+              "type": "object",
+              "properties": {
+                "auto": { "title": "Auto", "type": "boolean", "default": true },
+                "cool": { "title": "Cool", "type": "boolean", "default": true },
+                "heat": { "title": "Heat", "type": "boolean", "default": true }
+              }
+            },
+            "presets": {
+              "title": "Enabled Preset Modes (shown as switches in climate card)",
+              "type": "object",
+              "properties": {
+                "sleep": { "title": "Sleep Mode", "type": "boolean", "default": true },
+                "health": { "title": "Health / Ionizer", "type": "boolean", "default": true },
+                "eco": { "title": "Eco / Mildew Prevention", "type": "boolean", "default": true },
+                "clean": { "title": "Self Clean", "type": "boolean", "default": true }
+              }
+            },
+            "showDisplay": {
+              "title": "Show Display Switch",
+              "type": "boolean",
+              "default": true
+            },
+            "pollInterval": {
+              "title": "Poll Interval (seconds)",
+              "type": "integer",
+              "default": 30,
+              "minimum": 5,
+              "maximum": 300
+            },
+            "tempStep": {
+              "title": "Temperature Step",
+              "type": "number",
+              "default": 0.5,
+              "oneOf": [
+                { "title": "0.5 °C", "enum": [0.5] },
+                { "title": "1 °C", "enum": [1] }
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/index.js

@@ -0,0 +1,15 @@
+/**
+ * homebridge-ac-freedom
+ *
+ * Homebridge plugin for AUX air conditioners via Broadlink (local) and AUX Cloud API.
+ * Exposes HeaterCooler with linked Switch services for presets inside the climate card.
+ */
+
+const { AcFreedomPlatform } = require('./src/platform');
+
+const PLUGIN_NAME = 'homebridge-ac-freedom';
+const PLATFORM_NAME = 'AcFreedom';
+
+module.exports = (api) => {
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, AcFreedomPlatform);
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "homebridge-ac-freedom",
+  "version": "1.0.0",
+  "description": "Homebridge plugin for AUX air conditioners via Broadlink (local UDP) and AUX Cloud API",
+  "main": "index.js",
+  "scripts": {
+    "lint": "eslint src/"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "homebridge",
+    "aux",
+    "broadlink",
+    "air-conditioner",
+    "hvac",
+    "climate"
+  ],
+  "author": "azadaydinli",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/azadaydinli/homebridge-ac-freedom.git"
+  },
+  "engines": {
+    "homebridge": ">=1.6.0",
+    "node": ">=18.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "homepage": "https://github.com/azadaydinli/homebridge-ac-freedom"
+}

package/src/ac-accessory.js

@@ -0,0 +1,481 @@
+/**
+ * AcFreedomAccessory
+ *
+ * Exposes a HeaterCooler service with linked Switch services for preset modes.
+ * Presets (sleep, health, eco, clean) and display appear as toggles inside
+ * the climate card in HomeKit.
+ */
+
+'use strict';
+
+// Cloud API param keys
+const CLOUD = {
+  POWER: 'pwr',
+  MODE: 'ac_mode',
+  TEMP_TARGET: 'temp',
+  TEMP_AMBIENT: 'envtemp',
+  FAN_SPEED: 'ac_mark',
+  SWING_V: 'ac_vdir',
+  SWING_H: 'ac_hdir',
+  SLEEP: 'ac_slp',
+  HEALTH: 'ac_health',
+  ECO: 'mldprf',
+  CLEAN: 'ac_clean',
+  DISPLAY: 'scrdisp',
+};
+
+// Cloud mode values: 0=COOL, 1=HEAT, 2=DRY, 3=FAN, 4=AUTO
+const CLOUD_MODE = { AUTO: 4, COOL: 0, HEAT: 1, DRY: 2, FAN: 3 };
+
+// Fan speed values
+const FAN_SPEED = { AUTO: 0, LOW: 1, MEDIUM: 2, HIGH: 3, TURBO: 4, MUTE: 5 };
+
+class AcFreedomAccessory {
+  constructor(platform, accessory, config, deviceApi) {
+    this.platform = platform;
+    this.accessory = accessory;
+    this.config = config;
+    this.deviceApi = deviceApi;
+    this.log = platform.log;
+
+    this.Service = platform.api.hap.Service;
+    this.Characteristic = platform.api.hap.Characteristic;
+
+    // Current state cache
+    this.state = {
+      power: false,
+      mode: CLOUD_MODE.AUTO,
+      targetTemp: 24,
+      currentTemp: 24,
+      fanSpeed: FAN_SPEED.AUTO,
+      swingV: false,
+      swingH: false,
+      sleep: false,
+      health: false,
+      eco: false,
+      clean: false,
+      display: true,
+    };
+
+    this.presetConfigs = {
+      sleep: { label: 'Sleep Mode', cloudKey: CLOUD.SLEEP, localAttr: 'sleep' },
+      health: { label: 'Health', cloudKey: CLOUD.HEALTH, localAttr: 'health' },
+      eco: { label: 'Eco', cloudKey: CLOUD.ECO, localAttr: 'mildew' },
+      clean: { label: 'Clean', cloudKey: CLOUD.CLEAN, localAttr: 'clean' },
+    };
+
+    this.setupAccessoryInfo();
+    this.setupHeaterCooler();
+    this.setupPresetSwitches();
+    this.setupDisplaySwitch();
+
+    // Start polling
+    const interval = (config.pollInterval || 30) * 1000;
+    this.pollTimer = setInterval(() => this.pollState(), interval);
+    this.pollState();
+  }
+
+  // ── Accessory Information ──────────────────────────────────────
+  setupAccessoryInfo() {
+    const infoService = this.accessory.getService(this.Service.AccessoryInformation)
+      || this.accessory.addService(this.Service.AccessoryInformation);
+
+    infoService
+      .setCharacteristic(this.Characteristic.Manufacturer, 'AUX')
+      .setCharacteristic(this.Characteristic.Model, 'AC Freedom')
+      .setCharacteristic(this.Characteristic.SerialNumber, this.config.name || 'AC-001');
+  }
+
+  // ── HeaterCooler Service ───────────────────────────────────────
+  setupHeaterCooler() {
+    this.heaterCooler = this.accessory.getService(this.Service.HeaterCooler)
+      || this.accessory.addService(this.Service.HeaterCooler, this.config.name);
+
+    const C = this.Characteristic;
+    const hvac = this.config.hvacModes || { auto: true, cool: true, heat: true };
+
+    // Active (on/off)
+    this.heaterCooler.getCharacteristic(C.Active)
+      .onGet(() => this.state.power ? C.Active.ACTIVE : C.Active.INACTIVE)
+      .onSet(async (value) => {
+        this.state.power = value === C.Active.ACTIVE;
+        await this.sendPower(this.state.power);
+      });
+
+    // Current state
+    this.heaterCooler.getCharacteristic(C.CurrentHeaterCoolerState)
+      .onGet(() => {
+        if (!this.state.power) return C.CurrentHeaterCoolerState.INACTIVE;
+        switch (this.state.mode) {
+          case CLOUD_MODE.HEAT: return C.CurrentHeaterCoolerState.HEATING;
+          case CLOUD_MODE.COOL: return C.CurrentHeaterCoolerState.COOLING;
+          default: return C.CurrentHeaterCoolerState.IDLE;
+        }
+      });
+
+    // Target state (auto/heat/cool)
+    const validStates = [];
+    if (hvac.auto) validStates.push(C.TargetHeaterCoolerState.AUTO);
+    if (hvac.heat) validStates.push(C.TargetHeaterCoolerState.HEAT);
+    if (hvac.cool) validStates.push(C.TargetHeaterCoolerState.COOL);
+    if (validStates.length === 0) validStates.push(C.TargetHeaterCoolerState.AUTO);
+
+    this.heaterCooler.getCharacteristic(C.TargetHeaterCoolerState)
+      .setProps({ validValues: validStates })
+      .onGet(() => {
+        switch (this.state.mode) {
+          case CLOUD_MODE.HEAT: return C.TargetHeaterCoolerState.HEAT;
+          case CLOUD_MODE.COOL: return C.TargetHeaterCoolerState.COOL;
+          default: return C.TargetHeaterCoolerState.AUTO;
+        }
+      })
+      .onSet(async (value) => {
+        let mode;
+        switch (value) {
+          case C.TargetHeaterCoolerState.HEAT: mode = CLOUD_MODE.HEAT; break;
+          case C.TargetHeaterCoolerState.COOL: mode = CLOUD_MODE.COOL; break;
+          default: mode = CLOUD_MODE.AUTO; break;
+        }
+        this.state.mode = mode;
+        await this.sendMode(mode);
+      });
+
+    // Current temperature
+    this.heaterCooler.getCharacteristic(C.CurrentTemperature)
+      .setProps({ minValue: -20, maxValue: 60 })
+      .onGet(() => this.state.currentTemp);
+
+    // Cooling threshold temperature
+    const step = this.config.tempStep || 0.5;
+    this.heaterCooler.getCharacteristic(C.CoolingThresholdTemperature)
+      .setProps({ minValue: 16, maxValue: 32, minStep: step })
+      .onGet(() => this.state.targetTemp)
+      .onSet(async (value) => {
+        this.state.targetTemp = value;
+        await this.sendTemperature(value);
+      });
+
+    // Heating threshold temperature
+    this.heaterCooler.getCharacteristic(C.HeatingThresholdTemperature)
+      .setProps({ minValue: 16, maxValue: 32, minStep: step })
+      .onGet(() => this.state.targetTemp)
+      .onSet(async (value) => {
+        this.state.targetTemp = value;
+        await this.sendTemperature(value);
+      });
+
+    // Rotation speed (fan: 0=auto, 20=mute, 40=low, 60=med, 80=high, 100=turbo)
+    this.heaterCooler.getCharacteristic(C.RotationSpeed)
+      .setProps({ minValue: 0, maxValue: 100, minStep: 20 })
+      .onGet(() => this.fanSpeedToPercent(this.state.fanSpeed))
+      .onSet(async (value) => {
+        this.state.fanSpeed = this.percentToFanSpeed(value);
+        await this.sendFanSpeed(this.state.fanSpeed);
+      });
+
+    // Swing mode
+    this.heaterCooler.getCharacteristic(C.SwingMode)
+      .onGet(() => (this.state.swingV || this.state.swingH)
+        ? C.SwingMode.SWING_ENABLED
+        : C.SwingMode.SWING_DISABLED)
+      .onSet(async (value) => {
+        const on = value === C.SwingMode.SWING_ENABLED;
+        this.state.swingV = on;
+        this.state.swingH = on;
+        await this.sendSwing(on, on);
+      });
+  }
+
+  // ── Preset Switches (linked to HeaterCooler) ──────────────────
+  setupPresetSwitches() {
+    const presets = this.config.presets || { sleep: true, health: true, eco: true, clean: true };
+
+    this.presetSwitches = {};
+
+    for (const [key, cfg] of Object.entries(this.presetConfigs)) {
+      if (!presets[key]) {
+        // Remove if previously existed
+        const existing = this.accessory.getServiceById(this.Service.Switch, key);
+        if (existing) this.accessory.removeService(existing);
+        continue;
+      }
+
+      const switchService = this.accessory.getServiceById(this.Service.Switch, key)
+        || this.accessory.addService(this.Service.Switch, cfg.label, key);
+
+      switchService.setCharacteristic(this.Characteristic.Name, cfg.label);
+
+      switchService.getCharacteristic(this.Characteristic.On)
+        .onGet(() => this.state[key])
+        .onSet(async (value) => {
+          // Turn off other presets when activating one
+          if (value) {
+            for (const otherKey of Object.keys(this.presetConfigs)) {
+              if (otherKey !== key) this.state[otherKey] = false;
+            }
+          }
+          this.state[key] = value;
+          await this.sendPreset(key, value);
+          // Update other switches UI
+          this.refreshPresetSwitches(key);
+        });
+
+      // Link to HeaterCooler so it appears inside the climate card
+      this.heaterCooler.addLinkedService(switchService);
+      this.presetSwitches[key] = switchService;
+    }
+  }
+
+  refreshPresetSwitches(exceptKey) {
+    for (const [key, svc] of Object.entries(this.presetSwitches)) {
+      if (key !== exceptKey) {
+        svc.updateCharacteristic(this.Characteristic.On, this.state[key]);
+      }
+    }
+  }
+
+  // ── Display Switch (linked to HeaterCooler) ────────────────────
+  setupDisplaySwitch() {
+    if (this.config.showDisplay === false) {
+      const existing = this.accessory.getServiceById(this.Service.Switch, 'display');
+      if (existing) this.accessory.removeService(existing);
+      return;
+    }
+
+    this.displaySwitch = this.accessory.getServiceById(this.Service.Switch, 'display')
+      || this.accessory.addService(this.Service.Switch, 'Display', 'display');
+
+    this.displaySwitch.setCharacteristic(this.Characteristic.Name, 'Display');
+
+    this.displaySwitch.getCharacteristic(this.Characteristic.On)
+      .onGet(() => this.state.display)
+      .onSet(async (value) => {
+        this.state.display = value;
+        await this.sendDisplay(value);
+      });
+
+    this.heaterCooler.addLinkedService(this.displaySwitch);
+  }
+
+  // ── Fan speed mapping ──────────────────────────────────────────
+  fanSpeedToPercent(speed) {
+    const map = { 0: 0, 5: 20, 1: 40, 2: 60, 3: 80, 4: 100 };
+    return map[speed] ?? 0;
+  }
+
+  percentToFanSpeed(pct) {
+    if (pct <= 0) return FAN_SPEED.AUTO;
+    if (pct <= 20) return FAN_SPEED.MUTE;
+    if (pct <= 40) return FAN_SPEED.LOW;
+    if (pct <= 60) return FAN_SPEED.MEDIUM;
+    if (pct <= 80) return FAN_SPEED.HIGH;
+    return FAN_SPEED.TURBO;
+  }
+
+  // ── Poll state ─────────────────────────────────────────────────
+  async pollState() {
+    try {
+      if (this.deviceApi.type === 'cloud') {
+        await this.pollCloud();
+      } else {
+        await this.pollLocal();
+      }
+      this.updateCharacteristics();
+    } catch (err) {
+      this.log.warn('Poll failed: %s', err.message);
+    }
+  }
+
+  async pollCloud() {
+    const { api, device } = this.deviceApi;
+    try {
+      const params = await api.getDeviceParams(device);
+      if (!params) return;
+
+      this.state.power = !!params[CLOUD.POWER];
+      this.state.mode = params[CLOUD.MODE] ?? CLOUD_MODE.AUTO;
+      this.state.targetTemp = (params[CLOUD.TEMP_TARGET] ?? 240) / 10;
+      this.state.currentTemp = (params[CLOUD.TEMP_AMBIENT] ?? 240) / 10;
+      this.state.fanSpeed = params[CLOUD.FAN_SPEED] ?? FAN_SPEED.AUTO;
+      this.state.swingV = !!params[CLOUD.SWING_V];
+      this.state.swingH = !!params[CLOUD.SWING_H];
+      this.state.sleep = !!params[CLOUD.SLEEP];
+      this.state.health = !!params[CLOUD.HEALTH];
+      this.state.eco = !!params[CLOUD.ECO];
+      this.state.clean = !!params[CLOUD.CLEAN];
+      this.state.display = !!params[CLOUD.DISPLAY];
+    } catch (err) {
+      // Re-login on token expiry
+      if (err.message && err.message.includes('token')) {
+        const cloud = this.config.cloud;
+        await api.login(cloud.email, cloud.password);
+      }
+      throw err;
+    }
+  }
+
+  async pollLocal() {
+    const { api } = this.deviceApi;
+    const ok = await api.update();
+    if (!ok) return;
+
+    const s = api.state;
+    this.state.power = !!s.power;
+    this.state.targetTemp = s.temperature;
+    this.state.currentTemp = s.ambientTemp;
+    this.state.fanSpeed = s.fanSpeed;
+    this.state.swingV = s.verticalFixation === 7;
+    this.state.swingH = s.horizontalFixation === 7;
+    this.state.sleep = !!s.sleep;
+    this.state.health = !!s.health;
+    this.state.eco = !!s.mildew;
+    this.state.clean = !!s.clean;
+    this.state.display = !!s.display;
+
+    // Map local mode to cloud mode values
+    const modeMap = { 1: CLOUD_MODE.COOL, 2: CLOUD_MODE.DRY, 4: CLOUD_MODE.HEAT, 6: CLOUD_MODE.FAN, 8: CLOUD_MODE.AUTO };
+    this.state.mode = modeMap[s.mode] ?? CLOUD_MODE.AUTO;
+  }
+
+  updateCharacteristics() {
+    const C = this.Characteristic;
+
+    this.heaterCooler.updateCharacteristic(C.Active,
+      this.state.power ? C.Active.ACTIVE : C.Active.INACTIVE);
+
+    if (!this.state.power) {
+      this.heaterCooler.updateCharacteristic(C.CurrentHeaterCoolerState,
+        C.CurrentHeaterCoolerState.INACTIVE);
+    } else {
+      switch (this.state.mode) {
+        case CLOUD_MODE.HEAT:
+          this.heaterCooler.updateCharacteristic(C.CurrentHeaterCoolerState,
+            C.CurrentHeaterCoolerState.HEATING);
+          break;
+        case CLOUD_MODE.COOL:
+          this.heaterCooler.updateCharacteristic(C.CurrentHeaterCoolerState,
+            C.CurrentHeaterCoolerState.COOLING);
+          break;
+        default:
+          this.heaterCooler.updateCharacteristic(C.CurrentHeaterCoolerState,
+            C.CurrentHeaterCoolerState.IDLE);
+      }
+    }
+
+    this.heaterCooler.updateCharacteristic(C.CurrentTemperature, this.state.currentTemp);
+    this.heaterCooler.updateCharacteristic(C.CoolingThresholdTemperature, this.state.targetTemp);
+    this.heaterCooler.updateCharacteristic(C.HeatingThresholdTemperature, this.state.targetTemp);
+    this.heaterCooler.updateCharacteristic(C.RotationSpeed, this.fanSpeedToPercent(this.state.fanSpeed));
+    this.heaterCooler.updateCharacteristic(C.SwingMode,
+      (this.state.swingV || this.state.swingH) ? C.SwingMode.SWING_ENABLED : C.SwingMode.SWING_DISABLED);
+
+    // Update preset switches
+    for (const [key, svc] of Object.entries(this.presetSwitches || {})) {
+      svc.updateCharacteristic(C.On, this.state[key]);
+    }
+
+    // Update display switch
+    if (this.displaySwitch) {
+      this.displaySwitch.updateCharacteristic(C.On, this.state.display);
+    }
+  }
+
+  // ── Send commands ──────────────────────────────────────────────
+  async sendPower(on) {
+    if (this.deviceApi.type === 'cloud') {
+      await this.cloudSet({ [CLOUD.POWER]: on ? 1 : 0 });
+    } else {
+      this.deviceApi.api.state.power = on ? 1 : 0;
+      await this.deviceApi.api.setState();
+    }
+  }
+
+  async sendMode(mode) {
+    if (this.deviceApi.type === 'cloud') {
+      await this.cloudSet({ [CLOUD.POWER]: 1, [CLOUD.MODE]: mode });
+    } else {
+      // Map cloud mode to local mode
+      const localModeMap = {
+        [CLOUD_MODE.AUTO]: 8, [CLOUD_MODE.COOL]: 1,
+        [CLOUD_MODE.HEAT]: 4, [CLOUD_MODE.DRY]: 2, [CLOUD_MODE.FAN]: 6,
+      };
+      const api = this.deviceApi.api;
+      api.state.power = 1;
+      api.state.mode = localModeMap[mode] ?? 8;
+      await api.setState();
+    }
+  }
+
+  async sendTemperature(temp) {
+    if (this.deviceApi.type === 'cloud') {
+      await this.cloudSet({ [CLOUD.TEMP_TARGET]: Math.round(temp * 10) });
+    } else {
+      this.deviceApi.api.state.temperature = temp;
+      await this.deviceApi.api.setState();
+    }
+  }
+
+  async sendFanSpeed(speed) {
+    if (this.deviceApi.type === 'cloud') {
+      await this.cloudSet({ [CLOUD.FAN_SPEED]: speed });
+    } else {
+      const api = this.deviceApi.api;
+      api.state.fanSpeed = speed;
+      api.state.turbo = speed === FAN_SPEED.TURBO ? 1 : 0;
+      api.state.mute = speed === FAN_SPEED.MUTE ? 1 : 0;
+      await api.setState();
+    }
+  }
+
+  async sendSwing(v, h) {
+    if (this.deviceApi.type === 'cloud') {
+      await this.cloudSet({ [CLOUD.SWING_V]: v ? 1 : 0, [CLOUD.SWING_H]: h ? 1 : 0 });
+    } else {
+      const api = this.deviceApi.api;
+      api.state.verticalFixation = v ? 7 : 0;
+      api.state.horizontalFixation = h ? 7 : 0;
+      await api.setState();
+    }
+  }
+
+  async sendPreset(key, on) {
+    const cfg = this.presetConfigs[key];
+    if (!cfg) return;
+
+    if (this.deviceApi.type === 'cloud') {
+      // Turn off all presets, then set the target one
+      const update = {
+        [CLOUD.SLEEP]: 0,
+        [CLOUD.HEALTH]: 0,
+        [CLOUD.ECO]: 0,
+        [CLOUD.CLEAN]: 0,
+      };
+      if (on) update[cfg.cloudKey] = 1;
+      await this.cloudSet(update);
+    } else {
+      const api = this.deviceApi.api;
+      api.state.sleep = 0;
+      api.state.health = 0;
+      api.state.mildew = 0;
+      api.state.clean = 0;
+      if (on) api.state[cfg.localAttr] = 1;
+      await api.setState();
+    }
+  }
+
+  async sendDisplay(on) {
+    if (this.deviceApi.type === 'cloud') {
+      await this.cloudSet({ [CLOUD.DISPLAY]: on ? 1 : 0 });
+    } else {
+      this.deviceApi.api.state.display = on ? 1 : 0;
+      await this.deviceApi.api.setState();
+    }
+  }
+
+  async cloudSet(params) {
+    const { api, device } = this.deviceApi;
+    await api.setDeviceParams(device, params);
+  }
+}
+
+module.exports = { AcFreedomAccessory };