homebridge-pax-calima 2.2.1 → 2.3.1

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.1",
+  "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"