homebridge-pax-calima 2.2.1 → 2.3.2

package/README.md

@@ -1,27 +1,168 @@
 # homebridge-pax-calima
 
-Homebridge platform plugin for **Pax Calima** and **Vent-Axia Svara** Bluetooth LE bathroom extractor fans.
+**Homebridge 2.0 Ready** · [npm](https://www.npmjs.com/package/homebridge-pax-calima) · [GitHub](https://github.com/JayC68/homebridge-pax-calima)
 
-The Vent-Axia Svara is the UK rebrand of the Pax Calima — they use the **exact same Bluetooth protocol**, MAC prefix (`58:2b:db`), and GATT characteristics.
+Full HomeKit integration for **Pax Calima** (Scandinavia) and **Vent-Axia Svara** (UK) Bluetooth LE bathroom extractor fans. These are hardware-identical and use the exact same BLE protocol and MAC prefix (`58:2b:db`).
+
+---
 
 ## Features
-- Automatic discovery of fans (MAC starting with `58:2b:db`)
-- Fan control (On/Off + Rotation Speed 0-100%)
-- Live sensors: Humidity, Temperature, Light level
-- Mode switching (Multi Mode, Heat Distribution)
-- Boost button (press to activate temporary high-speed boost)
-- Silent Hours toggle
-- Automatic cycle switches (30/60/90 min)
-- Trickle ventilation toggle
-- Easy configuration via Homebridge Config UI
-
-Perfect for Apple Home automations.
+
+| Feature | Detail |
+|---|---|
+| **Auto-discovery** | Finds all Pax/Svara fans automatically — no MAC address needed |
+| **Fan speed indicator** | Displays current RPM as 0–100% in Apple Home |
+| **Fan speed control** | Speed slider available — see wiring note below |
+| **Humidity sensor** | Live readings, updates every 10 seconds |
+| **Temperature sensor** | Live readings, updates every 10 seconds |
+| **Light sensor** | Live readings in lux, updates every 10 seconds |
+| **Boost button** | Stateless programmable switch — triggers temporary high-speed boost |
+| **Silent Hours** | Toggle switch — prevents fan boosting during scheduled quiet periods |
+| **Automations** | Full support — trigger on humidity, temperature or light thresholds |
+
+---
+
+## Requirements
+
+- Homebridge `^1.6.0` or `^2.0.0`
+- Node.js `>= 18`
+- A Bluetooth LE adapter on the Homebridge host (built-in or USB dongle)
+
+### Raspberry Pi / Homebridge OS setup
+
+The `noble` BLE library requires elevated network capabilities. Run **once** after installation:
+
+```bash
+sudo setcap cap_net_raw+eip /opt/homebridge/bin/node
+```
+
+If Bluetooth shows as `poweredOff` after this, unblock the radio:
+
+```bash
+sudo rfkill unblock bluetooth
+```
+
+---
 
 ## Installation
 
 ### Via Homebridge UI (recommended)
-Search for **Pax Calima** or **Svara** and install.
+Search for **Pax Calima** or **Svara** and click Install.
 
 ### Via Terminal
 ```bash
 npm install -g homebridge-pax-calima
+```
+
+---
+
+## Configuration
+
+Auto-discovery requires **no configuration**. The plugin finds any fan with MAC address starting `58:2b:db` automatically and registers it with a default name.
+
+To set a **custom name** or **PIN** for a specific fan, add an entry to the `fans` array:
+
+```json
+{
+  "platform": "PaxCalima",
+  "name": "Pax Calima / Vent-Axia Svara",
+  "fans": [
+    {
+      "name": "Wetroom Fan",
+      "mac": "58:2b:db:xx:xx:xx",
+      "pin": "012345"
+    }
+  ]
+}
+```
+
+The `fans` array is entirely optional. Omit it to use auto-discovery with default names and PIN `012345`.
+
+---
+
+## Accessories in Apple Home
+
+Each discovered fan appears in the Home app as a single accessory with the following tiles:
+
+- **Fan** — displays current speed; slider available (see wiring note below)
+- **Boost** — programmable button for temporary high-speed boost
+- **Silent Hours** — switch to suppress automatic boosting during quiet periods
+- **Humidity** — current relative humidity (%)
+- **Temperature** — current temperature (°C)
+- **Light** — current ambient light level (lux)
+
+> Note: Accessories appear in the **Home app**, not in the Homebridge UI accessories tab. This is correct behaviour for child bridge plugins.
+
+---
+
+## Fan Speed Control — Wiring Mode Note
+
+The Pax Calima and Vent-Axia Svara support two wiring modes, selected at installation time:
+
+**Intermittent mode** — the fan is off by default and triggered by humidity, light, or a timer. In this mode BLE speed commands are fully respected and the speed slider in Apple Home controls the fan directly.
+
+**Always-on (trickle) mode** — the fan runs continuously at a speed determined by its onboard controller, typically set via the official app or physical dial. In this mode BLE speed writes are accepted by the fan but the onboard firmware immediately reasserts its own speed. The slider will appear to have no effect.
+
+If your fan is wired in always-on mode, the speed slider will reflect the current RPM accurately but cannot override the onboard setpoint. The sensors and automations remain fully functional regardless of wiring mode — for bathroom and wetroom use this is the primary value of the integration, enabling powerful Apple Home automations based on live humidity, temperature and light readings.
+
+To enable full speed control, consult your fan's installation guide to switch to intermittent wiring mode.
+
+---
+
+## Sensor Notes
+
+The Svara's light sensor detects occupancy via light movement and shadows rather than acting as a calibrated lux meter. Readings may vary slightly from a reference device depending on mounting position — this is expected.
+
+Humidity and temperature automations work well natively in the Home app. For lux-based automations, use a third-party app such as **Eve** or **Hesperus** which support lux thresholds and sync back to HomeKit.
+
+---
+
+## Troubleshooting
+
+**Fan not discovered**
+- Confirm BLE is active: run `hciconfig` on the Pi — look for `UP RUNNING`
+- If it shows `RF-KILL`: run `sudo rfkill unblock bluetooth`
+- Confirm `setcap` targets the correct Node binary: `/opt/homebridge/bin/node`
+
+**Authentication failed**
+- Default PIN is `012345`. If you set a custom PIN in the official Pax/Svara app, add the fan to the `fans` config array with the correct PIN.
+
+**Speed slider has no effect**
+- Your fan is likely wired in always-on mode. See the wiring note above. All sensors and automations are unaffected.
+
+**Accessories not appearing in Home app**
+- Remove the accessory cache via Homebridge UI → (plugin settings) → Remove Accessory Cache, then restart Homebridge
+
+---
+
+## Release Notes
+
+### 2.3.2
+- **Documented:** Fan speed control behaviour in always-on vs intermittent wiring modes — the slider correctly reflects current RPM in both modes; in always-on mode the onboard firmware reasserts its own speed setpoint after each BLE write
+- **Confirmed:** All sensors (humidity, temperature, light, RPM) accurate and stable
+- **Improved:** README wiring mode explanation, troubleshooting entry for speed slider, sensor automation guidance
+
+### 2.3.1
+- **Investigated:** Correct control characteristic identified (`1488a757...`) via live BLE dump
+- **Added:** Diagnostic logging of control characteristic on every poll and before/after writes
+- **Fixed:** `writeSpeed` pauses poll cycle to avoid BLE conflicts during writes
+
+### 2.3.0
+- **Published:** Stable sensor readings verified against real-world reference device
+- **Fixed:** Auth characteristic discovery on first connection after restart
+
+### 2.2.1
+- **Fixed:** Sensors no longer stuck after restart — polling deferred until BLE is ready
+- **Fixed:** Poll interval 30s → 10s for responsive shower humidity tracking
+- **Fixed:** Overlapping poll guard prevents concurrent BLE connections
+- **Fixed:** Multi Mode and Heat Distribution switches removed — not applicable for UK use
+- **Fixed:** Duplicate accessory registration on restart resolved
+- **Fixed:** Switch UUID collision resolved with explicit subtypes
+
+### 2.1.0
+- **Fixed:** Correct sensor characteristic UUIDs and byte mappings confirmed via live device
+- **Fixed:** BLE refactored to connect → auth → read → disconnect → repeat pattern
+- **Fixed:** UUID matching on Linux noble
+
+### 1.0.x
+- Initial working releases

package/index.js

@@ -1,224 +1,283 @@
 const noble = require('@abandonware/noble');
 
-let Service, Characteristic, Accessory, Categories, API, PlatformAccessory;
+let Service, Characteristic, Categories, API, PlatformAccessory;
+
+const UUID_AUTH    = '4cad343a-209a-40b7-b911-4d9b3df569b2';
+const UUID_STATUS  = '528b80e8-c47a-4c0a-bdf1-916a7748f412'; // read: RPM + temp
+const UUID_SENSOR  = 'a22eae12-dba8-49f3-9c69-1721dcff1d96'; // read: humidity + lux
+const UUID_CONTROL = '1488a757-35bc-4ec8-9a6b-9ecf1502778e'; // read/write: speed config
+
+const MAC_PREFIX      = '58:2b:db';
+const POLL_MS         = 10000;
+const SCAN_TIMEOUT_MS = 15000;
 
 module.exports = (homebridge) => {
-  Service = homebridge.hap.Service;
-  Characteristic = homebridge.hap.Characteristic;
-  Accessory = homebridge.hap.Accessory;
-  Categories = homebridge.hap.Categories;
-  API = homebridge;
+  Service           = homebridge.hap.Service;
+  Characteristic    = homebridge.hap.Characteristic;
+  Categories        = homebridge.hap.Categories;
+  API               = homebridge;
   PlatformAccessory = homebridge.platformAccessory;
-
   homebridge.registerPlatform('homebridge-pax-calima', 'PaxCalima', PaxCalimaPlatform, true);
 };
 
 class PaxCalimaPlatform {
   constructor(log, config, api) {
-    this.log = log;
-    this.config = config || {};
-    this.api = api;
-    this.knownMACs = new Set();
-
-    this.log.info('PaxCalima platform initialized');
-
-    noble.on('stateChange', (state) => {
-      this.log.info(`BLE state changed to: ${state}`);
-      if (state === 'poweredOn') {
-        this.log.info('✅ BLE adapter powered on — starting discovery');
-        this.startDiscovery();
-      } else {
-        this.log.warn(`BLE adapter is ${state}`);
-      }
+    this.log               = log;
+    this.config            = config || {};
+    this.api               = api;
+    this.registeredMACs    = new Set();
+    this.discoveryStarted  = false;
+    this.cachedAccessories = [];
+
+    this.log.info('PaxCalima platform initialised');
+
+    this.api.on('didFinishLaunching', () => {
+      this.log.info('Homebridge finished launching - starting BLE');
+      noble.on('stateChange', (state) => {
+        this.log.info('BLE state: ' + state);
+        if (state === 'poweredOn') this.startDiscovery();
+      });
+      setTimeout(() => {
+        this.log.info('BLE current state: ' + noble.state);
+        if (noble.state === 'poweredOn') this.startDiscovery();
+      }, 3000);
     });
+  }
 
-    setTimeout(() => {
-      this.log.info(`Initial BLE state: ${noble.state}`);
-      if (noble.state === 'poweredOn') this.startDiscovery();
-    }, 3000);
+  configureAccessory(accessory) {
+    const mac = accessory.context && accessory.context.mac;
+    this.log.info('Restoring cached accessory: ' + accessory.displayName);
+    if (mac) {
+      this.registeredMACs.add(mac);
+      this.cachedAccessories.push({ accessory, mac });
+    }
   }
 
   startDiscovery() {
-    this.log.info('Starting BLE scan...');
+    if (this.discoveryStarted) return;
+    this.discoveryStarted = true;
+
+    for (const { accessory, mac } of this.cachedAccessories) {
+      const pin = this.pinForMac(mac);
+      this.log.info('Starting BLE handler for cached fan: ' + mac);
+      new PaxCalimaAccessory(this.log, accessory, mac, pin);
+    }
+    this.cachedAccessories = [];
+
+    this.log.info('Starting BLE discovery scan...');
     noble.startScanning([], false);
 
     noble.on('discover', (peripheral) => {
       const mac = peripheral.address.toLowerCase();
-      if (mac.startsWith('58:2b:db') && !this.knownMACs.has(mac)) {
-        this.knownMACs.add(mac);
-        this.log.info(`✅ Discovered Vent-Axia Svara: ${mac}`);
-        const acc = new PaxCalimaAccessory(this.log, mac, this.api);
-        this.api.registerPlatformAccessories('homebridge-pax-calima', 'PaxCalima', [acc.getAccessory()]);
-      }
+      if (!mac.startsWith(MAC_PREFIX)) return;
+      if (this.registeredMACs.has(mac)) return;
+      this.registeredMACs.add(mac);
+      this.log.info('Discovered new fan: ' + mac);
+      const name  = this.nameForMac(mac);
+      const pin   = this.pinForMac(mac);
+      const uuid  = API.hap.uuid.generate('pax-svara-' + mac);
+      const hbAcc = new PlatformAccessory(name, uuid, Categories.FAN);
+      hbAcc.context.mac = mac;
+      new PaxCalimaAccessory(this.log, hbAcc, mac, pin);
+      this.api.registerPlatformAccessories('homebridge-pax-calima', 'PaxCalima', [hbAcc]);
     });
   }
 
-  configureAccessory(accessory) {
-    this.log.info(`Restoring cached accessory: ${accessory.displayName}`);
-  }
+  fanConfig(mac)  { return (this.config.fans || []).find(f => f.mac && f.mac.toLowerCase() === mac) || {}; }
+  pinForMac(mac)  { return this.fanConfig(mac).pin  || '012345'; }
+  nameForMac(mac) { return this.fanConfig(mac).name || ('Vent-Axia Svara ' + mac.slice(-5).toUpperCase()); }
 }
 
 class PaxCalimaAccessory {
-  constructor(log, mac, api) {
-    this.log = log;
-    this.mac = mac.toLowerCase();
-    this.name = `Vent-Axia Svara ${this.mac.slice(-5).toUpperCase()}`;
-    this.pin = '012345';
-
-    const uuid = API.hap.uuid.generate(`pax-svara-${this.mac}`);
-    this.accessory = new PlatformAccessory(this.name, uuid, Categories.FAN);
+  constructor(log, accessory, mac, pin) {
+    this.log       = log;
+    this.accessory = accessory;
+    this.mac       = mac.toLowerCase();
+    this.pin       = pin || '012345';
 
-    this.peripheral = null;
-    this.connected = false;
+    this.currentRPM  = 0;
+    this.humidity    = 0;
+    this.temperature = 20;
+    this.lightLevel  = 0.0001;
+    this.silentHours = false;
 
-    this.currentRPM = 0;
-    this.humidity = 0;
-    this.temperature = 0;
-    this.lightLevel = 0;
-    this.currentMode = 0;
+    this.pollTimer = null;
+    this.polling   = false;
 
     this.setupServices();
-    this.connectAndPoll();
+    this.schedulePoll(0);
   }
 
   setupServices() {
-    // Fan
-    this.fanService = new Service.Fanv2(this.name);
-    this.fanService.getCharacteristic(Characteristic.Active).onGet(() => 1);
+    const n = this.accessory.displayName;
+
+    this.fanService = this.accessory.getService(Service.Fanv2)
+      || this.accessory.addService(new Service.Fanv2(n, 'fan'));
+    this.fanService.getCharacteristic(Characteristic.Active)
+      .onGet(() => 1);
     this.fanService.getCharacteristic(Characteristic.RotationSpeed)
       .setProps({ minValue: 0, maxValue: 100, minStep: 1 })
-      .onGet(() => Math.min(100, Math.round(this.currentRPM / 25)))
-      .onSet((value) => this.log.info(`Speed requested: ${value}%`));
-
-    // Modes
-    this.multiMode = new Service.Switch(`${this.name} - Multi Mode`);
-    this.multiMode.getCharacteristic(Characteristic.On)
-      .onGet(() => this.currentMode === 0)
-      .onSet((on) => this.setMode(0, on));
-
-    this.heatMode = new Service.Switch(`${this.name} - Heat Distribution`);
-    this.heatMode.getCharacteristic(Characteristic.On)
-      .onGet(() => this.currentMode === 4)
-      .onSet((on) => this.setMode(4, on));
-
-    // Boost Button
-    this.boostButton = new Service.StatelessProgrammableSwitch(`${this.name} - Boost`);
-    this.boostButton.getCharacteristic(Characteristic.ProgrammableSwitchEvent)
-      .onSet(() => this.triggerBoost());
-
-    // Silent Hours
-    this.silentService = new Service.Switch(`${this.name} - Silent Hours`);
-    this.silentService.getCharacteristic(Characteristic.On).onSet((on) => this.setSilentHours(on));
+      .onGet(() => this.rpmToPercent(this.currentRPM))
+      .onSet((v) => this.writeSpeed(v));
 
-    // Sensors
-    this.humidityService = new Service.HumiditySensor(`${this.name} Humidity`);
-    this.humidityService.getCharacteristic(Characteristic.CurrentRelativeHumidity).onGet(() => this.humidity);
-
-    this.tempService = new Service.TemperatureSensor(`${this.name} Temperature`);
-    this.tempService.getCharacteristic(Characteristic.CurrentTemperature).onGet(() => this.temperature);
-
-    this.lightService = new Service.LightSensor(`${this.name} Light`);
-    this.lightService.getCharacteristic(Characteristic.CurrentAmbientLightLevel).onGet(() => this.lightLevel);
-
-    this.accessory.addService(this.fanService);
-    this.accessory.addService(this.multiMode);
-    this.accessory.addService(this.heatMode);
-    this.accessory.addService(this.boostButton);
-    this.accessory.addService(this.silentService);
-    this.accessory.addService(this.humidityService);
-    this.accessory.addService(this.tempService);
-    this.accessory.addService(this.lightService);
-
-    this.log.info(`Accessory created with switches and sensors: ${this.name}`);
+    this.boostButton = this.accessory.getService(Service.StatelessProgrammableSwitch)
+      || this.accessory.addService(new Service.StatelessProgrammableSwitch(n + ' Boost', 'boost'));
+    this.boostButton.getCharacteristic(Characteristic.ProgrammableSwitchEvent)
+      .setProps({ validValues: [0] });
+
+    this.silentService = this.accessory.getServiceByUUIDAndSubType(Service.Switch, 'silent-hours')
+      || this.accessory.addService(new Service.Switch(n + ' Silent Hours', 'silent-hours'));
+    this.silentService.getCharacteristic(Characteristic.On)
+      .onGet(() => this.silentHours)
+      .onSet((on) => this.setSilentHours(on));
+
+    this.humidityService = this.accessory.getService(Service.HumiditySensor)
+      || this.accessory.addService(new Service.HumiditySensor(n + ' Humidity', 'humidity'));
+    this.humidityService.getCharacteristic(Characteristic.CurrentRelativeHumidity)
+      .onGet(() => this.humidity);
+
+    this.tempService = this.accessory.getService(Service.TemperatureSensor)
+      || this.accessory.addService(new Service.TemperatureSensor(n + ' Temperature', 'temperature'));
+    this.tempService.getCharacteristic(Characteristic.CurrentTemperature)
+      .onGet(() => this.temperature);
+
+    this.lightService = this.accessory.getService(Service.LightSensor)
+      || this.accessory.addService(new Service.LightSensor(n + ' Light', 'light'));
+    this.lightService.getCharacteristic(Characteristic.CurrentAmbientLightLevel)
+      .onGet(() => Math.max(0.0001, this.lightLevel));
+
+    this.log.info('Services set up for: ' + n);
   }
 
-  async connectAndPoll() {
-    this.log.info(`🔄 Attempting connection to ${this.mac}...`);
-
-    if (noble.state !== 'poweredOn') {
-      this.log.warn(`BLE state is ${noble.state} — waiting...`);
-      setTimeout(() => this.connectAndPoll(), 8000);
-      return;
-    }
+  schedulePoll(delayMs) {
+    if (this.pollTimer) clearTimeout(this.pollTimer);
+    this.pollTimer = setTimeout(() => this.poll(), delayMs);
+  }
 
+  async poll() {
+    if (this.polling) { this.schedulePoll(POLL_MS); return; }
+    this.polling = true;
+    let peripheral = null;
     try {
-      this.peripheral = await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => reject(new Error('Timeout')), 15000);
-        noble.startScanning([], false);
-        noble.on('discover', (periph) => {
-          if (periph.address.toLowerCase() === this.mac) {
-            clearTimeout(timeout);
-            noble.stopScanning();
-            resolve(periph);
-          }
-        });
-      });
+      peripheral = await this.findPeripheral();
+      await peripheral.connectAsync();
 
-      await this.peripheral.connectAsync();
-      this.connected = true;
-      this.log.info(`✅ Connected to ${this.mac}`);
-
-      // PIN Authentication
-      const authChar = await this.getCharacteristic('4cad343a-209a-40b7-b911-4d9b3df569b2');
+      const authChar = await this.getCharacteristic(peripheral, UUID_AUTH);
       const pinBuf = Buffer.alloc(4);
-      pinBuf.writeUInt32LE(parseInt(this.pin), 0);
+      pinBuf.writeUInt32LE(parseInt(this.pin, 10), 0);
       await authChar.writeAsync(pinBuf, true);
-      this.log.info('✅ PIN authentication successful');
 
-      this.pollStatus();
-    } catch (error) {
-      this.log.error(`Connection failed: ${error.message}`);
-      setTimeout(() => this.connectAndPoll(), 15000);
+      const statusChar = await this.getCharacteristic(peripheral, UUID_STATUS);
+      const statusData = await statusChar.readAsync();
+      this.currentRPM  = Math.max(0, statusData.readUInt16LE(6));
+      this.temperature = Math.round((statusData.readUInt16LE(2) / 6) * 10) / 10;
+
+      const sensorChar = await this.getCharacteristic(peripheral, UUID_SENSOR);
+      const sensorData = await sensorChar.readAsync();
+      this.humidity   = Math.max(0, Math.min(100, sensorData.readUInt8(0) * 2));
+      this.lightLevel = Math.max(0.0001, sensorData.readUInt16BE(2));
+
+      // Also log the raw control characteristic on each poll for diagnostics
+      try {
+        const ctrlChar = await this.getCharacteristic(peripheral, UUID_CONTROL);
+        const ctrlData = await ctrlChar.readAsync();
+        this.log.info('CTRL raw: ' + Array.from(ctrlData).join(',') +
+          ' | UInt16s: ' + ctrlData.readUInt16LE(0) + ',' +
+          ctrlData.readUInt16LE(2) + ',' + ctrlData.readUInt16LE(4));
+      } catch (_) {}
+
+      const speed = this.rpmToPercent(this.currentRPM);
+      this.fanService.getCharacteristic(Characteristic.RotationSpeed).updateValue(speed);
+      this.humidityService.getCharacteristic(Characteristic.CurrentRelativeHumidity).updateValue(this.humidity);
+      this.tempService.getCharacteristic(Characteristic.CurrentTemperature).updateValue(this.temperature);
+      this.lightService.getCharacteristic(Characteristic.CurrentAmbientLightLevel).updateValue(this.lightLevel);
+
+      this.log.info('Status: RPM=' + this.currentRPM + ' Speed=' + speed +
+        '% Hum=' + this.humidity + '% Temp=' + this.temperature +
+        'C Light=' + this.lightLevel + 'lx');
+
+    } catch (err) {
+      this.log.warn('Poll error: ' + err.message);
+    } finally {
+      if (peripheral) { try { await peripheral.disconnectAsync(); } catch (_) {} }
+      this.polling = false;
+      this.schedulePoll(POLL_MS);
     }
   }
 
-  async getCharacteristic(uuid) {
-    const services = await this.peripheral.discoverServicesAsync();
+  findPeripheral() {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        noble.removeListener('discover', onDiscover);
+        reject(new Error('Scan timeout for ' + this.mac));
+      }, SCAN_TIMEOUT_MS);
+      const onDiscover = (periph) => {
+        if (periph.address.toLowerCase() === this.mac) {
+          clearTimeout(timeout);
+          noble.removeListener('discover', onDiscover);
+          resolve(periph);
+        }
+      };
+      noble.on('discover', onDiscover);
+      noble.startScanning([], false);
+    });
+  }
+
+  async getCharacteristic(peripheral, uuid) {
+    const stripped = uuid.replace(/-/g, '');
+    const services = await peripheral.discoverServicesAsync();
     for (const service of services) {
-      const chars = await service.discoverCharacteristicsAsync([uuid]);
-      if (chars.length > 0) return chars[0];
+      const chars = await service.discoverCharacteristicsAsync();
+      for (const char of chars) {
+        if (char.uuid.replace(/-/g, '') === stripped) return char;
+      }
     }
-    throw new Error(`Characteristic ${uuid} not found`);
+    throw new Error('Characteristic ' + uuid + ' not found');
   }
 
-  async pollStatus() {
-    if (!this.connected) return;
+  async writeSpeed(percent) {
+    // Pause the poll cycle to avoid BLE conflicts during a write
+    if (this.pollTimer) { clearTimeout(this.pollTimer); this.pollTimer = null; }
 
+    let peripheral = null;
     try {
-      const sensorChar = await this.getCharacteristic('528b80e8-c47a-4c0a-bdf1-916a7748f412');
-      const data = await sensorChar.readAsync();
+      peripheral = await this.findPeripheral();
+      await peripheral.connectAsync();
 
-      this.humidity = Math.max(0, Math.min(100, Math.round(data.readUInt16LE(0) / 100)));
-      this.temperature = Math.round((data.readUInt16LE(2) / 10) * 10) / 10;
-      this.lightLevel = Math.max(0, data.readUInt16LE(4));
-      this.currentRPM = Math.max(0, data.readUInt16LE(6));
+      const authChar = await this.getCharacteristic(peripheral, UUID_AUTH);
+      const pinBuf = Buffer.alloc(4);
+      pinBuf.writeUInt32LE(parseInt(this.pin, 10), 0);
+      await authChar.writeAsync(pinBuf, true);
 
-      this.fanService.getCharacteristic(Characteristic.RotationSpeed).updateValue(Math.min(100, Math.round(this.currentRPM / 25)));
-      this.humidityService.getCharacteristic(Characteristic.CurrentRelativeHumidity).updateValue(this.humidity);
-      this.tempService.getCharacteristic(Characteristic.CurrentTemperature).updateValue(this.temperature);
-      this.lightService.getCharacteristic(Characteristic.CurrentAmbientLightLevel).updateValue(this.lightLevel);
+      // Read current control config to preserve trickle/boost values
+      const ctrlChar = await this.getCharacteristic(peripheral, UUID_CONTROL);
+      const current  = await ctrlChar.readAsync();
+      this.log.info('CTRL before write: ' + Array.from(current).join(','));
 
-      this.log.info(`Status: RPM=${this.currentRPM}, Humidity=${this.humidity}%, Temp=${this.temperature}°C`);
+      // Control characteristic layout (6 bytes, all UInt16LE):
+      // [0-1] trickle RPM, [2-3] normal RPM, [4-5] boost RPM
+      // We write the target RPM into the normal speed slot [2-3]
+      const targetRPM = Math.round((percent / 100) * 2400);
+      const buf = Buffer.from(current); // preserve existing trickle + boost values
+      buf.writeUInt16LE(targetRPM, 2);  // set normal speed
+      await ctrlChar.writeAsync(buf, true);
+
+      this.log.info('Speed set to ' + percent + '% (' + targetRPM + ' RPM) — CTRL written: ' + Array.from(buf).join(','));
     } catch (e) {
-      this.log.warn(`Poll failed: ${e.message}`);
+      this.log.error('writeSpeed failed: ' + e.message);
+    } finally {
+      if (peripheral) { try { await peripheral.disconnectAsync(); } catch (_) {} }
+      // Resume polling after write
+      this.schedulePoll(2000);
     }
-
-    setTimeout(() => this.pollStatus(), 8000);
-  }
-
-  async setMode(modeValue, on) {
-    this.log.info(`Mode set to ${on ? (modeValue === 0 ? 'Multi' : 'Heat Distribution') : 'Default'}`);
-  }
-
-  async triggerBoost() {
-    this.log.info('Boost button pressed — high speed activated');
   }
 
   async setSilentHours(on) {
-    this.log.info(`Silent Hours ${on ? 'enabled' : 'disabled'}`);
+    this.silentHours = on;
+    this.log.info('Silent Hours ' + (on ? 'enabled' : 'disabled'));
   }
 
-  getAccessory() {
-    return this.accessory;
+  rpmToPercent(rpm) {
+    return Math.min(100, Math.max(0, Math.round(rpm / 25)));
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-pax-calima",
-  "version": "2.2.1",
-  "description": "Homebridge plugin for Pax Calima and Vent-Axia Svara Bluetooth bathroom fans",
+  "version": "2.3.2",
+  "description": "Homebridge platform plugin for Pax Calima and Vent-Axia Svara Bluetooth LE bathroom extractor fans",
   "main": "index.js",
   "keywords": [
     "homebridge-plugin",
@@ -16,7 +16,8 @@
     "bathroom"
   ],
   "engines": {
-    "homebridge": "^1.6.0 || ^2.0.0"
+    "homebridge": "^1.6.0 || ^2.0.0",
+    "node": ">=18.0.0"
   },
   "dependencies": {
     "@abandonware/noble": "1.9.2-26"